Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 8f2ab833

History | View | Annotate | Download (193 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 <limits.h>
29
#include "avcodec.h"
30
#include "dsputil.h"
31
#include "mpegvideo.h"
32
#include "faandct.h"
33

    
34
#ifdef USE_FASTMEMCPY
35
#include "fastmemcpy.h"
36
#endif
37

    
38
//#undef NDEBUG
39
//#include <assert.h>
40

    
41
#ifdef CONFIG_ENCODERS
42
static void encode_picture(MpegEncContext *s, int picture_number);
43
#endif //CONFIG_ENCODERS
44
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s, 
45
                                   DCTELEM *block, int n, int qscale);
46
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, 
47
                                   DCTELEM *block, int n, int qscale);
48
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
49
                                   DCTELEM *block, int n, int qscale);
50
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
51
                                   DCTELEM *block, int n, int qscale);
52
static void dct_unquantize_h263_intra_c(MpegEncContext *s, 
53
                                  DCTELEM *block, int n, int qscale);
54
static void dct_unquantize_h263_inter_c(MpegEncContext *s, 
55
                                  DCTELEM *block, int n, int qscale);
56
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
57
#ifdef CONFIG_ENCODERS
58
static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
59
static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
60
static int sse_mb(MpegEncContext *s);
61
static void  denoise_dct_c(MpegEncContext *s, DCTELEM *block);
62
#endif //CONFIG_ENCODERS
63

    
64
#ifdef HAVE_XVMC
65
extern int  XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
66
extern void XVMC_field_end(MpegEncContext *s);
67
extern void XVMC_decode_mb(MpegEncContext *s);
68
#endif
69

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

    
72

    
73
/* enable all paranoid tests for rounding, overflows, etc... */
74
//#define PARANOID
75

    
76
//#define DEBUG
77

    
78

    
79
/* for jpeg fast DCT */
80
#define CONST_BITS 14
81

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

    
94
static const uint8_t h263_chroma_roundtab[16] = {
95
//  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
96
    0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
97
};
98

    
99
static const uint8_t ff_default_chroma_qscale_table[32]={
100
//  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
101
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
102
};
103

    
104
#ifdef CONFIG_ENCODERS
105
static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
106
static uint8_t default_fcode_tab[MAX_MV*2+1];
107

    
108
enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
109

    
110
static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
111
                           const uint16_t *quant_matrix, int bias, int qmin, int qmax)
112
{
113
    int qscale;
114

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

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

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

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

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

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

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

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

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

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

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

    
253
#endif //CONFIG_ENCODERS
254

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

    
268
    s->picture_structure= PICT_FRAME;
269
    
270
    return 0;
271
}
272

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

    
278
static void copy_picture_attributes(AVFrame *dst, AVFrame *src){
279
    dst->pict_type              = src->pict_type;
280
    dst->quality                = src->quality;
281
    dst->coded_picture_number   = src->coded_picture_number;
282
    dst->display_picture_number = src->display_picture_number;
283
//    dst->reference              = src->reference;
284
    dst->pts                    = src->pts;
285
    dst->interlaced_frame       = src->interlaced_frame;
286
    dst->top_field_first        = src->top_field_first;
287
}
288

    
289
/**
290
 * allocates a Picture
291
 * The pixels are allocated/set by calling get_buffer() if shared=0
292
 */
293
static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
294
    const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
295
    const int mb_array_size= s->mb_stride*s->mb_height;
296
    const int b8_array_size= s->b8_stride*s->mb_height*2;
297
    const int b4_array_size= s->b4_stride*s->mb_height*4;
298
    int i;
299
    
300
    if(shared){
301
        assert(pic->data[0]);
302
        assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
303
        pic->type= FF_BUFFER_TYPE_SHARED;
304
    }else{
305
        int r;
306
        
307
        assert(!pic->data[0]);
308
        
309
        r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
310
        
311
        if(r<0 || !pic->age || !pic->type || !pic->data[0]){
312
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
313
            return -1;
314
        }
315

    
316
        if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
317
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
318
            return -1;
319
        }
320

    
321
        if(pic->linesize[1] != pic->linesize[2]){
322
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride missmatch)\n");
323
            return -1;
324
        }
325

    
326
        s->linesize  = pic->linesize[0];
327
        s->uvlinesize= pic->linesize[1];
328
    }
329
    
330
    if(pic->qscale_table==NULL){
331
        if (s->encoding) {        
332
            CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
333
            CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
334
            CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
335
        }
336

    
337
        CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
338
        CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
339
        CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num    * sizeof(int))
340
        pic->mb_type= pic->mb_type_base + s->mb_stride+1;
341
        if(s->out_format == FMT_H264){
342
            for(i=0; i<2; i++){
343
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+1)  * sizeof(uint16_t))
344
                pic->motion_val[i]= pic->motion_val_base[i]+1;
345
                CHECKED_ALLOCZ(pic->ref_index[i] , b8_array_size * sizeof(uint8_t))
346
            }
347
            pic->motion_subsample_log2= 2;
348
        }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
349
            for(i=0; i<2; i++){
350
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+1) * sizeof(uint16_t)*2) //FIXME
351
                pic->motion_val[i]= pic->motion_val_base[i]+1;
352
            }
353
            pic->motion_subsample_log2= 3;
354
        }
355
        pic->qstride= s->mb_stride;
356
        CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
357
    }
358

    
359
    //it might be nicer if the application would keep track of these but it would require a API change
360
    memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
361
    s->prev_pict_types[0]= s->pict_type;
362
    if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
363
        pic->age= INT_MAX; // skiped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
364
    
365
    return 0;
366
fail: //for the CHECKED_ALLOCZ macro
367
    return -1;
368
}
369

    
370
/**
371
 * deallocates a picture
372
 */
373
static void free_picture(MpegEncContext *s, Picture *pic){
374
    int i;
375

    
376
    if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
377
        s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
378
    }
379

    
380
    av_freep(&pic->mb_var);
381
    av_freep(&pic->mc_mb_var);
382
    av_freep(&pic->mb_mean);
383
    av_freep(&pic->mbskip_table);
384
    av_freep(&pic->qscale_table);
385
    av_freep(&pic->mb_type_base);
386
    av_freep(&pic->pan_scan);
387
    pic->mb_type= NULL;
388
    for(i=0; i<2; i++){
389
        av_freep(&pic->motion_val_base[i]);
390
        av_freep(&pic->ref_index[i]);
391
    }
392
    
393
    if(pic->type == FF_BUFFER_TYPE_SHARED){
394
        for(i=0; i<4; i++){
395
            pic->base[i]=
396
            pic->data[i]= NULL;
397
        }
398
        pic->type= 0;        
399
    }
400
}
401

    
402
/* init common structure for both encoder and decoder */
403
int MPV_common_init(MpegEncContext *s)
404
{
405
    int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
406

    
407
    dsputil_init(&s->dsp, s->avctx);
408
    DCT_common_init(s);
409

    
410
    s->flags= s->avctx->flags;
411

    
412
    s->mb_width  = (s->width  + 15) / 16;
413
    s->mb_height = (s->height + 15) / 16;
414
    s->mb_stride = s->mb_width + 1;
415
    s->b8_stride = s->mb_width*2 + 1;
416
    s->b4_stride = s->mb_width*4 + 1;
417
    mb_array_size= s->mb_height * s->mb_stride;
418
    mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
419

    
420
    /* set default edge pos, will be overriden in decode_header if needed */
421
    s->h_edge_pos= s->mb_width*16;
422
    s->v_edge_pos= s->mb_height*16;
423

    
424
    s->mb_num = s->mb_width * s->mb_height;
425
    
426
    s->block_wrap[0]=
427
    s->block_wrap[1]=
428
    s->block_wrap[2]=
429
    s->block_wrap[3]= s->mb_width*2 + 2;
430
    s->block_wrap[4]=
431
    s->block_wrap[5]= s->mb_width + 2;
432

    
433
    s->y_dc_scale_table=
434
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
435
    s->chroma_qscale_table= ff_default_chroma_qscale_table;
436
    if (!s->encoding)
437
        s->progressive_sequence= 1;
438
    s->progressive_frame= 1;
439
    s->coded_picture_number = 0;
440

    
441
    y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
442
    c_size = (s->mb_width + 2) * (s->mb_height + 2);
443
    yc_size = y_size + 2 * c_size;
444

    
445
    /* convert fourcc to upper case */
446
    s->avctx->codec_tag=   toupper( s->avctx->codec_tag     &0xFF)          
447
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
448
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16) 
449
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
450

    
451
    s->avctx->stream_codec_tag=   toupper( s->avctx->stream_codec_tag     &0xFF)          
452
                               + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
453
                               + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16) 
454
                               + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
455

    
456
    CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
457
    s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
458

    
459
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
460

    
461
    CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
462
    for(y=0; y<s->mb_height; y++){
463
        for(x=0; x<s->mb_width; x++){
464
            s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
465
        }
466
    }
467
    s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
468
    
469
    if (s->encoding) {
470
        /* Allocate MV tables */
471
        CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
472
        CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
473
        CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
474
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
475
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
476
        CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
477
        s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
478
        s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
479
        s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
480
        s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
481
        s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
482
        s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
483

    
484
        //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
485
        CHECKED_ALLOCZ(s->me.scratchpad,  s->width*2*16*3*sizeof(uint8_t)) 
486
        
487
        CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
488
        CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
489

    
490
        if(s->codec_id==CODEC_ID_MPEG4){
491
            CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
492
            CHECKED_ALLOCZ(   s->pb2_buffer, PB_BUFFER_SIZE);
493
        }
494
        
495
        if(s->msmpeg4_version){
496
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
497
        }
498
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
499

    
500
        /* Allocate MB type table */
501
        CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint16_t)) //needed for encoding
502
        
503
        CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
504
        
505
        CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
506
        CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
507
        CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
508
        CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
509
        CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
510
        CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
511
        
512
        if(s->avctx->noise_reduction){
513
            CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
514
            CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
515
        }
516
    }
517
    CHECKED_ALLOCZ(s->blocks, 64*6*2 * sizeof(DCTELEM))
518
        
519
    CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
520

    
521
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
522
    
523
    if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
524
        /* interlaced direct mode decoding tables */
525
            for(i=0; i<2; i++){
526
                int j, k;
527
                for(j=0; j<2; j++){
528
                    for(k=0; k<2; k++){
529
                        CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k]     , mv_table_size * 2 * sizeof(int16_t))
530
                        s->b_field_mv_table[i][j][k]    = s->b_field_mv_table_base[i][j][k]     + s->mb_stride + 1;
531
                    }
532
                    CHECKED_ALLOCZ(s->b_field_select_table[i][j]     , mb_array_size * 2 * sizeof(uint8_t))
533
                    CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j]     , mv_table_size * 2 * sizeof(int16_t))
534
                    s->p_field_mv_table[i][j]    = s->p_field_mv_table_base[i][j]     + s->mb_stride + 1;
535
                }
536
                CHECKED_ALLOCZ(s->p_field_select_table[i]      , mb_array_size * 2 * sizeof(uint8_t))
537
            }
538
    }
539
    if (s->out_format == FMT_H263) {
540
        /* ac values */
541
        CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(int16_t) * 16);
542
        s->ac_val[1] = s->ac_val[0] + y_size;
543
        s->ac_val[2] = s->ac_val[1] + c_size;
544
        
545
        /* cbp values */
546
        CHECKED_ALLOCZ(s->coded_block, y_size);
547
        
548
        /* divx501 bitstream reorder buffer */
549
        CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
550

    
551
        /* cbp, ac_pred, pred_dir */
552
        CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
553
        CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
554
    }
555
    
556
    if (s->h263_pred || s->h263_plus || !s->encoding) {
557
        /* dc values */
558
        //MN: we need these for error resilience of intra-frames
559
        CHECKED_ALLOCZ(s->dc_val[0], yc_size * sizeof(int16_t));
560
        s->dc_val[1] = s->dc_val[0] + y_size;
561
        s->dc_val[2] = s->dc_val[1] + c_size;
562
        for(i=0;i<yc_size;i++)
563
            s->dc_val[0][i] = 1024;
564
    }
565

    
566
    /* which mb is a intra block */
567
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
568
    memset(s->mbintra_table, 1, mb_array_size);
569
    
570
    /* default structure is frame */
571
    s->picture_structure = PICT_FRAME;
572
    
573
    /* init macroblock skip table */
574
    CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
575
    //Note the +1 is for a quicker mpeg4 slice_end detection
576
    CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
577
    
578
    s->block= s->blocks[0];
579

    
580
    for(i=0;i<12;i++){
581
        s->pblocks[i] = (short *)(&s->block[i]);
582
    }
583

    
584
    s->parse_context.state= -1;
585
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
586
       s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
587
       s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
588
       s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
589
    }
590

    
591
    s->context_initialized = 1;
592
    return 0;
593
 fail:
594
    MPV_common_end(s);
595
    return -1;
596
}
597

    
598

    
599
//extern int sads;
600

    
601
/* init common structure for both encoder and decoder */
602
void MPV_common_end(MpegEncContext *s)
603
{
604
    int i, j, k;
605

    
606
    av_freep(&s->parse_context.buffer);
607
    s->parse_context.buffer_size=0;
608

    
609
    av_freep(&s->mb_type);
610
    av_freep(&s->p_mv_table_base);
611
    av_freep(&s->b_forw_mv_table_base);
612
    av_freep(&s->b_back_mv_table_base);
613
    av_freep(&s->b_bidir_forw_mv_table_base);
614
    av_freep(&s->b_bidir_back_mv_table_base);
615
    av_freep(&s->b_direct_mv_table_base);
616
    s->p_mv_table= NULL;
617
    s->b_forw_mv_table= NULL;
618
    s->b_back_mv_table= NULL;
619
    s->b_bidir_forw_mv_table= NULL;
620
    s->b_bidir_back_mv_table= NULL;
621
    s->b_direct_mv_table= NULL;
622
    for(i=0; i<2; i++){
623
        for(j=0; j<2; j++){
624
            for(k=0; k<2; k++){
625
                av_freep(&s->b_field_mv_table_base[i][j][k]);
626
                s->b_field_mv_table[i][j][k]=NULL;
627
            }
628
            av_freep(&s->b_field_select_table[i][j]);
629
            av_freep(&s->p_field_mv_table_base[i][j]);
630
            s->p_field_mv_table[i][j]=NULL;
631
        }
632
        av_freep(&s->p_field_select_table[i]);
633
    }
634
    
635
    av_freep(&s->dc_val[0]);
636
    av_freep(&s->ac_val[0]);
637
    av_freep(&s->coded_block);
638
    av_freep(&s->mbintra_table);
639
    av_freep(&s->cbp_table);
640
    av_freep(&s->pred_dir_table);
641
    av_freep(&s->me.scratchpad);
642
    av_freep(&s->me.map);
643
    av_freep(&s->me.score_map);
644
    
645
    av_freep(&s->mbskip_table);
646
    av_freep(&s->prev_pict_types);
647
    av_freep(&s->bitstream_buffer);
648
    av_freep(&s->tex_pb_buffer);
649
    av_freep(&s->pb2_buffer);
650
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
651
    av_freep(&s->avctx->stats_out);
652
    av_freep(&s->ac_stats);
653
    av_freep(&s->error_status_table);
654
    av_freep(&s->mb_index2xy);
655
    av_freep(&s->lambda_table);
656
    av_freep(&s->q_intra_matrix);
657
    av_freep(&s->q_inter_matrix);
658
    av_freep(&s->q_intra_matrix16);
659
    av_freep(&s->q_inter_matrix16);
660
    av_freep(&s->blocks);
661
    av_freep(&s->input_picture);
662
    av_freep(&s->reordered_input_picture);
663
    av_freep(&s->dct_error_sum);
664
    av_freep(&s->dct_offset);
665

    
666
    if(s->picture){
667
        for(i=0; i<MAX_PICTURE_COUNT; i++){
668
            free_picture(s, &s->picture[i]);
669
        }
670
    }
671
    av_freep(&s->picture);
672
    avcodec_default_free_buffers(s->avctx);
673
    s->context_initialized = 0;
674
    s->last_picture_ptr=
675
    s->next_picture_ptr=
676
    s->current_picture_ptr= NULL;
677
    for(i=0; i<3; i++)
678
        if (s->visualization_buffer[i])
679
            av_free(s->visualization_buffer[i]);
680
}
681

    
682
#ifdef CONFIG_ENCODERS
683

    
684
/* init video encoder */
685
int MPV_encode_init(AVCodecContext *avctx)
686
{
687
    MpegEncContext *s = avctx->priv_data;
688
    int i, dummy;
689
    int chroma_h_shift, chroma_v_shift;
690

    
691
    avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME
692

    
693
    s->bit_rate = avctx->bit_rate;
694
    s->width = avctx->width;
695
    s->height = avctx->height;
696
    if(avctx->gop_size > 600){
697
        av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
698
        avctx->gop_size=600;
699
    }
700
    s->gop_size = avctx->gop_size;
701
    s->avctx = avctx;
702
    s->flags= avctx->flags;
703
    s->max_b_frames= avctx->max_b_frames;
704
    s->codec_id= avctx->codec->id;
705
    s->luma_elim_threshold  = avctx->luma_elim_threshold;
706
    s->chroma_elim_threshold= avctx->chroma_elim_threshold;
707
    s->strict_std_compliance= avctx->strict_std_compliance;
708
    s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
709
    s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
710
    s->mpeg_quant= avctx->mpeg_quant;
711
    s->rtp_mode= !!avctx->rtp_payload_size;
712

    
713
    if (s->gop_size <= 1) {
714
        s->intra_only = 1;
715
        s->gop_size = 12;
716
    } else {
717
        s->intra_only = 0;
718
    }
719

    
720
    s->me_method = avctx->me_method;
721

    
722
    /* Fixed QSCALE */
723
    s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
724
    
725
    s->adaptive_quant= (   s->avctx->lumi_masking
726
                        || s->avctx->dark_masking
727
                        || s->avctx->temporal_cplx_masking 
728
                        || s->avctx->spatial_cplx_masking
729
                        || s->avctx->p_masking
730
                        || (s->flags&CODEC_FLAG_QP_RD))
731
                       && !s->fixed_qscale;
732
    
733
    s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
734
    s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
735
    s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
736

    
737
    if(avctx->rc_max_rate && !avctx->rc_buffer_size){
738
        av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
739
        return -1;
740
    }    
741

    
742
    if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
743
        av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isnt recommanded!\n");
744
    }    
745
        
746
    if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 
747
       && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
748
        av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
749
        return -1;
750
    }
751
        
752
    if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
753
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decission\n");
754
        return -1;
755
    }
756
    
757
    if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
758
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
759
        return -1;
760
    }
761
    
762
    if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
763
        av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
