Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ e20c4069

History | View | Annotate | Download (149 KB)

1
/*
2
 * The simplest mpeg encoder (well, it was the simplest!)
3
 * Copyright (c) 2000,2001 Fabrice Bellard.
4
 *
5
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9
 *
10
 * This library is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 *
19
 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
20
 */
21
 
22
/**
23
 * @file mpegvideo.c
24
 * The simplest mpeg encoder (well, it was the simplest!).
25
 */ 
26
 
27
#include <ctype.h>
28
#include <limits.h>
29
#include "avcodec.h"
30
#include "dsputil.h"
31
#include "mpegvideo.h"
32

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

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

    
40
#ifdef CONFIG_ENCODERS
41
static void encode_picture(MpegEncContext *s, int picture_number);
42
#endif //CONFIG_ENCODERS
43
static void dct_unquantize_mpeg1_c(MpegEncContext *s, 
44
                                   DCTELEM *block, int n, int qscale);
45
static void dct_unquantize_mpeg2_c(MpegEncContext *s,
46
                                   DCTELEM *block, int n, int qscale);
47
static void dct_unquantize_h263_c(MpegEncContext *s, 
48
                                  DCTELEM *block, int n, int qscale);
49
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
50
#ifdef CONFIG_ENCODERS
51
static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
52
static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
53
#endif //CONFIG_ENCODERS
54

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

    
57

    
58
/* enable all paranoid tests for rounding, overflows, etc... */
59
//#define PARANOID
60

    
61
//#define DEBUG
62

    
63

    
64
/* for jpeg fast DCT */
65
#define CONST_BITS 14
66

    
67
static const uint16_t aanscales[64] = {
68
    /* precomputed values scaled up by 14 bits */
69
    16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
70
    22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
71
    21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
72
    19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
73
    16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
74
    12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
75
    8867 , 12299, 11585, 10426,  8867,  6967,  4799,  2446,
76
    4520 ,  6270,  5906,  5315,  4520,  3552,  2446,  1247
77
};
78

    
79
static const uint8_t h263_chroma_roundtab[16] = {
80
//  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
81
    0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
82
};
83

    
84
#ifdef CONFIG_ENCODERS
85
static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
86
static uint8_t default_fcode_tab[MAX_MV*2+1];
87

    
88
enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
89

    
90
static void convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[64], uint16_t (*qmat16_bias)[64],
91
                           const uint16_t *quant_matrix, int bias, int qmin, int qmax)
92
{
93
    int qscale;
94

    
95
    for(qscale=qmin; qscale<=qmax; qscale++){
96
        int i;
97
        if (s->dsp.fdct == ff_jpeg_fdct_islow) {
98
            for(i=0;i<64;i++) {
99
                const int j= s->dsp.idct_permutation[i];
100
                /* 16 <= qscale * quant_matrix[i] <= 7905 */
101
                /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
102
                /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
103
                /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
104
                
105
                qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / 
106
                                (qscale * quant_matrix[j]));
107
            }
108
        } else if (s->dsp.fdct == fdct_ifast) {
109
            for(i=0;i<64;i++) {
110
                const int j= s->dsp.idct_permutation[i];
111
                /* 16 <= qscale * quant_matrix[i] <= 7905 */
112
                /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
113
                /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
114
                /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
115
                
116
                qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) / 
117
                                (aanscales[i] * qscale * quant_matrix[j]));
118
            }
119
        } else {
120
            for(i=0;i<64;i++) {
121
                const int j= s->dsp.idct_permutation[i];
122
                /* We can safely suppose that 16 <= quant_matrix[i] <= 255
123
                   So 16           <= qscale * quant_matrix[i]             <= 7905
124
                   so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
125
                   so 32768        >= (1<<19) / (qscale * quant_matrix[i]) >= 67
126
                */
127
                qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
128
//                qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
129
                qmat16[qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
130

    
131
                if(qmat16[qscale][i]==0 || qmat16[qscale][i]==128*256) qmat16[qscale][i]=128*256-1;
132
                qmat16_bias[qscale][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][i]);
133
            }
134
        }
135
    }
136
}
137
#endif //CONFIG_ENCODERS
138

    
139
void ff_init_scantable(MpegEncContext *s, ScanTable *st, const uint8_t *src_scantable){
140
    int i;
141
    int end;
142
    
143
    st->scantable= src_scantable;
144

    
145
    for(i=0; i<64; i++){
146
        int j;
147
        j = src_scantable[i];
148
        st->permutated[i] = s->dsp.idct_permutation[j];
149
#ifdef ARCH_POWERPC
150
        st->inverse[j] = i;
151
#endif
152
    }
153
    
154
    end=-1;
155
    for(i=0; i<64; i++){
156
        int j;
157
        j = st->permutated[i];
158
        if(j>end) end=j;
159
        st->raster_end[i]= end;
160
    }
161
}
162

    
163
/* init common dct for both encoder and decoder */
164
int DCT_common_init(MpegEncContext *s)
165
{
166
    s->dct_unquantize_h263 = dct_unquantize_h263_c;
167
    s->dct_unquantize_mpeg1 = dct_unquantize_mpeg1_c;
168
    s->dct_unquantize_mpeg2 = dct_unquantize_mpeg2_c;
169

    
170
#ifdef CONFIG_ENCODERS
171
    s->dct_quantize= dct_quantize_c;
172
#endif
173
        
174
#ifdef HAVE_MMX
175
    MPV_common_init_mmx(s);
176
#endif
177
#ifdef ARCH_ALPHA
178
    MPV_common_init_axp(s);
179
#endif
180
#ifdef HAVE_MLIB
181
    MPV_common_init_mlib(s);
182
#endif
183
#ifdef HAVE_MMI
184
    MPV_common_init_mmi(s);
185
#endif
186
#ifdef ARCH_ARMV4L
187
    MPV_common_init_armv4l(s);
188
#endif
189
#ifdef ARCH_POWERPC
190
    MPV_common_init_ppc(s);
191
#endif
192

    
193
#ifdef CONFIG_ENCODERS
194
    s->fast_dct_quantize= s->dct_quantize;
195

    
196
    if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
197
        s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
198
    }
199

    
200
#endif //CONFIG_ENCODERS
201

    
202
    /* load & permutate scantables
203
       note: only wmv uses differnt ones 
204
    */
205
    ff_init_scantable(s, &s->inter_scantable  , ff_zigzag_direct);
206
    ff_init_scantable(s, &s->intra_scantable  , ff_zigzag_direct);
207
    ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);
208
    ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
209

    
210
    s->picture_structure= PICT_FRAME;
211
    
212
    return 0;
213
}
214

    
215
/**
216
 * allocates a Picture
217
 * The pixels are allocated/set by calling get_buffer() if shared=0
218
 */
219
static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
220
    const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
221
    const int mb_array_size= s->mb_stride*s->mb_height;
222
    int i;
223
    
224
    if(shared){
225
        assert(pic->data[0]);
226
        assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
227
        pic->type= FF_BUFFER_TYPE_SHARED;
228
    }else{
229
        int r;
230
        
231
        assert(!pic->data[0]);
232
        
233
        r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
234
        
235
        if(r<0 || !pic->age || !pic->type || !pic->data[0]){
236
            fprintf(stderr, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
237
            return -1;
238
        }
239

    
240
        if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
241
            fprintf(stderr, "get_buffer() failed (stride changed)\n");
242
            return -1;
243
        }
244

    
245
        if(pic->linesize[1] != pic->linesize[2]){
246
            fprintf(stderr, "get_buffer() failed (uv stride missmatch)\n");
247
            return -1;
248
        }
249

    
250
        s->linesize  = pic->linesize[0];
251
        s->uvlinesize= pic->linesize[1];
252
    }
253
    
254
    if(pic->qscale_table==NULL){
255
        if (s->encoding) {        
256
            CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
257
            CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
258
            CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
259
            CHECKED_ALLOCZ(pic->mb_cmp_score, mb_array_size * sizeof(int32_t))
260
        }
261

    
262
        CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
263
        CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
264
        CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num    * sizeof(int))
265
        pic->mb_type= pic->mb_type_base + s->mb_stride+1;
266
        if(s->out_format == FMT_H264){
267
            for(i=0; i<2; i++){
268
                CHECKED_ALLOCZ(pic->motion_val[i], 2 * 16 * s->mb_num * sizeof(uint16_t))
269
                CHECKED_ALLOCZ(pic->ref_index[i] , 4 * s->mb_num * sizeof(uint8_t))
270
            }
271
        }
272
        pic->qstride= s->mb_stride;
273
    }
274

    
275
    //it might be nicer if the application would keep track of these but it would require a API change
276
    memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
277
    s->prev_pict_types[0]= s->pict_type;
278
    if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
279
        pic->age= INT_MAX; // skiped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
280
    
281
    return 0;
282
fail: //for the CHECKED_ALLOCZ macro
283
    return -1;
284
}
285

    
286
/**
287
 * deallocates a picture
288
 */
289
static void free_picture(MpegEncContext *s, Picture *pic){
290
    int i;
291

    
292
    if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
293
        s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
294
    }
295

    
296
    av_freep(&pic->mb_var);
297
    av_freep(&pic->mc_mb_var);
298
    av_freep(&pic->mb_mean);
299
    av_freep(&pic->mb_cmp_score);
300
    av_freep(&pic->mbskip_table);
301
    av_freep(&pic->qscale_table);
302
    av_freep(&pic->mb_type_base);
303
    pic->mb_type= NULL;
304
    for(i=0; i<2; i++){
305
        av_freep(&pic->motion_val[i]);
306
        av_freep(&pic->ref_index[i]);
307
    }
308
    
309
    if(pic->type == FF_BUFFER_TYPE_SHARED){
310
        for(i=0; i<4; i++){
311
            pic->base[i]=
312
            pic->data[i]= NULL;
313
        }
314
        pic->type= 0;        
315
    }
316
}
317

    
318
/* init common structure for both encoder and decoder */
319
int MPV_common_init(MpegEncContext *s)
320
{
321
    int y_size, c_size, yc_size, i, mb_array_size, x, y;
322

    
323
    dsputil_init(&s->dsp, s->avctx);
324
    DCT_common_init(s);
325

    
326
    s->flags= s->avctx->flags;
327

    
328
    s->mb_width  = (s->width  + 15) / 16;
329
    s->mb_height = (s->height + 15) / 16;
330
    s->mb_stride = s->mb_width + 1;
331
    mb_array_size= s->mb_height * s->mb_stride;
332

    
333
    /* set default edge pos, will be overriden in decode_header if needed */
334
    s->h_edge_pos= s->mb_width*16;
335
    s->v_edge_pos= s->mb_height*16;
336

    
337
    s->mb_num = s->mb_width * s->mb_height;
338
    
339
    s->block_wrap[0]=
340
    s->block_wrap[1]=
341
    s->block_wrap[2]=
342
    s->block_wrap[3]= s->mb_width*2 + 2;
343
    s->block_wrap[4]=
344
    s->block_wrap[5]= s->mb_width + 2;
345

    
346
    y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
347
    c_size = (s->mb_width + 2) * (s->mb_height + 2);
348
    yc_size = y_size + 2 * c_size;
349

    
350
    /* convert fourcc to upper case */
351
    s->avctx->codec_tag=   toupper( s->avctx->codec_tag     &0xFF)          
352
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
353
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16) 
354
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
355

    
356
    CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
357
    s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
358

    
359
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
360

    
361
    CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
362
    for(y=0; y<s->mb_height; y++){
363
        for(x=0; x<s->mb_width; x++){
364
            s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
365
        }
366
    }
367
    s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
368
    
369
    if (s->encoding) {
370
        int mv_table_size= s->mb_stride * (s->mb_height+2) + 1;
371

    
372
        /* Allocate MV tables */
373
        CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
374
        CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
375
        CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
376
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
377
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
378
        CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
379
        s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
380
        s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
381
        s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
382
        s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
383
        s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
384
        s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
385

    
386
        //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
387
        CHECKED_ALLOCZ(s->me.scratchpad,  s->width*2*16*3*sizeof(uint8_t)) 
388
        
389
        CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
390
        CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
391

    
392
        if(s->codec_id==CODEC_ID_MPEG4){
393
            CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
394
            CHECKED_ALLOCZ(   s->pb2_buffer, PB_BUFFER_SIZE);
395
        }
396
        
397
        if(s->msmpeg4_version){
398
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
399
        }
400
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
401

    
402
        /* Allocate MB type table */
403
        CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint8_t)) //needed for encoding
404
    }
405
        
406
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
407
    
408
    if (s->out_format == FMT_H263 || s->encoding) {
409
        int size;
410

    
411
        /* MV prediction */
412
        size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
413
        CHECKED_ALLOCZ(s->motion_val, size * 2 * sizeof(int16_t));
414
    }
415

    
416
    if(s->codec_id==CODEC_ID_MPEG4){
417
        /* interlaced direct mode decoding tables */
418
        CHECKED_ALLOCZ(s->field_mv_table, mb_array_size*2*2 * sizeof(int16_t))
419
        CHECKED_ALLOCZ(s->field_select_table, mb_array_size*2* sizeof(int8_t))
420
    }
421
    if (s->out_format == FMT_H263) {
422
        /* ac values */
423
        CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(int16_t) * 16);
424
        s->ac_val[1] = s->ac_val[0] + y_size;
425
        s->ac_val[2] = s->ac_val[1] + c_size;
426
        
427
        /* cbp values */
428
        CHECKED_ALLOCZ(s->coded_block, y_size);
429
        
430
        /* divx501 bitstream reorder buffer */
431
        CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
432

    
433
        /* cbp, ac_pred, pred_dir */
434
        CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
435
        CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
436
    }
437
    
438
    if (s->h263_pred || s->h263_plus || !s->encoding) {
439
        /* dc values */
440
        //MN: we need these for error resilience of intra-frames
441
        CHECKED_ALLOCZ(s->dc_val[0], yc_size * sizeof(int16_t));
442
        s->dc_val[1] = s->dc_val[0] + y_size;
443
        s->dc_val[2] = s->dc_val[1] + c_size;
444
        for(i=0;i<yc_size;i++)
445
            s->dc_val[0][i] = 1024;
446
    }
447

    
448
    /* which mb is a intra block */
449
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
450
    memset(s->mbintra_table, 1, mb_array_size);
451
    
452
    /* default structure is frame */
453
    s->picture_structure = PICT_FRAME;
454
    
455
    /* init macroblock skip table */
456
    CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
457
    //Note the +1 is for a quicker mpeg4 slice_end detection
458
    CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
459
    
460
    s->block= s->blocks[0];
461

    
462
    s->parse_context.state= -1;
463

    
464
    s->context_initialized = 1;
465
    return 0;
466
 fail:
467
    MPV_common_end(s);
468
    return -1;
469
}
470

    
471

    
472
//extern int sads;
473

    
474
/* init common structure for both encoder and decoder */
475
void MPV_common_end(MpegEncContext *s)
476
{
477
    int i;
478

    
479
    av_freep(&s->mb_type);
480
    av_freep(&s->p_mv_table_base);
481
    av_freep(&s->b_forw_mv_table_base);
482
    av_freep(&s->b_back_mv_table_base);
483
    av_freep(&s->b_bidir_forw_mv_table_base);
484
    av_freep(&s->b_bidir_back_mv_table_base);
485
    av_freep(&s->b_direct_mv_table_base);
486
    s->p_mv_table= NULL;
487
    s->b_forw_mv_table= NULL;
488
    s->b_back_mv_table= NULL;
489
    s->b_bidir_forw_mv_table= NULL;
490
    s->b_bidir_back_mv_table= NULL;
491
    s->b_direct_mv_table= NULL;
492
    
493
    av_freep(&s->motion_val);
494
    av_freep(&s->dc_val[0]);
495
    av_freep(&s->ac_val[0]);
496
    av_freep(&s->coded_block);
497
    av_freep(&s->mbintra_table);
498
    av_freep(&s->cbp_table);
499
    av_freep(&s->pred_dir_table);
500
    av_freep(&s->me.scratchpad);
501
    av_freep(&s->me.map);
502
    av_freep(&s->me.score_map);
503
    
504
    av_freep(&s->mbskip_table);
505
    av_freep(&s->prev_pict_types);
506
    av_freep(&s->bitstream_buffer);
507
    av_freep(&s->tex_pb_buffer);
508
    av_freep(&s->pb2_buffer);
509
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
510
    av_freep(&s->field_mv_table);
511
    av_freep(&s->field_select_table);
512
    av_freep(&s->avctx->stats_out);
513
    av_freep(&s->ac_stats);
514
    av_freep(&s->error_status_table);
515
    av_freep(&s->mb_index2xy);
516

    
517
    for(i=0; i<MAX_PICTURE_COUNT; i++){
518
        free_picture(s, &s->picture[i]);
519
    }
520
    avcodec_default_free_buffers(s->avctx);
521
    s->context_initialized = 0;
522
}
523

    
524
#ifdef CONFIG_ENCODERS
525

    
526
/* init video encoder */
527
int MPV_encode_init(AVCodecContext *avctx)
528
{
529
    MpegEncContext *s = avctx->priv_data;
530
    int i;
531

    
532
    avctx->pix_fmt = PIX_FMT_YUV420P;
533

    
534
    s->bit_rate = avctx->bit_rate;
535
    s->bit_rate_tolerance = avctx->bit_rate_tolerance;
536
    s->width = avctx->width;
537
    s->height = avctx->height;
538
    if(avctx->gop_size > 600){
539
        fprintf(stderr, "Warning keyframe interval too large! reducing it ...\n");
540
        avctx->gop_size=600;
541
    }
542
    s->gop_size = avctx->gop_size;
543
    s->rtp_mode = avctx->rtp_mode;
544
    s->rtp_payload_size = avctx->rtp_payload_size;
545
    if (avctx->rtp_callback)
546
        s->rtp_callback = avctx->rtp_callback;
547
    s->max_qdiff= avctx->max_qdiff;
548
    s->qcompress= avctx->qcompress;
549
    s->qblur= avctx->qblur;
550
    s->avctx = avctx;
551
    s->flags= avctx->flags;
552
    s->max_b_frames= avctx->max_b_frames;
553
    s->b_frame_strategy= avctx->b_frame_strategy;
554
    s->codec_id= avctx->codec->id;
555
    s->luma_elim_threshold  = avctx->luma_elim_threshold;
556
    s->chroma_elim_threshold= avctx->chroma_elim_threshold;
557
    s->strict_std_compliance= avctx->strict_std_compliance;
558
    s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
559
    s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
560
    s->mpeg_quant= avctx->mpeg_quant;
561

    
562
    if (s->gop_size <= 1) {
563
        s->intra_only = 1;
564
        s->gop_size = 12;
565
    } else {
566
        s->intra_only = 0;
567
    }
568

    
569
    s->me_method = avctx->me_method;
570

    
571
    /* Fixed QSCALE */
572
    s->fixed_qscale = (avctx->flags & CODEC_FLAG_QSCALE);
573
    
574
    s->adaptive_quant= (   s->avctx->lumi_masking
575
                        || s->avctx->dark_masking
576
                        || s->avctx->temporal_cplx_masking 
577
                        || s->avctx->spatial_cplx_masking
578
                        || s->avctx->p_masking)
579
                       && !s->fixed_qscale;
580
    
581
    s->progressive_sequence= !(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
582

    
583
    if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4){
584
        fprintf(stderr, "4MV not supporetd by codec\n");
585
        return -1;
586
    }
587
    
588
    if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
589
        fprintf(stderr, "qpel not supporetd by codec\n");
590
        return -1;
591
    }