764
        return -1;
765
    }
766

    
767
    if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
768
        av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
769
        return -1;
770
    }
771
    
772
    if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
773
        av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
774
        return -1;
775
    }
776
    
777
    if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
778
        av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n");
779
        return -1;
780
    }
781
        
782
    if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
783
        av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
784
        return -1;
785
    }
786

    
787
    if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
788
        av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
789
        return -1;
790
    }
791
    
792
    if(s->codec_id==CODEC_ID_MJPEG){
793
        s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
794
        s->inter_quant_bias= 0;
795
    }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
796
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
797
        s->inter_quant_bias= 0;
798
    }else{
799
        s->intra_quant_bias=0;
800
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
801
    }
802
    
803
    if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
804
        s->intra_quant_bias= avctx->intra_quant_bias;
805
    if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
806
        s->inter_quant_bias= avctx->inter_quant_bias;
807
        
808
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
809

    
810
    av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
811
    s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
812

    
813
    switch(avctx->codec->id) {
814
    case CODEC_ID_MPEG1VIDEO:
815
        s->out_format = FMT_MPEG1;
816
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
817
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
818
        break;
819
    case CODEC_ID_MPEG2VIDEO:
820
        s->out_format = FMT_MPEG1;
821
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
822
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
823
        s->rtp_mode= 1;
824
        break;
825
    case CODEC_ID_LJPEG:
826
    case CODEC_ID_MJPEG:
827
        s->out_format = FMT_MJPEG;
828
        s->intra_only = 1; /* force intra only for jpeg */
829
        s->mjpeg_write_tables = 1; /* write all tables */
830
        s->mjpeg_data_only_frames = 0; /* write all the needed headers */
831
        s->mjpeg_vsample[0] = 1<<chroma_v_shift;
832
        s->mjpeg_vsample[1] = 1;
833
        s->mjpeg_vsample[2] = 1; 
834
        s->mjpeg_hsample[0] = 1<<chroma_h_shift;
835
        s->mjpeg_hsample[1] = 1; 
836
        s->mjpeg_hsample[2] = 1; 
837
        if (mjpeg_init(s) < 0)
838
            return -1;
839
        avctx->delay=0;
840
        s->low_delay=1;
841
        break;
842
#ifdef CONFIG_RISKY
843
    case CODEC_ID_H263:
844
        if (h263_get_picture_format(s->width, s->height) == 7) {
845
            av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
846
            return -1;
847
        }
848
        s->out_format = FMT_H263;
849
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
850
        avctx->delay=0;
851
        s->low_delay=1;
852
        break;
853
    case CODEC_ID_H263P:
854
        s->out_format = FMT_H263;
855
        s->h263_plus = 1;
856
        /* Fx */
857
        s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
858
        s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
859
        s->modified_quant= s->h263_aic;
860
        s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
861
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
862
        s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
863
        s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
864
        s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
865

    
866
        /* /Fx */
867
        /* These are just to be sure */
868
        avctx->delay=0;
869
        s->low_delay=1;
870
        break;
871
    case CODEC_ID_FLV1:
872
        s->out_format = FMT_H263;
873
        s->h263_flv = 2; /* format = 1; 11-bit codes */
874
        s->unrestricted_mv = 1;
875
        s->rtp_mode=0; /* don't allow GOB */
876
        avctx->delay=0;
877
        s->low_delay=1;
878
        break;
879
    case CODEC_ID_RV10:
880
        s->out_format = FMT_H263;
881
        avctx->delay=0;
882
        s->low_delay=1;
883
        break;
884
    case CODEC_ID_MPEG4:
885
        s->out_format = FMT_H263;
886
        s->h263_pred = 1;
887
        s->unrestricted_mv = 1;
888
        s->low_delay= s->max_b_frames ? 0 : 1;
889
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
890
        break;
891
    case CODEC_ID_MSMPEG4V1:
892
        s->out_format = FMT_H263;
893
        s->h263_msmpeg4 = 1;
894
        s->h263_pred = 1;
895
        s->unrestricted_mv = 1;
896
        s->msmpeg4_version= 1;
897
        avctx->delay=0;
898
        s->low_delay=1;
899
        break;
900
    case CODEC_ID_MSMPEG4V2:
901
        s->out_format = FMT_H263;
902
        s->h263_msmpeg4 = 1;
903
        s->h263_pred = 1;
904
        s->unrestricted_mv = 1;
905
        s->msmpeg4_version= 2;
906
        avctx->delay=0;
907
        s->low_delay=1;
908
        break;
909
    case CODEC_ID_MSMPEG4V3:
910
        s->out_format = FMT_H263;
911
        s->h263_msmpeg4 = 1;
912
        s->h263_pred = 1;
913
        s->unrestricted_mv = 1;
914
        s->msmpeg4_version= 3;
915
        s->flipflop_rounding=1;
916
        avctx->delay=0;
917
        s->low_delay=1;
918
        break;
919
    case CODEC_ID_WMV1:
920
        s->out_format = FMT_H263;
921
        s->h263_msmpeg4 = 1;
922
        s->h263_pred = 1;
923
        s->unrestricted_mv = 1;
924
        s->msmpeg4_version= 4;
925
        s->flipflop_rounding=1;
926
        avctx->delay=0;
927
        s->low_delay=1;
928
        break;
929
    case CODEC_ID_WMV2:
930
        s->out_format = FMT_H263;
931
        s->h263_msmpeg4 = 1;
932
        s->h263_pred = 1;
933
        s->unrestricted_mv = 1;
934
        s->msmpeg4_version= 5;
935
        s->flipflop_rounding=1;
936
        avctx->delay=0;
937
        s->low_delay=1;
938
        break;
939
#endif
940
    default:
941
        return -1;
942
    }
943
    
944
    { /* set up some save defaults, some codecs might override them later */
945
        static int done=0;
946
        if(!done){
947
            int i;
948
            done=1;
949

    
950
            default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
951
            memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
952
            memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
953

    
954
            for(i=-16; i<16; i++){
955
                default_fcode_tab[i + MAX_MV]= 1;
956
            }
957
        }
958
    }
959
    s->me.mv_penalty= default_mv_penalty;
960
    s->fcode_tab= default_fcode_tab;
961
 
962
    /* dont use mv_penalty table for crap MV as it would be confused */
963
    //FIXME remove after fixing / removing old ME
964
    if (s->me_method < ME_EPZS) s->me.mv_penalty = default_mv_penalty;
965

    
966
    s->encoding = 1;
967

    
968
    /* init */
969
    if (MPV_common_init(s) < 0)
970
        return -1;
971

    
972
    if(s->modified_quant)
973
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
974
    s->progressive_frame= 
975
    s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
976
    
977
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
978
    
979
    ff_init_me(s);
980

    
981
#ifdef CONFIG_ENCODERS
982
#ifdef CONFIG_RISKY
983
    if (s->out_format == FMT_H263)
984
        h263_encode_init(s);
985
    if(s->msmpeg4_version)
986
        ff_msmpeg4_encode_init(s);
987
#endif
988
    if (s->out_format == FMT_MPEG1)
989
        ff_mpeg1_encode_init(s);
990
#endif
991

    
992
    /* init default q matrix */
993
    for(i=0;i<64;i++) {
994
        int j= s->dsp.idct_permutation[i];
995
#ifdef CONFIG_RISKY
996
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
997
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
998
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
999
        }else if(s->out_format == FMT_H263){
1000
            s->intra_matrix[j] =
1001
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1002
        }else
1003
#endif
1004
        { /* mpeg1/2 */
1005
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1006
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1007
        }
1008
        if(s->avctx->intra_matrix)
1009
            s->intra_matrix[j] = s->avctx->intra_matrix[i];
1010
        if(s->avctx->inter_matrix)
1011
            s->inter_matrix[j] = s->avctx->inter_matrix[i];
1012
    }
1013

    
1014
    /* precompute matrix */
1015
    /* for mjpeg, we do include qscale in the matrix */
1016
    if (s->out_format != FMT_MJPEG) {
1017
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 
1018
                       s->intra_matrix, s->intra_quant_bias, 1, 31);
1019
        convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, 
1020
                       s->inter_matrix, s->inter_quant_bias, 1, 31);
1021
    }
1022

    
1023
    if(ff_rate_control_init(s) < 0)
1024
        return -1;
1025

    
1026
    s->picture_number = 0;
1027
    s->input_picture_number = 0;
1028
    s->picture_in_gop_number = 0;
1029
    s->fake_picture_number = 0;
1030
    /* motion detector init */
1031
    s->f_code = 1;
1032
    s->b_code = 1;
1033

    
1034
    return 0;
1035
}
1036

    
1037
int MPV_encode_end(AVCodecContext *avctx)
1038
{
1039
    MpegEncContext *s = avctx->priv_data;
1040

    
1041
#ifdef STATS
1042
    print_stats();
1043
#endif
1044

    
1045
    ff_rate_control_uninit(s);
1046

    
1047
    MPV_common_end(s);
1048
    if (s->out_format == FMT_MJPEG)
1049
        mjpeg_close(s);
1050

    
1051
    av_freep(&avctx->extradata);
1052
      
1053
    return 0;
1054
}
1055

    
1056
#endif //CONFIG_ENCODERS
1057

    
1058
void init_rl(RLTable *rl)
1059
{
1060
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1061
    uint8_t index_run[MAX_RUN+1];
1062
    int last, run, level, start, end, i;
1063

    
1064
    /* compute max_level[], max_run[] and index_run[] */
1065
    for(last=0;last<2;last++) {
1066
        if (last == 0) {
1067
            start = 0;
1068
            end = rl->last;
1069
        } else {
1070
            start = rl->last;
1071
            end = rl->n;
1072
        }
1073

    
1074
        memset(max_level, 0, MAX_RUN + 1);
1075
        memset(max_run, 0, MAX_LEVEL + 1);
1076
        memset(index_run, rl->n, MAX_RUN + 1);
1077
        for(i=start;i<end;i++) {
1078
            run = rl->table_run[i];
1079
            level = rl->table_level[i];
1080
            if (index_run[run] == rl->n)
1081
                index_run[run] = i;
1082
            if (level > max_level[run])
1083
                max_level[run] = level;
1084
            if (run > max_run[level])
1085
                max_run[level] = run;
1086
        }
1087
        rl->max_level[last] = av_malloc(MAX_RUN + 1);
1088
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1089
        rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1090
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1091
        rl->index_run[last] = av_malloc(MAX_RUN + 1);
1092
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1093
    }
1094
}
1095

    
1096
/* draw the edges of width 'w' of an image of size width, height */
1097
//FIXME check that this is ok for mpeg4 interlaced
1098
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1099
{
1100
    uint8_t *ptr, *last_line;
1101
    int i;
1102

    
1103
    last_line = buf + (height - 1) * wrap;
1104
    for(i=0;i<w;i++) {
1105
        /* top and bottom */
1106
        memcpy(buf - (i + 1) * wrap, buf, width);
1107
        memcpy(last_line + (i + 1) * wrap, last_line, width);
1108
    }
1109
    /* left and right */
1110
    ptr = buf;
1111
    for(i=0;i<height;i++) {
1112
        memset(ptr - w, ptr[0], w);
1113
        memset(ptr + width, ptr[width-1], w);
1114
        ptr += wrap;
1115
    }
1116
    /* corners */
1117
    for(i=0;i<w;i++) {
1118
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1119
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1120
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1121
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1122
    }
1123
}
1124

    
1125
int ff_find_unused_picture(MpegEncContext *s, int shared){
1126
    int i;
1127
    
1128
    if(shared){
1129
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1130
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1131
        }
1132
    }else{
1133
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1134
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1135
        }
1136
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1137
            if(s->picture[i].data[0]==NULL) return i;
1138
        }
1139
    }
1140

    
1141
    assert(0);
1142
    return -1;
1143
}
1144

    
1145
static void update_noise_reduction(MpegEncContext *s){
1146
    int intra, i;
1147

    
1148
    for(intra=0; intra<2; intra++){
1149
        if(s->dct_count[intra] > (1<<16)){
1150
            for(i=0; i<64; i++){
1151
                s->dct_error_sum[intra][i] >>=1;
1152
            }
1153
            s->dct_count[intra] >>= 1;
1154
        }
1155
        
1156
        for(i=0; i<64; i++){
1157
            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);
1158
        }
1159
    }
1160
}
1161

    
1162
/**
1163
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1164
 */
1165
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1166
{
1167
    int i;
1168
    AVFrame *pic;
1169
    s->mb_skiped = 0;
1170

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

    
1173
    /* mark&release old frames */
1174
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr->data[0]) {
1175
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1176

    
1177
        /* release forgotten pictures */
1178
        /* if(mpeg124/h263) */
1179
        if(!s->encoding){
1180
            for(i=0; i<MAX_PICTURE_COUNT; i++){
1181
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1182
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1183
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
1184
                }
1185
            }
1186
        }
1187
    }
1188
alloc:
1189
    if(!s->encoding){
1190
        /* release non refernce frames */
1191
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1192
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1193
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1194
            }
1195
        }
1196

    
1197
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1198
            pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1199
        else{
1200
            i= ff_find_unused_picture(s, 0);
1201
            pic= (AVFrame*)&s->picture[i];
1202
        }
1203

    
1204
        pic->reference= s->pict_type != B_TYPE ? 3 : 0;
1205

    
1206
        pic->coded_picture_number= s->coded_picture_number++;
1207
        
1208
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1209
            return -1;
1210

    
1211
        s->current_picture_ptr= (Picture*)pic;
1212
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1213
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1214
    }
1215

    
1216
    s->current_picture_ptr->pict_type= s->pict_type;
1217
//    if(s->flags && CODEC_FLAG_QSCALE) 
1218
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1219
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1220

    
1221
    copy_picture(&s->current_picture, s->current_picture_ptr);
1222
  
1223
  if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1224
    if (s->pict_type != B_TYPE) {
1225
        s->last_picture_ptr= s->next_picture_ptr;
1226
        s->next_picture_ptr= s->current_picture_ptr;
1227
    }
1228
    
1229
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1230
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1231
    
1232
    if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1233
        av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1234
        assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1235
        goto alloc;
1236
    }
1237

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

    
1240
    if(s->picture_structure!=PICT_FRAME){
1241
        int i;
1242
        for(i=0; i<4; i++){
1243
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1244
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1245
            } 
1246
            s->current_picture.linesize[i] *= 2;
1247
            s->last_picture.linesize[i] *=2;
1248
            s->next_picture.linesize[i] *=2;
1249
        }
1250
    }
1251
  }
1252
   
1253
    s->hurry_up= s->avctx->hurry_up;
1254
    s->error_resilience= avctx->error_resilience;
1255

    
1256
    /* set dequantizer, we cant do it during init as it might change for mpeg4
1257
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1258
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1259
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1260
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1261
    }else if(s->out_format == FMT_H263){
1262
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1263
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1264
    }else{
1265
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1266
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1267
    }
1268

    
1269
    if(s->dct_error_sum){
1270
        assert(s->avctx->noise_reduction && s->encoding);
1271

    
1272
        update_noise_reduction(s);
1273
    }
1274
        
1275
#ifdef HAVE_XVMC
1276
    if(s->avctx->xvmc_acceleration)
1277
        return XVMC_field_start(s, avctx);
1278
#endif
1279
    return 0;
1280
}
1281

    
1282
/* generic function for encode/decode called after a frame has been coded/decoded */
1283
void MPV_frame_end(MpegEncContext *s)
1284
{
1285
    int i;
1286
    /* draw edge for correct motion prediction if outside */
1287
#ifdef HAVE_XVMC
1288
//just to make sure that all data is rendered.
1289
    if(s->avctx->xvmc_acceleration){
1290
        XVMC_field_end(s);
1291
    }else
1292
#endif
1293
    if(s->unrestricted_mv && s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1294
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1295
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1296
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1297
    }
1298
    emms_c();
1299
    
1300
    s->last_pict_type    = s->pict_type;
1301
    if(s->pict_type!=B_TYPE){
1302
        s->last_non_b_pict_type= s->pict_type;
1303
    }
1304
#if 0
1305
        /* copy back current_picture variables */
1306
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1307
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1308
            s->picture[i]= s->current_picture;
1309
            break;
1310
        }    
1311
    }
1312
    assert(i<MAX_PICTURE_COUNT);
1313
#endif    
1314

    
1315
    if(s->encoding){
1316
        /* release non refernce frames */
1317
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1318
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1319
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1320
            }
1321
        }
1322
    }
1323
    // clear copies, to avoid confusion
1324
#if 0
1325
    memset(&s->last_picture, 0, sizeof(Picture));
1326
    memset(&s->next_picture, 0, sizeof(Picture));
1327
    memset(&s->current_picture, 0, sizeof(Picture));
1328
#endif
1329
}
1330

    
1331
/**
1332
 * draws an line from (ex, ey) -> (sx, sy).
1333
 * @param w width of the image
1334
 * @param h height of the image
1335
 * @param stride stride/linesize of the image
1336
 * @param color color of the arrow
1337
 */
1338
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1339
    int t, x, y, f;
1340
    
1341
    sx= clip(sx, 0, w-1);
1342
    sy= clip(sy, 0, h-1);
1343
    ex= clip(ex, 0, w-1);
1344
    ey= clip(ey, 0, h-1);
1345
    
1346
    buf[sy*stride + sx]+= color;
1347
    
1348
    if(ABS(ex - sx) > ABS(ey - sy)){
1349
        if(sx > ex){
1350
            t=sx; sx=ex; ex=t;
1351
            t=sy; sy=ey; ey=t;
1352
        }
1353
        buf+= sx + sy*stride;
1354
        ex-= sx;
1355
        f= ((ey-sy)<<16)/ex;
1356
        for(x= 0; x <= ex; x++){
1357
            y= ((x*f) + (1<<15))>>16;
1358
            buf[y*stride + x]+= color;
1359
        }
1360
    }else{
1361
        if(sy > ey){
1362
            t=sx; sx=ex; ex=t;
1363
            t=sy; sy=ey; ey=t;
1364
        }
1365
        buf+= sx + sy*stride;
1366
        ey-= sy;
1367
        if(ey) f= ((ex-sx)<<16)/ey;
1368
        else   f= 0;
1369
        for(y= 0; y <= ey; y++){
1370
            x= ((y*f) + (1<<15))>>16;
1371
            buf[y*stride + x]+= color;
1372
        }
1373
    }
1374
}
1375

    
1376
/**
1377
 * draws an arrow from (ex, ey) -> (sx, sy).
1378
 * @param w width of the image
1379
 * @param h height of the image
1380
 * @param stride stride/linesize of the image
1381
 * @param color color of the arrow
1382
 */
1383
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1384
    int dx,dy;
1385

    
1386
    sx= clip(sx, -100, w+100);
1387
    sy= clip(sy, -100, h+100);
1388
    ex= clip(ex, -100, w+100);
1389
    ey= clip(ey, -100, h+100);
1390
    
1391
    dx= ex - sx;
1392
    dy= ey - sy;
1393
    
1394
    if(dx*dx + dy*dy > 3*3){
1395
        int rx=  dx + dy;
1396
        int ry= -dx + dy;
1397
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1398
        
1399
        //FIXME subpixel accuracy
1400
        rx= ROUNDED_DIV(rx*3<<4, length);
1401
        ry= ROUNDED_DIV(ry*3<<4, length);
1402
        
1403
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1404
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1405
    }
1406
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1407
}
1408

    
1409
/**
1410
 * prints debuging info for the given picture.
1411
 */
1412
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1413

    
1414
    if(!pict || !pict->mb_type) return;
1415

    
1416
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1417
        int x,y;
1418
        
1419
        av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1420
        switch (pict->pict_type) {
1421
            case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1422
            case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1423
            case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1424
            case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1425
            case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1426
            case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;            
1427
        }
1428
        for(y=0; y<s->mb_height; y++){
1429
            for(x=0; x<s->mb_width; x++){
1430
                if(s->avctx->debug&FF_DEBUG_SKIP){
1431
                    int count= s->mbskip_table[x + y*s->mb_stride];
1432
                    if(count>9) count=9;
1433
                    av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1434
                }
1435
                if(s->avctx->debug&FF_DEBUG_QP){
1436
                    av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1437
                }
1438
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1439
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
1440
                    //Type & MV direction
1441
                    if(IS_PCM(mb_type))
1442
                        av_log(s->avctx, AV_LOG_DEBUG, "P");
1443
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1444
                        av_log(s->avctx, AV_LOG_DEBUG, "A");
1445
                    else if(IS_INTRA4x4(mb_type))
1446
                        av_log(s->avctx, AV_LOG_DEBUG, "i");
1447
                    else if(IS_INTRA16x16(mb_type))
1448
                        av_log(s->avctx, AV_LOG_DEBUG, "I");
1449
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1450
                        av_log(s->avctx, AV_LOG_DEBUG, "d");
1451
                    else if(IS_DIRECT(mb_type))
1452
                        av_log(s->avctx, AV_LOG_DEBUG, "D");
1453
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1454
                        av_log(s->avctx, AV_LOG_DEBUG, "g");
1455
                    else if(IS_GMC(mb_type))
1456
                        av_log(s->avctx, AV_LOG_DEBUG, "G");
1457
                    else if(IS_SKIP(mb_type))
1458
                        av_log(s->avctx, AV_LOG_DEBUG, "S");
1459
                    else if(!USES_LIST(mb_type, 1))
1460
                        av_log(s->avctx, AV_LOG_DEBUG, ">");
1461
                    else if(!USES_LIST(mb_type, 0))
1462
                        av_log(s->avctx, AV_LOG_DEBUG, "<");
1463
                    else{
1464
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1465
                        av_log(s->avctx, AV_LOG_DEBUG, "X");
1466
                    }
1467
                    
1468
                    //segmentation
1469
                    if(IS_8X8(mb_type))
1470
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1471
                    else if(IS_16X8(mb_type))
1472
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1473
                    else if(IS_8X16(mb_type))
1474
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1475
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1476
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1477
                    else
1478
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1479
                    
1480
                        
1481
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1482
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1483
                    else
1484
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1485
                }
1486
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1487
            }
1488
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1489
        }
1490
    }
1491

    
1492
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1493
        const int shift= 1 + s->quarter_sample;
1494
        int mb_y;
1495
        uint8_t *ptr;
1496
        int i;
1497
        int h_chroma_shift, v_chroma_shift;
1498
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1499

    
1500
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1501
        for(i=0; i<3; i++){
1502
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*s->height:pict->linesize[i]*s->height >> v_chroma_shift);
1503
            pict->data[i]= s->visualization_buffer[i];
1504
        }
1505
        pict->type= FF_BUFFER_TYPE_COPY;
1506
        ptr= pict->data[0];
1507

    
1508
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1509
            int mb_x;
1510
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1511
                const int mb_index= mb_x + mb_y*s->mb_stride;
1512
                if((s->avctx->debug_mv) && pict->motion_val){
1513
                  int type;
1514
                  for(type=0; type<3; type++){
1515
                    int direction;
1516
                    switch (type) {
1517
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1518
                                continue;
1519
                              direction = 0;
1520
                              break;
1521
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1522
                                continue;
1523
                              direction = 0;
1524
                              break;
1525
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1526
                                continue;
1527
                              direction = 1;
1528
                              break;
1529
                    }
1530
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1531
                        continue;
1532

    
1533
                    if(IS_8X8(pict->mb_type[mb_index])){
1534
                      int i;
1535
                      for(i=0; i<4; i++){
1536
                        int sx= mb_x*16 + 4 + 8*(i&1);
1537
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1538
                        int xy= 1 + mb_x*2 + (i&1) + (mb_y*2 + 1 + (i>>1))*(s->mb_width*2 + 2);
1539
                        int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1540
                        int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1541
                        draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1542
                      }
1543
                    }else if(IS_16X8(pict->mb_type[mb_index])){
1544
                      int i;
1545
                      for(i=0; i<2; i++){
1546
                        int sx=mb_x*16 + 8;
1547
                        int sy=mb_y*16 + 4 + 8*i;
1548
                        int xy=1 + mb_x*2 + (mb_y*2 + 1 + i)*(s->mb_width*2 + 2);
1549
                        int mx=(pict->motion_val[direction][xy][0]>>shift) + sx;
1550
                        int my=(pict->motion_val[direction][xy][1]>>shift) + sy;
1551
                        draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1552
                      }
1553
                    }else{
1554
                      int sx= mb_x*16 + 8;
1555
                      int sy= mb_y*16 + 8;
1556
                      int xy= 1 + mb_x*2 + (mb_y*2 + 1)*(s->mb_width*2 + 2);
1557
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1558
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1559
                      draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1560
                    }
1561
                  }                  
1562
                }
1563
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1564
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1565
                    int y;
1566
                    for(y=0; y<8; y++){
1567
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1568
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1569
                    }
1570
                }
1571
                if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1572
                    int mb_type= pict->mb_type[mb_index];
1573
                    uint64_t u,v;
1574
                    int y;
1575
#define COLOR(theta, r)\
1576
u= (int)(128 + r*cos(theta*3.141592/180));\
1577
v= (int)(128 + r*sin(theta*3.141592/180));
1578

    
1579
                    
1580
                    u=v=128;
1581
                    if(IS_PCM(mb_type)){
1582
                        COLOR(120,48)
1583
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1584
                        COLOR(30,48)
1585
                    }else if(IS_INTRA4x4(mb_type)){
1586
                        COLOR(90,48)
1587
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1588
//                        COLOR(120,48)
1589
                    }else if(IS_DIRECT(mb_type)){
1590
                        COLOR(150,48)
1591
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1592
                        COLOR(170,48)
1593
                    }else if(IS_GMC(mb_type)){
1594
                        COLOR(190,48)
1595
                    }else if(IS_SKIP(mb_type)){
1596
//                        COLOR(180,48)
1597
                    }else if(!USES_LIST(mb_type, 1)){
1598
                        COLOR(240,48)
1599
                    }else if(!USES_LIST(mb_type, 0)){
1600
                        COLOR(0,48)
1601
                    }else{
1602
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1603
                        COLOR(300,48)
1604
                    }
1605

    
1606
                    u*= 0x0101010101010101ULL;
1607
                    v*= 0x0101010101010101ULL;
1608
                    for(y=0; y<8; y++){
1609
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1610
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1611
                    }
1612

    
1613
                    //segmentation
1614
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1615
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1616
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1617
                    }
1618
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1619
                        for(y=0; y<16; y++)
1620
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1621
                    }
1622
                        
1623
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1624
                        // hmm
1625
                    }
1626
                }
1627
                s->mbskip_table[mb_index]=0;
1628
            }
1629
        }
1630
    }
1631
}
1632

    
1633
#ifdef CONFIG_ENCODERS
1634

    
1635
static int get_sae(uint8_t *src, int ref, int stride){
1636
    int x,y;
1637
    int acc=0;
1638
    
1639
    for(y=0; y<16; y++){
1640
        for(x=0; x<16; x++){
1641
            acc+= ABS(src[x+y*stride] - ref);
1642
        }
1643
    }
1644
    
1645
    return acc;
1646
}
1647

    
1648
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1649
    int x, y, w, h;
1650
    int acc=0;
1651
    
1652
    w= s->width &~15;
1653
    h= s->height&~15;
1654
    
1655
    for(y=0; y<h; y+=16){
1656
        for(x=0; x<w; x+=16){
1657
            int offset= x + y*stride;
1658
            int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1659
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1660
            int sae = get_sae(src + offset, mean, stride);
1661
            
1662
            acc+= sae + 500 < sad;
1663
        }
1664
    }
1665
    return acc;
1666
}
1667

    
1668

    
1669
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1670
    AVFrame *pic=NULL;
1671
    int i;
1672
    const int encoding_delay= s->max_b_frames;
1673
    int direct=1;
1674
    
1675
  if(pic_arg){
1676
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1677
    if(pic_arg->linesize[0] != s->linesize) direct=0;
1678
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1679
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1680
  
1681
//    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1682
    
1683
    if(direct){
1684
        i= ff_find_unused_picture(s, 1);
1685

    
1686
        pic= (AVFrame*)&s->picture[i];
1687
        pic->reference= 3;
1688
    
1689
        for(i=0; i<4; i++){
1690
            pic->data[i]= pic_arg->data[i];
1691
            pic->linesize[i]= pic_arg->linesize[i];
1692
        }
1693
        alloc_picture(s, (Picture*)pic, 1);
1694
    }else{
1695
        int offset= 16;
1696
        i= ff_find_unused_picture(s, 0);
1697

    
1698
        pic= (AVFrame*)&s->picture[i];
1699
        pic->reference= 3;
1700

    
1701
        alloc_picture(s, (Picture*)pic, 0);
1702

    
1703
        if(   pic->data[0] + offset == pic_arg->data[0] 
1704
           && pic->data[1] + offset == pic_arg->data[1]
1705
           && pic->data[2] + offset == pic_arg->data[2]){
1706
       // empty
1707
        }else{
1708
            int h_chroma_shift, v_chroma_shift;
1709
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1710
        
1711
            for(i=0; i<3; i++){
1712
                int src_stride= pic_arg->linesize[i];
1713
                int dst_stride= i ? s->uvlinesize : s->linesize;
1714
                int h_shift= i ? h_chroma_shift : 0;
1715
                int v_shift= i ? v_chroma_shift : 0;
1716
                int w= s->width >>h_shift;
1717
                int h= s->height>>v_shift;
1718
                uint8_t *src= pic_arg->data[i];
1719
                uint8_t *dst= pic->data[i] + offset;
1720
            
1721
                if(src_stride==dst_stride)
1722
                    memcpy(dst, src, src_stride*h);
1723
                else{
1724
                    while(h--){
1725
                        memcpy(dst, src, w);
1726
                        dst += dst_stride;
1727
                        src += src_stride;
1728
                    }
1729
                }
1730
            }
1731
        }
1732
    }
1733
    copy_picture_attributes(pic, pic_arg);
1734
    
1735
    pic->display_picture_number= s->input_picture_number++;
1736
  }
1737

    
1738
    /* shift buffer entries */
1739
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1740
        s->input_picture[i-1]= s->input_picture[i];
1741
        
1742
    s->input_picture[encoding_delay]= (Picture*)pic;
1743

    
1744
    return 0;
1745
}
1746

    
1747
static void select_input_picture(MpegEncContext *s){
1748
    int i;
1749

    
1750
    for(i=1; i<MAX_PICTURE_COUNT; i++)
1751
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1752
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1753

    
1754
    /* set next picture types & ordering */
1755
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1756
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
1757
            s->reordered_input_picture[0]= s->input_picture[0];
1758
            s->reordered_input_picture[0]->pict_type= I_TYPE;
1759
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
1760
        }else{
1761
            int b_frames;
1762
            
1763
            if(s->flags&CODEC_FLAG_PASS2){
1764
                for(i=0; i<s->max_b_frames+1; i++){
1765
                    int pict_num= s->input_picture[0]->display_picture_number + i;
1766
                    int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1767
                    s->input_picture[i]->pict_type= pict_type;
1768
                    
1769
                    if(i + 1 >= s->rc_context.num_entries) break;
1770
                }
1771
            }
1772

    
1773
            if(s->input_picture[0]->pict_type){
1774
                /* user selected pict_type */
1775
                for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
1776
                    if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
1777
                }
1778
            
1779
                if(b_frames > s->max_b_frames){
1780
                    av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
1781
                    b_frames = s->max_b_frames;
1782
                }
1783
            }else if(s->avctx->b_frame_strategy==0){
1784
                b_frames= s->max_b_frames;
1785
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
1786
            }else if(s->avctx->b_frame_strategy==1){
1787
                for(i=1; i<s->max_b_frames+1; i++){
1788
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
1789
                        s->input_picture[i]->b_frame_score= 
1790
                            get_intra_count(s, s->input_picture[i  ]->data[0], 
1791
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
1792
                    }
1793
                }
1794
                for(i=0; i<s->max_b_frames; i++){
1795
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
1796
                }
1797
                                
1798
                b_frames= FFMAX(0, i-1);
1799
                
1800
                /* reset scores */
1801
                for(i=0; i<b_frames+1; i++){
1802
                    s->input_picture[i]->b_frame_score=0;
1803
                }
1804
            }else{
1805
                av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1806
                b_frames=0;
1807
            }
1808

    
1809
            emms_c();
1810
//static int b_count=0;
1811
//b_count+= b_frames;
1812
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
1813
                        
1814
            s->reordered_input_picture[0]= s->input_picture[b_frames];
1815
            if(   s->picture_in_gop_number + b_frames >= s->gop_size 
1816
               || s->reordered_input_picture[0]->pict_type== I_TYPE)
1817
                s->reordered_input_picture[0]->pict_type= I_TYPE;
1818
            else
1819
                s->reordered_input_picture[0]->pict_type= P_TYPE;
1820
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
1821
            for(i=0; i<b_frames; i++){
1822
                s->reordered_input_picture[i+1]= s->input_picture[i];
1823
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
1824
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
1825
            }
1826
        }
1827
    }
1828
    
1829
    if(s->reordered_input_picture[0]){
1830
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
1831

    
1832
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
1833

    
1834
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
1835
            // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
1836
        
1837
            int i= ff_find_unused_picture(s, 0);
1838
            Picture *pic= &s->picture[i];
1839

    
1840
            /* mark us unused / free shared pic */
1841
            for(i=0; i<4; i++)
1842
                s->reordered_input_picture[0]->data[i]= NULL;
1843
            s->reordered_input_picture[0]->type= 0;
1844
            
1845
            copy_picture_attributes((AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
1846
            pic->reference              = s->reordered_input_picture[0]->reference;
1847
            
1848
            alloc_picture(s, pic, 0);
1849

    
1850
            s->current_picture_ptr= pic;
1851
        }else{
1852
            // input is not a shared pix -> reuse buffer for current_pix
1853

    
1854
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
1855
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
1856
            
1857
            s->current_picture_ptr= s->reordered_input_picture[0];
1858
            for(i=0; i<4; i++){
1859
                s->new_picture.data[i]+=16;
1860
            }
1861
        }
1862
        copy_picture(&s->current_picture, s->current_picture_ptr);
1863
    
1864
        s->picture_number= s->new_picture.display_picture_number;
1865
//printf("dpn:%d\n", s->picture_number);
1866
    }else{
1867
       memset(&s->new_picture, 0, sizeof(Picture));
1868
    }
1869
}
1870

    
1871
int MPV_encode_picture(AVCodecContext *avctx,
1872
                       unsigned char *buf, int buf_size, void *data)
1873
{
1874
    MpegEncContext *s = avctx->priv_data;
1875
    AVFrame *pic_arg = data;
1876
    int i, stuffing_count;
1877

    
1878
    if(avctx->pix_fmt != PIX_FMT_YUV420P){
1879
        av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
1880
        return -1;
1881
    }
1882
    
1883
    init_put_bits(&s->pb, buf, buf_size);
1884

    
1885
    s->picture_in_gop_number++;
1886

    
1887
    load_input_picture(s, pic_arg);
1888
    
1889
    select_input_picture(s);
1890
    
1891
    /* output? */
1892
    if(s->new_picture.data[0]){
1893
        s->pict_type= s->new_picture.pict_type;
1894
//emms_c();
1895
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
1896
        MPV_frame_start(s, avctx);
1897

    
1898
        encode_picture(s, s->picture_number);
1899
        
1900
        avctx->real_pict_num  = s->picture_number;
1901
        avctx->header_bits = s->header_bits;
1902
        avctx->mv_bits     = s->mv_bits;
1903
        avctx->misc_bits   = s->misc_bits;
1904
        avctx->i_tex_bits  = s->i_tex_bits;
1905
        avctx->p_tex_bits  = s->p_tex_bits;
1906
        avctx->i_count     = s->i_count;
1907
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
1908
        avctx->skip_count  = s->skip_count;
1909

    
1910
        MPV_frame_end(s);
1911

    
1912
        if (s->out_format == FMT_MJPEG)
1913
            mjpeg_picture_trailer(s);
1914
        
1915
        if(s->flags&CODEC_FLAG_PASS1)
1916
            ff_write_pass1_stats(s);
1917

    
1918
        for(i=0; i<4; i++){
1919
            avctx->error[i] += s->current_picture_ptr->error[i];
1920
        }
1921
    }
1922

    
1923
    flush_put_bits(&s->pb);
1924
    s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1925

    
1926
    stuffing_count= ff_vbv_update(s, s->frame_bits);
1927
    if(stuffing_count){
1928
        switch(s->codec_id){
1929
        case CODEC_ID_MPEG1VIDEO:
1930
        case CODEC_ID_MPEG2VIDEO:
1931
            while(stuffing_count--){
1932
                put_bits(&s->pb, 8, 0);
1933
            }
1934
        break;
1935
        case CODEC_ID_MPEG4:
1936
            put_bits(&s->pb, 16, 0);
1937
            put_bits(&s->pb, 16, 0x1C3);
1938
            stuffing_count -= 4;
1939
            while(stuffing_count--){
1940
                put_bits(&s->pb, 8, 0xFF);
1941
            }
1942
        break;
1943
        default:
1944
            av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1945
        }
1946
        flush_put_bits(&s->pb);
1947
        s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1948
    }
1949

    
1950
    /* update mpeg1/2 vbv_delay for CBR */    
1951
    if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate){
1952
        int vbv_delay;
1953

    
1954
        assert(s->repeat_first_field==0);
1955
        
1956
        vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
1957
        assert(vbv_delay < 0xFFFF);
1958

    
1959
        s->vbv_delay_ptr[0] &= 0xF8;
1960
        s->vbv_delay_ptr[0] |= vbv_delay>>13;
1961
        s->vbv_delay_ptr[1]  = vbv_delay>>5;
1962
        s->vbv_delay_ptr[2] &= 0x07;
1963
        s->vbv_delay_ptr[2] |= vbv_delay<<3;
1964
    }