592

    
593
    if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
594
        fprintf(stderr, "data partitioning not supporetd by codec\n");
595
        return -1;
596
    }
597
    
598
    if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO){
599
        fprintf(stderr, "b frames not supporetd by codec\n");
600
        return -1;
601
    }
602
    
603
    if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
604
        fprintf(stderr, "mpeg2 style quantization not supporetd by codec\n");
605
        return -1;
606
    }
607
        
608
    if(s->codec_id==CODEC_ID_MJPEG){
609
        s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
610
        s->inter_quant_bias= 0;
611
    }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO){
612
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
613
        s->inter_quant_bias= 0;
614
    }else{
615
        s->intra_quant_bias=0;
616
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
617
    }
618
    
619
    if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
620
        s->intra_quant_bias= avctx->intra_quant_bias;
621
    if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
622
        s->inter_quant_bias= avctx->inter_quant_bias;
623
    
624
    switch(avctx->codec->id) {
625
    case CODEC_ID_MPEG1VIDEO:
626
        s->out_format = FMT_MPEG1;
627
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
628
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
629
        break;
630
    case CODEC_ID_MJPEG:
631
        s->out_format = FMT_MJPEG;
632
        s->intra_only = 1; /* force intra only for jpeg */
633
        s->mjpeg_write_tables = 1; /* write all tables */
634
        s->mjpeg_data_only_frames = 0; /* write all the needed headers */
635
        s->mjpeg_vsample[0] = 2; /* set up default sampling factors */
636
        s->mjpeg_vsample[1] = 1; /* the only currently supported values */
637
        s->mjpeg_vsample[2] = 1; 
638
        s->mjpeg_hsample[0] = 2;
639
        s->mjpeg_hsample[1] = 1; 
640
        s->mjpeg_hsample[2] = 1; 
641
        if (mjpeg_init(s) < 0)
642
            return -1;
643
        avctx->delay=0;
644
        s->low_delay=1;
645
        break;
646
#ifdef CONFIG_RISKY
647
    case CODEC_ID_H263:
648
        if (h263_get_picture_format(s->width, s->height) == 7) {
649
            printf("Input picture size isn't suitable for h263 codec! try h263+\n");
650
            return -1;
651
        }
652
        s->out_format = FMT_H263;
653
        avctx->delay=0;
654
        s->low_delay=1;
655
        break;
656
    case CODEC_ID_H263P:
657
        s->out_format = FMT_H263;
658
        s->h263_plus = 1;
659
        /* Fx */
660
        s->unrestricted_mv=(avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
661
        s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
662
        /* /Fx */
663
        /* These are just to be sure */
664
        s->umvplus = 1;
665
        avctx->delay=0;
666
        s->low_delay=1;
667
        break;
668
    case CODEC_ID_RV10:
669
        s->out_format = FMT_H263;
670
        s->h263_rv10 = 1;
671
        avctx->delay=0;
672
        s->low_delay=1;
673
        break;
674
    case CODEC_ID_MPEG4:
675
        s->out_format = FMT_H263;
676
        s->h263_pred = 1;
677
        s->unrestricted_mv = 1;
678
        s->low_delay= s->max_b_frames ? 0 : 1;
679
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
680
        break;
681
    case CODEC_ID_MSMPEG4V1:
682
        s->out_format = FMT_H263;
683
        s->h263_msmpeg4 = 1;
684
        s->h263_pred = 1;
685
        s->unrestricted_mv = 1;
686
        s->msmpeg4_version= 1;
687
        avctx->delay=0;
688
        s->low_delay=1;
689
        break;
690
    case CODEC_ID_MSMPEG4V2:
691
        s->out_format = FMT_H263;
692
        s->h263_msmpeg4 = 1;
693
        s->h263_pred = 1;
694
        s->unrestricted_mv = 1;
695
        s->msmpeg4_version= 2;
696
        avctx->delay=0;
697
        s->low_delay=1;
698
        break;
699
    case CODEC_ID_MSMPEG4V3:
700
        s->out_format = FMT_H263;
701
        s->h263_msmpeg4 = 1;
702
        s->h263_pred = 1;
703
        s->unrestricted_mv = 1;
704
        s->msmpeg4_version= 3;
705
        s->flipflop_rounding=1;
706
        avctx->delay=0;
707
        s->low_delay=1;
708
        break;
709
    case CODEC_ID_WMV1:
710
        s->out_format = FMT_H263;
711
        s->h263_msmpeg4 = 1;
712
        s->h263_pred = 1;
713
        s->unrestricted_mv = 1;
714
        s->msmpeg4_version= 4;
715
        s->flipflop_rounding=1;
716
        avctx->delay=0;
717
        s->low_delay=1;
718
        break;
719
    case CODEC_ID_WMV2:
720
        s->out_format = FMT_H263;
721
        s->h263_msmpeg4 = 1;
722
        s->h263_pred = 1;
723
        s->unrestricted_mv = 1;
724
        s->msmpeg4_version= 5;
725
        s->flipflop_rounding=1;
726
        avctx->delay=0;
727
        s->low_delay=1;
728
        break;
729
#endif
730
    default:
731
        return -1;
732
    }
733
    
734
    { /* set up some save defaults, some codecs might override them later */
735
        static int done=0;
736
        if(!done){
737
            int i;
738
            done=1;
739

    
740
            default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
741
            memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
742
            memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
743

    
744
            for(i=-16; i<16; i++){
745
                default_fcode_tab[i + MAX_MV]= 1;
746
            }
747
        }
748
    }
749
    s->me.mv_penalty= default_mv_penalty;
750
    s->fcode_tab= default_fcode_tab;
751
    s->y_dc_scale_table=
752
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
753
 
754
    /* dont use mv_penalty table for crap MV as it would be confused */
755
    //FIXME remove after fixing / removing old ME
756
    if (s->me_method < ME_EPZS) s->me.mv_penalty = default_mv_penalty;
757

    
758
    s->encoding = 1;
759

    
760
    /* init */
761
    if (MPV_common_init(s) < 0)
762
        return -1;
763
    
764
    ff_init_me(s);
765

    
766
#ifdef CONFIG_ENCODERS
767
#ifdef CONFIG_RISKY
768
    if (s->out_format == FMT_H263)
769
        h263_encode_init(s);
770
    if(s->msmpeg4_version)
771
        ff_msmpeg4_encode_init(s);
772
#endif
773
    if (s->out_format == FMT_MPEG1)
774
        ff_mpeg1_encode_init(s);
775
#endif
776

    
777
    /* init default q matrix */
778
    for(i=0;i<64;i++) {
779
        int j= s->dsp.idct_permutation[i];
780
#ifdef CONFIG_RISKY
781
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
782
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
783
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
784
        }else if(s->out_format == FMT_H263){
785
            s->intra_matrix[j] =
786
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
787
        }else
788
#endif
789
        { /* mpeg1 */
790
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
791
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
792
        }
793
    }
794

    
795
    /* precompute matrix */
796
    /* for mjpeg, we do include qscale in the matrix */
797
    if (s->out_format != FMT_MJPEG) {
798
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, s->q_intra_matrix16_bias, 
799
                       s->intra_matrix, s->intra_quant_bias, 1, 31);
800
        convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16, s->q_inter_matrix16_bias, 
801
                       s->inter_matrix, s->inter_quant_bias, 1, 31);
802
    }
803

    
804
    if(ff_rate_control_init(s) < 0)
805
        return -1;
806

    
807
    s->picture_number = 0;
808
    s->picture_in_gop_number = 0;
809
    s->fake_picture_number = 0;
810
    /* motion detector init */
811
    s->f_code = 1;
812
    s->b_code = 1;
813

    
814
    return 0;
815
}
816

    
817
int MPV_encode_end(AVCodecContext *avctx)
818
{
819
    MpegEncContext *s = avctx->priv_data;
820

    
821
#ifdef STATS
822
    print_stats();
823
#endif
824

    
825
    ff_rate_control_uninit(s);
826

    
827
    MPV_common_end(s);
828
    if (s->out_format == FMT_MJPEG)
829
        mjpeg_close(s);
830
      
831
    return 0;
832
}
833

    
834
#endif //CONFIG_ENCODERS
835

    
836
void init_rl(RLTable *rl)
837
{
838
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
839
    uint8_t index_run[MAX_RUN+1];
840
    int last, run, level, start, end, i;
841

    
842
    /* compute max_level[], max_run[] and index_run[] */
843
    for(last=0;last<2;last++) {
844
        if (last == 0) {
845
            start = 0;
846
            end = rl->last;
847
        } else {
848
            start = rl->last;
849
            end = rl->n;
850
        }
851

    
852
        memset(max_level, 0, MAX_RUN + 1);
853
        memset(max_run, 0, MAX_LEVEL + 1);
854
        memset(index_run, rl->n, MAX_RUN + 1);
855
        for(i=start;i<end;i++) {
856
            run = rl->table_run[i];
857
            level = rl->table_level[i];
858
            if (index_run[run] == rl->n)
859
                index_run[run] = i;
860
            if (level > max_level[run])
861
                max_level[run] = level;
862
            if (run > max_run[level])
863
                max_run[level] = run;
864
        }
865
        rl->max_level[last] = av_malloc(MAX_RUN + 1);
866
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
867
        rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
868
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
869
        rl->index_run[last] = av_malloc(MAX_RUN + 1);
870
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
871
    }
872
}
873

    
874
/* draw the edges of width 'w' of an image of size width, height */
875
//FIXME check that this is ok for mpeg4 interlaced
876
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
877
{
878
    uint8_t *ptr, *last_line;
879
    int i;
880

    
881
    last_line = buf + (height - 1) * wrap;
882
    for(i=0;i<w;i++) {
883
        /* top and bottom */
884
        memcpy(buf - (i + 1) * wrap, buf, width);
885
        memcpy(last_line + (i + 1) * wrap, last_line, width);
886
    }
887
    /* left and right */
888
    ptr = buf;
889
    for(i=0;i<height;i++) {
890
        memset(ptr - w, ptr[0], w);
891
        memset(ptr + width, ptr[width-1], w);
892
        ptr += wrap;
893
    }
894
    /* corners */
895
    for(i=0;i<w;i++) {
896
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
897
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
898
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
899
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
900
    }
901
}
902

    
903
static int find_unused_picture(MpegEncContext *s, int shared){
904
    int i;
905
    
906
    if(shared){
907
        for(i=0; i<MAX_PICTURE_COUNT; i++){
908
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) break;
909
        }
910
    }else{
911
        for(i=0; i<MAX_PICTURE_COUNT; i++){
912
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) break; //FIXME
913
        }
914
        for(i=0; i<MAX_PICTURE_COUNT; i++){
915
            if(s->picture[i].data[0]==NULL) break;
916
        }
917
    }
918

    
919
    assert(i<MAX_PICTURE_COUNT);
920
    return i;
921
}
922

    
923
/* generic function for encode/decode called before a frame is coded/decoded */
924
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
925
{
926
    int i;
927
    AVFrame *pic;
928

    
929
    s->mb_skiped = 0;
930

    
931
    assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264);
932

    
933
    /* mark&release old frames */
934
    if (s->pict_type != B_TYPE && s->last_picture_ptr) {
935
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
936

    
937
        /* release forgotten pictures */
938
        /* if(mpeg124/h263) */
939
        if(!s->encoding){
940
            for(i=0; i<MAX_PICTURE_COUNT; i++){
941
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
942
                    fprintf(stderr, "releasing zombie picture\n");
943
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
944
                }
945
            }
946
        }
947
    }
948
alloc:
949
    if(!s->encoding){
950
        /* release non refernce frames */
951
        for(i=0; i<MAX_PICTURE_COUNT; i++){
952
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
953
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
954
            }
955
        }
956

    
957
        i= find_unused_picture(s, 0);
958
    
959
        pic= (AVFrame*)&s->picture[i];
960
        pic->reference= s->pict_type != B_TYPE ? 3 : 0;
961

    
962
        if(s->current_picture_ptr)
963
            pic->coded_picture_number= s->current_picture_ptr->coded_picture_number+1;
964
        
965
        alloc_picture(s, (Picture*)pic, 0);
966

    
967
        s->current_picture_ptr= &s->picture[i];
968
    }
969

    
970
    s->current_picture_ptr->pict_type= s->pict_type;
971
    s->current_picture_ptr->quality= s->qscale;
972
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
973

    
974
    s->current_picture= *s->current_picture_ptr;
975
  
976
  if(s->out_format != FMT_H264){
977
    if (s->pict_type != B_TYPE) {
978
        s->last_picture_ptr= s->next_picture_ptr;
979
        s->next_picture_ptr= s->current_picture_ptr;
980
    }
981
    
982
    if(s->last_picture_ptr) s->last_picture= *s->last_picture_ptr;
983
    if(s->next_picture_ptr) s->next_picture= *s->next_picture_ptr;
984
    if(s->new_picture_ptr ) s->new_picture = *s->new_picture_ptr;
985
    
986
    if(s->picture_structure!=PICT_FRAME){
987
        int i;
988
        for(i=0; i<4; i++){
989
            if(s->picture_structure == PICT_BOTTOM_FIELD){
990
                 s->current_picture.data[i] += s->current_picture.linesize[i];
991
            } 
992
            s->current_picture.linesize[i] *= 2;
993
            s->last_picture.linesize[i] *=2;
994
            s->next_picture.linesize[i] *=2;
995
        }
996
    }
997
    
998
    if(s->pict_type != I_TYPE && s->last_picture_ptr==NULL){
999
        fprintf(stderr, "warning: first frame is no keyframe\n");
1000
        assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1001
        goto alloc;
1002
    }
1003
  }
1004
   
1005
    s->hurry_up= s->avctx->hurry_up;
1006
    s->error_resilience= avctx->error_resilience;
1007

    
1008
    /* set dequantizer, we cant do it during init as it might change for mpeg4
1009
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1010
    if(s->out_format == FMT_H263){
1011
        if(s->mpeg_quant)
1012
            s->dct_unquantize = s->dct_unquantize_mpeg2;
1013
        else
1014
            s->dct_unquantize = s->dct_unquantize_h263;
1015
    }else 
1016
        s->dct_unquantize = s->dct_unquantize_mpeg1;
1017

    
1018
    return 0;
1019
}
1020

    
1021
/* generic function for encode/decode called after a frame has been coded/decoded */
1022
void MPV_frame_end(MpegEncContext *s)
1023
{
1024
    int i;
1025
    /* draw edge for correct motion prediction if outside */
1026
    if(s->codec_id!=CODEC_ID_SVQ1){
1027
        if (s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1028
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1029
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1030
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1031
        }
1032
    }
1033
    emms_c();
1034
    
1035
    s->last_pict_type    = s->pict_type;
1036
    if(s->pict_type!=B_TYPE){
1037
        s->last_non_b_pict_type= s->pict_type;
1038
    }
1039
#if 0
1040
        /* copy back current_picture variables */
1041
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1042
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1043
            s->picture[i]= s->current_picture;
1044
            break;
1045
        }    
1046
    }
1047
    assert(i<MAX_PICTURE_COUNT);
1048
#endif    
1049

    
1050
    if(s->encoding){
1051
        /* release non refernce frames */
1052
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1053
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1054
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1055
            }
1056
        }
1057
    }
1058
    // clear copies, to avoid confusion
1059
#if 0
1060
    memset(&s->last_picture, 0, sizeof(Picture));
1061
    memset(&s->next_picture, 0, sizeof(Picture));
1062
    memset(&s->current_picture, 0, sizeof(Picture));
1063
#endif
1064
}
1065

    
1066
/**
1067
 * prints debuging info for the given picture.
1068
 */
1069
void ff_print_debug_info(MpegEncContext *s, Picture *pict){
1070

    
1071
    if(!pict || !pict->mb_type) return;
1072

    
1073
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1074
        int x,y;
1075

    
1076
        for(y=0; y<s->mb_height; y++){
1077
            for(x=0; x<s->mb_width; x++){
1078
                if(s->avctx->debug&FF_DEBUG_SKIP){
1079
                    int count= s->mbskip_table[x + y*s->mb_stride];
1080
                    if(count>9) count=9;
1081
                    printf("%1d", count);
1082
                }
1083
                if(s->avctx->debug&FF_DEBUG_QP){
1084
                    printf("%2d", pict->qscale_table[x + y*s->mb_stride]);
1085
                }
1086
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1087
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
1088
                    
1089
                    //Type & MV direction
1090
                    if(IS_PCM(mb_type))
1091
                        printf("P");
1092
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1093
                        printf("A");
1094
                    else if(IS_INTRA4x4(mb_type))
1095
                        printf("i");
1096
                    else if(IS_INTRA16x16(mb_type))
1097
                        printf("I");
1098
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1099
                        printf("d");
1100
                    else if(IS_DIRECT(mb_type))
1101
                        printf("D");
1102
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1103
                        printf("g");
1104
                    else if(IS_GMC(mb_type))
1105
                        printf("G");
1106
                    else if(IS_SKIP(mb_type))
1107
                        printf("S");
1108
                    else if(!USES_LIST(mb_type, 1))
1109
                        printf(">");
1110
                    else if(!USES_LIST(mb_type, 0))
1111
                        printf("<");
1112
                    else{
1113
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1114
                        printf("X");
1115
                    }
1116
                    
1117
                    //segmentation
1118
                    if(IS_8X8(mb_type))
1119
                        printf("+");
1120
                    else if(IS_16X8(mb_type))
1121
                        printf("-");
1122
                    else if(IS_8X16(mb_type))
1123
                        printf("?");
1124
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1125
                        printf(" ");
1126
                    else
1127
                        printf("?");
1128
                    
1129
                        
1130
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1131
                        printf("=");
1132
                    else
1133
                        printf(" ");
1134
                }
1135
//                printf(" ");
1136
            }
1137
            printf("\n");
1138
        }
1139
    }
1140
}
1141

    
1142
#ifdef CONFIG_ENCODERS
1143

    
1144
static int get_sae(uint8_t *src, int ref, int stride){
1145
    int x,y;
1146
    int acc=0;
1147
    
1148
    for(y=0; y<16; y++){
1149
        for(x=0; x<16; x++){
1150
            acc+= ABS(src[x+y*stride] - ref);
1151
        }
1152
    }
1153
    
1154
    return acc;
1155
}
1156

    
1157
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1158
    int x, y, w, h;
1159
    int acc=0;
1160
    
1161
    w= s->width &~15;