1965

    
1966
    s->total_bits += s->frame_bits;
1967
    avctx->frame_bits  = s->frame_bits;
1968
    
1969
    return s->frame_bits/8;
1970
}
1971

    
1972
#endif //CONFIG_ENCODERS
1973

    
1974
static inline void gmc1_motion(MpegEncContext *s,
1975
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1976
                               int dest_offset,
1977
                               uint8_t **ref_picture, int src_offset)
1978
{
1979
    uint8_t *ptr;
1980
    int offset, src_x, src_y, linesize, uvlinesize;
1981
    int motion_x, motion_y;
1982
    int emu=0;
1983

    
1984
    motion_x= s->sprite_offset[0][0];
1985
    motion_y= s->sprite_offset[0][1];
1986
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1987
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1988
    motion_x<<=(3-s->sprite_warping_accuracy);
1989
    motion_y<<=(3-s->sprite_warping_accuracy);
1990
    src_x = clip(src_x, -16, s->width);
1991
    if (src_x == s->width)
1992
        motion_x =0;
1993
    src_y = clip(src_y, -16, s->height);
1994
    if (src_y == s->height)
1995
        motion_y =0;
1996

    
1997
    linesize = s->linesize;
1998
    uvlinesize = s->uvlinesize;
1999
    
2000
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
2001

    
2002
    dest_y+=dest_offset;
2003
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2004
        if(   (unsigned)src_x >= s->h_edge_pos - 17
2005
           || (unsigned)src_y >= s->v_edge_pos - 17){
2006
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2007
            ptr= s->edge_emu_buffer;
2008
        }
2009
    }
2010
    
2011
    if((motion_x|motion_y)&7){
2012
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2013
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2014
    }else{
2015
        int dxy;
2016
        
2017
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2018
        if (s->no_rounding){
2019
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2020
        }else{
2021
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2022
        }
2023
    }
2024
    
2025
    if(s->flags&CODEC_FLAG_GRAY) return;
2026

    
2027
    motion_x= s->sprite_offset[1][0];
2028
    motion_y= s->sprite_offset[1][1];
2029
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2030
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2031
    motion_x<<=(3-s->sprite_warping_accuracy);
2032
    motion_y<<=(3-s->sprite_warping_accuracy);
2033
    src_x = clip(src_x, -8, s->width>>1);
2034
    if (src_x == s->width>>1)
2035
        motion_x =0;
2036
    src_y = clip(src_y, -8, s->height>>1);
2037
    if (src_y == s->height>>1)
2038
        motion_y =0;
2039

    
2040
    offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
2041
    ptr = ref_picture[1] + offset;
2042
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2043
        if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2044
           || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2045
            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);
2046
            ptr= s->edge_emu_buffer;
2047
            emu=1;
2048
        }
2049
    }
2050
    s->dsp.gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2051
    
2052
    ptr = ref_picture[2] + offset;
2053
    if(emu){
2054
        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);
2055
        ptr= s->edge_emu_buffer;
2056
    }
2057
    s->dsp.gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2058
    
2059
    return;
2060
}
2061

    
2062
static inline void gmc_motion(MpegEncContext *s,
2063
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2064
                               int dest_offset,
2065
                               uint8_t **ref_picture, int src_offset)
2066
{
2067
    uint8_t *ptr;
2068
    int linesize, uvlinesize;
2069
    const int a= s->sprite_warping_accuracy;
2070
    int ox, oy;
2071

    
2072
    linesize = s->linesize;
2073
    uvlinesize = s->uvlinesize;
2074

    
2075
    ptr = ref_picture[0] + src_offset;
2076

    
2077
    dest_y+=dest_offset;
2078
    
2079
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2080
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2081

    
2082
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2083
           ox, 
2084
           oy, 
2085
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2086
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2087
           a+1, (1<<(2*a+1)) - s->no_rounding,
2088
           s->h_edge_pos, s->v_edge_pos);
2089
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2090
           ox + s->sprite_delta[0][0]*8, 
2091
           oy + s->sprite_delta[1][0]*8, 
2092
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2093
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2094
           a+1, (1<<(2*a+1)) - s->no_rounding,
2095
           s->h_edge_pos, s->v_edge_pos);
2096

    
2097
    if(s->flags&CODEC_FLAG_GRAY) return;
2098

    
2099

    
2100
    dest_cb+=dest_offset>>1;
2101
    dest_cr+=dest_offset>>1;
2102
    
2103
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2104
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2105

    
2106
    ptr = ref_picture[1] + (src_offset>>1);
2107
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2108
           ox, 
2109
           oy, 
2110
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2111
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2112
           a+1, (1<<(2*a+1)) - s->no_rounding,
2113
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2114
    
2115
    ptr = ref_picture[2] + (src_offset>>1);
2116
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2117
           ox, 
2118
           oy, 
2119
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2120
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2121
           a+1, (1<<(2*a+1)) - s->no_rounding,
2122
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2123
}
2124

    
2125
/**
2126
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2127
 * @param buf destination buffer
2128
 * @param src source buffer
2129
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2130
 * @param block_w width of block
2131
 * @param block_h height of block
2132
 * @param src_x x coordinate of the top left sample of the block in the source buffer
2133
 * @param src_y y coordinate of the top left sample of the block in the source buffer
2134
 * @param w width of the source buffer
2135
 * @param h height of the source buffer
2136
 */
2137
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
2138
                                    int src_x, int src_y, int w, int h){
2139
    int x, y;
2140
    int start_y, start_x, end_y, end_x;
2141

    
2142
    if(src_y>= h){
2143
        src+= (h-1-src_y)*linesize;
2144
        src_y=h-1;
2145
    }else if(src_y<=-block_h){
2146
        src+= (1-block_h-src_y)*linesize;
2147
        src_y=1-block_h;
2148
    }
2149
    if(src_x>= w){
2150
        src+= (w-1-src_x);
2151
        src_x=w-1;
2152
    }else if(src_x<=-block_w){
2153
        src+= (1-block_w-src_x);
2154
        src_x=1-block_w;
2155
    }
2156

    
2157
    start_y= FFMAX(0, -src_y);
2158
    start_x= FFMAX(0, -src_x);
2159
    end_y= FFMIN(block_h, h-src_y);
2160
    end_x= FFMIN(block_w, w-src_x);
2161

    
2162
    // copy existing part
2163
    for(y=start_y; y<end_y; y++){
2164
        for(x=start_x; x<end_x; x++){
2165
            buf[x + y*linesize]= src[x + y*linesize];
2166
        }
2167
    }
2168

    
2169
    //top
2170
    for(y=0; y<start_y; y++){
2171
        for(x=start_x; x<end_x; x++){
2172
            buf[x + y*linesize]= buf[x + start_y*linesize];
2173
        }
2174
    }
2175

    
2176
    //bottom
2177
    for(y=end_y; y<block_h; y++){
2178
        for(x=start_x; x<end_x; x++){
2179
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2180
        }
2181
    }
2182
                                    
2183
    for(y=0; y<block_h; y++){
2184
       //left
2185
        for(x=0; x<start_x; x++){
2186
            buf[x + y*linesize]= buf[start_x + y*linesize];
2187
        }
2188
       
2189
       //right
2190
        for(x=end_x; x<block_w; x++){
2191
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2192
        }
2193
    }
2194
}
2195

    
2196
static inline int hpel_motion(MpegEncContext *s, 
2197
                                  uint8_t *dest, uint8_t *src, 
2198
                                  int src_x, int src_y,
2199
                                  int width, int height, int stride,
2200
                                  int h_edge_pos, int v_edge_pos,
2201
                                  int w, int h, op_pixels_func *pix_op,
2202
                                  int motion_x, int motion_y)
2203
{
2204
    int dxy;
2205
    int emu=0;
2206

    
2207
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2208
    src_x += motion_x >> 1;
2209
    src_y += motion_y >> 1;
2210
                
2211
    /* WARNING: do no forget half pels */
2212
    src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2213
    if (src_x == width)
2214
        dxy &= ~1;
2215
    src_y = clip(src_y, -16, height);
2216
    if (src_y == height)
2217
        dxy &= ~2;
2218
    src += src_y * stride + src_x;
2219

    
2220
    if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2221
        if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2222
           || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2223
            ff_emulated_edge_mc(s->edge_emu_buffer, src, stride, w+1, h+1,
2224
                             src_x, src_y, h_edge_pos, v_edge_pos);
2225
            src= s->edge_emu_buffer;
2226
            emu=1;
2227
        }
2228
    }
2229
    pix_op[dxy](dest, src, stride, h);
2230
    return emu;
2231
}
2232

    
2233
/* apply one mpeg motion vector to the three components */
2234
static inline void mpeg_motion(MpegEncContext *s,
2235
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2236
                               int dest_offset,
2237
                               uint8_t **ref_picture, int src_offset,
2238
                               int field_based, op_pixels_func (*pix_op)[4],
2239
                               int motion_x, int motion_y, int h)
2240
{
2241
    uint8_t *ptr;
2242
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, uvlinesize;
2243
    int emu=0;
2244
#if 0    
2245
if(s->quarter_sample)
2246
{
2247
    motion_x>>=1;
2248
    motion_y>>=1;
2249
}
2250
#endif
2251

    
2252
    height = s->height >> field_based;
2253
    v_edge_pos = s->v_edge_pos >> field_based;
2254
    uvlinesize = s->current_picture.linesize[1] << field_based;
2255

    
2256
    emu= hpel_motion(s, 
2257
                dest_y + dest_offset, ref_picture[0] + src_offset,
2258
                s->mb_x * 16, s->mb_y * (16 >> field_based),
2259
                s->width, height, s->current_picture.linesize[0] << field_based,
2260
                s->h_edge_pos, v_edge_pos,
2261
                16, h, pix_op[0],
2262
                motion_x, motion_y);
2263

    
2264

    
2265
    if(s->flags&CODEC_FLAG_GRAY) return;
2266

    
2267
    if (s->out_format == FMT_H263) {
2268
        dxy = 0;
2269
        if ((motion_x & 3) != 0)
2270
            dxy |= 1;
2271
        if ((motion_y & 3) != 0)
2272
            dxy |= 2;
2273
        mx = motion_x >> 2;
2274
        my = motion_y >> 2;
2275
    } else {
2276
        mx = motion_x / 2;
2277
        my = motion_y / 2;
2278
        dxy = ((my & 1) << 1) | (mx & 1);
2279
        mx >>= 1;
2280
        my >>= 1;
2281
    }
2282
    
2283
    src_x = s->mb_x * 8 + mx;
2284
    src_y = s->mb_y * (8 >> field_based) + my;
2285
    src_x = clip(src_x, -8, s->width >> 1);
2286
    if (src_x == (s->width >> 1))
2287
        dxy &= ~1;
2288
    src_y = clip(src_y, -8, height >> 1);
2289
    if (src_y == (height >> 1))
2290
        dxy &= ~2;
2291
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
2292
    ptr = ref_picture[1] + offset;
2293
    if(emu){
2294
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
2295
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2296
        ptr= s->edge_emu_buffer + (src_offset >> 1);
2297
    }
2298
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
2299

    
2300
    ptr = ref_picture[2] + offset;
2301
    if(emu){
2302
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
2303
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2304
        ptr= s->edge_emu_buffer + (src_offset >> 1);
2305
    }
2306
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
2307
}
2308
//FIXME move to dsputil, avg variant, 16x16 version
2309
static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2310
    int x;
2311
    uint8_t * const top   = src[1];
2312
    uint8_t * const left  = src[2];
2313
    uint8_t * const mid   = src[0];
2314
    uint8_t * const right = src[3];
2315
    uint8_t * const bottom= src[4];
2316
#define OBMC_FILTER(x, t, l, m, r, b)\
2317
    dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2318
#define OBMC_FILTER4(x, t, l, m, r, b)\
2319
    OBMC_FILTER(x         , t, l, m, r, b);\
2320
    OBMC_FILTER(x+1       , t, l, m, r, b);\
2321
    OBMC_FILTER(x  +stride, t, l, m, r, b);\
2322
    OBMC_FILTER(x+1+stride, t, l, m, r, b);
2323
    
2324
    x=0;
2325
    OBMC_FILTER (x  , 2, 2, 4, 0, 0);
2326
    OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2327
    OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2328
    OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2329
    OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2330
    OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2331
    x+= stride;
2332
    OBMC_FILTER (x  , 1, 2, 5, 0, 0);
2333
    OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2334
    OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2335
    OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2336
    x+= stride;
2337
    OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
2338
    OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2339
    OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2340
    OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2341
    x+= 2*stride;
2342
    OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
2343
    OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2344
    OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2345
    OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2346
    x+= 2*stride;
2347
    OBMC_FILTER (x  , 0, 2, 5, 0, 1);
2348
    OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2349
    OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2350
    OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2351
    OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2352
    OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2353
    x+= stride;
2354
    OBMC_FILTER (x  , 0, 2, 4, 0, 2);
2355
    OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2356
    OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2357
    OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2358
}
2359

    
2360
/* obmc for 1 8x8 luma block */
2361
static inline void obmc_motion(MpegEncContext *s,
2362
                               uint8_t *dest, uint8_t *src,
2363
                               int src_x, int src_y,
2364
                               op_pixels_func *pix_op,
2365
                               int16_t mv[5][2]/* mid top left right bottom*/)
2366
#define MID    0
2367
{
2368
    int i;
2369
    uint8_t *ptr[5];
2370
    
2371
    assert(s->quarter_sample==0);
2372
    
2373
    for(i=0; i<5; i++){
2374
        if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2375
            ptr[i]= ptr[MID];
2376
        }else{
2377
            ptr[i]= s->edge_emu_buffer + 16 + 8*(i&1) + s->linesize*8*(i>>1);
2378
            hpel_motion(s, ptr[i], src,
2379
                        src_x, src_y,
2380
                        s->width, s->height, s->linesize,
2381
                        s->h_edge_pos, s->v_edge_pos,
2382
                        8, 8, pix_op,
2383
                        mv[i][0], mv[i][1]);
2384
        }
2385
    }
2386

    
2387
    put_obmc(dest, ptr, s->linesize);                
2388
}
2389

    
2390
static inline void qpel_motion(MpegEncContext *s,
2391
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2392
                               int dest_offset,
2393
                               uint8_t **ref_picture, int src_offset,
2394
                               int field_based, op_pixels_func (*pix_op)[4],
2395
                               qpel_mc_func (*qpix_op)[16],
2396
                               int motion_x, int motion_y, int h)
2397
{
2398
    uint8_t *ptr;
2399
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
2400
    int emu=0;
2401

    
2402
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2403
    src_x = s->mb_x * 16 + (motion_x >> 2);
2404
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2405

    
2406
    height = s->height >> field_based;
2407
    v_edge_pos = s->v_edge_pos >> field_based;
2408
    src_x = clip(src_x, -16, s->width);
2409
    if (src_x == s->width)
2410
        dxy &= ~3;
2411
    src_y = clip(src_y, -16, height);
2412
    if (src_y == height)
2413
        dxy &= ~12;
2414
    linesize = s->linesize << field_based;
2415
    uvlinesize = s->uvlinesize << field_based;
2416
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
2417
    dest_y += dest_offset;
2418
//printf("%d %d %d\n", src_x, src_y, dxy);
2419
    
2420
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2421
        if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 
2422
           || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
2423
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr - src_offset, s->linesize, 17, 17+field_based, 
2424
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2425
            ptr= s->edge_emu_buffer + src_offset;
2426
            emu=1;
2427
        }
2428
    }
2429
    if(!field_based)
2430
        qpix_op[0][dxy](dest_y, ptr, linesize);
2431
    else{
2432
        //damn interlaced mode
2433
        //FIXME boundary mirroring is not exactly correct here
2434
        qpix_op[1][dxy](dest_y  , ptr  , linesize);
2435
        qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
2436
    }
2437

    
2438
    if(s->flags&CODEC_FLAG_GRAY) return;
2439

    
2440
    if(field_based){
2441
        mx= motion_x/2;
2442
        my= motion_y>>1;
2443
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2444
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
2445
        mx= (motion_x>>1) + rtab[motion_x&7];
2446
        my= (motion_y>>1) + rtab[motion_y&7];
2447
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2448
        mx= (motion_x>>1)|(motion_x&1);
2449
        my= (motion_y>>1)|(motion_y&1);
2450
    }else{
2451
        mx= motion_x/2;
2452
        my= motion_y/2;
2453
    }
2454
    mx= (mx>>1)|(mx&1);
2455
    my= (my>>1)|(my&1);
2456

    
2457
    dxy= (mx&1) | ((my&1)<<1);
2458
    mx>>=1;
2459
    my>>=1;
2460

    
2461
    src_x = s->mb_x * 8 + mx;
2462
    src_y = s->mb_y * (8 >> field_based) + my;
2463
    src_x = clip(src_x, -8, s->width >> 1);
2464
    if (src_x == (s->width >> 1))
2465
        dxy &= ~1;
2466
    src_y = clip(src_y, -8, height >> 1);
2467
    if (src_y == (height >> 1))
2468
        dxy &= ~2;
2469

    
2470
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
2471
    ptr = ref_picture[1] + offset;
2472
    if(emu){
2473
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
2474
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2475
        ptr= s->edge_emu_buffer + (src_offset >> 1);
2476
    }
2477
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
2478
    
2479
    ptr = ref_picture[2] + offset;
2480
    if(emu){
2481
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
2482
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2483
        ptr= s->edge_emu_buffer + (src_offset >> 1);
2484
    }
2485
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
2486
}
2487

    
2488
inline int ff_h263_round_chroma(int x){
2489
    if (x >= 0)
2490
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2491
    else {
2492
        x = -x;
2493
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2494
    }
2495
}
2496

    
2497
/**
2498
 * h263 chorma 4mv motion compensation.
2499
 */