1162
    h= s->height&~15;
1163
    
1164
    for(y=0; y<h; y+=16){
1165
        for(x=0; x<w; x+=16){
1166
            int offset= x + y*stride;
1167
            int sad = s->dsp.pix_abs16x16(src + offset, ref + offset, stride);
1168
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1169
            int sae = get_sae(src + offset, mean, stride);
1170
            
1171
            acc+= sae + 500 < sad;
1172
        }
1173
    }
1174
    return acc;
1175
}
1176

    
1177

    
1178
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1179
    AVFrame *pic;
1180
    int i;
1181
    const int encoding_delay= s->max_b_frames;
1182
    int direct=1;
1183

    
1184
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1185
    if(pic_arg->linesize[0] != s->linesize) direct=0;
1186
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1187
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1188
  
1189
//    printf("%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1190
    
1191
    if(direct){
1192
        i= find_unused_picture(s, 1);
1193

    
1194
        pic= (AVFrame*)&s->picture[i];
1195
        pic->reference= 3;
1196
    
1197
        for(i=0; i<4; i++){
1198
            pic->data[i]= pic_arg->data[i];
1199
            pic->linesize[i]= pic_arg->linesize[i];
1200
        }
1201
        alloc_picture(s, (Picture*)pic, 1);
1202
    }else{
1203
        i= find_unused_picture(s, 0);
1204

    
1205
        pic= (AVFrame*)&s->picture[i];
1206
        pic->reference= 3;
1207

    
1208
        alloc_picture(s, (Picture*)pic, 0);
1209
        for(i=0; i<4; i++){
1210
            /* the input will be 16 pixels to the right relative to the actual buffer start
1211
             * and the current_pic, so the buffer can be reused, yes its not beatifull 
1212
             */
1213
            pic->data[i]+= 16; 
1214
        }
1215

    
1216
        if(   pic->data[0] == pic_arg->data[0] 
1217
           && pic->data[1] == pic_arg->data[1]
1218
           && pic->data[2] == pic_arg->data[2]){
1219
       // empty
1220
        }else{
1221
            int h_chroma_shift, v_chroma_shift;
1222
        
1223
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1224
        
1225
            for(i=0; i<3; i++){
1226
                int src_stride= pic_arg->linesize[i];
1227
                int dst_stride= i ? s->uvlinesize : s->linesize;
1228
                int h_shift= i ? h_chroma_shift : 0;
1229
                int v_shift= i ? v_chroma_shift : 0;
1230
                int w= s->width >>h_shift;
1231
                int h= s->height>>v_shift;
1232
                uint8_t *src= pic_arg->data[i];
1233
                uint8_t *dst= pic->data[i];
1234
            
1235
                if(src_stride==dst_stride)
1236
                    memcpy(dst, src, src_stride*h);
1237
                else{
1238
                    while(h--){
1239
                        memcpy(dst, src, w);
1240
                        dst += dst_stride;
1241
                        src += src_stride;
1242
                    }
1243
                }
1244
            }
1245
        }
1246
    }
1247
    pic->quality= pic_arg->quality;
1248
    pic->pict_type= pic_arg->pict_type;
1249
    pic->pts = pic_arg->pts;
1250
    
1251
    if(s->input_picture[encoding_delay])
1252
        pic->display_picture_number= s->input_picture[encoding_delay]->display_picture_number + 1;
1253

    
1254
    /* shift buffer entries */
1255
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1256
        s->input_picture[i-1]= s->input_picture[i];
1257
        
1258
    s->input_picture[encoding_delay]= (Picture*)pic;
1259

    
1260
    return 0;
1261
}
1262

    
1263
static void select_input_picture(MpegEncContext *s){
1264
    int i;
1265
    const int encoding_delay= s->max_b_frames;
1266
    int coded_pic_num=0;    
1267

    
1268
    if(s->reordered_input_picture[0])
1269
        coded_pic_num= s->reordered_input_picture[0]->coded_picture_number + 1;
1270

    
1271
    for(i=1; i<MAX_PICTURE_COUNT; i++)
1272
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1273
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1274

    
1275
    /* set next picture types & ordering */
1276
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1277
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
1278
            s->reordered_input_picture[0]= s->input_picture[0];
1279
            s->reordered_input_picture[0]->pict_type= I_TYPE;
1280
            s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1281
        }else{
1282
            int b_frames;
1283
            
1284
            if(s->flags&CODEC_FLAG_PASS2){
1285
                for(i=0; i<s->max_b_frames+1; i++){
1286
                    int pict_num= s->input_picture[0]->display_picture_number + i;
1287
                    int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1288
                    s->input_picture[i]->pict_type= pict_type;
1289
                    
1290
                    if(i + 1 >= s->rc_context.num_entries) break;
1291
                }
1292
            }
1293

    
1294
            if(s->input_picture[0]->pict_type){
1295
                /* user selected pict_type */
1296
                for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
1297
                    if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
1298
                }
1299
            
1300
                if(b_frames > s->max_b_frames){
1301
                    fprintf(stderr, "warning, too many bframes in a row\n");
1302
                    b_frames = s->max_b_frames;
1303
                }
1304
            }else if(s->b_frame_strategy==0){
1305
                b_frames= s->max_b_frames;
1306
            }else if(s->b_frame_strategy==1){
1307
                for(i=1; i<s->max_b_frames+1; i++){
1308
                    if(s->input_picture[i]->b_frame_score==0){
1309
                        s->input_picture[i]->b_frame_score= 
1310
                            get_intra_count(s, s->input_picture[i  ]->data[0], 
1311
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
1312
                    }
1313
                }
1314
                for(i=0; i<s->max_b_frames; i++){
1315
                    if(s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
1316
                }
1317
                                
1318
                b_frames= FFMAX(0, i-1);
1319
                
1320
                /* reset scores */
1321
                for(i=0; i<b_frames+1; i++){
1322
                    s->input_picture[i]->b_frame_score=0;
1323
                }
1324
            }else{
1325
                fprintf(stderr, "illegal b frame strategy\n");
1326
                b_frames=0;
1327
            }
1328

    
1329
            emms_c();
1330
//static int b_count=0;
1331
//b_count+= b_frames;
1332
//printf("b_frames: %d\n", b_count);
1333
                        
1334
            s->reordered_input_picture[0]= s->input_picture[b_frames];
1335
            if(   s->picture_in_gop_number + b_frames >= s->gop_size 
1336
               || s->reordered_input_picture[0]->pict_type== I_TYPE)
1337
                s->reordered_input_picture[0]->pict_type= I_TYPE;
1338
            else
1339
                s->reordered_input_picture[0]->pict_type= P_TYPE;
1340
            s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1341
            for(i=0; i<b_frames; i++){
1342
                coded_pic_num++;
1343
                s->reordered_input_picture[i+1]= s->input_picture[i];
1344
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
1345
                s->reordered_input_picture[i+1]->coded_picture_number= coded_pic_num;
1346
            }
1347
        }
1348
    }
1349
    
1350
    if(s->reordered_input_picture[0]){
1351
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
1352

    
1353
        s->new_picture= *s->reordered_input_picture[0];
1354

    
1355
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
1356
            // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
1357
        
1358
            int i= find_unused_picture(s, 0);
1359
            Picture *pic= &s->picture[i];
1360

    
1361
            /* mark us unused / free shared pic */
1362
            for(i=0; i<4; i++)
1363
                s->reordered_input_picture[0]->data[i]= NULL;
1364
            s->reordered_input_picture[0]->type= 0;
1365
            
1366
            //FIXME bad, copy * except
1367
            pic->pict_type = s->reordered_input_picture[0]->pict_type;
1368
            pic->quality   = s->reordered_input_picture[0]->quality;
1369
            pic->coded_picture_number = s->reordered_input_picture[0]->coded_picture_number;
1370
            pic->reference = s->reordered_input_picture[0]->reference;
1371
            
1372
            alloc_picture(s, pic, 0);
1373

    
1374
            s->current_picture_ptr= pic;
1375
        }else{
1376
            // input is not a shared pix -> reuse buffer for current_pix
1377

    
1378
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
1379
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
1380
            
1381
            s->current_picture_ptr= s->reordered_input_picture[0];
1382
            for(i=0; i<4; i++){
1383
                //reverse the +16 we did before storing the input
1384
                s->current_picture_ptr->data[i]-=16;
1385
            }
1386
        }
1387
        s->current_picture= *s->current_picture_ptr;
1388
    
1389
        s->picture_number= s->new_picture.display_picture_number;
1390
//printf("dpn:%d\n", s->picture_number);
1391
    }else{
1392
       memset(&s->new_picture, 0, sizeof(Picture));
1393
    }
1394
}
1395

    
1396
int MPV_encode_picture(AVCodecContext *avctx,
1397
                       unsigned char *buf, int buf_size, void *data)
1398
{
1399
    MpegEncContext *s = avctx->priv_data;
1400
    AVFrame *pic_arg = data;
1401
    int i;
1402

    
1403
    init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
1404

    
1405
    s->picture_in_gop_number++;
1406

    
1407
    load_input_picture(s, pic_arg);
1408
    
1409
    select_input_picture(s);
1410
    
1411
    /* output? */
1412
    if(s->new_picture.data[0]){
1413

    
1414
        s->pict_type= s->new_picture.pict_type;
1415
        if (s->fixed_qscale){ /* the ratecontrol needs the last qscale so we dont touch it for CBR */
1416
            s->qscale= (int)(s->new_picture.quality+0.5);
1417
            assert(s->qscale);
1418
        }
1419
//emms_c();
1420
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
1421
        MPV_frame_start(s, avctx);
1422

    
1423
        encode_picture(s, s->picture_number);
1424
        
1425
        avctx->real_pict_num  = s->picture_number;
1426
        avctx->header_bits = s->header_bits;
1427
        avctx->mv_bits     = s->mv_bits;
1428
        avctx->misc_bits   = s->misc_bits;
1429
        avctx->i_tex_bits  = s->i_tex_bits;
1430
        avctx->p_tex_bits  = s->p_tex_bits;
1431
        avctx->i_count     = s->i_count;
1432
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
1433
        avctx->skip_count  = s->skip_count;
1434

    
1435
        MPV_frame_end(s);
1436

    
1437
        if (s->out_format == FMT_MJPEG)
1438
            mjpeg_picture_trailer(s);
1439
        
1440
        if(s->flags&CODEC_FLAG_PASS1)
1441
            ff_write_pass1_stats(s);
1442

    
1443
        for(i=0; i<4; i++){
1444
            avctx->error[i] += s->current_picture_ptr->error[i];
1445
        }
1446
    }
1447

    
1448
    s->input_picture_number++;
1449

    
1450
    flush_put_bits(&s->pb);
1451
    s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1452
    
1453
    s->total_bits += s->frame_bits;
1454
    avctx->frame_bits  = s->frame_bits;
1455
    
1456
    return pbBufPtr(&s->pb) - s->pb.buf;
1457
}
1458

    
1459
#endif //CONFIG_ENCODERS
1460

    
1461
static inline void gmc1_motion(MpegEncContext *s,
1462
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1463
                               int dest_offset,
1464
                               uint8_t **ref_picture, int src_offset)
1465
{
1466
    uint8_t *ptr;
1467
    int offset, src_x, src_y, linesize, uvlinesize;
1468
    int motion_x, motion_y;
1469
    int emu=0;
1470

    
1471
    motion_x= s->sprite_offset[0][0];
1472
    motion_y= s->sprite_offset[0][1];
1473
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1474
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1475
    motion_x<<=(3-s->sprite_warping_accuracy);
1476
    motion_y<<=(3-s->sprite_warping_accuracy);
1477
    src_x = clip(src_x, -16, s->width);
1478
    if (src_x == s->width)
1479
        motion_x =0;
1480
    src_y = clip(src_y, -16, s->height);
1481
    if (src_y == s->height)
1482
        motion_y =0;
1483

    
1484
    linesize = s->linesize;
1485
    uvlinesize = s->uvlinesize;
1486
    
1487
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1488

    
1489
    dest_y+=dest_offset;
1490
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1491
        if(src_x<0 || src_y<0 || src_x + 17 >= s->h_edge_pos
1492
                              || src_y + 17 >= s->v_edge_pos){
1493
            ff_emulated_edge_mc(s, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1494
            ptr= s->edge_emu_buffer;
1495
        }
1496
    }
1497
    
1498
    if((motion_x|motion_y)&7){
1499
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1500
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1501
    }else{
1502
        int dxy;
1503
        
1504
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
1505
        if (s->no_rounding){
1506
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
1507
        }else{
1508
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
1509
        }
1510
    }
1511
    
1512
    if(s->flags&CODEC_FLAG_GRAY) return;
1513

    
1514
    motion_x= s->sprite_offset[1][0];
1515
    motion_y= s->sprite_offset[1][1];
1516
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
1517
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
1518
    motion_x<<=(3-s->sprite_warping_accuracy);
1519
    motion_y<<=(3-s->sprite_warping_accuracy);
1520
    src_x = clip(src_x, -8, s->width>>1);
1521
    if (src_x == s->width>>1)
1522
        motion_x =0;
1523
    src_y = clip(src_y, -8, s->height>>1);
1524
    if (src_y == s->height>>1)
1525
        motion_y =0;
1526

    
1527
    offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
1528
    ptr = ref_picture[1] + offset;
1529
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1530
        if(src_x<0 || src_y<0 || src_x + 9 >= s->h_edge_pos>>1
1531
                              || src_y + 9 >= s->v_edge_pos>>1){
1532
            ff_emulated_edge_mc(s, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1533
            ptr= s->edge_emu_buffer;
1534
            emu=1;
1535
        }
1536
    }
1537
    s->dsp.gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1538
    
1539
    ptr = ref_picture[2] + offset;
1540
    if(emu){
1541
        ff_emulated_edge_mc(s, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1542
        ptr= s->edge_emu_buffer;
1543
    }
1544
    s->dsp.gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1545
    
1546
    return;
1547
}
1548

    
1549
static inline void gmc_motion(MpegEncContext *s,
1550
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1551
                               int dest_offset,
1552
                               uint8_t **ref_picture, int src_offset)
1553
{
1554
    uint8_t *ptr;
1555
    int linesize, uvlinesize;
1556
    const int a= s->sprite_warping_accuracy;
1557
    int ox, oy;
1558

    
1559
    linesize = s->linesize;
1560
    uvlinesize = s->uvlinesize;
1561

    
1562
    ptr = ref_picture[0] + src_offset;
1563

    
1564
    dest_y+=dest_offset;
1565
    
1566
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
1567
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
1568

    
1569
    s->dsp.gmc(dest_y, ptr, linesize, 16,
1570
           ox, 
1571
           oy, 
1572
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1573
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1574
           a+1, (1<<(2*a+1)) - s->no_rounding,
1575
           s->h_edge_pos, s->v_edge_pos);
1576
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
1577
           ox + s->sprite_delta[0][0]*8, 
1578
           oy + s->sprite_delta[1][0]*8, 
1579
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1580
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1581
           a+1, (1<<(2*a+1)) - s->no_rounding,
1582
           s->h_edge_pos, s->v_edge_pos);
1583

    
1584
    if(s->flags&CODEC_FLAG_GRAY) return;
1585

    
1586

    
1587
    dest_cb+=dest_offset>>1;
1588
    dest_cr+=dest_offset>>1;
1589
    
1590
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
1591
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
1592

    
1593
    ptr = ref_picture[1] + (src_offset>>1);
1594
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
1595
           ox, 
1596
           oy, 
1597
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1598
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1599
           a+1, (1<<(2*a+1)) - s->no_rounding,
1600
           s->h_edge_pos>>1, s->v_edge_pos>>1);
1601
    
1602
    ptr = ref_picture[2] + (src_offset>>1);
1603
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
1604
           ox, 
1605
           oy, 
1606
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1607
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1608
           a+1, (1<<(2*a+1)) - s->no_rounding,
1609
           s->h_edge_pos>>1, s->v_edge_pos>>1);
1610
}
1611

    
1612

    
1613
void ff_emulated_edge_mc(MpegEncContext *s, uint8_t *src, int linesize, int block_w, int block_h, 
1614
                                    int src_x, int src_y, int w, int h){
1615
    int x, y;
1616
    int start_y, start_x, end_y, end_x;
1617
    uint8_t *buf= s->edge_emu_buffer;
1618

    
1619
    if(src_y>= h){
1620
        src+= (h-1-src_y)*linesize;
1621
        src_y=h-1;
1622
    }else if(src_y<=-block_h){
1623
        src+= (1-block_h-src_y)*linesize;
1624
        src_y=1-block_h;
1625
    }
1626
    if(src_x>= w){
1627
        src+= (w-1-src_x);
1628
        src_x=w-1;
1629
    }else if(src_x<=-block_w){
1630
        src+= (1-block_w-src_x);
1631
        src_x=1-block_w;
1632
    }
1633

    
1634
    start_y= FFMAX(0, -src_y);
1635
    start_x= FFMAX(0, -src_x);
1636
    end_y= FFMIN(block_h, h-src_y);
1637
    end_x= FFMIN(block_w, w-src_x);
1638

    
1639
    // copy existing part
1640
    for(y=start_y; y<end_y; y++){
1641
        for(x=start_x; x<end_x; x++){
1642
            buf[x + y*linesize]= src[x + y*linesize];
1643
        }
1644
    }
1645

    
1646
    //top
1647
    for(y=0; y<start_y; y++){
1648
        for(x=start_x; x<end_x; x++){
1649
            buf[x + y*linesize]= buf[x + start_y*linesize];
1650
        }
1651
    }
1652

    
1653
    //bottom
1654
    for(y=end_y; y<block_h; y++){
1655
        for(x=start_x; x<end_x; x++){
1656
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1657
        }
1658
    }
1659
                                    
1660
    for(y=0; y<block_h; y++){
1661
       //left
1662
        for(x=0; x<start_x; x++){
1663
            buf[x + y*linesize]= buf[start_x + y*linesize];
1664
        }
1665
       
1666
       //right
1667
        for(x=end_x; x<block_w; x++){
1668
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1669
        }
1670
    }
1671
}
1672

    
1673

    
1674
/* apply one mpeg motion vector to the three components */
1675
static inline void mpeg_motion(MpegEncContext *s,
1676
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1677
                               int dest_offset,
1678
                               uint8_t **ref_picture, int src_offset,
1679
                               int field_based, op_pixels_func (*pix_op)[4],
1680
                               int motion_x, int motion_y, int h)
1681
{
1682
    uint8_t *ptr;
1683
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1684
    int emu=0;
1685
#if 0    
1686
if(s->quarter_sample)
1687
{
1688
    motion_x>>=1;
1689
    motion_y>>=1;
1690
}
1691
#endif
1692
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1693
    src_x = s->mb_x * 16 + (motion_x >> 1);
1694
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 1);
1695
                
1696
    /* WARNING: do no forget half pels */
1697
    height = s->height >> field_based;
1698
    v_edge_pos = s->v_edge_pos >> field_based;
1699
    src_x = clip(src_x, -16, s->width);