2500
static inline void chroma_4mv_motion(MpegEncContext *s,
2501
                                     uint8_t *dest_cb, uint8_t *dest_cr,
2502
                                     uint8_t **ref_picture,
2503
                                     op_pixels_func *pix_op,
2504
                                     int mx, int my){
2505
    int dxy, emu=0, src_x, src_y, offset;
2506
    uint8_t *ptr;
2507
    
2508
    /* In case of 8X8, we construct a single chroma motion vector
2509
       with a special rounding */
2510
    mx= ff_h263_round_chroma(mx);
2511
    my= ff_h263_round_chroma(my);
2512
    
2513
    dxy = ((my & 1) << 1) | (mx & 1);
2514
    mx >>= 1;
2515
    my >>= 1;
2516

    
2517
    src_x = s->mb_x * 8 + mx;
2518
    src_y = s->mb_y * 8 + my;
2519
    src_x = clip(src_x, -8, s->width/2);
2520
    if (src_x == s->width/2)
2521
        dxy &= ~1;
2522
    src_y = clip(src_y, -8, s->height/2);
2523
    if (src_y == s->height/2)
2524
        dxy &= ~2;
2525
    
2526
    offset = (src_y * (s->uvlinesize)) + src_x;
2527
    ptr = ref_picture[1] + offset;
2528
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2529
        if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
2530
           || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
2531
            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);
2532
            ptr= s->edge_emu_buffer;
2533
            emu=1;
2534
        }
2535
    }
2536
    pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
2537

    
2538
    ptr = ref_picture[2] + offset;
2539
    if(emu){
2540
        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);
2541
        ptr= s->edge_emu_buffer;
2542
    }
2543
    pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
2544
}
2545

    
2546
/**
2547
 * motion compesation of a single macroblock
2548
 * @param s context
2549
 * @param dest_y luma destination pointer
2550
 * @param dest_cb chroma cb/u destination pointer
2551
 * @param dest_cr chroma cr/v destination pointer
2552
 * @param dir direction (0->forward, 1->backward)
2553
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2554
 * @param pic_op halfpel motion compensation function (average or put normally)
2555
 * @param pic_op qpel motion compensation function (average or put normally)
2556
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2557
 */
2558
static inline void MPV_motion(MpegEncContext *s, 
2559
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2560
                              int dir, uint8_t **ref_picture, 
2561
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
2562
{
2563
    int dxy, mx, my, src_x, src_y, motion_x, motion_y;
2564
    int mb_x, mb_y, i;
2565
    uint8_t *ptr, *dest;
2566

    
2567
    mb_x = s->mb_x;
2568
    mb_y = s->mb_y;
2569

    
2570
    if(s->obmc && s->pict_type != B_TYPE){
2571
        int16_t mv_cache[4][4][2];
2572
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
2573
        const int mot_stride= s->mb_width*2 + 2;
2574
        const int mot_xy= 1 + mb_x*2 + (mb_y*2 + 1)*mot_stride;
2575

    
2576
        assert(!s->mb_skiped);
2577
                
2578
        memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
2579
        memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2580
        memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2581

    
2582
        if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
2583
            memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
2584
        }else{
2585
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
2586
        }
2587

    
2588
        if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
2589
            *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
2590
            *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
2591
        }else{
2592
            *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
2593
            *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
2594
        }
2595

    
2596
        if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
2597
            *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
2598
            *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
2599
        }else{
2600
            *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
2601
            *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
2602
        }
2603
        
2604
        mx = 0;
2605
        my = 0;
2606
        for(i=0;i<4;i++) {
2607
            const int x= (i&1)+1;
2608
            const int y= (i>>1)+1;
2609
            int16_t mv[5][2]= {
2610
                {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
2611
                {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
2612
                {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
2613
                {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
2614
                {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
2615
            //FIXME cleanup
2616
            obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2617
                        ref_picture[0],
2618
                        mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2619
                        pix_op[1],
2620
                        mv);
2621

    
2622
            mx += mv[0][0];
2623
            my += mv[0][1];
2624
        }
2625
        if(!(s->flags&CODEC_FLAG_GRAY))
2626
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2627

    
2628
        return;
2629
    }
2630
   
2631
    switch(s->mv_type) {
2632
    case MV_TYPE_16X16:
2633
#ifdef CONFIG_RISKY
2634
        if(s->mcsel){
2635
            if(s->real_sprite_warping_points==1){
2636
                gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
2637
                            ref_picture, 0);
2638
            }else{
2639
                gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
2640
                            ref_picture, 0);
2641
            }
2642
        }else if(s->quarter_sample){
2643
            qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2644
                        ref_picture, 0,
2645
                        0, pix_op, qpix_op,
2646
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2647
        }else if(s->mspel){
2648
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
2649
                        ref_picture, pix_op,
2650
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2651
        }else
2652
#endif
2653
        {
2654
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2655
                        ref_picture, 0,
2656
                        0, pix_op,
2657
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2658
        }           
2659
        break;
2660
    case MV_TYPE_8X8:
2661
        mx = 0;
2662
        my = 0;
2663
        if(s->quarter_sample){
2664
            for(i=0;i<4;i++) {
2665
                motion_x = s->mv[dir][i][0];
2666
                motion_y = s->mv[dir][i][1];
2667

    
2668
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2669
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
2670
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
2671
                    
2672
                /* WARNING: do no forget half pels */
2673
                src_x = clip(src_x, -16, s->width);
2674
                if (src_x == s->width)
2675
                    dxy &= ~3;
2676
                src_y = clip(src_y, -16, s->height);
2677
                if (src_y == s->height)
2678
                    dxy &= ~12;
2679
                    
2680
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2681
                if(s->flags&CODEC_FLAG_EMU_EDGE){
2682
                    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8 
2683
                       || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
2684
                        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);
2685
                        ptr= s->edge_emu_buffer;
2686
                    }
2687
                }
2688
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2689
                qpix_op[1][dxy](dest, ptr, s->linesize);
2690

    
2691
                mx += s->mv[dir][i][0]/2;
2692
                my += s->mv[dir][i][1]/2;
2693
            }
2694
        }else{
2695
            for(i=0;i<4;i++) {
2696
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2697
                            ref_picture[0],
2698
                            mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2699
                            s->width, s->height, s->linesize,
2700
                            s->h_edge_pos, s->v_edge_pos,
2701
                            8, 8, pix_op[1],
2702
                            s->mv[dir][i][0], s->mv[dir][i][1]);
2703

    
2704
                mx += s->mv[dir][i][0];
2705
                my += s->mv[dir][i][1];
2706
            }
2707
        }
2708

    
2709
        if(!(s->flags&CODEC_FLAG_GRAY))
2710
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2711
        break;
2712
    case MV_TYPE_FIELD:
2713
        if (s->picture_structure == PICT_FRAME) {
2714
            if(s->quarter_sample){
2715
                /* top field */
2716
                qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2717
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2718
                            1, pix_op, qpix_op,
2719
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
2720
                /* bottom field */
2721
                qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2722
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2723
                            1, pix_op, qpix_op,
2724
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
2725
            }else{
2726
                /* top field */       
2727
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2728
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2729
                            1, pix_op,
2730
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
2731
                /* bottom field */
2732
                mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2733
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2734
                            1, pix_op,
2735
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
2736
            }
2737
        } else {
2738
            int offset;
2739
            if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2740
                offset= s->field_select[dir][0] ? s->linesize : 0;
2741
            }else{
2742
                ref_picture= s->current_picture.data;
2743
                offset= s->field_select[dir][0] ? s->linesize : -s->linesize; 
2744
            } 
2745

    
2746
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2747
                        ref_picture, offset,
2748
                        0, pix_op,
2749
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2750
        }
2751
        break;
2752
    case MV_TYPE_16X8:{
2753
        int offset;
2754
         uint8_t ** ref2picture;
2755

    
2756
            if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2757
                ref2picture= ref_picture;
2758
                offset= s->field_select[dir][0] ? s->linesize : 0;
2759
            }else{
2760
                ref2picture= s->current_picture.data;
2761
                offset= s->field_select[dir][0] ? s->linesize : -s->linesize; 
2762
            } 
2763

    
2764
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2765
                        ref2picture, offset,
2766
                        0, pix_op,
2767
                        s->mv[dir][0][0], s->mv[dir][0][1], 8);
2768

    
2769

    
2770
            if(s->picture_structure == s->field_select[dir][1] + 1 || s->pict_type == B_TYPE || s->first_field){
2771
                ref2picture= ref_picture;
2772
                offset= s->field_select[dir][1] ? s->linesize : 0;
2773
            }else{
2774
                ref2picture= s->current_picture.data;
2775
                offset= s->field_select[dir][1] ? s->linesize : -s->linesize; 
2776
            } 
2777
            // I know it is ugly but this is the only way to fool emu_edge without rewrite mpeg_motion
2778
            mpeg_motion(s, dest_y+16*s->linesize, dest_cb+8*s->uvlinesize, dest_cr+8*s->uvlinesize,
2779
                        0,
2780
                        ref2picture, offset,
2781
                        0, pix_op,
2782
                        s->mv[dir][1][0], s->mv[dir][1][1]+16, 8);
2783
        }
2784
        
2785
        break;
2786
    case MV_TYPE_DMV:
2787
    {
2788
    op_pixels_func (*dmv_pix_op)[4];
2789
    int offset;
2790

    
2791
        dmv_pix_op = s->dsp.put_pixels_tab;
2792

    
2793
        if(s->picture_structure == PICT_FRAME){
2794
            //put top field from top field
2795
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2796
                        ref_picture, 0,
2797
                        1, dmv_pix_op,
2798
                        s->mv[dir][0][0], s->mv[dir][0][1], 8);
2799
            //put bottom field from bottom field
2800
            mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2801
                        ref_picture, s->linesize,
2802
                        1, dmv_pix_op,
2803
                        s->mv[dir][0][0], s->mv[dir][0][1], 8);
2804

    
2805
            dmv_pix_op = s->dsp.avg_pixels_tab; 
2806
        
2807
            //avg top field from bottom field
2808
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2809
                        ref_picture, s->linesize,
2810
                        1, dmv_pix_op,
2811
                        s->mv[dir][2][0], s->mv[dir][2][1], 8);
2812
            //avg bottom field from top field
2813
            mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2814
                        ref_picture, 0,
2815
                        1, dmv_pix_op,
2816
                        s->mv[dir][3][0], s->mv[dir][3][1], 8);
2817

    
2818
        }else{
2819
            offset=(s->picture_structure == PICT_BOTTOM_FIELD)? 
2820
                         s->linesize : 0;
2821

    
2822
            //put field from the same parity
2823
            //same parity is never in the same frame
2824
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2825
                        ref_picture,offset,
2826
                        0,dmv_pix_op,
2827
                        s->mv[dir][0][0],s->mv[dir][0][1],16);
2828

    
2829
            // after put we make avg of the same block
2830
            dmv_pix_op=s->dsp.avg_pixels_tab; 
2831

    
2832
            //opposite parity is always in the same frame if this is second field
2833
            if(!s->first_field){
2834
                ref_picture = s->current_picture.data;    
2835
                //top field is one linesize from frame beginig
2836
                offset=(s->picture_structure == PICT_BOTTOM_FIELD)? 
2837
                        -s->linesize : s->linesize;
2838
            }else 
2839
                offset=(s->picture_structure == PICT_BOTTOM_FIELD)? 
2840
                        0 : s->linesize;
2841

    
2842
            //avg field from the opposite parity
2843
            mpeg_motion(s, dest_y, dest_cb, dest_cr,0,
2844
                        ref_picture, offset,
2845
                        0,dmv_pix_op,
2846
                        s->mv[dir][2][0],s->mv[dir][2][1],16);
2847
        }
2848
    }
2849
    break;
2850
    default: assert(0);
2851
    }
2852
}
2853

    
2854

    
2855
/* put block[] to dest[] */
2856
static inline void put_dct(MpegEncContext *s, 
2857
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2858
{
2859
    s->dct_unquantize_intra(s, block, i, qscale);
2860
    s->dsp.idct_put (dest, line_size, block);
2861
}
2862

    
2863
/* add block[] to dest[] */
2864
static inline void add_dct(MpegEncContext *s, 
2865
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
2866
{
2867
    if (s->block_last_index[i] >= 0) {
2868
        s->dsp.idct_add (dest, line_size, block);
2869
    }
2870
}
2871

    
2872
static inline void add_dequant_dct(MpegEncContext *s, 
2873
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2874
{
2875
    if (s->block_last_index[i] >= 0) {
2876
        s->dct_unquantize_inter(s, block, i, qscale);
2877

    
2878
        s->dsp.idct_add (dest, line_size, block);
2879
    }
2880
}
2881

    
2882
/**
2883
 * cleans dc, ac, coded_block for the current non intra MB
2884
 */
2885
void ff_clean_intra_table_entries(MpegEncContext *s)
2886
{
2887
    int wrap = s->block_wrap[0];
2888
    int xy = s->block_index[0];
2889
    
2890
    s->dc_val[0][xy           ] = 
2891
    s->dc_val[0][xy + 1       ] = 
2892
    s->dc_val[0][xy     + wrap] =
2893
    s->dc_val[0][xy + 1 + wrap] = 1024;
2894
    /* ac pred */
2895
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2896
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2897
    if (s->msmpeg4_version>=3) {
2898
        s->coded_block[xy           ] =
2899
        s->coded_block[xy + 1       ] =
2900
        s->coded_block[xy     + wrap] =
2901
        s->coded_block[xy + 1 + wrap] = 0;
2902
    }
2903
    /* chroma */
2904
    wrap = s->block_wrap[4];
2905
    xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
2906
    s->dc_val[1][xy] =
2907
    s->dc_val[2][xy] = 1024;
2908
    /* ac pred */
2909
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2910
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2911
    
2912
    s->mbintra_table[s->mb_x + s->mb_y*s->mb_stride]= 0;
2913
}
2914

    
2915
/* generic function called after a macroblock has been parsed by the
2916
   decoder or after it has been encoded by the encoder.
2917

2918
   Important variables used:
2919
   s->mb_intra : true if intra macroblock
2920
   s->mv_dir   : motion vector direction
2921
   s->mv_type  : motion vector type
2922
   s->mv       : motion vector
2923
   s->interlaced_dct : true if interlaced dct used (mpeg2)
2924
 */
2925
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
2926
{
2927
    int mb_x, mb_y;
2928
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2929
#ifdef HAVE_XVMC
2930
    if(s->avctx->xvmc_acceleration){
2931
        XVMC_decode_mb(s);//xvmc uses pblocks
2932
        return;
2933
    }
2934
#endif
2935

    
2936
    mb_x = s->mb_x;
2937
    mb_y = s->mb_y;
2938

    
2939
    s->current_picture.qscale_table[mb_xy]= s->qscale;
2940

    
2941
    /* update DC predictors for P macroblocks */
2942
    if (!s->mb_intra) {
2943
        if (s->h263_pred || s->h263_aic) {
2944
            if(s->mbintra_table[mb_xy])
2945
                ff_clean_intra_table_entries(s);
2946
        } else {
2947
            s->last_dc[0] =
2948
            s->last_dc[1] =
2949
            s->last_dc[2] = 128 << s->intra_dc_precision;
2950
        }
2951
    }
2952
    else if (s->h263_pred || s->h263_aic)
2953
        s->mbintra_table[mb_xy]=1;
2954

    
2955
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
2956
        uint8_t *dest_y, *dest_cb, *dest_cr;
2957
        int dct_linesize, dct_offset;
2958
        op_pixels_func (*op_pix)[4];
2959
        qpel_mc_func (*op_qpix)[16];
2960
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
2961
        const int uvlinesize= s->current_picture.linesize[1];
2962
        const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band;
2963

    
2964
        /* avoid copy if macroblock skipped in last frame too */
2965
        /* skip only during decoding as we might trash the buffers during encoding a bit */
2966
        if(!s->encoding){
2967
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2968
            const int age= s->current_picture.age;
2969

    
2970
            assert(age);
2971

    
2972
            if (s->mb_skiped) {
2973
                s->mb_skiped= 0;
2974
                assert(s->pict_type!=I_TYPE);
2975
 
2976
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
2977
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2978

    
2979
                /* if previous was skipped too, then nothing to do !  */
2980
                if (*mbskip_ptr >= age && s->current_picture.reference){
2981
                    return;
2982
                }
2983
            } else if(!s->current_picture.reference){
2984
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2985
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2986
            } else{
2987
                *mbskip_ptr = 0; /* not skipped */
2988
            }
2989
        }
2990

    
2991
        if (s->interlaced_dct) {
2992
            dct_linesize = linesize * 2;
2993
            dct_offset = linesize;
2994
        } else {
2995
            dct_linesize = linesize;
2996
            dct_offset = linesize * 8;
2997
        }
2998
        if(readable){
2999
            dest_y=  s->dest[0];
3000
            dest_cb= s->dest[1];
3001
            dest_cr= s->dest[2];
3002
        }else{
3003
            dest_y = s->edge_emu_buffer+32; //FIXME cleanup scratchpad pointers
3004
            dest_cb= s->edge_emu_buffer+48;
3005
            dest_cr= s->edge_emu_buffer+56;
3006
        }
3007
        if (!s->mb_intra) {
3008
            /* motion handling */
3009
            /* decoding or more than one mb_type (MC was allready done otherwise) */
3010
            if(!s->encoding){
3011
                if ((!s->no_rounding) || s->pict_type==B_TYPE){                
3012
                    op_pix = s->dsp.put_pixels_tab;
3013
                    op_qpix= s->dsp.put_qpel_pixels_tab;
3014
                }else{
3015
                    op_pix = s->dsp.put_no_rnd_pixels_tab;
3016
                    op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3017
                }
3018

    
3019
                if (s->mv_dir & MV_DIR_FORWARD) {
3020
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3021
                    op_pix = s->dsp.avg_pixels_tab;
3022
                    op_qpix= s->dsp.avg_qpel_pixels_tab;
3023
                }
3024
                if (s->mv_dir & MV_DIR_BACKWARD) {
3025
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3026
                }
3027
            }
3028

    
3029
            /* skip dequant / idct if we are really late ;) */
3030
            if(s->hurry_up>1) return;
3031

    
3032
            /* add dct residue */
3033
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3034
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3035
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
3036
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
3037
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
3038
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
3039

    
3040
                if(!(s->flags&CODEC_FLAG_GRAY)){
3041
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3042
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3043
                }
3044
            } else if(s->codec_id != CODEC_ID_WMV2){
3045
                add_dct(s, block[0], 0, dest_y, dct_linesize);
3046
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
3047
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
3048
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
3049

    
3050
                if(!(s->flags&CODEC_FLAG_GRAY)){
3051
                    add_dct(s, block[4], 4, dest_cb, uvlinesize);
3052
                    add_dct(s, block[5], 5, dest_cr, uvlinesize);
3053
                }
3054
            } 
3055
#ifdef CONFIG_RISKY
3056
            else{
3057
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3058
            }
3059
#endif
3060
        } else {
3061
            /* dct only in intra block */
3062
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3063
                put_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
3064
                put_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
3065
                put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
3066
                put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
3067

    
3068
                if(!(s->flags&CODEC_FLAG_GRAY)){
3069
                    put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3070
                    put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3071
                }
3072
            }else{
3073
                s->dsp.idct_put(dest_y                 , dct_linesize, block[0]);
3074
                s->dsp.idct_put(dest_y              + 8, dct_linesize, block[1]);
3075
                s->dsp.idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
3076
                s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
3077

    
3078
                if(!(s->flags&CODEC_FLAG_GRAY)){
3079
                    s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3080
                    s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3081
                }
3082
            }
3083
        }
3084
        if(!readable){
3085
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3086
            s->dsp.put_pixels_tab[1][0](s->dest[1], dest_cb, uvlinesize, 8);
3087
            s->dsp.put_pixels_tab[1][0](s->dest[2], dest_cr, uvlinesize, 8);
3088
        }
3089
    }
3090
}
3091

    
3092
#ifdef CONFIG_ENCODERS
3093

    
3094
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3095
{
3096
    static const char tab[64]=
3097
        {3,2,2,1,1,1,1,1,
3098
         1,1,1,1,1,1,1,1,
3099
         1,1,1,1,1,1,1,1,
3100
         0,0,0,0,0,0,0,0,
3101
         0,0,0,0,0,0,0,0,
3102
         0,0,0,0,0,0,0,0,
3103
         0,0,0,0,0,0,0,0,
3104
         0,0,0,0,0,0,0,0};
3105
    int score=0;
3106
    int run=0;
3107
    int i;
3108
    DCTELEM *block= s->block[n];
3109
    const int last_index= s->block_last_index[n];
3110
    int skip_dc;
3111

    
3112
    if(threshold<0){
3113
        skip_dc=0;
3114
        threshold= -threshold;
3115
    }else
3116
        skip_dc=1;
3117

    
3118
    /* are all which we could set to zero are allready zero? */
3119
    if(last_index<=skip_dc - 1) return;
3120

    
3121
    for(i=0; i<=last_index; i++){
3122
        const int j = s->intra_scantable.permutated[i];
3123
        const int level = ABS(block[j]);
3124
        if(level==1){
3125
            if(skip_dc && i==0) continue;
3126
            score+= tab[run];
3127
            run=0;
3128
        }else if(level>1){
3129
            return;
3130
        }else{
3131
            run++;
3132
        }
3133
    }
3134
    if(score >= threshold) return;
3135
    for(i=skip_dc; i<=last_index; i++){
3136
        const int j = s->intra_scantable.permutated[i];
3137
        block[j]=0;
3138
    }
3139
    if(block[0]) s->block_last_index[n]= 0;
3140
    else         s->block_last_index[n]= -1;
3141
}
3142

    
3143
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
3144
{
3145
    int i;
3146
    const int maxlevel= s->max_qcoeff;
3147
    const int minlevel= s->min_qcoeff;
3148
    int overflow=0;
3149
    
3150
    if(s->mb_intra){
3151
        i=1; //skip clipping of intra dc
3152
    }else
3153
        i=0;
3154
    
3155
    for(;i<=last_index; i++){
3156
        const int j= s->intra_scantable.permutated[i];
3157
        int level = block[j];
3158
       
3159
        if     (level>maxlevel){
3160
            level=maxlevel;
3161
            overflow++;
3162
        }else if(level<minlevel){
3163
            level=minlevel;
3164
            overflow++;
3165
        }
3166
        
3167
        block[j]= level;
3168
    }
3169
    
3170
    if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
3171
        av_log(s->avctx, AV_LOG_INFO, "warning, cliping %d dct coefficents to %d..%d\n", overflow, minlevel, maxlevel);
3172
}
3173

    
3174
#endif //CONFIG_ENCODERS
3175

    
3176
/**
3177
 *
3178
 * @param h is the normal height, this will be reduced automatically if needed for the last row
3179
 */
3180
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3181
    if (s->avctx->draw_horiz_band) {
3182
        AVFrame *src;
3183
        int offset[4];
3184
        
3185
        if(s->picture_structure != PICT_FRAME){
3186
            h <<= 1;
3187
            y <<= 1;
3188
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3189
        }
3190

    
3191
        h= FFMIN(h, s->height - y);
3192

    
3193
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) 
3194
            src= (AVFrame*)s->current_picture_ptr;
3195
        else if(s->last_picture_ptr)
3196
            src= (AVFrame*)s->last_picture_ptr;
3197
        else
3198
            return;
3199
            
3200
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3201
            offset[0]=
3202
            offset[1]=
3203
            offset[2]=
3204
            offset[3]= 0;
3205
        }else{
3206
            offset[0]= y * s->linesize;;
3207
            offset[1]= 
3208
            offset[2]= (y>>1) * s->uvlinesize;;
3209
            offset[3]= 0;
3210
        }
3211

    
3212
        emms_c();
3213

    
3214
        s->avctx->draw_horiz_band(s->avctx, src, offset,
3215
                                  y, s->picture_structure, h);
3216
    }
3217
}
3218

    
3219
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3220
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3221
    const int uvlinesize= s->current_picture.linesize[1];
3222
        
3223
    s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3224
    s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1)     + s->mb_x*2;
3225
    s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1 + s->mb_x*2;
3226
    s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2)     + s->mb_x*2;
3227
    s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
3228
    s->block_index[5]= s->block_wrap[4]*(s->mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
3229
    
3230
    if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){
3231
        s->dest[0] = s->current_picture.data[0] + s->mb_x * 16 - 16;
3232
        s->dest[1] = s->current_picture.data[1] + s->mb_x * 8 - 8;
3233
        s->dest[2] = s->current_picture.data[2] + s->mb_x * 8 - 8;
3234
    }else{
3235
        s->dest[0] = s->current_picture.data[0] + (s->mb_y * 16* linesize  ) + s->mb_x * 16 - 16;
3236
        s->dest[1] = s->current_picture.data[1] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
3237
        s->dest[2] = s->current_picture.data[2] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
3238
    }    
3239
}
3240

    
3241
#ifdef CONFIG_ENCODERS
3242

    
3243
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
3244
{
3245
    const int mb_x= s->mb_x;
3246
    const int mb_y= s->mb_y;
3247
    int i;
3248
    int skip_dct[6];
3249
    int dct_offset   = s->linesize*8; //default for progressive frames
3250
    
3251
    for(i=0; i<6; i++) skip_dct[i]=0;
3252
    
3253
    if(s->adaptive_quant){
3254
        const int last_qp= s->qscale;
3255
        const int mb_xy= mb_x + mb_y*s->mb_stride;
3256

    
3257
        s->lambda= s->lambda_table[mb_xy];
3258
        update_qscale(s);
3259
    
3260
        if(!(s->flags&CODEC_FLAG_QP_RD)){
3261
            s->dquant= s->qscale - last_qp;
3262

    
3263
            if(s->out_format==FMT_H263)
3264
                s->dquant= clip(s->dquant, -2, 2); //FIXME RD
3265
            
3266
            if(s->codec_id==CODEC_ID_MPEG4){        
3267
                if(!s->mb_intra){
3268
                    if((s->mv_dir&MV_DIRECT) || s->mv_type==MV_TYPE_8X8)
3269
                        s->dquant=0;
3270
                }
3271
            }
3272
        }
3273
        ff_set_qscale(s, last_qp + s->dquant);
3274
    }
3275

    
3276
    if (s->mb_intra) {
3277
        uint8_t *ptr;
3278
        int wrap_y;
3279
        int emu=0;
3280

    
3281
        wrap_y = s->linesize;
3282
        ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
3283

    
3284
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
3285
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
3286
            ptr= s->edge_emu_buffer;
3287
            emu=1;
3288
        }
3289
        
3290
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3291
            int progressive_score, interlaced_score;
3292

    
3293
            s->interlaced_dct=0;
3294
            progressive_score= s->dsp.ildct_cmp[4](s, ptr           , NULL, wrap_y, 8) 
3295
                              +s->dsp.ildct_cmp[4](s, ptr + wrap_y*8, NULL, wrap_y, 8) - 400;
3296

    
3297
            if(progressive_score > 0){
3298
                interlaced_score = s->dsp.ildct_cmp[4](s, ptr           , NULL, wrap_y*2, 8) 
3299
                                  +s->dsp.ildct_cmp[4](s, ptr + wrap_y  , NULL, wrap_y*2, 8);
3300
                if(progressive_score > interlaced_score){
3301
                    s->interlaced_dct=1;
3302
            
3303
                    dct_offset= wrap_y;
3304
                    wrap_y<<=1;
3305
                }
3306
            }
3307
        }
3308
        
3309
        s->dsp.get_pixels(s->block[0], ptr                 , wrap_y);
3310
        s->dsp.get_pixels(s->block[1], ptr              + 8, wrap_y);
3311
        s->dsp.get_pixels(s->block[2], ptr + dct_offset    , wrap_y);
3312
        s->dsp.get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
3313

    
3314
        if(s->flags&CODEC_FLAG_GRAY){
3315
            skip_dct[4]= 1;
3316
            skip_dct[5]= 1;
3317
        }else{
3318
            int wrap_c = s->uvlinesize;
3319
            ptr = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
3320
            if(emu){
3321
                ff_emulated_edge_mc(s->edge_emu_buffer, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3322
                ptr= s->edge_emu_buffer;
3323
            }
3324
            s->dsp.get_pixels(s->block[4], ptr, wrap_c);
3325

    
3326
            ptr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3327
            if(emu){
3328
                ff_emulated_edge_mc(s->edge_emu_buffer, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3329
                ptr= s->edge_emu_buffer;
3330
            }
3331
            s->dsp.get_pixels(s->block[5], ptr, wrap_c);
3332
        }
3333
    }else{
3334
        op_pixels_func (*op_pix)[4];
3335
        qpel_mc_func (*op_qpix)[16];
3336
        uint8_t *dest_y, *dest_cb, *dest_cr;
3337
        uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3338
        int wrap_y, wrap_c;
3339
        int emu=0;
3340

    
3341
        dest_y  = s->dest[0];
3342
        dest_cb = s->dest[1];
3343
        dest_cr = s->dest[2];
3344
        wrap_y = s->linesize;
3345
        wrap_c = s->uvlinesize;
3346
        ptr_y  = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
3347
        ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
3348
        ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3349

    
3350
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
3351
            op_pix = s->dsp.put_pixels_tab;
3352
            op_qpix= s->dsp.put_qpel_pixels_tab;
3353
        }else{
3354
            op_pix = s->dsp.put_no_rnd_pixels_tab;
3355
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3356
        }
3357

    
3358
        if (s->mv_dir & MV_DIR_FORWARD) {
3359
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3360
            op_pix = s->dsp.avg_pixels_tab;
3361
            op_qpix= s->dsp.avg_qpel_pixels_tab;
3362
        }
3363
        if (s->mv_dir & MV_DIR_BACKWARD) {
3364
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3365
        }
3366

    
3367
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
3368
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
3369
            ptr_y= s->edge_emu_buffer;
3370
            emu=1;
3371
        }
3372
        
3373
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3374
            int progressive_score, interlaced_score;
3375

    
3376
            s->interlaced_dct=0;
3377
            progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8) 
3378
                              +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
3379
            
3380
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
3381

    
3382
            if(progressive_score>0){
3383
                interlaced_score = s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y*2, 8) 
3384
                                  +s->dsp.ildct_cmp[0](s, dest_y + wrap_y  , ptr_y + wrap_y  , wrap_y*2, 8);
3385
            
3386
                if(progressive_score > interlaced_score){
3387
                    s->interlaced_dct=1;
3388
            
3389
                    dct_offset= wrap_y;
3390
                    wrap_y<<=1;
3391
                }
3392
            }
3393
        }
3394
        
3395
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
3396
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
3397
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
3398
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
3399
        
3400
        if(s->flags&CODEC_FLAG_GRAY){
3401
            skip_dct[4]= 1;
3402
            skip_dct[5]= 1;
3403
        }else{
3404
            if(emu){
3405
                ff_emulated_edge_mc(s->edge_emu_buffer, ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3406
                ptr_cb= s->edge_emu_buffer;
3407
            }
3408
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
3409
            if(emu){
3410
                ff_emulated_edge_mc(s->edge_emu_buffer, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3411
                ptr_cr= s->edge_emu_buffer;
3412
            }
3413
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
3414
        }
3415
        /* pre quantization */         
3416
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
3417
            //FIXME optimize
3418
            if(s->dsp.sad[1](NULL, ptr_y               , dest_y               , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
3419
            if(s->dsp.sad[1](NULL, ptr_y            + 8, dest_y            + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
3420
            if(s->dsp.sad[1](NULL, ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
3421
            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;
3422
            if(s->dsp.sad[1](NULL, ptr_cb              , dest_cb              , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
3423
            if(s->dsp.sad[1](NULL, ptr_cr              , dest_cr              , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
3424
#if 0
3425
{
3426
 static int stat[7];
3427
 int num=0;
3428
 for(i=0; i<6; i++)
3429
  if(skip_dct[i]) num++;
3430
 stat[num]++;
3431
 
3432
 if(s->mb_x==0 && s->mb_y==0){
3433
  for(i=0; i<7; i++){
3434
   printf("%6d %1d\n", stat[i], i);
3435
  }
3436
 }
3437
}
3438
#endif
3439
        }
3440

    
3441
    }
3442
            
3443
    /* DCT & quantize */
3444
    if(s->out_format==FMT_MJPEG){
3445
        for(i=0;i<6;i++) {
3446
            int overflow;
3447
            s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
3448
            if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
3449
        }
3450
    }else{
3451
        for(i=0;i<6;i++) {
3452
            if(!skip_dct[i]){
3453
                int overflow;
3454
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
3455
            // FIXME we could decide to change to quantizer instead of clipping
3456
            // JS: I don't think that would be a good idea it could lower quality instead
3457
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
3458
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
3459
            }else
3460
                s->block_last_index[i]= -1;
3461
        }
3462
        
3463
        if(s->luma_elim_threshold && !s->mb_intra)
3464
            for(i=0; i<4; i++)
3465
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
3466
        if(s->chroma_elim_threshold && !s->mb_intra)
3467
            for(i=4; i<6; i++)
3468
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
3469

    
3470
        if(s->flags & CODEC_FLAG_CBP_RD){
3471
            for(i=0;i<6;i++) {
3472
                if(s->block_last_index[i] == -1)
3473
                    s->coded_score[i]= INT_MAX/256;
3474
            }
3475
        }
3476
    }
3477

    
3478
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
3479
        s->block_last_index[4]=
3480
        s->block_last_index[5]= 0;
3481
        s->block[4][0]=
3482
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
3483
    }
3484

    
3485
    //non c quantize code returns incorrect block_last_index FIXME
3486
    if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
3487
        for(i=0; i<6; i++){
3488
            int j;
3489
            if(s->block_last_index[i]>0){
3490
                for(j=63; j>0; j--){
3491
                    if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
3492
                }
3493
                s->block_last_index[i]= j;
3494
            }
3495
        }
3496
    }
3497

    
3498
    /* huffman encode */
3499
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
3500
    case CODEC_ID_MPEG1VIDEO:
3501
    case CODEC_ID_MPEG2VIDEO:
3502
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
3503
#ifdef CONFIG_RISKY
3504
    case CODEC_ID_MPEG4:
3505
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3506
    case CODEC_ID_MSMPEG4V2:
3507
    case CODEC_ID_MSMPEG4V3:
3508
    case CODEC_ID_WMV1:
3509
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3510
    case CODEC_ID_WMV2:
3511
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
3512
    case CODEC_ID_H263:
3513
    case CODEC_ID_H263P:
3514
    case CODEC_ID_FLV1:
3515
    case CODEC_ID_RV10:
3516
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
3517
#endif
3518
    case CODEC_ID_MJPEG:
3519
        mjpeg_encode_mb(s, s->block); break;
3520
    default:
3521
        assert(0);
3522
    }
3523
}
3524

    
3525
#endif //CONFIG_ENCODERS
3526

    
3527
/**
3528
 * combines the (truncated) bitstream to a complete frame
3529
 * @returns -1 if no complete frame could be created
3530
 */
3531
int ff_combine_frame( MpegEncContext *s, int next, uint8_t **buf, int *buf_size){
3532
    ParseContext *pc= &s->parse_context;
3533

    
3534
#if 0
3535
    if(pc->overread){
3536
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
3537
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
3538
    }
3539
#endif
3540

    
3541
    /* copy overreaded byes from last frame into buffer */
3542
    for(; pc->overread>0; pc->overread--){
3543
        pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
3544
    }
3545
    
3546
    pc->last_index= pc->index;
3547

    
3548
    /* copy into buffer end return */
3549
    if(next == END_NOT_FOUND){
3550
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
3551

    
3552
        memcpy(&pc->buffer[pc->index], *buf, *buf_size);
3553
        pc->index += *buf_size;
3554
        return -1;
3555
    }
3556

    
3557
    *buf_size=
3558
    pc->overread_index= pc->index + next;
3559
    
3560
    /* append to buffer */
3561
    if(pc->index){
3562
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
3563

    
3564
        memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
3565
        pc->index = 0;
3566
        *buf= pc->buffer;
3567
    }
3568

    
3569
    /* store overread bytes */
3570
    for(;next < 0; next++){
3571
        pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
3572
        pc->overread++;
3573
    }
3574

    
3575
#if 0
3576
    if(pc->overread){
3577
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
3578
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
3579
    }
3580
#endif
3581

    
3582
    return 0;
3583
}
3584

    
3585
void ff_mpeg_flush(AVCodecContext *avctx){
3586
    int i;
3587
    MpegEncContext *s = avctx->priv_data;
3588
    
3589
    for(i=0; i<MAX_PICTURE_COUNT; i++){
3590
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
3591
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
3592
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
3593
    }
3594
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
3595
    
3596
    s->parse_context.state= -1;
3597
    s->parse_context.frame_start_found= 0;
3598
    s->parse_context.overread= 0;
3599
    s->parse_context.overread_index= 0;
3600
    s->parse_context.index= 0;
3601
    s->parse_context.last_index= 0;
3602
}
3603

    
3604
#ifdef CONFIG_ENCODERS
3605
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
3606
{
3607
    int bytes= length>>4;
3608
    int bits= length&15;
3609
    int i;
3610

    
3611
    if(length==0) return;
3612

    
3613
    for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
3614
    put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
3615
}
3616

    
3617
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
3618
    int i;
3619

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

    
3622
    /* mpeg1 */
3623
    d->mb_skip_run= s->mb_skip_run;
3624
    for(i=0; i<3; i++)
3625
        d->last_dc[i]= s->last_dc[i];
3626
    
3627
    /* statistics */
3628
    d->mv_bits= s->mv_bits;
3629
    d->i_tex_bits= s->i_tex_bits;
3630
    d->p_tex_bits= s->p_tex_bits;
3631
    d->i_count= s->i_count;
3632
    d->f_count= s->f_count;
3633
    d->b_count= s->b_count;
3634
    d->skip_count= s->skip_count;
3635
    d->misc_bits= s->misc_bits;
3636
    d->last_bits= 0;
3637

    
3638
    d->mb_skiped= 0;
3639
    d->qscale= s->qscale;
3640
    d->dquant= s->dquant;
3641
}
3642

    
3643
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
3644
    int i;
3645

    
3646
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
3647
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
3648
    
3649
    /* mpeg1 */
3650
    d->mb_skip_run= s->mb_skip_run;
3651
    for(i=0; i<3; i++)
3652
        d->last_dc[i]= s->last_dc[i];
3653
    
3654
    /* statistics */
3655
    d->mv_bits= s->mv_bits;
3656
    d->i_tex_bits= s->i_tex_bits;
3657
    d->p_tex_bits= s->p_tex_bits;
3658
    d->i_count= s->i_count;
3659
    d->f_count= s->f_count;
3660
    d->b_count= s->b_count;
3661
    d->skip_count= s->skip_count;
3662
    d->misc_bits= s->misc_bits;
3663

    
3664
    d->mb_intra= s->mb_intra;
3665
    d->mb_skiped= s->mb_skiped;
3666
    d->mv_type= s->mv_type;
3667
    d->mv_dir= s->mv_dir;
3668
    d->pb= s->pb;
3669
    if(s->data_partitioning){
3670
        d->pb2= s->pb2;
3671
        d->tex_pb= s->tex_pb;
3672
    }
3673
    d->block= s->block;
3674
    for(i=0; i<6; i++)
3675
        d->block_last_index[i]= s->block_last_index[i];
3676
    d->interlaced_dct= s->interlaced_dct;
3677
    d->qscale= s->qscale;
3678
}
3679

    
3680
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
3681
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
3682
                           int *dmin, int *next_block, int motion_x, int motion_y)
3683
{
3684
    int score;
3685
    uint8_t *dest_backup[3];
3686
    
3687
    copy_context_before_encode(s, backup, type);
3688

    
3689
    s->block= s->blocks[*next_block];
3690
    s->pb= pb[*next_block];
3691
    if(s->data_partitioning){
3692
        s->pb2   = pb2   [*next_block];
3693
        s->tex_pb= tex_pb[*next_block];
3694
    }
3695
    
3696
    if(*next_block){
3697
        memcpy(dest_backup, s->dest, sizeof(s->dest));
3698
        s->dest[0] = s->me.scratchpad;
3699
        s->dest[1] = s->me.scratchpad + 16;
3700
        s->dest[2] = s->me.scratchpad + 16 + 8;
3701
        assert(2*s->uvlinesize == s->linesize); //should be no prob for encoding
3702
        assert(s->linesize >= 64); //FIXME
3703
    }
3704

    
3705
    encode_mb(s, motion_x, motion_y);
3706
    
3707
    score= get_bit_count(&s->pb);
3708
    if(s->data_partitioning){
3709
        score+= get_bit_count(&s->pb2);
3710
        score+= get_bit_count(&s->tex_pb);
3711
    }
3712
   
3713
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
3714
        MPV_decode_mb(s, s->block);
3715

    
3716
        score *= s->lambda2;
3717
        score += sse_mb(s) << FF_LAMBDA_SHIFT;
3718
    }
3719
    
3720
    if(*next_block){
3721
        memcpy(s->dest, dest_backup, sizeof(s->dest));
3722
    }
3723

    
3724
    if(score<*dmin){
3725
        *dmin= score;
3726
        *next_block^=1;
3727

    
3728
        copy_context_after_encode(best, s, type);
3729
    }
3730
}
3731
                
3732
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
3733
    uint32_t *sq = squareTbl + 256;
3734
    int acc=0;
3735
    int x,y;
3736
    
3737
    if(w==16 && h==16) 
3738
        return s->dsp.sse[0](NULL, src1, src2, stride, 16);
3739
    else if(w==8 && h==8)
3740
        return s->dsp.sse[1](NULL, src1, src2, stride, 8);
3741
    
3742
    for(y=0; y<h; y++){
3743
        for(x=0; x<w; x++){
3744
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
3745
        } 
3746
    }
3747
    
3748
    assert(acc>=0);
3749
    
3750
    return acc;
3751
}
3752

    
3753
static int sse_mb(MpegEncContext *s){
3754
    int w= 16;
3755
    int h= 16;
3756

    
3757
    if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3758
    if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3759

    
3760
    if(w==16 && h==16)
3761
        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)
3762
               +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)