1700
    if (src_x == s->width)
1701
        dxy &= ~1;
1702
    src_y = clip(src_y, -16, height);
1703
    if (src_y == height)
1704
        dxy &= ~2;
1705
    linesize   = s->current_picture.linesize[0] << field_based;
1706
    uvlinesize = s->current_picture.linesize[1] << field_based;
1707
    ptr = ref_picture[0] + (src_y * linesize) + (src_x) + src_offset;
1708
    dest_y += dest_offset;
1709

    
1710
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1711
        if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 16 > s->h_edge_pos
1712
                              || src_y + (motion_y&1) + h  > v_edge_pos){
1713
            ff_emulated_edge_mc(s, ptr - src_offset, s->linesize, 17, 17+field_based,  //FIXME linesize? and uv below
1714
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1715
            ptr= s->edge_emu_buffer + src_offset;
1716
            emu=1;
1717
        }
1718
    }
1719
    pix_op[0][dxy](dest_y, ptr, linesize, h);
1720

    
1721
    if(s->flags&CODEC_FLAG_GRAY) return;
1722

    
1723
    if (s->out_format == FMT_H263) {
1724
        dxy = 0;
1725
        if ((motion_x & 3) != 0)
1726
            dxy |= 1;
1727
        if ((motion_y & 3) != 0)
1728
            dxy |= 2;
1729
        mx = motion_x >> 2;
1730
        my = motion_y >> 2;
1731
    } else {
1732
        mx = motion_x / 2;
1733
        my = motion_y / 2;
1734
        dxy = ((my & 1) << 1) | (mx & 1);
1735
        mx >>= 1;
1736
        my >>= 1;
1737
    }
1738
    
1739
    src_x = s->mb_x * 8 + mx;
1740
    src_y = s->mb_y * (8 >> field_based) + my;
1741
    src_x = clip(src_x, -8, s->width >> 1);
1742
    if (src_x == (s->width >> 1))
1743
        dxy &= ~1;
1744
    src_y = clip(src_y, -8, height >> 1);
1745
    if (src_y == (height >> 1))
1746
        dxy &= ~2;
1747
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1748
    ptr = ref_picture[1] + offset;
1749
    if(emu){
1750
        ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
1751
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1752
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1753
    }
1754
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1755

    
1756
    ptr = ref_picture[2] + offset;
1757
    if(emu){
1758
        ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
1759
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1760
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1761
    }
1762
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1763
}
1764

    
1765
static inline void qpel_motion(MpegEncContext *s,
1766
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1767
                               int dest_offset,
1768
                               uint8_t **ref_picture, int src_offset,
1769
                               int field_based, op_pixels_func (*pix_op)[4],
1770
                               qpel_mc_func (*qpix_op)[16],
1771
                               int motion_x, int motion_y, int h)
1772
{
1773
    uint8_t *ptr;
1774
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1775
    int emu=0;
1776

    
1777
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1778
    src_x = s->mb_x * 16 + (motion_x >> 2);
1779
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
1780

    
1781
    height = s->height >> field_based;
1782
    v_edge_pos = s->v_edge_pos >> field_based;
1783
    src_x = clip(src_x, -16, s->width);
1784
    if (src_x == s->width)
1785
        dxy &= ~3;
1786
    src_y = clip(src_y, -16, height);
1787
    if (src_y == height)
1788
        dxy &= ~12;
1789
    linesize = s->linesize << field_based;
1790
    uvlinesize = s->uvlinesize << field_based;
1791
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1792
    dest_y += dest_offset;
1793
//printf("%d %d %d\n", src_x, src_y, dxy);
1794
    
1795
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1796
        if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 16 > s->h_edge_pos
1797
                              || src_y + (motion_y&3) + h  > v_edge_pos){
1798
            ff_emulated_edge_mc(s, ptr - src_offset, s->linesize, 17, 17+field_based, 
1799
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1800
            ptr= s->edge_emu_buffer + src_offset;
1801
            emu=1;
1802
        }
1803
    }
1804
    if(!field_based)
1805
        qpix_op[0][dxy](dest_y, ptr, linesize);
1806
    else{
1807
        //damn interlaced mode
1808
        //FIXME boundary mirroring is not exactly correct here
1809
        qpix_op[1][dxy](dest_y  , ptr  , linesize);
1810
        qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
1811
    }
1812

    
1813
    if(s->flags&CODEC_FLAG_GRAY) return;
1814

    
1815
    if(field_based){
1816
        mx= motion_x/2;
1817
        my= motion_y>>1;
1818
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
1819
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
1820
        mx= (motion_x>>1) + rtab[motion_x&7];
1821
        my= (motion_y>>1) + rtab[motion_y&7];
1822
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
1823
        mx= (motion_x>>1)|(motion_x&1);
1824
        my= (motion_y>>1)|(motion_y&1);
1825
    }else{
1826
        mx= motion_x/2;
1827
        my= motion_y/2;
1828
    }
1829
    mx= (mx>>1)|(mx&1);
1830
    my= (my>>1)|(my&1);
1831

    
1832
    dxy= (mx&1) | ((my&1)<<1);
1833
    mx>>=1;
1834
    my>>=1;
1835

    
1836
    src_x = s->mb_x * 8 + mx;
1837
    src_y = s->mb_y * (8 >> field_based) + my;
1838
    src_x = clip(src_x, -8, s->width >> 1);
1839
    if (src_x == (s->width >> 1))
1840
        dxy &= ~1;
1841
    src_y = clip(src_y, -8, height >> 1);
1842
    if (src_y == (height >> 1))
1843
        dxy &= ~2;
1844

    
1845
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1846
    ptr = ref_picture[1] + offset;
1847
    if(emu){
1848
        ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
1849
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1850
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1851
    }
1852
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1853
    
1854
    ptr = ref_picture[2] + offset;
1855
    if(emu){
1856
        ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
1857
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1858
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1859
    }
1860
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1861
}
1862

    
1863
inline int ff_h263_round_chroma(int x){
1864
    if (x >= 0)
1865
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
1866
    else {
1867
        x = -x;
1868
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
1869
    }
1870
}
1871

    
1872
/**
1873
 * motion compesation of a single macroblock
1874
 * @param s context
1875
 * @param dest_y luma destination pointer
1876
 * @param dest_cb chroma cb/u destination pointer
1877
 * @param dest_cr chroma cr/v destination pointer
1878
 * @param dir direction (0->forward, 1->backward)
1879
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1880
 * @param pic_op halfpel motion compensation function (average or put normally)
1881
 * @param pic_op qpel motion compensation function (average or put normally)
1882
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1883
 */
1884
static inline void MPV_motion(MpegEncContext *s, 
1885
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1886
                              int dir, uint8_t **ref_picture, 
1887
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
1888
{
1889
    int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
1890
    int mb_x, mb_y, i;
1891
    uint8_t *ptr, *dest;
1892
    int emu=0;
1893

    
1894
    mb_x = s->mb_x;
1895
    mb_y = s->mb_y;
1896

    
1897
    switch(s->mv_type) {
1898
    case MV_TYPE_16X16:
1899
#ifdef CONFIG_RISKY
1900
        if(s->mcsel){
1901
            if(s->real_sprite_warping_points==1){
1902
                gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
1903
                            ref_picture, 0);
1904
            }else{
1905
                gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
1906
                            ref_picture, 0);
1907
            }
1908
        }else if(s->quarter_sample){
1909
            qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1910
                        ref_picture, 0,
1911
                        0, pix_op, qpix_op,
1912
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1913
        }else if(s->mspel){
1914
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
1915
                        ref_picture, pix_op,
1916
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1917
        }else
1918
#endif
1919
        {
1920
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1921
                        ref_picture, 0,
1922
                        0, pix_op,
1923
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1924
        }           
1925
        break;
1926
    case MV_TYPE_8X8:
1927
        mx = 0;
1928
        my = 0;
1929
        if(s->quarter_sample){
1930
            for(i=0;i<4;i++) {
1931
                motion_x = s->mv[dir][i][0];
1932
                motion_y = s->mv[dir][i][1];
1933

    
1934
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1935
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
1936
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
1937
                    
1938
                /* WARNING: do no forget half pels */
1939
                src_x = clip(src_x, -16, s->width);
1940
                if (src_x == s->width)
1941
                    dxy &= ~3;
1942
                src_y = clip(src_y, -16, s->height);
1943
                if (src_y == s->height)
1944
                    dxy &= ~12;
1945
                    
1946
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1947
                if(s->flags&CODEC_FLAG_EMU_EDGE){
1948
                    if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 8 > s->h_edge_pos
1949
                                          || src_y + (motion_y&3) + 8 > s->v_edge_pos){
1950
                        ff_emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1951
                        ptr= s->edge_emu_buffer;
1952
                    }
1953
                }
1954
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1955
                qpix_op[1][dxy](dest, ptr, s->linesize);
1956

    
1957
                mx += s->mv[dir][i][0]/2;
1958
                my += s->mv[dir][i][1]/2;
1959
            }
1960
        }else{
1961
            for(i=0;i<4;i++) {
1962
                motion_x = s->mv[dir][i][0];
1963
                motion_y = s->mv[dir][i][1];
1964

    
1965
                dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1966
                src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;
1967
                src_y = mb_y * 16 + (motion_y >> 1) + (i >>1) * 8;
1968
                    
1969
                /* WARNING: do no forget half pels */
1970
                src_x = clip(src_x, -16, s->width);
1971
                if (src_x == s->width)
1972
                    dxy &= ~1;
1973
                src_y = clip(src_y, -16, s->height);
1974
                if (src_y == s->height)
1975
                    dxy &= ~2;
1976
                    
1977
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1978
                if(s->flags&CODEC_FLAG_EMU_EDGE){
1979
                    if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 8 > s->h_edge_pos
1980
                                          || src_y + (motion_y&1) + 8 > s->v_edge_pos){
1981
                        ff_emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1982
                        ptr= s->edge_emu_buffer;
1983
                    }
1984
                }
1985
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1986
                pix_op[1][dxy](dest, ptr, s->linesize, 8);
1987

    
1988
                mx += s->mv[dir][i][0];
1989
                my += s->mv[dir][i][1];
1990
            }
1991
        }
1992

    
1993
        if(s->flags&CODEC_FLAG_GRAY) break;
1994
        /* In case of 8X8, we construct a single chroma motion vector
1995
           with a special rounding */
1996
        mx= ff_h263_round_chroma(mx);
1997
        my= ff_h263_round_chroma(my);
1998
        dxy = ((my & 1) << 1) | (mx & 1);
1999
        mx >>= 1;
2000
        my >>= 1;
2001

    
2002
        src_x = mb_x * 8 + mx;
2003
        src_y = mb_y * 8 + my;
2004
        src_x = clip(src_x, -8, s->width/2);
2005
        if (src_x == s->width/2)
2006
            dxy &= ~1;
2007
        src_y = clip(src_y, -8, s->height/2);
2008
        if (src_y == s->height/2)
2009
            dxy &= ~2;
2010
        
2011
        offset = (src_y * (s->uvlinesize)) + src_x;
2012
        ptr = ref_picture[1] + offset;
2013
        if(s->flags&CODEC_FLAG_EMU_EDGE){
2014
                if(src_x<0 || src_y<0 || src_x + (dxy &1) + 8 > s->h_edge_pos>>1
2015
                                      || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
2016
                    ff_emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2017
                    ptr= s->edge_emu_buffer;
2018
                    emu=1;
2019
                }
2020
            }
2021
        pix_op[1][dxy](dest_cb, ptr, s->uvlinesize, 8);
2022

    
2023
        ptr = ref_picture[2] + offset;
2024
        if(emu){
2025
            ff_emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2026
            ptr= s->edge_emu_buffer;
2027
        }
2028
        pix_op[1][dxy](dest_cr, ptr, s->uvlinesize, 8);
2029
        break;
2030
    case MV_TYPE_FIELD:
2031
        if (s->picture_structure == PICT_FRAME) {
2032
            if(s->quarter_sample){
2033
                /* top field */
2034
                qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2035
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2036
                            1, pix_op, qpix_op,
2037
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
2038
                /* bottom field */
2039
                qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2040
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2041
                            1, pix_op, qpix_op,
2042
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
2043
            }else{
2044
                /* top field */       
2045
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2046
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2047
                            1, pix_op,
2048
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
2049
                /* bottom field */
2050
                mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2051
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2052
                            1, pix_op,
2053
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
2054
            }
2055
        } else {
2056
            int offset;
2057
            if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2058
                offset= s->field_select[dir][0] ? s->linesize : 0;
2059
            }else{
2060
                ref_picture= s->current_picture.data;
2061
                offset= s->field_select[dir][0] ? s->linesize : -s->linesize; 
2062
            } 
2063

    
2064
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2065
                        ref_picture, offset,
2066
                        0, pix_op,
2067
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2068
        }
2069
        break;
2070
    }
2071
}
2072

    
2073

    
2074
/* put block[] to dest[] */
2075
static inline void put_dct(MpegEncContext *s, 
2076
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
2077
{
2078
    s->dct_unquantize(s, block, i, s->qscale);
2079
    s->dsp.idct_put (dest, line_size, block);
2080
}
2081

    
2082
/* add block[] to dest[] */
2083
static inline void add_dct(MpegEncContext *s, 
2084
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
2085
{
2086
    if (s->block_last_index[i] >= 0) {
2087
        s->dsp.idct_add (dest, line_size, block);
2088
    }
2089
}
2090

    
2091
static inline void add_dequant_dct(MpegEncContext *s, 
2092
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
2093
{
2094
    if (s->block_last_index[i] >= 0) {
2095
        s->dct_unquantize(s, block, i, s->qscale);
2096

    
2097
        s->dsp.idct_add (dest, line_size, block);
2098
    }
2099
}
2100

    
2101
/**
2102
 * cleans dc, ac, coded_block for the current non intra MB
2103
 */
2104
void ff_clean_intra_table_entries(MpegEncContext *s)
2105
{
2106
    int wrap = s->block_wrap[0];
2107
    int xy = s->block_index[0];
2108
    
2109
    s->dc_val[0][xy           ] = 
2110
    s->dc_val[0][xy + 1       ] = 
2111
    s->dc_val[0][xy     + wrap] =
2112
    s->dc_val[0][xy + 1 + wrap] = 1024;
2113
    /* ac pred */
2114
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2115
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2116
    if (s->msmpeg4_version>=3) {
2117
        s->coded_block[xy           ] =
2118
        s->coded_block[xy + 1       ] =
2119
        s->coded_block[xy     + wrap] =
2120
        s->coded_block[xy + 1 + wrap] = 0;
2121
    }
2122
    /* chroma */
2123
    wrap = s->block_wrap[4];
2124
    xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
2125
    s->dc_val[1][xy] =
2126
    s->dc_val[2][xy] = 1024;
2127
    /* ac pred */
2128
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2129
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2130
    
2131
    s->mbintra_table[s->mb_x + s->mb_y*s->mb_stride]= 0;
2132
}
2133

    
2134
/* generic function called after a macroblock has been parsed by the
2135
   decoder or after it has been encoded by the encoder.
2136

2137
   Important variables used:
2138
   s->mb_intra : true if intra macroblock
2139
   s->mv_dir   : motion vector direction
2140
   s->mv_type  : motion vector type
2141
   s->mv       : motion vector
2142
   s->interlaced_dct : true if interlaced dct used (mpeg2)
2143
 */
2144
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
2145
{
2146
    int mb_x, mb_y;
2147
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2148

    
2149
    mb_x = s->mb_x;
2150
    mb_y = s->mb_y;
2151

    
2152
    s->current_picture.qscale_table[mb_xy]= s->qscale;
2153

    
2154
    /* update DC predictors for P macroblocks */
2155
    if (!s->mb_intra) {
2156
        if (s->h263_pred || s->h263_aic) {
2157
            if(s->mbintra_table[mb_xy])
2158
                ff_clean_intra_table_entries(s);
2159
        } else {
2160
            s->last_dc[0] =
2161
            s->last_dc[1] =
2162
            s->last_dc[2] = 128 << s->intra_dc_precision;
2163
        }
2164
    }
2165
    else if (s->h263_pred || s->h263_aic)
2166
        s->mbintra_table[mb_xy]=1;
2167

    
2168
    /* update motion predictor, not for B-frames as they need the motion_val from the last P/S-Frame */
2169
    if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) { //FIXME move into h263.c if possible, format specific stuff shouldnt be here
2170
        //FIXME a lot of thet is only needed for !low_delay
2171
        const int wrap = s->block_wrap[0];
2172
        const int xy = s->block_index[0];
2173
        if(s->mv_type != MV_TYPE_8X8){
2174
            int motion_x, motion_y;
2175
            if (s->mb_intra) {
2176
                motion_x = 0;
2177
                motion_y = 0;
2178
            } else if (s->mv_type == MV_TYPE_16X16) {
2179
                motion_x = s->mv[0][0][0];
2180
                motion_y = s->mv[0][0][1];
2181
            } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
2182
                int i;
2183
                motion_x = s->mv[0][0][0] + s->mv[0][1][0];
2184
                motion_y = s->mv[0][0][1] + s->mv[0][1][1];
2185
                motion_x = (motion_x>>1) | (motion_x&1);
2186
                for(i=0; i<2; i++){
2187
                    s->field_mv_table[mb_xy][i][0]= s->mv[0][i][0];
2188
                    s->field_mv_table[mb_xy][i][1]= s->mv[0][i][1];
2189
                    s->field_select_table[mb_xy][i]= s->field_select[0][i];
2190
                }
2191
            }
2192
            
2193
            /* no update if 8X8 because it has been done during parsing */
2194
            s->motion_val[xy][0] = motion_x;
2195
            s->motion_val[xy][1] = motion_y;
2196
            s->motion_val[xy + 1][0] = motion_x;
2197
            s->motion_val[xy + 1][1] = motion_y;
2198
            s->motion_val[xy + wrap][0] = motion_x;
2199
            s->motion_val[xy + wrap][1] = motion_y;
2200
            s->motion_val[xy + 1 + wrap][0] = motion_x;
2201
            s->motion_val[xy + 1 + wrap][1] = motion_y;
2202
        }
2203

    
2204
        if(s->encoding){ //FIXME encoding MUST be cleaned up
2205
            if (s->mv_type == MV_TYPE_8X8) 
2206
                s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
2207
            else
2208
                s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
2209
        }
2210
    }
2211
    
2212
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
2213
        uint8_t *dest_y, *dest_cb, *dest_cr;
2214
        int dct_linesize, dct_offset;
2215
        op_pixels_func (*op_pix)[4];
2216
        qpel_mc_func (*op_qpix)[16];
2217
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
2218
        const int uvlinesize= s->current_picture.linesize[1];
2219

    
2220
        /* avoid copy if macroblock skipped in last frame too */
2221
        if (s->pict_type != B_TYPE) {
2222
            s->current_picture.mbskip_table[mb_xy]= s->mb_skiped;
2223
        }
2224

    
2225
        /* skip only during decoding as we might trash the buffers during encoding a bit */
2226
        if(!s->encoding){
2227
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2228
            const int age= s->current_picture.age;
2229

    
2230
            assert(age);
2231

    
2232
            if (s->mb_skiped) {
2233
                s->mb_skiped= 0;
2234
                assert(s->pict_type!=I_TYPE);
2235
 
2236
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
2237
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2238

    
2239
                /* if previous was skipped too, then nothing to do !  */
2240
                if (*mbskip_ptr >= age && s->current_picture.reference){
2241
                    return;
2242
                }
2243
            } else if(!s->current_picture.reference){
2244
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2245
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2246
            } else{
2247
                *mbskip_ptr = 0; /* not skipped */
2248
            }
2249
        }else
2250
            s->mb_skiped= 0;
2251

    
2252
        if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){ //FIXME precalc
2253
            dest_y  = s->current_picture.data[0] + mb_x * 16;
2254
            dest_cb = s->current_picture.data[1] + mb_x * 8;
2255
            dest_cr = s->current_picture.data[2] + mb_x * 8;
2256
        }else{
2257
            dest_y  = s->current_picture.data[0] + (mb_y * 16* linesize  ) + mb_x * 16;
2258
            dest_cb = s->current_picture.data[1] + (mb_y * 8 * uvlinesize) + mb_x * 8;
2259
            dest_cr = s->current_picture.data[2] + (mb_y * 8 * uvlinesize) + mb_x * 8;
2260
        }
2261

    
2262
        if (s->interlaced_dct) {
2263
            dct_linesize = linesize * 2;
2264
            dct_offset = linesize;
2265
        } else {
2266
            dct_linesize = linesize;
2267
            dct_offset = linesize * 8;
2268
        }
2269

    
2270
        if (!s->mb_intra) {
2271
            /* motion handling */
2272
            /* decoding or more than one mb_type (MC was allready done otherwise) */
2273
            if((!s->encoding) || (s->mb_type[mb_xy]&(s->mb_type[mb_xy]-1))){
2274
                if ((!s->no_rounding) || s->pict_type==B_TYPE){                
2275
                    op_pix = s->dsp.put_pixels_tab;
2276
                    op_qpix= s->dsp.put_qpel_pixels_tab;
2277
                }else{
2278
                    op_pix = s->dsp.put_no_rnd_pixels_tab;
2279
                    op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2280
                }
2281

    
2282
                if (s->mv_dir & MV_DIR_FORWARD) {
2283
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2284
                    op_pix = s->dsp.avg_pixels_tab;
2285
                    op_qpix= s->dsp.avg_qpel_pixels_tab;
2286
                }
2287
                if (s->mv_dir & MV_DIR_BACKWARD) {
2288
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2289
                }
2290
            }
2291

    
2292
            /* skip dequant / idct if we are really late ;) */
2293
            if(s->hurry_up>1) return;
2294

    
2295
            /* add dct residue */
2296
            if(s->encoding || !(   s->mpeg2 || s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO 
2297
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2298
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
2299
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2300
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2301
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2302

    
2303
                if(!(s->flags&CODEC_FLAG_GRAY)){
2304
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize);
2305
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize);
2306
                }
2307
            } else if(s->codec_id != CODEC_ID_WMV2){
2308
                add_dct(s, block[0], 0, dest_y, dct_linesize);
2309
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2310
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2311
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2312

    
2313
                if(!(s->flags&CODEC_FLAG_GRAY)){
2314
                    add_dct(s, block[4], 4, dest_cb, uvlinesize);
2315
                    add_dct(s, block[5], 5, dest_cr, uvlinesize);
2316
                }
2317
            } 
2318
#ifdef CONFIG_RISKY
2319
            else{
2320
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2321
            }
2322
#endif
2323
        } else {
2324
            /* dct only in intra block */
2325
            if(s->encoding || !(s->mpeg2 || s->codec_id==CODEC_ID_MPEG1VIDEO)){
2326
                put_dct(s, block[0], 0, dest_y, dct_linesize);
2327
                put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2328
                put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2329
                put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2330

    
2331
                if(!(s->flags&CODEC_FLAG_GRAY)){
2332
                    put_dct(s, block[4], 4, dest_cb, uvlinesize);
2333
                    put_dct(s, block[5], 5, dest_cr, uvlinesize);
2334
                }
2335
            }else{
2336
                s->dsp.idct_put(dest_y                 , dct_linesize, block[0]);
2337
                s->dsp.idct_put(dest_y              + 8, dct_linesize, block[1]);
2338
                s->dsp.idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
2339
                s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
2340

    
2341
                if(!(s->flags&CODEC_FLAG_GRAY)){
2342
                    s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2343
                    s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2344
                }
2345
            }
2346
        }
2347
    }
2348
}
2349

    
2350
#ifdef CONFIG_ENCODERS
2351

    
2352
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
2353
{
2354
    static const char tab[64]=
2355
        {3,2,2,1,1,1,1,1,
2356
         1,1,1,1,1,1,1,1,
2357
         1,1,1,1,1,1,1,1,
2358
         0,0,0,0,0,0,0,0,
2359
         0,0,0,0,0,0,0,0,
2360
         0,0,0,0,0,0,0,0,
2361
         0,0,0,0,0,0,0,0,
2362
         0,0,0,0,0,0,0,0};
2363
    int score=0;
2364
    int run=0;
2365
    int i;
2366
    DCTELEM *block= s->block[n];
2367
    const int last_index= s->block_last_index[n];
2368
    int skip_dc;
2369

    
2370
    if(threshold<0){
2371
        skip_dc=0;
2372
        threshold= -threshold;
2373
    }else
2374
        skip_dc=1;
2375

    
2376
    /* are all which we could set to zero are allready zero? */
2377
    if(last_index<=skip_dc - 1) return;
2378

    
2379
    for(i=0; i<=last_index; i++){
2380
        const int j = s->intra_scantable.permutated[i];
2381
        const int level = ABS(block[j]);
2382
        if(level==1){
2383
            if(skip_dc && i==0) continue;
2384
            score+= tab[run];
2385
            run=0;
2386
        }else if(level>1){
2387
            return;
2388
        }else{
2389
            run++;
2390
        }
2391
    }
2392
    if(score >= threshold) return;
2393
    for(i=skip_dc; i<=last_index; i++){
2394
        const int j = s->intra_scantable.permutated[i];
2395
        block[j]=0;
2396
    }
2397
    if(block[0]) s->block_last_index[n]= 0;
2398
    else         s->block_last_index[n]= -1;
2399
}
2400

    
2401
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
2402
{
2403
    int i;
2404
    const int maxlevel= s->max_qcoeff;
2405
    const int minlevel= s->min_qcoeff;
2406
    
2407
    if(s->mb_intra){
2408
        i=1; //skip clipping of intra dc
2409
    }else
2410
        i=0;
2411
    
2412
    for(;i<=last_index; i++){
2413
        const int j= s->intra_scantable.permutated[i];
2414
        int level = block[j];
2415
       
2416
        if     (level>maxlevel) level=maxlevel;
2417
        else if(level<minlevel) level=minlevel;
2418

    
2419
        block[j]= level;
2420
    }
2421
}
2422

    
2423
#if 0
2424
static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
2425
    int score=0;
2426
    int x,y;
2427
    
2428
    for(y=0; y<7; y++){
2429
        for(x=0; x<16; x+=4){
2430
            score+= ABS(s[x  ] - s[x  +stride]) + ABS(s[x+1] - s[x+1+stride]) 
2431
                   +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
2432
        }
2433
        s+= stride;
2434
    }
2435
    
2436
    return score;
2437
}
2438

2439
static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
2440
    int score=0;
2441
    int x,y;
2442
    
2443
    for(y=0; y<7; y++){
2444
        for(x=0; x<16; x++){
2445
            score+= ABS(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2446
        }
2447
        s1+= stride;
2448
        s2+= stride;
2449
    }
2450
    
2451
    return score;
2452
}
2453
#else
2454
#define SQ(a) ((a)*(a))
2455

    
2456
static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
2457
    int score=0;
2458
    int x,y;
2459
    
2460
    for(y=0; y<7; y++){
2461
        for(x=0; x<16; x+=4){
2462
            score+= SQ(s[x  ] - s[x  +stride]) + SQ(s[x+1] - s[x+1+stride]) 
2463
                   +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
2464
        }
2465
        s+= stride;
2466
    }
2467
    
2468
    return score;
2469
}
2470

    
2471
static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
2472
    int score=0;
2473
    int x,y;
2474
    
2475
    for(y=0; y<7; y++){
2476
        for(x=0; x<16; x++){
2477
            score+= SQ(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2478
        }
2479
        s1+= stride;
2480
        s2+= stride;
2481
    }
2482
    
2483
    return score;
2484
}
2485

    
2486
#endif
2487

    
2488
#endif //CONFIG_ENCODERS
2489

    
2490
/**
2491
 *
2492
 * @param h is the normal height, this will be reduced automatically if needed for the last row
2493
 */
2494
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2495
    if (    s->avctx->draw_horiz_band 
2496
        && (s->last_picture_ptr || s->low_delay) ) {
2497
        uint8_t *src_ptr[3];
2498
        int offset;
2499
        h= FFMIN(h, s->height - y);
2500

    
2501
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME)
2502
            offset = 0;
2503
        else
2504
            offset = y * s->linesize;
2505

    
2506
        if(s->pict_type==B_TYPE || s->low_delay){
2507
            src_ptr[0] = s->current_picture.data[0] + offset;
2508
            src_ptr[1] = s->current_picture.data[1] + (offset >> 2);
2509
            src_ptr[2] = s->current_picture.data[2] + (offset >> 2);
2510
        } else {
2511
            src_ptr[0] = s->last_picture.data[0] + offset;
2512
            src_ptr[1] = s->last_picture.data[1] + (offset >> 2);
2513
            src_ptr[2] = s->last_picture.data[2] + (offset >> 2);
2514
        }
2515
        emms_c();
2516

    
2517
        s->avctx->draw_horiz_band(s->avctx, src_ptr, s->linesize,
2518
                               y, s->width, h);
2519
    }
2520
}
2521

    
2522
#ifdef CONFIG_ENCODERS
2523

    
2524
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2525
{
2526
    const int mb_x= s->mb_x;
2527
    const int mb_y= s->mb_y;
2528
    int i;
2529
    int skip_dct[6];
2530
    int dct_offset   = s->linesize*8; //default for progressive frames
2531
    
2532
    for(i=0; i<6; i++) skip_dct[i]=0;
2533
    
2534
    if(s->adaptive_quant){
2535
        s->dquant= s->current_picture.qscale_table[mb_x + mb_y*s->mb_stride] - s->qscale;
2536

    
2537
        if(s->out_format==FMT_H263){
2538
            if     (s->dquant> 2) s->dquant= 2;
2539
            else if(s->dquant<-2) s->dquant=-2;
2540
        }
2541
            
2542
        if(s->codec_id==CODEC_ID_MPEG4){        
2543
            if(!s->mb_intra){
2544
                if(s->mv_dir&MV_DIRECT)
2545
                    s->dquant=0;
2546

    
2547
                assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
2548
            }
2549
        }
2550
        s->qscale+= s->dquant;
2551
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2552
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2553
    }
2554

    
2555
    if (s->mb_intra) {
2556
        uint8_t *ptr;
2557
        int wrap_y;
2558
        int emu=0;
2559

    
2560
        wrap_y = s->linesize;
2561
        ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2562

    
2563
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2564
            ff_emulated_edge_mc(s, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2565
            ptr= s->edge_emu_buffer;
2566
            emu=1;
2567
        }
2568
        
2569
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2570
            int progressive_score, interlaced_score;
2571
            
2572
            progressive_score= pix_vcmp16x8(ptr, wrap_y  ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
2573
            interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y  , wrap_y*2);
2574
            
2575
            if(progressive_score > interlaced_score + 100){
2576
                s->interlaced_dct=1;
2577
            
2578
                dct_offset= wrap_y;
2579
                wrap_y<<=1;
2580
            }else
2581
                s->interlaced_dct=0;
2582
        }
2583
        
2584
        s->dsp.get_pixels(s->block[0], ptr                 , wrap_y);
2585
        s->dsp.get_pixels(s->block[1], ptr              + 8, wrap_y);
2586
        s->dsp.get_pixels(s->block[2], ptr + dct_offset    , wrap_y);
2587
        s->dsp.get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
2588

    
2589
        if(s->flags&CODEC_FLAG_GRAY){
2590
            skip_dct[4]= 1;
2591
            skip_dct[5]= 1;
2592
        }else{
2593
            int wrap_c = s->uvlinesize;
2594
            ptr = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2595
            if(emu){
2596
                ff_emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2597
                ptr= s->edge_emu_buffer;
2598
            }
2599
            s->dsp.get_pixels(s->block[4], ptr, wrap_c);
2600

    
2601
            ptr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2602
            if(emu){
2603
                ff_emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2604
                ptr= s->edge_emu_buffer;
2605
            }
2606
            s->dsp.get_pixels(s->block[5], ptr, wrap_c);
2607
        }
2608
    }else{
2609
        op_pixels_func (*op_pix)[4];
2610
        qpel_mc_func (*op_qpix)[16];
2611
        uint8_t *dest_y, *dest_cb, *dest_cr;
2612
        uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2613
        int wrap_y, wrap_c;
2614
        int emu=0;
2615

    
2616
        dest_y  = s->current_picture.data[0] + (mb_y * 16 * s->linesize    ) + mb_x * 16;
2617
        dest_cb = s->current_picture.data[1] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2618
        dest_cr = s->current_picture.data[2] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2619
        wrap_y = s->linesize;
2620
        wrap_c = s->uvlinesize;
2621
        ptr_y  = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2622
        ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2623
        ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2624

    
2625
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
2626
            op_pix = s->dsp.put_pixels_tab;
2627
            op_qpix= s->dsp.put_qpel_pixels_tab;
2628
        }else{
2629
            op_pix = s->dsp.put_no_rnd_pixels_tab;
2630
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2631
        }
2632

    
2633
        if (s->mv_dir & MV_DIR_FORWARD) {
2634
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2635
            op_pix = s->dsp.avg_pixels_tab;
2636
            op_qpix= s->dsp.avg_qpel_pixels_tab;
2637
        }
2638
        if (s->mv_dir & MV_DIR_BACKWARD) {
2639
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2640
        }
2641

    
2642
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2643
            ff_emulated_edge_mc(s, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2644
            ptr_y= s->edge_emu_buffer;
2645
            emu=1;
2646
        }
2647
        
2648
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2649
            int progressive_score, interlaced_score;
2650
            
2651
            progressive_score= pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y  ) 
2652
                             + pix_diff_vcmp16x8(ptr_y + wrap_y*8, dest_y + wrap_y*8, wrap_y  );
2653
            interlaced_score = pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y*2)
2654
                             + pix_diff_vcmp16x8(ptr_y + wrap_y  , dest_y + wrap_y  , wrap_y*2);
2655
            
2656
            if(progressive_score > interlaced_score + 600){
2657
                s->interlaced_dct=1;
2658
            
2659
                dct_offset= wrap_y;
2660
                wrap_y<<=1;
2661
            }else
2662
                s->interlaced_dct=0;
2663
        }
2664
        
2665
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
2666
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
2667
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
2668
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
2669
        