3763
               +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);
3764
    else
3765
        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)
3766
               +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)
3767
               +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);
3768
}
3769

    
3770
static void encode_picture(MpegEncContext *s, int picture_number)
3771
{
3772
    int mb_x, mb_y, pdif = 0;
3773
    int i, j;
3774
    int bits;
3775
    MpegEncContext best_s, backup_s;
3776
    uint8_t bit_buf[2][3000];
3777
    uint8_t bit_buf2[2][3000];
3778
    uint8_t bit_buf_tex[2][3000];
3779
    PutBitContext pb[2], pb2[2], tex_pb[2];
3780

    
3781
    for(i=0; i<2; i++){
3782
        init_put_bits(&pb    [i], bit_buf    [i], 3000);
3783
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000);
3784
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000);
3785
    }
3786

    
3787
    s->picture_number = picture_number;
3788
    
3789
    /* Reset the average MB variance */
3790
    s->current_picture.mb_var_sum = 0;
3791
    s->current_picture.mc_mb_var_sum = 0;
3792

    
3793
#ifdef CONFIG_RISKY
3794
    /* we need to initialize some time vars before we can encode b-frames */
3795
    // RAL: Condition added for MPEG1VIDEO
3796
    if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
3797
        ff_set_mpeg4_time(s, s->picture_number); 
3798
#endif
3799
        
3800
    s->scene_change_score=0;
3801
    
3802
    s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration
3803
    
3804
    if(s->pict_type==I_TYPE){
3805
        if(s->msmpeg4_version >= 3) s->no_rounding=1;
3806
        else                        s->no_rounding=0;
3807
    }else if(s->pict_type!=B_TYPE){
3808
        if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
3809
            s->no_rounding ^= 1;          
3810
    }
3811
    
3812
    /* Estimate motion for every MB */
3813
    s->mb_intra=0; //for the rate distoration & bit compare functions
3814
    if(s->pict_type != I_TYPE){
3815
        if(s->pict_type != B_TYPE){
3816
            if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
3817
                s->me.pre_pass=1;
3818
                s->me.dia_size= s->avctx->pre_dia_size;
3819

    
3820
                for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) {
3821
                    for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) {
3822
                        s->mb_x = mb_x;
3823
                        s->mb_y = mb_y;
3824
                        ff_pre_estimate_p_frame_motion(s, mb_x, mb_y);
3825
                    }
3826
                }
3827
                s->me.pre_pass=0;
3828
            }
3829
        }
3830

    
3831
        s->me.dia_size= s->avctx->dia_size;
3832
        for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3833
            s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3834
            s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3835
            s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3836
            s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3837
            for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3838
                s->mb_x = mb_x;
3839
                s->mb_y = mb_y;
3840
                s->block_index[0]+=2;
3841
                s->block_index[1]+=2;
3842
                s->block_index[2]+=2;
3843
                s->block_index[3]+=2;
3844
                
3845
                /* compute motion vector & mb_type and store in context */
3846
                if(s->pict_type==B_TYPE)
3847
                    ff_estimate_b_frame_motion(s, mb_x, mb_y);
3848
                else
3849
                    ff_estimate_p_frame_motion(s, mb_x, mb_y);
3850
            }
3851
        }
3852
    }else /* if(s->pict_type == I_TYPE) */{
3853
        /* I-Frame */
3854
        //FIXME do we need to zero them?
3855
        memset(s->current_picture.motion_val[0][0], 0, sizeof(int16_t)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
3856
        memset(s->p_mv_table   , 0, sizeof(int16_t)*(s->mb_stride)*s->mb_height*2);
3857
        for(i=0; i<s->mb_stride*s->mb_height; i++)
3858
            s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3859
        
3860
        if(!s->fixed_qscale){
3861
            /* finding spatial complexity for I-frame rate control */
3862
            for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3863
                for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3864
                    int xx = mb_x * 16;
3865
                    int yy = mb_y * 16;
3866
                    uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
3867
                    int varc;
3868
                    int sum = s->dsp.pix_sum(pix, s->linesize);
3869
    
3870
                    varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
3871

    
3872
                    s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
3873
                    s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
3874
                    s->current_picture.mb_var_sum    += varc;
3875
                }
3876
            }
3877
        }
3878
    }
3879
    emms_c();
3880

    
3881
    if(s->scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){
3882
        s->pict_type= I_TYPE;
3883
        for(i=0; i<s->mb_stride*s->mb_height; i++)
3884
            s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3885
//printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3886
    }
3887

    
3888
    if(!s->umvplus){
3889
        if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
3890
            s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3891

    
3892
            if(s->flags & CODEC_FLAG_INTERLACED_ME){
3893
                int a,b;
3894
                a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3895
                b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3896
                s->f_code= FFMAX(s->f_code, FFMAX(a,b));
3897
            }
3898
                    
3899
            ff_fix_long_p_mvs(s);
3900
            ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3901
            if(s->flags & CODEC_FLAG_INTERLACED_ME){
3902
                for(i=0; i<2; i++){
3903
                    for(j=0; j<2; j++)
3904
                        ff_fix_long_mvs(s, s->p_field_select_table[i], j, 
3905
                                        s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3906
                }
3907
            }
3908
        }
3909

    
3910
        if(s->pict_type==B_TYPE){
3911
            int a, b;
3912

    
3913
            a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3914
            b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3915
            s->f_code = FFMAX(a, b);
3916

    
3917
            a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3918
            b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3919
            s->b_code = FFMAX(a, b);
3920

    
3921
            ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3922
            ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3923
            ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3924
            ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3925
            if(s->flags & CODEC_FLAG_INTERLACED_ME){
3926
                int dir;
3927
                for(dir=0; dir<2; dir++){
3928
                    for(i=0; i<2; i++){
3929
                        for(j=0; j<2; j++){
3930
                            int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I) 
3931
                                          : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3932
                            ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j, 
3933
                                            s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3934
                        }
3935
                    }
3936
                }
3937
            }
3938
        }
3939
    }
3940
    
3941
    if (!s->fixed_qscale) 
3942
        s->current_picture.quality = ff_rate_estimate_qscale(s);
3943

    
3944
    if(s->adaptive_quant){
3945
#ifdef CONFIG_RISKY
3946
        switch(s->codec_id){
3947
        case CODEC_ID_MPEG4:
3948
            ff_clean_mpeg4_qscales(s);
3949
            break;
3950
        case CODEC_ID_H263:
3951
        case CODEC_ID_H263P:
3952
        case CODEC_ID_FLV1:
3953
            ff_clean_h263_qscales(s);
3954
            break;
3955
        }
3956
#endif
3957

    
3958
        s->lambda= s->lambda_table[0];
3959
        //FIXME broken
3960
    }else
3961
        s->lambda= s->current_picture.quality;
3962
//printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
3963
    update_qscale(s);
3964
    
3965
    if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==I_TYPE && !(s->flags & CODEC_FLAG_QSCALE)) 
3966
        s->qscale= 3; //reduce cliping problems
3967
        
3968
    if (s->out_format == FMT_MJPEG) {
3969
        /* for mjpeg, we do include qscale in the matrix */
3970
        s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
3971
        for(i=1;i<64;i++){
3972
            int j= s->dsp.idct_permutation[i];
3973

    
3974
            s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3975
        }
3976
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 
3977
                       s->intra_matrix, s->intra_quant_bias, 8, 8);
3978
    }
3979
    
3980
    //FIXME var duplication
3981
    s->current_picture.key_frame= s->pict_type == I_TYPE;
3982
    s->current_picture.pict_type= s->pict_type;
3983

    
3984
    if(s->current_picture.key_frame)
3985
        s->picture_in_gop_number=0;
3986

    
3987
    s->last_bits= get_bit_count(&s->pb);
3988
    switch(s->out_format) {
3989
    case FMT_MJPEG:
3990
        mjpeg_picture_header(s);
3991
        break;
3992
#ifdef CONFIG_RISKY
3993
    case FMT_H263:
3994
        if (s->codec_id == CODEC_ID_WMV2) 
3995
            ff_wmv2_encode_picture_header(s, picture_number);
3996
        else if (s->h263_msmpeg4) 
3997
            msmpeg4_encode_picture_header(s, picture_number);
3998
        else if (s->h263_pred)
3999
            mpeg4_encode_picture_header(s, picture_number);
4000
        else if (s->codec_id == CODEC_ID_RV10) 
4001
            rv10_encode_picture_header(s, picture_number);
4002
        else if (s->codec_id == CODEC_ID_FLV1)
4003
            ff_flv_encode_picture_header(s, picture_number);
4004
        else
4005
            h263_encode_picture_header(s, picture_number);
4006
        break;
4007
#endif
4008
    case FMT_MPEG1:
4009
        mpeg1_encode_picture_header(s, picture_number);
4010
        break;
4011
    case FMT_H264:
4012
        break;
4013
    }
4014
    bits= get_bit_count(&s->pb);
4015
    s->header_bits= bits - s->last_bits;
4016
    s->last_bits= bits;
4017
    s->mv_bits=0;
4018
    s->misc_bits=0;
4019
    s->i_tex_bits=0;
4020
    s->p_tex_bits=0;
4021
    s->i_count=0;
4022
    s->f_count=0;
4023
    s->b_count=0;
4024
    s->skip_count=0;
4025

    
4026
    for(i=0; i<3; i++){
4027
        /* init last dc values */
4028
        /* note: quant matrix value (8) is implied here */
4029
        s->last_dc[i] = 128;
4030
        
4031
        s->current_picture_ptr->error[i] = 0;
4032
    }
4033
    s->mb_skip_run = 0;
4034
    memset(s->last_mv, 0, sizeof(s->last_mv));
4035
     
4036
    s->last_mv_dir = 0;
4037

    
4038
#ifdef CONFIG_RISKY
4039
    switch(s->codec_id){
4040
    case CODEC_ID_H263:
4041
    case CODEC_ID_H263P:
4042
    case CODEC_ID_FLV1:
4043
        s->gob_index = ff_h263_get_gob_height(s);
4044
        break;
4045
    case CODEC_ID_MPEG4:
4046
        if(s->partitioned_frame)
4047
            ff_mpeg4_init_partitions(s);
4048
        break;
4049
    }
4050
#endif
4051

    
4052
    s->resync_mb_x=0;
4053
    s->resync_mb_y=0;
4054
    s->first_slice_line = 1;
4055
    s->ptr_lastgob = s->pb.buf;
4056
    for(mb_y=0; mb_y < s->mb_height; mb_y++) {
4057
        s->mb_x=0;
4058
        s->mb_y= mb_y;
4059

    
4060
        ff_set_qscale(s, s->qscale);
4061
        ff_init_block_index(s);
4062
        
4063
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4064
            const int xy= mb_y*s->mb_stride + mb_x;
4065
            int mb_type= s->mb_type[xy];
4066
//            int d;
4067
            int dmin= INT_MAX;
4068
            int dir;
4069

    
4070
            s->mb_x = mb_x;
4071
            ff_update_block_index(s);
4072

    
4073
            /* write gob / video packet header  */
4074
#ifdef CONFIG_RISKY
4075
            if(s->rtp_mode){
4076
                int current_packet_size, is_gob_start;
4077
                
4078
                current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4079
                
4080
                is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0; 
4081
                
4082
                switch(s->codec_id){
4083
                case CODEC_ID_H263:
4084
                case CODEC_ID_H263P:
4085
                    if(!s->h263_slice_structured)
4086
                        if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
4087
                    break;
4088
                case CODEC_ID_MPEG2VIDEO:
4089
                    if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
4090
                case CODEC_ID_MPEG1VIDEO:
4091
                    if(s->mb_skip_run) is_gob_start=0;
4092
                    break;
4093
                }
4094
                
4095
                if(is_gob_start){
4096
                    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
4097
                        ff_mpeg4_merge_partitions(s);
4098
                        ff_mpeg4_init_partitions(s);
4099
                    }
4100
                
4101
                    if(s->codec_id==CODEC_ID_MPEG4) 
4102
                        ff_mpeg4_stuffing(&s->pb);
4103

    
4104
                    align_put_bits(&s->pb);
4105
                    flush_put_bits(&s->pb);
4106

    
4107
                    assert((get_bit_count(&s->pb)&7) == 0);
4108
                    current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4109
                    
4110
                    if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
4111
                        int r= get_bit_count(&s->pb)/8 + s->picture_number + s->codec_id + s->mb_x + s->mb_y;
4112
                        int d= 100 / s->avctx->error_rate;
4113
                        if(r % d == 0){
4114
                            current_packet_size=0;
4115
#ifndef ALT_BITSTREAM_WRITER
4116
                            s->pb.buf_ptr= s->ptr_lastgob;
4117
#endif
4118
                            assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
4119
                        }
4120
                    }
4121
        
4122
                    if (s->avctx->rtp_callback)
4123
                        s->avctx->rtp_callback(s->ptr_lastgob, current_packet_size, 0);
4124
                    
4125
                    switch(s->codec_id){
4126
                    case CODEC_ID_MPEG4:
4127
                        ff_mpeg4_encode_video_packet_header(s);
4128
                        ff_mpeg4_clean_buffers(s);
4129
                    break;
4130
                    case CODEC_ID_MPEG1VIDEO:
4131
                    case CODEC_ID_MPEG2VIDEO:
4132
                        ff_mpeg1_encode_slice_header(s);
4133
                        ff_mpeg1_clean_buffers(s);
4134
                    break;
4135
                    case CODEC_ID_H263:
4136
                    case CODEC_ID_H263P:
4137
                        h263_encode_gob_header(s, mb_y);                       
4138
                    break;
4139
                    }
4140

    
4141
                    if(s->flags&CODEC_FLAG_PASS1){
4142
                        int bits= get_bit_count(&s->pb);
4143
                        s->misc_bits+= bits - s->last_bits;
4144
                        s->last_bits= bits;
4145
                    }
4146
    
4147
                    s->ptr_lastgob += current_packet_size;
4148
                    s->first_slice_line=1;
4149
                    s->resync_mb_x=mb_x;
4150
                    s->resync_mb_y=mb_y;
4151
                }
4152
            }
4153
#endif
4154

    
4155
            if(  (s->resync_mb_x   == s->mb_x)
4156
               && s->resync_mb_y+1 == s->mb_y){
4157
                s->first_slice_line=0; 
4158
            }
4159

    
4160
            s->mb_skiped=0;
4161
            s->dquant=0; //only for QP_RD