2670
        if(s->flags&CODEC_FLAG_GRAY){
2671
            skip_dct[4]= 1;
2672
            skip_dct[5]= 1;
2673
        }else{
2674
            if(emu){
2675
                ff_emulated_edge_mc(s, ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2676
                ptr_cb= s->edge_emu_buffer;
2677
            }
2678
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2679
            if(emu){
2680
                ff_emulated_edge_mc(s, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2681
                ptr_cr= s->edge_emu_buffer;
2682
            }
2683
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2684
        }
2685
        /* pre quantization */         
2686
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
2687
            //FIXME optimize
2688
            if(s->dsp.pix_abs8x8(ptr_y               , dest_y               , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
2689
            if(s->dsp.pix_abs8x8(ptr_y            + 8, dest_y            + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
2690
            if(s->dsp.pix_abs8x8(ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
2691
            if(s->dsp.pix_abs8x8(ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
2692
            if(s->dsp.pix_abs8x8(ptr_cb              , dest_cb              , wrap_c) < 20*s->qscale) skip_dct[4]= 1;
2693
            if(s->dsp.pix_abs8x8(ptr_cr              , dest_cr              , wrap_c) < 20*s->qscale) skip_dct[5]= 1;
2694
#if 0
2695
{
2696
 static int stat[7];
2697
 int num=0;
2698
 for(i=0; i<6; i++)
2699
  if(skip_dct[i]) num++;
2700
 stat[num]++;
2701
 
2702
 if(s->mb_x==0 && s->mb_y==0){
2703
  for(i=0; i<7; i++){
2704
   printf("%6d %1d\n", stat[i], i);
2705
  }
2706
 }
2707
}
2708
#endif
2709
        }
2710

    
2711
    }
2712
            
2713
#if 0
2714
            {
2715
                float adap_parm;
2716
                
2717
                adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_stride*mb_y+mb_x] + 1.0) /
2718
                            ((s->mb_var[s->mb_stride*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);
2719
            
2720
                printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d", 
2721
                        (s->mb_type[s->mb_stride*mb_y+mb_x] > 0) ? 'I' : 'P', 
2722
                        s->qscale, adap_parm, s->qscale*adap_parm,
2723
                        s->mb_var[s->mb_stride*mb_y+mb_x], s->avg_mb_var);
2724
            }
2725
#endif
2726
    /* DCT & quantize */
2727
    if(s->out_format==FMT_MJPEG){
2728
        for(i=0;i<6;i++) {
2729
            int overflow;
2730
            s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
2731
            if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2732
        }
2733
    }else{
2734
        for(i=0;i<6;i++) {
2735
            if(!skip_dct[i]){
2736
                int overflow;
2737
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2738
            // FIXME we could decide to change to quantizer instead of clipping
2739
            // JS: I don't think that would be a good idea it could lower quality instead
2740
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
2741
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2742
            }else
2743
                s->block_last_index[i]= -1;
2744
        }
2745
        if(s->luma_elim_threshold && !s->mb_intra)
2746
            for(i=0; i<4; i++)
2747
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2748
        if(s->chroma_elim_threshold && !s->mb_intra)
2749
            for(i=4; i<6; i++)
2750
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2751
    }
2752

    
2753
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
2754
        s->block_last_index[4]=
2755
        s->block_last_index[5]= 0;
2756
        s->block[4][0]=
2757
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
2758
    }
2759

    
2760
    /* huffman encode */
2761
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2762
    case CODEC_ID_MPEG1VIDEO:
2763
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
2764
#ifdef CONFIG_RISKY
2765
    case CODEC_ID_MPEG4:
2766
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
2767
    case CODEC_ID_MSMPEG4V2:
2768
    case CODEC_ID_MSMPEG4V3:
2769
    case CODEC_ID_WMV1:
2770
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
2771
    case CODEC_ID_WMV2:
2772
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
2773
    case CODEC_ID_H263:
2774
    case CODEC_ID_H263P:
2775
    case CODEC_ID_RV10:
2776
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
2777
#endif
2778
    case CODEC_ID_MJPEG:
2779
        mjpeg_encode_mb(s, s->block); break;
2780
    default:
2781
        assert(0);
2782
    }
2783
}
2784

    
2785
#endif //CONFIG_ENCODERS
2786

    
2787
/**
2788
 * combines the (truncated) bitstream to a complete frame
2789
 * @returns -1 if no complete frame could be created
2790
 */
2791
int ff_combine_frame( MpegEncContext *s, int next, uint8_t **buf, int *buf_size){
2792
    ParseContext *pc= &s->parse_context;
2793

    
2794
#if 0
2795
    if(pc->overread){
2796
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
2797
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
2798
    }
2799
#endif
2800

    
2801
    /* copy overreaded byes from last frame into buffer */
2802
    for(; pc->overread>0; pc->overread--){
2803
        pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
2804
    }
2805
    
2806
    pc->last_index= pc->index;
2807

    
2808
    /* copy into buffer end return */
2809
    if(next == END_NOT_FOUND){
2810
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
2811

    
2812
        memcpy(&pc->buffer[pc->index], *buf, *buf_size);
2813
        pc->index += *buf_size;
2814
        return -1;
2815
    }
2816
    
2817
    pc->overread_index= pc->index + next;
2818
    
2819
    /* append to buffer */
2820
    if(pc->index){
2821
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
2822

    
2823
        memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
2824
        pc->index = 0;
2825
        *buf= pc->buffer;
2826
        *buf_size= pc->last_index + next;
2827
    }
2828

    
2829
    /* store overread bytes */
2830
    for(;next < 0; next++){
2831
        pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
2832
        pc->overread++;
2833
    }
2834

    
2835
#if 0
2836
    if(pc->overread){
2837
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
2838
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
2839
    }
2840
#endif
2841

    
2842
    return 0;
2843
}
2844

    
2845
#ifdef CONFIG_ENCODERS
2846
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
2847
{
2848
    int bytes= length>>4;
2849
    int bits= length&15;
2850
    int i;
2851

    
2852
    if(length==0) return;
2853

    
2854
    for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
2855
    put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
2856
}
2857

    
2858
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2859
    int i;
2860

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

    
2863
    /* mpeg1 */
2864
    d->mb_skip_run= s->mb_skip_run;
2865
    for(i=0; i<3; i++)
2866
        d->last_dc[i]= s->last_dc[i];
2867
    
2868
    /* statistics */
2869
    d->mv_bits= s->mv_bits;
2870
    d->i_tex_bits= s->i_tex_bits;
2871
    d->p_tex_bits= s->p_tex_bits;
2872
    d->i_count= s->i_count;
2873
    d->f_count= s->f_count;
2874
    d->b_count= s->b_count;
2875
    d->skip_count= s->skip_count;
2876
    d->misc_bits= s->misc_bits;
2877
    d->last_bits= 0;
2878

    
2879
    d->mb_skiped= s->mb_skiped;
2880
    d->qscale= s->qscale;
2881
}
2882

    
2883
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2884
    int i;
2885

    
2886
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
2887
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
2888
    
2889
    /* mpeg1 */
2890
    d->mb_skip_run= s->mb_skip_run;
2891
    for(i=0; i<3; i++)
2892
        d->last_dc[i]= s->last_dc[i];
2893
    
2894
    /* statistics */
2895
    d->mv_bits= s->mv_bits;
2896
    d->i_tex_bits= s->i_tex_bits;
2897
    d->p_tex_bits= s->p_tex_bits;
2898
    d->i_count= s->i_count;
2899
    d->f_count= s->f_count;
2900
    d->b_count= s->b_count;
2901
    d->skip_count= s->skip_count;
2902
    d->misc_bits= s->misc_bits;
2903

    
2904
    d->mb_intra= s->mb_intra;
2905
    d->mb_skiped= s->mb_skiped;
2906
    d->mv_type= s->mv_type;
2907
    d->mv_dir= s->mv_dir;
2908
    d->pb= s->pb;
2909
    if(s->data_partitioning){
2910
        d->pb2= s->pb2;
2911
        d->tex_pb= s->tex_pb;
2912
    }
2913
    d->block= s->block;
2914
    for(i=0; i<6; i++)
2915
        d->block_last_index[i]= s->block_last_index[i];
2916
    d->interlaced_dct= s->interlaced_dct;
2917
    d->qscale= s->qscale;
2918
}
2919

    
2920
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
2921
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2922
                           int *dmin, int *next_block, int motion_x, int motion_y)
2923
{
2924
    int bits_count;
2925
    
2926
    copy_context_before_encode(s, backup, type);
2927

    
2928
    s->block= s->blocks[*next_block];
2929
    s->pb= pb[*next_block];
2930
    if(s->data_partitioning){
2931
        s->pb2   = pb2   [*next_block];
2932
        s->tex_pb= tex_pb[*next_block];
2933
    }
2934

    
2935
    encode_mb(s, motion_x, motion_y);
2936

    
2937
    bits_count= get_bit_count(&s->pb);
2938
    if(s->data_partitioning){
2939
        bits_count+= get_bit_count(&s->pb2);
2940
        bits_count+= get_bit_count(&s->tex_pb);
2941
    }
2942

    
2943
    if(bits_count<*dmin){
2944
        *dmin= bits_count;
2945
        *next_block^=1;
2946

    
2947
        copy_context_after_encode(best, s, type);
2948
    }
2949
}
2950
                
2951
static inline int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2952
    uint32_t *sq = squareTbl + 256;
2953
    int acc=0;
2954
    int x,y;
2955
    
2956
    if(w==16 && h==16) 
2957
        return s->dsp.sse[0](NULL, src1, src2, stride);
2958
    else if(w==8 && h==8)
2959
        return s->dsp.sse[1](NULL, src1, src2, stride);
2960
    
2961
    for(y=0; y<h; y++){
2962
        for(x=0; x<w; x++){
2963
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2964
        } 
2965
    }
2966
    
2967
    assert(acc>=0);
2968
    
2969
    return acc;
2970
}
2971

    
2972
static void encode_picture(MpegEncContext *s, int picture_number)
2973
{
2974
    int mb_x, mb_y, pdif = 0;
2975
    int i;
2976
    int bits;
2977
    MpegEncContext best_s, backup_s;
2978
    uint8_t bit_buf[2][3000];
2979
    uint8_t bit_buf2[2][3000];
2980
    uint8_t bit_buf_tex[2][3000];
2981
    PutBitContext pb[2], pb2[2], tex_pb[2];
2982

    
2983
    for(i=0; i<2; i++){
2984
        init_put_bits(&pb    [i], bit_buf    [i], 3000, NULL, NULL);
2985
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000, NULL, NULL);
2986
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
2987
    }
2988

    
2989
    s->picture_number = picture_number;
2990
    
2991
    /* Reset the average MB variance */
2992
    s->current_picture.mb_var_sum = 0;
2993
    s->current_picture.mc_mb_var_sum = 0;
2994

    
2995
#ifdef CONFIG_RISKY
2996
    /* we need to initialize some time vars before we can encode b-frames */
2997
    // RAL: Condition added for MPEG1VIDEO
2998
    if (s->codec_id == CODEC_ID_MPEG1VIDEO || (s->h263_pred && !s->h263_msmpeg4))
2999
        ff_set_mpeg4_time(s, s->picture_number); 
3000
#endif
3001
        
3002
    s->scene_change_score=0;
3003
    
3004
    s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
3005
    
3006
    if(s->pict_type==I_TYPE){
3007
        if(s->msmpeg4_version >= 3) s->no_rounding=1;
3008
        else                        s->no_rounding=0;
3009
    }else if(s->pict_type!=B_TYPE){
3010
        if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
3011
            s->no_rounding ^= 1;          
3012
    }
3013
    
3014
    /* Estimate motion for every MB */
3015
    s->mb_intra=0; //for the rate distoration & bit compare functions
3016
    if(s->pict_type != I_TYPE){
3017
        if(s->pict_type != B_TYPE){
3018
            if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
3019
                s->me.pre_pass=1;
3020
                s->me.dia_size= s->avctx->pre_dia_size;
3021

    
3022
                for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) {
3023
                    for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) {
3024
                        s->mb_x = mb_x;
3025
                        s->mb_y = mb_y;
3026
                        ff_pre_estimate_p_frame_motion(s, mb_x, mb_y);
3027
                    }
3028
                }
3029
                s->me.pre_pass=0;
3030
            }
3031
        }
3032

    
3033
        s->me.dia_size= s->avctx->dia_size;
3034
        for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3035
            s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3036
            s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3037
            s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3038
            s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3039
            for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3040
                s->mb_x = mb_x;
3041
                s->mb_y = mb_y;
3042
                s->block_index[0]+=2;
3043
                s->block_index[1]+=2;
3044
                s->block_index[2]+=2;
3045
                s->block_index[3]+=2;
3046
                
3047
                /* compute motion vector & mb_type and store in context */
3048
                if(s->pict_type==B_TYPE)
3049
                    ff_estimate_b_frame_motion(s, mb_x, mb_y);
3050
                else
3051
                    ff_estimate_p_frame_motion(s, mb_x, mb_y);
3052
            }
3053
        }
3054
    }else /* if(s->pict_type == I_TYPE) */{
3055
        /* I-Frame */
3056
        //FIXME do we need to zero them?
3057
        memset(s->motion_val[0], 0, sizeof(int16_t)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
3058
        memset(s->p_mv_table   , 0, sizeof(int16_t)*(s->mb_stride)*s->mb_height*2);
3059
        memset(s->mb_type      , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3060
        
3061
        if(!s->fixed_qscale){
3062
            /* finding spatial complexity for I-frame rate control */
3063
            for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3064
                for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3065
                    int xx = mb_x * 16;
3066
                    int yy = mb_y * 16;
3067
                    uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
3068
                    int varc;
3069
                    int sum = s->dsp.pix_sum(pix, s->linesize);
3070
    
3071
                    varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
3072

    
3073
                    s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
3074
                    s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
3075
                    s->current_picture.mb_var_sum    += varc;
3076
                }
3077
            }
3078
        }
3079
    }
3080
    emms_c();
3081

    
3082
    if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
3083
        s->pict_type= I_TYPE;
3084
        memset(s->mb_type   , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3085
//printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3086
    }
3087

    
3088
    if(!s->umvplus){
3089
        if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
3090
            s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
3091
        
3092
            ff_fix_long_p_mvs(s);
3093
        }
3094

    
3095
        if(s->pict_type==B_TYPE){
3096
            int a, b;
3097

    
3098
            a = ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
3099
            b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, MB_TYPE_BIDIR);
3100
            s->f_code = FFMAX(a, b);
3101

    
3102
            a = ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
3103
            b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, MB_TYPE_BIDIR);
3104
            s->b_code = FFMAX(a, b);
3105

    
3106
            ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
3107
            ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
3108
            ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
3109
            ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
3110
        }
3111
    }
3112
    
3113
    if (s->fixed_qscale) 
3114
        s->frame_qscale = s->current_picture.quality;
3115
    else
3116
        s->frame_qscale = ff_rate_estimate_qscale(s);
3117

    
3118
    if(s->adaptive_quant){
3119
#ifdef CONFIG_RISKY
3120
        switch(s->codec_id){
3121
        case CODEC_ID_MPEG4:
3122
            ff_clean_mpeg4_qscales(s);
3123
            break;
3124
        case CODEC_ID_H263:
3125
        case CODEC_ID_H263P:
3126
            ff_clean_h263_qscales(s);
3127
            break;
3128
        }
3129
#endif
3130

    
3131
        s->qscale= s->current_picture.qscale_table[0];
3132
    }else
3133
        s->qscale= (int)(s->frame_qscale + 0.5);
3134
        
3135
    if (s->out_format == FMT_MJPEG) {
3136
        /* for mjpeg, we do include qscale in the matrix */
3137
        s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
3138
        for(i=1;i<64;i++){
3139
            int j= s->dsp.idct_permutation[i];
3140

    
3141
            s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3142
        }
3143
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, 
3144
                       s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
3145
    }
3146
    
3147
    //FIXME var duplication
3148
    s->current_picture.key_frame= s->pict_type == I_TYPE;
3149
    s->current_picture.pict_type= s->pict_type;
3150

    
3151
    if(s->current_picture.key_frame)
3152
        s->picture_in_gop_number=0;
3153

    
3154
    s->last_bits= get_bit_count(&s->pb);
3155
    switch(s->out_format) {
3156
    case FMT_MJPEG:
3157
        mjpeg_picture_header(s);
3158
        break;
3159
#ifdef CONFIG_RISKY
3160
    case FMT_H263:
3161
        if (s->codec_id == CODEC_ID_WMV2) 
3162
            ff_wmv2_encode_picture_header(s, picture_number);
3163
        else if (s->h263_msmpeg4) 
3164
            msmpeg4_encode_picture_header(s, picture_number);
3165
        else if (s->h263_pred)
3166
            mpeg4_encode_picture_header(s, picture_number);
3167
        else if (s->h263_rv10) 
3168
            rv10_encode_picture_header(s, picture_number);
3169
        else
3170
            h263_encode_picture_header(s, picture_number);
3171
        break;
3172
#endif
3173
    case FMT_MPEG1:
3174
        mpeg1_encode_picture_header(s, picture_number);
3175
        break;
3176
    }
3177
    bits= get_bit_count(&s->pb);
3178
    s->header_bits= bits - s->last_bits;
3179
    s->last_bits= bits;
3180
    s->mv_bits=0;
3181
    s->misc_bits=0;
3182
    s->i_tex_bits=0;
3183
    s->p_tex_bits=0;
3184
    s->i_count=0;
3185
    s->f_count=0;
3186
    s->b_count=0;
3187
    s->skip_count=0;
3188

    
3189
    for(i=0; i<3; i++){
3190
        /* init last dc values */
3191
        /* note: quant matrix value (8) is implied here */
3192
        s->last_dc[i] = 128;
3193
        
3194
        s->current_picture_ptr->error[i] = 0;
3195
    }
3196
    s->mb_skip_run = 0;
3197
    s->last_mv[0][0][0] = 0;
3198
    s->last_mv[0][0][1] = 0;
3199
    s->last_mv[1][0][0] = 0;
3200
    s->last_mv[1][0][1] = 0;
3201
     
3202
    s->last_mv_dir = 0;
3203

    
3204
#ifdef CONFIG_RISKY
3205
    if (s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P)
3206
        s->gob_index = ff_h263_get_gob_height(s);
3207

    
3208
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3209
        ff_mpeg4_init_partitions(s);
3210
#endif
3211

    
3212
    s->resync_mb_x=0;
3213
    s->resync_mb_y=0;
3214
    s->first_slice_line = 1;
3215
    s->ptr_lastgob = s->pb.buf;
3216
    for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3217
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
3218
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
3219
        
3220
        s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3221
        s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3222
        s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3223
        s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3224
        s->block_index[4]= s->block_wrap[4]*(mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2);
3225
        s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
3226
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3227
            const int xy= mb_y*s->mb_stride + mb_x;
3228
            int mb_type= s->mb_type[xy];
3229
//            int d;
3230
            int dmin=10000000;
3231

    
3232
            s->mb_x = mb_x;
3233
            s->mb_y = mb_y;
3234
            s->block_index[0]+=2;
3235
            s->block_index[1]+=2;
3236
            s->block_index[2]+=2;
3237
            s->block_index[3]+=2;
3238
            s->block_index[4]++;
3239
            s->block_index[5]++;
3240

    
3241
            /* write gob / video packet header  */
3242
#ifdef CONFIG_RISKY
3243
            if(s->rtp_mode){
3244
                int current_packet_size, is_gob_start;
3245
                
3246
                current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
3247
                is_gob_start=0;
3248
                
3249
                if(s->codec_id==CODEC_ID_MPEG4){
3250
                    if(current_packet_size >= s->rtp_payload_size
3251
                       && s->mb_y + s->mb_x>0){
3252

    
3253
                        if(s->partitioned_frame){
3254
                            ff_mpeg4_merge_partitions(s);
3255
                            ff_mpeg4_init_partitions(s);
3256
                        }
3257
                        ff_mpeg4_encode_video_packet_header(s);
3258

    
3259
                        if(s->flags&CODEC_FLAG_PASS1){
3260
                            int bits= get_bit_count(&s->pb);
3261
                            s->misc_bits+= bits - s->last_bits;
3262
                            s->last_bits= bits;
3263
                        }
3264
                        ff_mpeg4_clean_buffers(s);
3265
                        is_gob_start=1;
3266
                    }
3267
                }else if(s->codec_id==CODEC_ID_MPEG1VIDEO){
3268
                    if(   current_packet_size >= s->rtp_payload_size 
3269
                       && s->mb_y + s->mb_x>0 && s->mb_skip_run==0){
3270
                        ff_mpeg1_encode_slice_header(s);
3271
                        ff_mpeg1_clean_buffers(s);
3272
                        is_gob_start=1;
3273
                    }
3274
                }else{
3275
                    if(current_packet_size >= s->rtp_payload_size
3276
                       && s->mb_x==0 && s->mb_y>0 && s->mb_y%s->gob_index==0){
3277
                       
3278
                        h263_encode_gob_header(s, mb_y);                       
3279
                        is_gob_start=1;
3280
                    }
3281
                }
3282

    
3283
                if(is_gob_start){
3284
                    s->ptr_lastgob = pbBufPtr(&s->pb);
3285
                    s->first_slice_line=1;
3286
                    s->resync_mb_x=mb_x;
3287
                    s->resync_mb_y=mb_y;
3288
                }
3289
            }
3290
#endif
3291

    
3292
            if(  (s->resync_mb_x   == s->mb_x)
3293
               && s->resync_mb_y+1 == s->mb_y){
3294
                s->first_slice_line=0; 
3295
            }
3296

    
3297
            if(mb_type & (mb_type-1)){ // more than 1 MB type possible
3298
                int next_block=0;
3299
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3300

    
3301
                copy_context_before_encode(&backup_s, s, -1);
3302
                backup_s.pb= s->pb;
3303
                best_s.data_partitioning= s->data_partitioning;
3304
                best_s.partitioned_frame= s->partitioned_frame;
3305
                if(s->data_partitioning){
3306
                    backup_s.pb2= s->pb2;
3307
                    backup_s.tex_pb= s->tex_pb;
3308
                }
3309

    
3310
                if(mb_type&MB_TYPE_INTER){
3311
                    s->mv_dir = MV_DIR_FORWARD;
3312
                    s->mv_type = MV_TYPE_16X16;
3313
                    s->mb_intra= 0;
3314
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
3315
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
3316
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb, 
3317
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3318
                }
3319
                if(mb_type&MB_TYPE_INTER4V){                 
3320
                    s->mv_dir = MV_DIR_FORWARD;
3321
                    s->mv_type = MV_TYPE_8X8;
3322
                    s->mb_intra= 0;
3323
                    for(i=0; i<4; i++){
3324
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3325
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3326
                    }
3327
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb, 
3328
                                 &dmin, &next_block, 0, 0);
3329
                }
3330
                if(mb_type&MB_TYPE_FORWARD){
3331
                    s->mv_dir = MV_DIR_FORWARD;
3332
                    s->mv_type = MV_TYPE_16X16;
3333
                    s->mb_intra= 0;
3334
                    s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3335
                    s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3336
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb, 
3337
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3338
                }
3339
                if(mb_type&MB_TYPE_BACKWARD){
3340
                    s->mv_dir = MV_DIR_BACKWARD;
3341
                    s->mv_type = MV_TYPE_16X16;
3342
                    s->mb_intra= 0;
3343
                    s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3344
                    s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3345
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb, 
3346
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3347
                }
3348
                if(mb_type&MB_TYPE_BIDIR){
3349
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3350
                    s->mv_type = MV_TYPE_16X16;
3351
                    s->mb_intra= 0;
3352
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3353
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3354
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3355
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3356
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb, 
3357
                                 &dmin, &next_block, 0, 0);
3358
                }
3359
                if(mb_type&MB_TYPE_DIRECT){
3360
                    int mx= s->b_direct_mv_table[xy][0];
3361
                    int my= s->b_direct_mv_table[xy][1];
3362
                    
3363
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3364
                    s->mb_intra= 0;
3365
#ifdef CONFIG_RISKY
3366
                    ff_mpeg4_set_direct_mv(s, mx, my);
3367
#endif
3368
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb, 
3369
                                 &dmin, &next_block, mx, my);
3370
                }
3371
                if(mb_type&MB_TYPE_INTRA){
3372
                    s->mv_dir = 0;
3373
                    s->mv_type = MV_TYPE_16X16;
3374
                    s->mb_intra= 1;
3375
                    s->mv[0][0][0] = 0;
3376
                    s->mv[0][0][1] = 0;
3377
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb, 
3378
                                 &dmin, &next_block, 0, 0);
3379
                    /* force cleaning of ac/dc pred stuff if needed ... */
3380
                    if(s->h263_pred || s->h263_aic)
3381
                        s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
3382
                }
3383
                copy_context_after_encode(s, &best_s, -1);
3384
                
3385
                pb_bits_count= get_bit_count(&s->pb);
3386
                flush_put_bits(&s->pb);
3387
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3388
                s->pb= backup_s.pb;
3389
                
3390
                if(s->data_partitioning){
3391
                    pb2_bits_count= get_bit_count(&s->pb2);
3392
                    flush_put_bits(&s->pb2);
3393
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3394
                    s->pb2= backup_s.pb2;
3395
                    
3396
                    tex_pb_bits_count= get_bit_count(&s->tex_pb);
3397
                    flush_put_bits(&s->tex_pb);
3398
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3399
                    s->tex_pb= backup_s.tex_pb;
3400
                }
3401
                s->last_bits= get_bit_count(&s->pb);
3402
            } else {
3403
                int motion_x, motion_y;
3404
                int intra_score;
3405
                int inter_score= s->current_picture.mb_cmp_score[mb_x + mb_y*s->mb_stride];
3406
                
3407
              if(!(s->flags&CODEC_FLAG_HQ) && s->pict_type==P_TYPE){
3408
                /* get luma score */
3409
                if((s->avctx->mb_cmp&0xFF)==FF_CMP_SSE){
3410
                    intra_score= (s->current_picture.mb_var[mb_x + mb_y*s->mb_stride]<<8) - 500; //FIXME dont scale it down so we dont have to fix it
3411
                }else{
3412
                    uint8_t *dest_y;
3413

    
3414
                    int mean= s->current_picture.mb_mean[mb_x + mb_y*s->mb_stride]; //FIXME
3415
                    mean*= 0x01010101;
3416
                    
3417
                    dest_y  = s->new_picture.data[0] + (mb_y * 16 * s->linesize    ) + mb_x * 16;
3418
                
3419
                    for(i=0; i<16; i++){
3420
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 0]) = mean;
3421
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 4]) = mean;
3422
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 8]) = mean;
3423
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+12]) = mean;
3424
                    }
3425

    
3426
                    s->mb_intra=1;
3427
                    intra_score= s->dsp.mb_cmp[0](s, s->me.scratchpad, dest_y, s->linesize);
3428
                                        
3429
/*                    printf("intra:%7d inter:%7d var:%7d mc_var.%7d\n", intra_score>>8, inter_score>>8, 
3430
                        s->current_picture.mb_var[mb_x + mb_y*s->mb_stride],
3431
                        s->current_picture.mc_mb_var[mb_x + mb_y*s->mb_stride]);*/
3432
                }
3433
                
3434
                /* get chroma score */
3435
                if(s->avctx->mb_cmp&FF_CMP_CHROMA){
3436
                    int i;
3437
                    
3438
                    s->mb_intra=1;
3439
                    for(i=1; i<3; i++){
3440
                        uint8_t *dest_c;
3441
                        int mean;
3442
                        
3443
                        if(s->out_format == FMT_H263){
3444
                            mean= (s->dc_val[i][mb_x + (mb_y+1)*(s->mb_width+2)] + 4)>>3; //FIXME not exact but simple ;)
3445
                        }else{
3446
                            mean= (s->last_dc[i] + 4)>>3;
3447
                        }
3448
                        dest_c = s->new_picture.data[i] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
3449
                        
3450
                        mean*= 0x01010101;
3451
                        for(i=0; i<8; i++){
3452
                            *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 0]) = mean;
3453
                            *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 4]) = mean;
3454
                        }
3455
                        
3456
                        intra_score+= s->dsp.mb_cmp[1](s, s->me.scratchpad, dest_c, s->uvlinesize);
3457
                    }                
3458
                }
3459

    
3460
                /* bias */
3461
                switch(s->avctx->mb_cmp&0xFF){
3462
                default:
3463
                case FF_CMP_SAD:
3464
                    intra_score+= 32*s->qscale;
3465
                    break;
3466
                case FF_CMP_SSE:
3467
                    intra_score+= 24*s->qscale*s->qscale;
3468
                    break;
3469
                case FF_CMP_SATD:
3470
                    intra_score+= 96*s->qscale;
3471
                    break;
3472
                case FF_CMP_DCT:
3473
                    intra_score+= 48*s->qscale;
3474
                    break;
3475
                case FF_CMP_BIT:
3476
                    intra_score+= 16;
3477
                    break;
3478
                case FF_CMP_PSNR:
3479
                case FF_CMP_RD:
3480
                    intra_score+= (s->qscale*s->qscale*109*8 + 64)>>7;
3481
                    break;
3482
                }
3483

    
3484
                if(intra_score < inter_score)
3485
                    mb_type= MB_TYPE_INTRA;
3486
              }  
3487
                
3488
                s->mv_type=MV_TYPE_16X16;
3489
                // only one MB-Type possible
3490
                
3491
                switch(mb_type){
3492
                case MB_TYPE_INTRA:
3493
                    s->mv_dir = 0;
3494
                    s->mb_intra= 1;
3495
                    motion_x= s->mv[0][0][0] = 0;
3496
                    motion_y= s->mv[0][0][1] = 0;
3497
                    break;
3498
                case MB_TYPE_INTER:
3499
                    s->mv_dir = MV_DIR_FORWARD;
3500
                    s->mb_intra= 0;
3501
                    motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3502
                    motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3503
                    break;
3504
                case MB_TYPE_INTER4V:
3505
                    s->mv_dir = MV_DIR_FORWARD;
3506
                    s->mv_type = MV_TYPE_8X8;
3507
                    s->mb_intra= 0;
3508
                    for(i=0; i<4; i++){
3509
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3510
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3511
                    }
3512
                    motion_x= motion_y= 0;
3513
                    break;
3514
                case MB_TYPE_DIRECT:
3515
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3516
                    s->mb_intra= 0;
3517
                    motion_x=s->b_direct_mv_table[xy][0];
3518
                    motion_y=s->b_direct_mv_table[xy][1];
3519
#ifdef CONFIG_RISKY
3520
                    ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3521
#endif
3522
                    break;
3523
                case MB_TYPE_BIDIR:
3524
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3525
                    s->mb_intra= 0;
3526
                    motion_x=0;
3527
                    motion_y=0;
3528
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3529
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3530
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3531
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3532
                    break;
3533
                case MB_TYPE_BACKWARD:
3534
                    s->mv_dir = MV_DIR_BACKWARD;
3535
                    s->mb_intra= 0;
3536
                    motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3537
                    motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3538
                    break;
3539
                case MB_TYPE_FORWARD:
3540
                    s->mv_dir = MV_DIR_FORWARD;
3541
                    s->mb_intra= 0;
3542
                    motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3543
                    motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3544
//                    printf(" %d %d ", motion_x, motion_y);
3545
                    break;
3546
                default:
3547
                    motion_x=motion_y=0; //gcc warning fix
3548
                    printf("illegal MB type\n");
3549
                }
3550

    
3551
                encode_mb(s, motion_x, motion_y);
3552

    
3553
                // RAL: Update last macrobloc type
3554
                s->last_mv_dir = s->mv_dir;
3555
            }
3556

    
3557
            /* clean the MV table in IPS frames for direct mode in B frames */
3558
            if(s->mb_intra /* && I,P,S_TYPE */){
3559
                s->p_mv_table[xy][0]=0;
3560
                s->p_mv_table[xy][1]=0;
3561
            }
3562

    
3563
            MPV_decode_mb(s, s->block);
3564
            
3565
            if(s->flags&CODEC_FLAG_PSNR){
3566
                int w= 16;
3567
                int h= 16;
3568

    
3569
                if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3570
                if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3571

    
3572
                s->current_picture_ptr->error[0] += sse(
3573
                    s,
3574
                    s->new_picture    .data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3575
                    s->current_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3576
                    w, h, s->linesize);
3577
                s->current_picture_ptr->error[1] += sse(
3578
                    s,
3579
                    s->new_picture    .data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3580
                    s->current_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3581
                    w>>1, h>>1, s->uvlinesize);
3582
                s->current_picture_ptr->error[2] += sse(
3583
                    s,
3584
                    s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3585
                    s->current_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3586
                    w>>1, h>>1, s->uvlinesize);
3587
            }
3588
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, get_bit_count(&s->pb));
3589
        }
3590
    }
3591
    emms_c();
3592

    
3593
#ifdef CONFIG_RISKY
3594
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3595
        ff_mpeg4_merge_partitions(s);
3596

    
3597
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
3598
        msmpeg4_encode_ext_header(s);
3599

    
3600
    if(s->codec_id==CODEC_ID_MPEG4) 
3601
        ff_mpeg4_stuffing(&s->pb);
3602
#endif
3603

    
3604
    //if (s->gob_number)
3605
    //    fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
3606
    
3607
    /* Send the last GOB if RTP */    
3608
    if (s->rtp_mode) {
3609
        flush_put_bits(&s->pb);
3610
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
3611
        /* Call the RTP callback to send the last GOB */
3612
        if (s->rtp_callback)
3613
            s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
3614
        s->ptr_lastgob = pbBufPtr(&s->pb);
3615
        //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
3616
    }