4162

    
4163
            if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible
4164
                int next_block=0;
4165
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
4166

    
4167
                copy_context_before_encode(&backup_s, s, -1);
4168
                backup_s.pb= s->pb;
4169
                best_s.data_partitioning= s->data_partitioning;
4170
                best_s.partitioned_frame= s->partitioned_frame;
4171
                if(s->data_partitioning){
4172
                    backup_s.pb2= s->pb2;
4173
                    backup_s.tex_pb= s->tex_pb;
4174
                }
4175

    
4176
                if(mb_type&CANDIDATE_MB_TYPE_INTER){
4177
                    s->mv_dir = MV_DIR_FORWARD;
4178
                    s->mv_type = MV_TYPE_16X16;
4179
                    s->mb_intra= 0;
4180
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
4181
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
4182
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb, 
4183
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4184
                }
4185
                if(mb_type&CANDIDATE_MB_TYPE_INTER_I){ 
4186
                    s->mv_dir = MV_DIR_FORWARD;
4187
                    s->mv_type = MV_TYPE_FIELD;
4188
                    s->mb_intra= 0;
4189
                    for(i=0; i<2; i++){
4190
                        j= s->field_select[0][i] = s->p_field_select_table[i][xy];
4191
                        s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
4192
                        s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
4193
                    }
4194
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb, 
4195
                                 &dmin, &next_block, 0, 0);
4196
                }
4197
                if(mb_type&CANDIDATE_MB_TYPE_SKIPED){
4198
                    s->mv_dir = MV_DIR_FORWARD;
4199
                    s->mv_type = MV_TYPE_16X16;
4200
                    s->mb_intra= 0;
4201
                    s->mv[0][0][0] = 0;
4202
                    s->mv[0][0][1] = 0;
4203
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPED, pb, pb2, tex_pb, 
4204
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4205
                }
4206
                if(mb_type&CANDIDATE_MB_TYPE_INTER4V){                 
4207
                    s->mv_dir = MV_DIR_FORWARD;
4208
                    s->mv_type = MV_TYPE_8X8;
4209
                    s->mb_intra= 0;
4210
                    for(i=0; i<4; i++){
4211
                        s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
4212
                        s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
4213
                    }
4214
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb, 
4215
                                 &dmin, &next_block, 0, 0);
4216
                }
4217
                if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
4218
                    s->mv_dir = MV_DIR_FORWARD;
4219
                    s->mv_type = MV_TYPE_16X16;
4220
                    s->mb_intra= 0;
4221
                    s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
4222
                    s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
4223
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb, 
4224
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4225
                }
4226
                if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
4227
                    s->mv_dir = MV_DIR_BACKWARD;
4228
                    s->mv_type = MV_TYPE_16X16;
4229
                    s->mb_intra= 0;
4230
                    s->mv[1][0][0] = s->b_back_mv_table[xy][0];
4231
                    s->mv[1][0][1] = s->b_back_mv_table[xy][1];
4232
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb, 
4233
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
4234
                }
4235
                if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
4236
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4237
                    s->mv_type = MV_TYPE_16X16;
4238
                    s->mb_intra= 0;
4239
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
4240
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
4241
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
4242
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
4243
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb, 
4244
                                 &dmin, &next_block, 0, 0);
4245
                }
4246
                if(mb_type&CANDIDATE_MB_TYPE_DIRECT){
4247
                    int mx= s->b_direct_mv_table[xy][0];
4248
                    int my= s->b_direct_mv_table[xy][1];
4249
                    
4250
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4251
                    s->mb_intra= 0;
4252
#ifdef CONFIG_RISKY
4253
                    ff_mpeg4_set_direct_mv(s, mx, my);
4254
#endif
4255
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb, 
4256
                                 &dmin, &next_block, mx, my);
4257
                }
4258
                if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){ 
4259
                    s->mv_dir = MV_DIR_FORWARD;
4260
                    s->mv_type = MV_TYPE_FIELD;
4261
                    s->mb_intra= 0;
4262
                    for(i=0; i<2; i++){
4263
                        j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
4264
                        s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
4265
                        s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
4266
                    }
4267
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb, 
4268
                                 &dmin, &next_block, 0, 0);
4269
                }
4270
                if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){ 
4271
                    s->mv_dir = MV_DIR_BACKWARD;
4272
                    s->mv_type = MV_TYPE_FIELD;
4273
                    s->mb_intra= 0;
4274
                    for(i=0; i<2; i++){
4275
                        j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
4276
                        s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
4277
                        s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
4278
                    }
4279
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb, 
4280
                                 &dmin, &next_block, 0, 0);
4281
                }
4282
                if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){ 
4283
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4284
                    s->mv_type = MV_TYPE_FIELD;
4285
                    s->mb_intra= 0;
4286
                    for(dir=0; dir<2; dir++){
4287
                        for(i=0; i<2; i++){
4288
                            j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
4289
                            s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
4290
                            s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
4291
                        }
4292
                    }
4293
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb, 
4294
                                 &dmin, &next_block, 0, 0);
4295
                }
4296
                if(mb_type&CANDIDATE_MB_TYPE_INTRA){
4297
                    s->mv_dir = 0;
4298
                    s->mv_type = MV_TYPE_16X16;
4299
                    s->mb_intra= 1;
4300
                    s->mv[0][0][0] = 0;
4301
                    s->mv[0][0][1] = 0;
4302
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb, 
4303
                                 &dmin, &next_block, 0, 0);
4304
                    if(s->h263_pred || s->h263_aic){
4305
                        if(best_s.mb_intra)
4306
                            s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
4307
                        else
4308
                            ff_clean_intra_table_entries(s); //old mode?
4309
                    }
4310
                }
4311

    
4312
                if(s->flags & CODEC_FLAG_QP_RD){
4313
                    if(best_s.mv_type==MV_TYPE_16X16 && !(best_s.mv_dir&MV_DIRECT)){
4314
                        const int last_qp= backup_s.qscale;
4315
                        int dquant, dir, qp, dc[6];
4316
                        DCTELEM ac[6][16];
4317
                        const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
4318
                        
4319
                        assert(backup_s.dquant == 0);
4320

    
4321
                        //FIXME intra
4322
                        s->mv_dir= best_s.mv_dir;
4323
                        s->mv_type = MV_TYPE_16X16;
4324
                        s->mb_intra= best_s.mb_intra;
4325
                        s->mv[0][0][0] = best_s.mv[0][0][0];
4326
                        s->mv[0][0][1] = best_s.mv[0][0][1];
4327
                        s->mv[1][0][0] = best_s.mv[1][0][0];
4328
                        s->mv[1][0][1] = best_s.mv[1][0][1];
4329
                        
4330
                        dir= s->pict_type == B_TYPE ? 2 : 1;
4331
                        if(last_qp + dir > s->avctx->qmax) dir= -dir;
4332
                        for(dquant= dir; dquant<=2 && dquant>=-2; dquant += dir){
4333
                            qp= last_qp + dquant;
4334
                            if(qp < s->avctx->qmin || qp > s->avctx->qmax)
4335
                                break;
4336
                            backup_s.dquant= dquant;
4337
                            if(s->mb_intra){
4338
                                for(i=0; i<6; i++){
4339
                                    dc[i]= s->dc_val[0][ s->block_index[i] ];
4340
                                    memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
4341
                                }
4342
                            }
4343

    
4344
                            encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb, 
4345
                                         &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
4346
                            if(best_s.qscale != qp){
4347
                                if(s->mb_intra){
4348
                                    for(i=0; i<6; i++){
4349
                                        s->dc_val[0][ s->block_index[i] ]= dc[i];
4350
                                        memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
4351
                                    }
4352
                                }
4353
                                if(dir > 0 && dquant==dir){
4354
                                    dquant= 0;
4355
                                    dir= -dir;
4356
                                }else
4357
                                    break;
4358
                            }
4359
                        }
4360
                        qp= best_s.qscale;
4361
                        s->current_picture.qscale_table[xy]= qp;
4362
                    }
4363
                }
4364

    
4365
                copy_context_after_encode(s, &best_s, -1);
4366
                
4367
                pb_bits_count= get_bit_count(&s->pb);
4368
                flush_put_bits(&s->pb);
4369
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
4370
                s->pb= backup_s.pb;
4371
                
4372
                if(s->data_partitioning){
4373
                    pb2_bits_count= get_bit_count(&s->pb2);
4374
                    flush_put_bits(&s->pb2);
4375
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
4376
                    s->pb2= backup_s.pb2;
4377
                    
4378
                    tex_pb_bits_count= get_bit_count(&s->tex_pb);
4379
                    flush_put_bits(&s->tex_pb);
4380
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
4381
                    s->tex_pb= backup_s.tex_pb;
4382
                }
4383
                s->last_bits= get_bit_count(&s->pb);
4384
               
4385
#ifdef CONFIG_RISKY
4386
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4387
                    ff_h263_update_motion_val(s);
4388
#endif
4389
        
4390
                if(next_block==0){
4391
                    s->dsp.put_pixels_tab[0][0](s->dest[0], s->me.scratchpad     , s->linesize  ,16);
4392
                    s->dsp.put_pixels_tab[1][0](s->dest[1], s->me.scratchpad + 16, s->uvlinesize, 8);
4393
                    s->dsp.put_pixels_tab[1][0](s->dest[2], s->me.scratchpad + 24, s->uvlinesize, 8);
4394
                }
4395

    
4396
                if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
4397
                    MPV_decode_mb(s, s->block);
4398
            } else {
4399
                int motion_x, motion_y;
4400
                s->mv_type=MV_TYPE_16X16;
4401
                // only one MB-Type possible
4402
                
4403
                switch(mb_type){
4404
                case CANDIDATE_MB_TYPE_INTRA:
4405
                    s->mv_dir = 0;
4406
                    s->mb_intra= 1;
4407
                    motion_x= s->mv[0][0][0] = 0;
4408
                    motion_y= s->mv[0][0][1] = 0;
4409
                    break;
4410
                case CANDIDATE_MB_TYPE_INTER:
4411
                    s->mv_dir = MV_DIR_FORWARD;
4412
                    s->mb_intra= 0;
4413
                    motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
4414
                    motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
4415
                    break;
4416
                case CANDIDATE_MB_TYPE_INTER_I:
4417
                    s->mv_dir = MV_DIR_FORWARD;
4418
                    s->mv_type = MV_TYPE_FIELD;
4419
                    s->mb_intra= 0;
4420
                    for(i=0; i<2; i++){
4421
                        j= s->field_select[0][i] = s->p_field_select_table[i][xy];
4422
                        s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
4423
                        s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
4424
                    }
4425
                    motion_x = motion_y = 0;
4426
                    break;
4427
                case CANDIDATE_MB_TYPE_INTER4V:
4428
                    s->mv_dir = MV_DIR_FORWARD;
4429
                    s->mv_type = MV_TYPE_8X8;
4430
                    s->mb_intra= 0;
4431
                    for(i=0; i<4; i++){
4432
                        s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
4433
                        s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
4434
                    }
4435
                    motion_x= motion_y= 0;
4436
                    break;
4437
                case CANDIDATE_MB_TYPE_DIRECT:
4438
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4439
                    s->mb_intra= 0;
4440
                    motion_x=s->b_direct_mv_table[xy][0];
4441
                    motion_y=s->b_direct_mv_table[xy][1];
4442
#ifdef CONFIG_RISKY
4443
                    ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
4444
#endif
4445
                    break;
4446
                case CANDIDATE_MB_TYPE_BIDIR:
4447
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4448
                    s->mb_intra= 0;
4449
                    motion_x=0;
4450
                    motion_y=0;
4451
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
4452
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
4453
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
4454
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
4455
                    break;
4456
                case CANDIDATE_MB_TYPE_BACKWARD:
4457
                    s->mv_dir = MV_DIR_BACKWARD;
4458
                    s->mb_intra= 0;
4459
                    motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
4460
                    motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
4461
                    break;
4462
                case CANDIDATE_MB_TYPE_FORWARD:
4463
                    s->mv_dir = MV_DIR_FORWARD;
4464
                    s->mb_intra= 0;
4465
                    motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
4466
                    motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
4467
//                    printf(" %d %d ", motion_x, motion_y);
4468
                    break;
4469
                case CANDIDATE_MB_TYPE_FORWARD_I:
4470
                    s->mv_dir = MV_DIR_FORWARD;
4471
                    s->mv_type = MV_TYPE_FIELD;
4472
                    s->mb_intra= 0;
4473
                    for(i=0; i<2; i++){
4474
                        j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
4475
                        s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
4476
                        s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
4477
                    }
4478
                    motion_x=motion_y=0;
4479
                    break;
4480
                case CANDIDATE_MB_TYPE_BACKWARD_I:
4481
                    s->mv_dir = MV_DIR_BACKWARD;
4482
                    s->mv_type = MV_TYPE_FIELD;
4483
                    s->mb_intra= 0;
4484
                    for(i=0; i<2; i++){
4485
                        j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
4486
                        s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
4487
                        s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
4488
                    }
4489
                    motion_x=motion_y=0;
4490
                    break;
4491
                case CANDIDATE_MB_TYPE_BIDIR_I:
4492
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4493
                    s->mv_type = MV_TYPE_FIELD;
4494
                    s->mb_intra= 0;
4495
                    for(dir=0; dir<2; dir++){
4496
                        for(i=0; i<2; i++){
4497
                            j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
4498
                            s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
4499
                            s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
4500
                        }
4501
                    }
4502
                    motion_x=motion_y=0;
4503
                    break;
4504
                default:
4505
                    motion_x=motion_y=0; //gcc warning fix
4506
                    av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
4507
                }
4508

    
4509
                encode_mb(s, motion_x, motion_y);
4510

    
4511
                // RAL: Update last macrobloc type
4512
                s->last_mv_dir = s->mv_dir;
4513
            
4514
#ifdef CONFIG_RISKY
4515
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4516
                    ff_h263_update_motion_val(s);
4517
#endif
4518
                
4519
                MPV_decode_mb(s, s->block);
4520
            }
4521

    
4522
            /* clean the MV table in IPS frames for direct mode in B frames */
4523
            if(s->mb_intra /* && I,P,S_TYPE */){
4524
                s->p_mv_table[xy][0]=0;
4525
                s->p_mv_table[xy][1]=0;
4526
            }
4527
            
4528
            if(s->flags&CODEC_FLAG_PSNR){
4529
                int w= 16;
4530
                int h= 16;
4531

    
4532
                if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4533
                if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4534

    
4535
                s->current_picture_ptr->error[0] += sse(
4536
                    s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
4537
                    s->dest[0], w, h, s->linesize);
4538
                s->current_picture_ptr->error[1] += sse(
4539
                    s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
4540
                    s->dest[1], w>>1, h>>1, s->uvlinesize);
4541
                s->current_picture_ptr->error[2] += sse(
4542
                    s, s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
4543
                    s->dest[2], w>>1, h>>1, s->uvlinesize);
4544
            }
4545
            if(s->loop_filter)
4546
                ff_h263_loop_filter(s);
4547
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, get_bit_count(&s->pb));
4548
        }
4549
    }
4550
    emms_c();
4551

    
4552
#ifdef CONFIG_RISKY
4553
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
4554
        ff_mpeg4_merge_partitions(s);
4555

    
4556
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
4557
        msmpeg4_encode_ext_header(s);
4558

    
4559
    if(s->codec_id==CODEC_ID_MPEG4) 
4560
        ff_mpeg4_stuffing(&s->pb);
4561
#endif
4562

    
4563
    /* Send the last GOB if RTP */    
4564
    if (s->avctx->rtp_callback) {
4565
        flush_put_bits(&s->pb);
4566
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
4567
        /* Call the RTP callback to send the last GOB */
4568
        s->avctx->rtp_callback(s->ptr_lastgob, pdif, 0);
4569
    }
4570
}
4571

    
4572
#endif //CONFIG_ENCODERS
4573

    
4574
static void  denoise_dct_c(MpegEncContext *s, DCTELEM *block){
4575
    const int intra= s->mb_intra;
4576
    int i;
4577

    
4578
    s->dct_count[intra]++;
4579

    
4580
    for(i=0; i<64; i++){
4581
        int level= block[i];
4582

    
4583
        if(level){
4584
            if(level>0){
4585
                s->dct_error_sum[intra][i] += level;
4586
                level -= s->dct_offset[intra][i];
4587
                if(level<0) level=0;
4588
            }else{
4589
                s->dct_error_sum[intra][i] -= level;
4590
                level += s->dct_offset[intra][i];
4591
                if(level>0) level=0;
4592
            }
4593
            block[i]= level;
4594
        }
4595
    }
4596
}
4597

    
4598
#ifdef CONFIG_ENCODERS
4599

    
4600
static int dct_quantize_trellis_c(MpegEncContext *s, 
4601
                        DCTELEM *block, int n,
4602
                        int qscale, int *overflow){
4603
    const int *qmat;
4604
    const uint8_t *scantable= s->intra_scantable.scantable;
4605
    const uint8_t *perm_scantable= s->intra_scantable.permutated;
4606
    int max=0;
4607
    unsigned int threshold1, threshold2;
4608
    int bias=0;
4609
    int run_tab[65];
4610
    int level_tab[65];
4611
    int score_tab[65];
4612
    int survivor[65];
4613
    int survivor_count;
4614
    int last_run=0;
4615
    int last_level=0;
4616
    int last_score= 0;
4617
    int last_i;
4618
    int coeff[2][64];
4619
    int coeff_count[64];
4620
    int qmul, qadd, start_i, last_non_zero, i, dc;
4621
    const int esc_length= s->ac_esc_length;
4622
    uint8_t * length;
4623
    uint8_t * last_length;
4624
    const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
4625
        
4626
    s->dsp.fdct (block);
4627
    
4628
    if(s->dct_error_sum)
4629
        s->denoise_dct(s, block);
4630
    qmul= qscale*16;
4631
    qadd= ((qscale-1)|1)*8;
4632

    
4633
    if (s->mb_intra) {
4634
        int q;
4635
        if (!s->h263_aic) {
4636
            if (n < 4)
4637
                q = s->y_dc_scale;
4638
            else
4639
                q = s->c_dc_scale;
4640
            q = q << 3;
4641
        } else{
4642
            /* For AIC we skip quant/dequant of INTRADC */
4643
            q = 1 << 3;
4644
            qadd=0;
4645
        }
4646
            
4647
        /* note: block[0] is assumed to be positive */
4648
        block[0] = (block[0] + (q >> 1)) / q;
4649
        start_i = 1;
4650
        last_non_zero = 0;
4651
        qmat = s->q_intra_matrix[qscale];
4652
        if(s->mpeg_quant || s->out_format == FMT_MPEG1)
4653
            bias= 1<<(QMAT_SHIFT-