3617
}
3618

    
3619
static int dct_quantize_trellis_c(MpegEncContext *s, 
3620
                        DCTELEM *block, int n,
3621
                        int qscale, int *overflow){
3622
    const int *qmat;
3623
    const uint8_t *scantable= s->intra_scantable.scantable;
3624
    int max=0;
3625
    unsigned int threshold1, threshold2;
3626
    int bias=0;
3627
    int run_tab[65];
3628
    int level_tab[65];
3629
    int score_tab[65];
3630
    int last_run=0;
3631
    int last_level=0;
3632
    int last_score= 0;
3633
    int last_i= 0;
3634
    int coeff[3][64];
3635
    int coeff_count[64];
3636
    int lambda, qmul, qadd, start_i, last_non_zero, i;
3637
    const int esc_length= s->ac_esc_length;
3638
    uint8_t * length;
3639
    uint8_t * last_length;
3640
    int score_limit=0;
3641
    int left_limit= 0;
3642
        
3643
    s->dsp.fdct (block);
3644

    
3645
    qmul= qscale*16;
3646
    qadd= ((qscale-1)|1)*8;
3647

    
3648
    if (s->mb_intra) {
3649
        int q;
3650
        if (!s->h263_aic) {
3651
            if (n < 4)
3652
                q = s->y_dc_scale;
3653
            else
3654
                q = s->c_dc_scale;
3655
            q = q << 3;
3656
        } else{
3657
            /* For AIC we skip quant/dequant of INTRADC */
3658
            q = 1 << 3;
3659
            qadd=0;
3660
        }
3661
            
3662
        /* note: block[0] is assumed to be positive */
3663
        block[0] = (block[0] + (q >> 1)) / q;
3664
        start_i = 1;
3665
        last_non_zero = 0;
3666
        qmat = s->q_intra_matrix[qscale];
3667
        if(s->mpeg_quant || s->codec_id== CODEC_ID_MPEG1VIDEO)
3668
            bias= 1<<(QMAT_SHIFT-1);
3669
        length     = s->intra_ac_vlc_length;
3670
        last_length= s->intra_ac_vlc_last_length;
3671
    } else {
3672
        start_i = 0;
3673
        last_non_zero = -1;
3674
        qmat = s->q_inter_matrix[qscale];
3675
        length     = s->inter_ac_vlc_length;
3676
        last_length= s->inter_ac_vlc_last_length;
3677
    }
3678

    
3679
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
3680
    threshold2= (threshold1<<1);
3681

    
3682
    for(i=start_i; i<64; i++) {
3683
        const int j = scantable[i];
3684
        const int k= i-start_i;
3685
        int level = block[j];
3686
        level = level * qmat[j];
3687

    
3688
//        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
3689
//           || bias-level >= (1<<(QMAT_SHIFT - 3))){
3690
        if(((unsigned)(level+threshold1))>threshold2){
3691
            if(level>0){
3692
                level= (bias + level)>>QMAT_SHIFT;
3693
                coeff[0][k]= level;
3694
                coeff[1][k]= level-1;
3695
//                coeff[2][k]= level-2;
3696
            }else{
3697
                level= (bias - level)>>QMAT_SHIFT;
3698
                coeff[0][k]= -level;
3699
                coeff[1][k]= -level+1;
3700
//                coeff[2][k]= -level+2;
3701
            }
3702
            coeff_count[k]= FFMIN(level, 2);
3703
            max |=level;
3704
            last_non_zero = i;
3705
        }else{
3706
            coeff[0][k]= (level>>31)|1;
3707
            coeff_count[k]= 1;
3708
        }
3709
    }
3710
    
3711
    *overflow= s->max_qcoeff < max; //overflow might have happend
3712
    
3713
    if(last_non_zero < start_i){
3714
        memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3715
        return last_non_zero;
3716
    }
3717

    
3718
    lambda= (qscale*qscale*64*105 + 64)>>7; //FIXME finetune
3719
        
3720
    score_tab[0]= 0;
3721
    for(i=0; i<=last_non_zero - start_i; i++){
3722
        int level_index, run, j;
3723
        const int dct_coeff= block[ scantable[i + start_i] ];
3724
        const int zero_distoration= dct_coeff*dct_coeff;
3725
        int best_score=256*256*256*120;
3726

    
3727
        last_score += zero_distoration;
3728
        for(level_index=0; level_index < coeff_count[i]; level_index++){
3729
            int distoration;
3730
            int level= coeff[level_index][i];
3731
            int unquant_coeff;
3732
            
3733
            assert(level);
3734

    
3735
            if(s->out_format == FMT_H263){
3736
                if(level>0){
3737
                    unquant_coeff= level*qmul + qadd;
3738
                }else{
3739
                    unquant_coeff= level*qmul - qadd;
3740
                }
3741
            }else{ //MPEG1
3742
                j= s->dsp.idct_permutation[ scantable[i + start_i] ]; //FIXME optimize
3743
                if(s->mb_intra){
3744
                    if (level < 0) {
3745
                        unquant_coeff = (int)((-level) * qscale * s->intra_matrix[j]) >> 3;
3746
                        unquant_coeff = -((unquant_coeff - 1) | 1);
3747
                    } else {
3748
                        unquant_coeff = (int)(  level  * qscale * s->intra_matrix[j]) >> 3;
3749
                        unquant_coeff =   (unquant_coeff - 1) | 1;
3750
                    }
3751
                }else{
3752
                    if (level < 0) {
3753
                        unquant_coeff = ((((-level) << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3754
                        unquant_coeff = -((unquant_coeff - 1) | 1);
3755
                    } else {
3756
                        unquant_coeff = (((  level  << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3757
                        unquant_coeff =   (unquant_coeff - 1) | 1;
3758
                    }
3759
                }
3760
                unquant_coeff<<= 3;
3761
            }
3762

    
3763
            distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff);
3764
            level+=64;
3765
            if((level&(~127)) == 0){
3766
                for(run=0; run<=i - left_limit; run++){
3767
                    int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3768
                    score += score_tab[i-run];
3769
                    
3770
                    if(score < best_score){
3771
                        best_score= 
3772
                        score_tab[i+1]= score;
3773
                        run_tab[i+1]= run;
3774
                        level_tab[i+1]= level-64;
3775
                    }
3776
                }
3777

    
3778
                if(s->out_format == FMT_H263){
3779
                    for(run=0; run<=i - left_limit; run++){
3780
                        int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3781
                        score += score_tab[i-run];
3782
                        if(score < last_score){
3783
                            last_score= score;
3784
                            last_run= run;
3785
                            last_level= level-64;
3786
                            last_i= i+1;
3787
                        }
3788
                    }
3789
                }
3790
            }else{
3791
                distoration += esc_length*lambda;
3792
                for(run=0; run<=i - left_limit; run++){
3793
                    int score= distoration + score_tab[i-run];
3794
                    
3795
                    if(score < best_score){
3796
                        best_score= 
3797
                        score_tab[i+1]= score;
3798
                        run_tab[i+1]= run;
3799
                        level_tab[i+1]= level-64;
3800
                    }
3801
                }
3802

    
3803
                if(s->out_format == FMT_H263){
3804
                    for(run=0; run<=i - left_limit; run++){
3805
                        int score= distoration + score_tab[i-run];
3806
                        if(score < last_score){
3807
                            last_score= score;
3808
                            last_run= run;
3809
                            last_level= level-64;
3810
                            last_i= i+1;
3811
                        }
3812
                    }
3813
                }
3814
            }
3815
        }
3816

    
3817
        for(j=left_limit; j<=i; j++){
3818
            score_tab[j] += zero_distoration;
3819
        }
3820
        score_limit+= zero_distoration;
3821
        if(score_tab[i+1] < score_limit)
3822
            score_limit= score_tab[i+1];
3823
        
3824
        //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3825
        while(score_tab[ left_limit ] > score_limit + lambda) left_limit++;
3826
    }
3827

    
3828
        //FIXME add some cbp penalty
3829

    
3830
    if(s->out_format != FMT_H263){
3831
        last_score= 256*256*256*120;
3832
        for(i= left_limit; i<=last_non_zero - start_i + 1; i++){
3833
            int score= score_tab[i];
3834
            if(i) score += lambda*2; //FIXME exacter?
3835

    
3836
            if(score < last_score){
3837
                last_score= score;
3838
                last_i= i;
3839
                last_level= level_tab[i];
3840
                last_run= run_tab[i];
3841
            }
3842
        }
3843
    }
3844
    
3845
    last_non_zero= last_i - 1 + start_i;
3846
    memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3847
    
3848
    if(last_non_zero < start_i)
3849
        return last_non_zero;
3850
    
3851
    i= last_i;
3852
    assert(last_level);
3853
//FIXME use permutated scantable
3854
    block[ s->dsp.idct_permutation[ scantable[last_non_zero] ] ]= last_level;
3855
    i -= last_run + 1;
3856
    
3857
    for(;i>0 ; i -= run_tab[i] + 1){
3858
        const int j= s->dsp.idct_permutation[ scantable[i - 1 + start_i] ];
3859
    
3860
        block[j]= level_tab[i];
3861
        assert(block[j]);
3862
    }
3863

    
3864
    return last_non_zero;
3865
}
3866

    
3867
static int dct_quantize_c(MpegEncContext *s, 
3868
                        DCTELEM *block, int n,
3869
                        int qscale, int *overflow)
3870
{
3871
    int i, j, level, last_non_zero, q;
3872
    const int *qmat;
3873
    const uint8_t *scantable= s->intra_scantable.scantable;
3874
    int bias;
3875
    int max=0;
3876
    unsigned int threshold1, threshold2;
3877

    
3878
    s->dsp.fdct (block);
3879

    
3880
    if (s->mb_intra) {
3881
        if (!s->h263_aic) {
3882
            if (n < 4)
3883
                q = s->y_dc_scale;
3884
            else
3885
                q = s->c_dc_scale;
3886
            q = q << 3;
3887
        } else
3888
            /* For AIC we skip quant/dequant of INTRADC */
3889
            q = 1 << 3;
3890
            
3891
        /* note: block[0] is assumed to be positive */
3892
        block[0] = (block[0] + (q >> 1)) / q;
3893
        i = 1;
3894
        last_non_zero = 0;
3895
        qmat = s->q_intra_matrix[qscale];
3896
        bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
3897
    } else {
3898
        i = 0;
3899
        last_non_zero = -1;
3900
        qmat = s->q_inter_matrix[qscale];
3901
        bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
3902
    }
3903
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
3904
    threshold2= (threshold1<<1);
3905

    
3906
    for(;i<64;i++) {
3907
        j = scantable[i];
3908
        level = block[j];
3909
        level = level * qmat[j];
3910

    
3911
//        if(   bias+level >= (1<<QMAT_SHIFT)
3912
//           || bias-level >= (1<<QMAT_SHIFT)){
3913
        if(((unsigned)(level+threshold1))>threshold2){
3914
            if(level>0){
3915
                level= (bias + level)>>QMAT_SHIFT;
3916
                block[j]= level;
3917
            }else{
3918
                level= (bias - level)>>QMAT_SHIFT;
3919
                block[j]= -level;
3920
            }
3921
            max |=level;
3922
            last_non_zero = i;
3923
        }else{
3924
            block[j]=0;
3925
        }
3926
    }
3927
    *overflow= s->max_qcoeff < max; //overflow might have happend
3928
    
3929
    /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
3930
    if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
3931
        ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
3932

    
3933
    return last_non_zero;
3934
}
3935

    
3936
#endif //CONFIG_ENCODERS
3937

    
3938
static void dct_unquantize_mpeg1_c(MpegEncContext *s, 
3939
                                   DCTELEM *block, int n, int qscale)
3940
{
3941
    int i, level, nCoeffs;
3942
    const uint16_t *quant_matrix;
3943

    
3944
    nCoeffs= s->block_last_index[n];
3945
    
3946
    if (s->mb_intra) {
3947
        if (n < 4) 
3948
            block[0] = block[0] * s->y_dc_scale;
3949
        else
3950
            block[0] = block[0] * s->c_dc_scale;
3951
        /* XXX: only mpeg1 */
3952
        quant_matrix = s->intra_matrix;
3953
        for(i=1;i<=nCoeffs;i++) {
3954
            int j= s->intra_scantable.permutated[i];
3955
            level = block[j];
3956
            if (level) {
3957
                if (level < 0) {
3958
                    level = -level;
3959
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3960
                    level = (level - 1) | 1;
3961
                    level = -level;
3962
                } else {
3963
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3964
                    level = (level - 1) | 1;
3965
                }
3966
#ifdef PARANOID
3967
                if (level < -2048 || level > 2047)
3968
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3969
#endif
3970
                block[j] = level;
3971
            }
3972
        }
3973
    } else {
3974
        i = 0;
3975
        quant_matrix = s->inter_matrix;
3976
        for(;i<=nCoeffs;i++) {
3977
            int j= s->intra_scantable.permutated[i];
3978
            level = block[j];
3979
            if (level) {
3980
                if (level < 0) {
3981
                    level = -level;
3982
                    level = (((level << 1) + 1) * qscale *
3983
                             ((int) (quant_matrix[j]))) >> 4;
3984
                    level = (level - 1) | 1;
3985
                    level = -level;
3986
                } else {
3987
                    level = (((level << 1) + 1) * qscale *
3988
                             ((int) (quant_matrix[j]))) >> 4;
3989
                    level = (level - 1) | 1;
3990
                }
3991
#ifdef PARANOID
3992
                if (level < -2048 || level > 2047)
3993
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3994
#endif
3995
                block[j] = level;
3996
            }
3997
        }
3998
    }
3999
}
4000

    
4001
static void dct_unquantize_mpeg2_c(MpegEncContext *s, 
4002
                                   DCTELEM *block, int n, int qscale)
4003
{
4004
    int i, level, nCoeffs;
4005
    const uint16_t *quant_matrix;
4006

    
4007
    if(s->alternate_scan) nCoeffs= 63;
4008
    else nCoeffs= s->block_last_index[n];
4009
    
4010
    if (s->mb_intra) {
4011
        if (n < 4) 
4012
            block[0] = block[0] * s->y_dc_scale;
4013
        else
4014
            block[0] = block[0] * s->c_dc_scale;
4015
        quant_matrix = s->intra_matrix;
4016
        for(i=1;i<=nCoeffs;i++) {
4017
            int j= s->intra_scantable.permutated[i];
4018
            level = block[j];
4019
            if (level) {
4020
                if (level < 0) {
4021
                    level = -level;
4022
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
4023
                    level = -level;
4024
                } else {
4025
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
4026
                }
4027
#ifdef PARANOID
4028
                if (level < -2048 || level > 2047)
4029
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4030
#endif
4031
                block[j] = level;
4032
            }
4033
        }
4034
    } else {
4035
        int sum=-1;
4036
        i = 0;
4037
        quant_matrix = s->inter_matrix;
4038
        for(;i<=nCoeffs;i++) {
4039
            int j= s->intra_scantable.permutated[i];
4040
            level = block[j];
4041
            if (level) {
4042
                if (level < 0) {
4043
                    level = -level;
4044
                    level = (((level << 1) + 1) * qscale *
4045
                             ((int) (quant_matrix[j]))) >> 4;
4046
                    level = -level;
4047
                } else {
4048
                    level = (((level << 1) + 1) * qscale *
4049
                             ((int) (quant_matrix[j]))) >> 4;
4050
                }
4051
#ifdef PARANOID
4052
                if (level < -2048 || level > 2047)
4053
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4054
#endif
4055
                block[j] = level;
4056
                sum+=level;
4057
            }
4058
        }
4059
        block[63]^=sum&1;
4060
    }
4061
}
4062

    
4063

    
4064
static void dct_unquantize_h263_c(MpegEncContext *s, 
4065
                                  DCTELEM *block, int n, int qscale)
4066
{
4067
    int i, level, qmul, qadd;
4068
    int nCoeffs;
4069
    
4070
    assert(s->block_last_index[n]>=0);
4071
    
4072
    qadd = (qscale - 1) | 1;
4073
    qmul = qscale << 1;
4074
    
4075
    if (s->mb_intra) {
4076
        if (!s->h263_aic) {
4077
            if (n < 4) 
4078
                block[0] = block[0] * s->y_dc_scale;
4079
            else
4080
                block[0] = block[0] * s->c_dc_scale;
4081
        }else
4082
            qadd = 0;
4083
        i = 1;
4084
        nCoeffs= 63; //does not allways use zigzag table 
4085
    } else {
4086
        i = 0;
4087
        nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
4088
    }
4089

    
4090
    for(;i<=nCoeffs;i++) {
4091
        level = block[i];
4092
        if (level) {
4093
            if (level < 0) {
4094
                level = level * qmul - qadd;
4095
            } else {
4096
                level = level * qmul + qadd;
4097
            }
4098
#ifdef PARANOID
4099
                if (level < -2048 || level > 2047)
4100
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4101
#endif
4102
            block[i] = level;
4103
        }
4104
    }
4105
}
4106

    
4107

    
4108
char ff_get_pict_type_char(int pict_type){
4109
    switch(pict_type){
4110
    case I_TYPE: return 'I'; 
4111
    case P_TYPE: return 'P'; 
4112
    case B_TYPE: return 'B'; 
4113
    case S_TYPE: return 'S'; 
4114
    case SI_TYPE:return 'i'; 
4115
    case SP_TYPE:return 'p'; 
4116
    default:     return '?';
4117
    }
4118
}
4119

    
4120
static const AVOption mpeg4_options[] =
4121
{
4122
    AVOPTION_CODEC_INT("bitrate", "desired video bitrate", bit_rate, 4, 240000000, 800000),
4123
    AVOPTION_CODEC_FLAG("vhq", "very high quality", flags, CODEC_FLAG_HQ, 0),
4124
    AVOPTION_CODEC_INT("ratetol", "number of bits the bitstream is allowed to diverge from the reference"
4125
                       "the reference can be CBR (for CBR pass1) or VBR (for pass2)",
4126
                       bit_rate_tolerance, 4, 240000000, 8000),
4127
    AVOPTION_CODEC_INT("qmin", "minimum quantizer", qmin, 1, 31, 2),
4128
    AVOPTION_CODEC_INT("qmax", "maximum quantizer", qmax, 1, 31, 31),
4129
    AVOPTION_CODEC_STRING("rc_eq", "rate control equation",
4130
                          rc_eq, "tex^qComp,option1,options2", 0),
4131
    AVOPTION_CODEC_INT("rc_minrate", "rate control minimum bitrate",
4132
                       rc_min_rate, 4, 24000000, 0),
4133
    AVOPTION_CODEC_INT("rc_maxrate", "rate control maximum bitrate",
4134
                       rc_max_rate, 4, 24000000, 0),
4135
    AVOPTION_CODEC_DOUBLE("rc_buf_aggresivity", "rate control buffer aggresivity",
4136
                          rc_buffer_aggressivity, 4, 24000000, 0),
4137
    AVOPTION_CODEC_DOUBLE("rc_initial_cplx", "initial complexity for pass1 ratecontrol",
4138
                          rc_initial_cplx, 0., 9999999., 0),
4139
    AVOPTION_CODEC_DOUBLE("i_quant_factor", "qscale factor between p and i frames",
4140
                          i_quant_factor, 0., 0., 0),
4141
    AVOPTION_CODEC_DOUBLE("i_quant_offset", "qscale offset between p and i frames",
4142
                          i_quant_factor, -999999., 999999., 0),
4143
    AVOPTION_CODEC_INT("dct_algo", "dct alghorithm",
4144
                       dct_algo, 0, 5, 0), // fixme - "Auto,FastInt,Int,MMX,MLib,Altivec"
4145
    AVOPTION_CODEC_DOUBLE("lumi_masking", "luminance masking",
4146
                          lumi_masking, 0., 999999., 0),
4147
    AVOPTION_CODEC_DOUBLE("temporal_cplx_masking", "temporary complexity masking",
4148
                          temporal_cplx_masking, 0., 999999., 0),
4149
    AVOPTION_CODEC_DOUBLE("spatial_cplx_masking", "spatial complexity masking",
4150
                          spatial_cplx_masking, 0., 999999., 0),
4151
    AVOPTION_CODEC_DOUBLE("p_masking", "p block masking",
4152
                          p_masking, 0., 999999., 0),
4153
    AVOPTION_CODEC_DOUBLE("dark_masking", "darkness masking",
4154
                          dark_masking, 0., 999999., 0),
4155
    AVOPTION_CODEC_INT("idct_algo", "idct alghorithm",
4156
                       idct_algo, 0, 8, 0), // fixme - "Auto,Int,Simple,SimpleMMX,LibMPEG2MMX,PS2,MLib,ARM,Altivec"
4157

    
4158
    AVOPTION_CODEC_INT("mb_qmin", "minimum MB quantizer",
4159
                       mb_qmin, 0, 8, 0),
4160
    AVOPTION_CODEC_INT("mb_qmax", "maximum MB quantizer",
4161
                       mb_qmin, 0, 8, 0),
4162

    
4163
    AVOPTION_CODEC_INT("me_cmp", "ME compare function",
4164
                       me_cmp, 0, 24000000, 0),
4165
    AVOPTION_CODEC_INT("me_sub_cmp", "subpixel ME compare function",
4166
                       me_sub_cmp, 0, 24000000, 0),
4167

    
4168

    
4169
    AVOPTION_CODEC_INT("dia_size", "ME diamond size & shape",
4170
                       dia_size, 0, 24000000, 0),
4171
    AVOPTION_CODEC_INT("last_predictor_count", "amount of previous MV predictors",
4172
                       last_predictor_count, 0, 24000000, 0),
4173

    
4174
    AVOPTION_CODEC_INT("pre_me", "pre pass for ME",
4175
                       pre_me, 0, 24000000, 0),
4176
    AVOPTION_CODEC_INT("me_pre_cmp", "ME pre pass compare function",
4177
                       me_pre_cmp, 0, 24000000, 0),
4178

    
4179
    AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4180
                       me_range, 0, 24000000, 0),
4181
    AVOPTION_CODEC_INT("pre_dia_size", "ME pre pass diamod size & shape",
4182
                       pre_dia_size, 0, 24000000, 0),
4183
    AVOPTION_CODEC_INT("me_subpel_quality", "subpel ME quality",
4184
                       me_subpel_quality, 0, 24000000, 0),
4185
    AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4186
                       me_range, 0, 24000000, 0),
4187
    AVOPTION_CODEC_FLAG("psnr", "calculate PSNR of compressed frames",
4188
                        flags, CODEC_FLAG_PSNR, 0),
4189
    AVOPTION_CODEC_RCOVERRIDE("rc_override", "ratecontrol override (=startframe,endframe,qscale,quality_factor)",
4190
                              rc_override),
4191
    AVOPTION_SUB(avoptions_common),
4192
    AVOPTION_END()
4193
};
4194

    
4195
#ifdef CONFIG_ENCODERS
4196

    
4197
AVCodec mpeg1video_encoder = {
4198
    "mpeg1video",
4199
    CODEC_TYPE_VIDEO,
4200
    CODEC_ID_MPEG1VIDEO,
4201
    sizeof(MpegEncContext),
4202
    MPV_encode_init,
4203
    MPV_encode_picture,
4204
    MPV_encode_end,
4205
};
4206

    
4207
#ifdef CONFIG_RISKY
4208

    
4209
AVCodec h263_encoder = {
4210
    "h263",
4211
    CODEC_TYPE_VIDEO,
4212
    CODEC_ID_H263,
4213
    sizeof(MpegEncContext),
4214
    MPV_encode_init,
4215
    MPV_encode_picture,
4216
    MPV_encode_end,
4217
};
4218

    
4219
AVCodec h263p_encoder = {
4220
    "h263p",
4221
    CODEC_TYPE_VIDEO,
4222
    CODEC_ID_H263P,
4223
    sizeof(MpegEncContext),
4224
    MPV_encode_init,
4225
    MPV_encode_picture,
4226
    MPV_encode_end,
4227
};
4228

    
4229
AVCodec rv10_encoder = {
4230
    "rv10",
4231
    CODEC_TYPE_VIDEO,
4232
    CODEC_ID_RV10,
4233
    sizeof(MpegEncContext),
4234
    MPV_encode_init,
4235
    MPV_encode_picture,
4236
    MPV_encode_end,
4237
};
4238

    
4239
AVCodec mpeg4_encoder = {
4240
    "mpeg4",
4241
    CODEC_TYPE_VIDEO,
4242
    CODEC_ID_MPEG4,
4243
    sizeof(MpegEncContext),
4244
    MPV_encode_init,
4245
    MPV_encode_picture,
4246
    MPV_encode_end,
4247
    .options = mpeg4_options,
4248
};
4249

    
4250
AVCodec msmpeg4v1_encoder = {
4251
    "msmpeg4v1",
4252
    CODEC_TYPE_VIDEO,
4253
    CODEC_ID_MSMPEG4V1,
4254
    sizeof(MpegEncContext),
4255
    MPV_encode_init,
4256
    MPV_encode_picture,
4257
    MPV_encode_end,
4258
    .options = mpeg4_options,
4259
};
4260

    
4261
AVCodec msmpeg4v2_encoder = {
4262
    "msmpeg4v2",
4263
    CODEC_TYPE_VIDEO,
4264
    CODEC_ID_MSMPEG4V2,
4265
    sizeof(MpegEncContext),
4266
    MPV_encode_init,
4267
    MPV_encode_picture,
4268
    MPV_encode_end,
4269
    .options = mpeg4_options,
4270
};
4271

    
4272
AVCodec msmpeg4v3_encoder = {
4273
    "msmpeg4",
4274
    CODEC_TYPE_VIDEO,
4275
    CODEC_ID_MSMPEG4V3,
4276
    sizeof(MpegEncContext),
4277
    MPV_encode_init,
4278
    MPV_encode_picture,
4279
    MPV_encode_end,
4280
    .options = mpeg4_options,
4281
};
4282

    
4283
AVCodec wmv1_encoder = {
4284
    "wmv1",
4285
    CODEC_TYPE_VIDEO,
4286
    CODEC_ID_WMV1,
4287
    sizeof(MpegEncContext),
4288
    MPV_encode_init,
4289
    MPV_encode_picture,
4290
    MPV_encode_end,
4291
    .options = mpeg4_options,
4292
};
4293

    
4294
#endif
4295

    
4296
AVCodec mjpeg_encoder = {
4297
    "mjpeg",
4298
    CODEC_TYPE_VIDEO,
4299
    CODEC_ID_MJPEG,
4300
    sizeof(MpegEncContext),
4301
    MPV_encode_init,
4302
    MPV_encode_picture,
4303
    MPV_encode_end,
4304
};
4305

    
4306
#endif //CONFIG_ENCODERS
4307