Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 9acbbd16

History | View | Annotate | Download (148 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_INTERNAL){
310
        for(i=0; i<4; i++){
311
            av_freep(&pic->base[i]);
312
            pic->data[i]= NULL;
313
        }
314
        av_freep(&pic->opaque);
315
        pic->type= 0;
316
    }else if(pic->type == FF_BUFFER_TYPE_SHARED){
317
        for(i=0; i<4; i++){
318
            pic->base[i]=
319
            pic->data[i]= NULL;
320
        }
321
        pic->type= 0;        
322
    }
323
}
324

    
325
/* init common structure for both encoder and decoder */
326
int MPV_common_init(MpegEncContext *s)
327
{
328
    int y_size, c_size, yc_size, i, mb_array_size, x, y;
329

    
330
    dsputil_init(&s->dsp, s->avctx);
331
    DCT_common_init(s);
332

    
333
    s->flags= s->avctx->flags;
334

    
335
    s->mb_width  = (s->width  + 15) / 16;
336
    s->mb_height = (s->height + 15) / 16;
337
    s->mb_stride = s->mb_width + 1;
338
    mb_array_size= s->mb_height * s->mb_stride;
339

    
340
    /* set default edge pos, will be overriden in decode_header if needed */
341
    s->h_edge_pos= s->mb_width*16;
342
    s->v_edge_pos= s->mb_height*16;
343

    
344
    s->mb_num = s->mb_width * s->mb_height;
345
    
346
    s->block_wrap[0]=
347
    s->block_wrap[1]=
348
    s->block_wrap[2]=
349
    s->block_wrap[3]= s->mb_width*2 + 2;
350
    s->block_wrap[4]=
351
    s->block_wrap[5]= s->mb_width + 2;
352

    
353
    y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
354
    c_size = (s->mb_width + 2) * (s->mb_height + 2);
355
    yc_size = y_size + 2 * c_size;
356

    
357
    /* convert fourcc to upper case */
358
    s->avctx->codec_tag=   toupper( s->avctx->codec_tag     &0xFF)          
359
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
360
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16) 
361
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
362

    
363
    CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
364
    s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
365

    
366
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
367

    
368
    CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
369
    for(y=0; y<s->mb_height; y++){
370
        for(x=0; x<s->mb_width; x++){
371
            s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
372
        }
373
    }
374
    s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
375
    
376
    if (s->encoding) {
377
        int mv_table_size= s->mb_stride * (s->mb_height+2) + 1;
378

    
379
        /* Allocate MV tables */
380
        CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
381
        CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
382
        CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
383
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
384
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
385
        CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
386
        s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
387
        s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
388
        s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
389
        s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
390
        s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
391
        s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
392

    
393
        //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
394
        CHECKED_ALLOCZ(s->me.scratchpad,  s->width*2*16*3*sizeof(uint8_t)) 
395
        
396
        CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
397
        CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
398

    
399
        if(s->codec_id==CODEC_ID_MPEG4){
400
            CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
401
            CHECKED_ALLOCZ(   s->pb2_buffer, PB_BUFFER_SIZE);
402
        }
403
        
404
        if(s->msmpeg4_version){
405
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
406
        }
407
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
408

    
409
        /* Allocate MB type table */
410
        CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint8_t)) //needed for encoding
411
    }
412
        
413
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
414
    
415
    if (s->out_format == FMT_H263 || s->encoding) {
416
        int size;
417

    
418
        /* MV prediction */
419
        size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
420
        CHECKED_ALLOCZ(s->motion_val, size * 2 * sizeof(int16_t));
421
    }
422

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

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

    
455
    /* which mb is a intra block */
456
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
457
    memset(s->mbintra_table, 1, mb_array_size);
458
    
459
    /* default structure is frame */
460
    s->picture_structure = PICT_FRAME;
461
    
462
    /* init macroblock skip table */
463
    CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
464
    //Note the +1 is for a quicker mpeg4 slice_end detection
465
    CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
466
    
467
    s->block= s->blocks[0];
468

    
469
    s->parse_context.state= -1;
470

    
471
    s->context_initialized = 1;
472
    return 0;
473
 fail:
474
    MPV_common_end(s);
475
    return -1;
476
}
477

    
478

    
479
//extern int sads;
480

    
481
/* init common structure for both encoder and decoder */
482
void MPV_common_end(MpegEncContext *s)
483
{
484
    int i;
485

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

    
524
    for(i=0; i<MAX_PICTURE_COUNT; i++){
525
        free_picture(s, &s->picture[i]);
526
    }
527
    s->context_initialized = 0;
528
}
529

    
530
#ifdef CONFIG_ENCODERS
531

    
532
/* init video encoder */
533
int MPV_encode_init(AVCodecContext *avctx)
534
{
535
    MpegEncContext *s = avctx->priv_data;
536
    int i;
537

    
538
    avctx->pix_fmt = PIX_FMT_YUV420P;
539

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

    
568
    if (s->gop_size <= 1) {
569
        s->intra_only = 1;
570
        s->gop_size = 12;
571
    } else {
572
        s->intra_only = 0;
573
    }
574

    
575
    s->me_method = avctx->me_method;
576

    
577
    /* Fixed QSCALE */
578
    s->fixed_qscale = (avctx->flags & CODEC_FLAG_QSCALE);
579
    
580
    s->adaptive_quant= (   s->avctx->lumi_masking
581
                        || s->avctx->dark_masking
582
                        || s->avctx->temporal_cplx_masking 
583
                        || s->avctx->spatial_cplx_masking
584
                        || s->avctx->p_masking)
585
                       && !s->fixed_qscale;
586
    
587
    s->progressive_sequence= !(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
588

    
589
    if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4){
590
        fprintf(stderr, "4MV not supporetd by codec\n");
591
        return -1;
592
    }
593
    
594
    if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
595
        fprintf(stderr, "qpel not supporetd by codec\n");
596
        return -1;
597
    }
598

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

    
746
            default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
747
            memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
748
            memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
749

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

    
764
    s->encoding = 1;
765

    
766
    /* init */
767
    if (MPV_common_init(s) < 0)
768
        return -1;
769
    
770
    ff_init_me(s);
771

    
772
#ifdef CONFIG_ENCODERS
773
#ifdef CONFIG_RISKY
774
    if (s->out_format == FMT_H263)
775
        h263_encode_init(s);
776
    if(s->msmpeg4_version)
777
        ff_msmpeg4_encode_init(s);
778
#endif
779
    if (s->out_format == FMT_MPEG1)
780
        ff_mpeg1_encode_init(s);
781
#endif
782

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

    
801
    /* precompute matrix */
802
    /* for mjpeg, we do include qscale in the matrix */
803
    if (s->out_format != FMT_MJPEG) {
804
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, s->q_intra_matrix16_bias, 
805
                       s->intra_matrix, s->intra_quant_bias, 1, 31);
806
        convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16, s->q_inter_matrix16_bias, 
807
                       s->inter_matrix, s->inter_quant_bias, 1, 31);
808
    }
809

    
810
    if(ff_rate_control_init(s) < 0)
811
        return -1;
812

    
813
    s->picture_number = 0;
814
    s->picture_in_gop_number = 0;
815
    s->fake_picture_number = 0;
816
    /* motion detector init */
817
    s->f_code = 1;
818
    s->b_code = 1;
819

    
820
    return 0;
821
}
822

    
823
int MPV_encode_end(AVCodecContext *avctx)
824
{
825
    MpegEncContext *s = avctx->priv_data;
826

    
827
#ifdef STATS
828
    print_stats();
829
#endif
830

    
831
    ff_rate_control_uninit(s);
832

    
833
    MPV_common_end(s);
834
    if (s->out_format == FMT_MJPEG)
835
        mjpeg_close(s);
836
      
837
    return 0;
838
}
839

    
840
#endif //CONFIG_ENCODERS
841

    
842
void init_rl(RLTable *rl)
843
{
844
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
845
    uint8_t index_run[MAX_RUN+1];
846
    int last, run, level, start, end, i;
847

    
848
    /* compute max_level[], max_run[] and index_run[] */
849
    for(last=0;last<2;last++) {
850
        if (last == 0) {
851
            start = 0;
852
            end = rl->last;
853
        } else {
854
            start = rl->last;
855
            end = rl->n;
856
        }
857

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

    
880
/* draw the edges of width 'w' of an image of size width, height */
881
//FIXME check that this is ok for mpeg4 interlaced
882
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
883
{
884
    uint8_t *ptr, *last_line;
885
    int i;
886

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

    
909
static int find_unused_picture(MpegEncContext *s, int shared){
910
    int i;
911
    
912
    if(shared){
913
        for(i=0; i<MAX_PICTURE_COUNT; i++){
914
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) break;
915
        }
916
    }else{
917
        for(i=0; i<MAX_PICTURE_COUNT; i++){
918
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) break; //FIXME
919
        }
920
        for(i=0; i<MAX_PICTURE_COUNT; i++){
921
            if(s->picture[i].data[0]==NULL) break;
922
        }
923
    }
924

    
925
    assert(i<MAX_PICTURE_COUNT);
926
    return i;
927
}
928

    
929
/* generic function for encode/decode called before a frame is coded/decoded */
930
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
931
{
932
    int i;
933
    AVFrame *pic;
934

    
935
    s->mb_skiped = 0;
936

    
937
    assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264);
938
        
939
    /* mark&release old frames */
940
    if (s->pict_type != B_TYPE && s->last_picture_ptr) {
941
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
942

    
943
        /* release forgotten pictures */
944
        /* if(mpeg124/h263) */
945
        if(!s->encoding){
946
            for(i=0; i<MAX_PICTURE_COUNT; i++){
947
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
948
                    fprintf(stderr, "releasing zombie picture\n");
949
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
950
                }
951
            }
952
        }
953
    }
954
    
955
alloc:
956
    if(!s->encoding){
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
    if(s->last_picture_ptr) s->last_picture= *s->last_picture_ptr;
982
    if(s->next_picture_ptr) s->next_picture= *s->next_picture_ptr;
983
    if(s->new_picture_ptr ) s->new_picture = *s->new_picture_ptr;
984
    
985
    if(s->picture_structure!=PICT_FRAME){
986
        int i;
987
        for(i=0; i<4; i++){
988
            if(s->picture_structure == PICT_BOTTOM_FIELD){
989
                 s->current_picture.data[i] += s->current_picture.linesize[i];
990
            } 
991
            s->current_picture.linesize[i] *= 2;
992
            s->last_picture.linesize[i] *=2;
993
            s->next_picture.linesize[i] *=2;
994
        }
995
    }
996
    
997
    if(s->pict_type != I_TYPE && s->last_picture_ptr==NULL){
998
        fprintf(stderr, "warning: first frame is no keyframe\n");
999
        assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1000
        goto alloc;
1001
    }
1002
  }
1003
   
1004
    s->hurry_up= s->avctx->hurry_up;
1005
    s->error_resilience= avctx->error_resilience;
1006

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

    
1017
    return 0;
1018
}
1019

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

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

    
1063
/**
1064
 * prints debuging info for the given picture.
1065
 */
1066
void ff_print_debug_info(MpegEncContext *s, Picture *pict){
1067

    
1068
    if(!pict || !pict->mb_type) return;
1069

    
1070
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1071
        int x,y;
1072

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

    
1139
#ifdef CONFIG_ENCODERS
1140

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

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

    
1174

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

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

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

    
1202
        pic= (AVFrame*)&s->picture[i];
1203
        pic->reference= 3;
1204

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

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

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

    
1257
    return 0;
1258
}
1259

    
1260
static void select_input_picture(MpegEncContext *s){
1261
    int i;
1262
    const int encoding_delay= s->max_b_frames;
1263
    int coded_pic_num=0;    
1264

    
1265
    if(s->reordered_input_picture[0])
1266
        coded_pic_num= s->reordered_input_picture[0]->coded_picture_number + 1;
1267

    
1268
    for(i=1; i<MAX_PICTURE_COUNT; i++)
1269
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1270
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1271

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

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

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

    
1350
        s->new_picture= *s->reordered_input_picture[0];
1351

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

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

    
1371
            s->current_picture_ptr= pic;
1372
        }else{
1373
            // input is not a shared pix -> reuse buffer for current_pix
1374

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

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

    
1400
    init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
1401

    
1402
    s->picture_in_gop_number++;
1403

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

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

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

    
1432
        MPV_frame_end(s);
1433

    
1434
        if (s->out_format == FMT_MJPEG)
1435
            mjpeg_picture_trailer(s);
1436
        
1437
        if(s->flags&CODEC_FLAG_PASS1)
1438
            ff_write_pass1_stats(s);
1439

    
1440
        for(i=0; i<4; i++){
1441
            avctx->error[i] += s->current_picture_ptr->error[i];
1442
        }
1443
    }
1444

    
1445
    s->input_picture_number++;
1446

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

    
1456
#endif //CONFIG_ENCODERS
1457

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

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

    
1481
    linesize = s->linesize;
1482
    uvlinesize = s->uvlinesize;
1483
    
1484
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1485

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

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

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

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

    
1556
    linesize = s->linesize;
1557
    uvlinesize = s->uvlinesize;
1558

    
1559
    ptr = ref_picture[0] + src_offset;
1560

    
1561
    dest_y+=dest_offset;
1562
    
1563
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
1564
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
1565

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

    
1581
    if(s->flags&CODEC_FLAG_GRAY) return;
1582

    
1583

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

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

    
1609

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

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

    
1631
    start_y= FFMAX(0, -src_y);
1632
    start_x= FFMAX(0, -src_x);
1633
    end_y= FFMIN(block_h, h-src_y);
1634
    end_x= FFMIN(block_w, w-src_x);
1635

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

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

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

    
1670

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

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

    
1718
    if(s->flags&CODEC_FLAG_GRAY) return;
1719

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

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

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

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

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

    
1810
    if(s->flags&CODEC_FLAG_GRAY) return;
1811

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

    
1829
    dxy= (mx&1) | ((my&1)<<1);
1830
    mx>>=1;
1831
    my>>=1;
1832

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

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

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

    
1869
static inline void MPV_motion(MpegEncContext *s, 
1870
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1871
                              int dir, uint8_t **ref_picture, 
1872
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
1873
{
1874
    int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
1875
    int mb_x, mb_y, i;
1876
    uint8_t *ptr, *dest;
1877
    int emu=0;
1878

    
1879
    mb_x = s->mb_x;
1880
    mb_y = s->mb_y;
1881

    
1882
    switch(s->mv_type) {
1883
    case MV_TYPE_16X16:
1884
#ifdef CONFIG_RISKY
1885
        if(s->mcsel){
1886
            if(s->real_sprite_warping_points==1){
1887
                gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
1888
                            ref_picture, 0);
1889
            }else{
1890
                gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
1891
                            ref_picture, 0);
1892
            }
1893
        }else if(s->quarter_sample){
1894
            qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1895
                        ref_picture, 0,
1896
                        0, pix_op, qpix_op,
1897
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1898
        }else if(s->mspel){
1899
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
1900
                        ref_picture, pix_op,
1901
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1902
        }else
1903
#endif
1904
        {
1905
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1906
                        ref_picture, 0,
1907
                        0, pix_op,
1908
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1909
        }           
1910
        break;
1911
    case MV_TYPE_8X8:
1912
        mx = 0;
1913
        my = 0;
1914
        if(s->quarter_sample){
1915
            for(i=0;i<4;i++) {
1916
                motion_x = s->mv[dir][i][0];
1917
                motion_y = s->mv[dir][i][1];
1918

    
1919
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1920
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
1921
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
1922
                    
1923
                /* WARNING: do no forget half pels */
1924
                src_x = clip(src_x, -16, s->width);
1925
                if (src_x == s->width)
1926
                    dxy &= ~3;
1927
                src_y = clip(src_y, -16, s->height);
1928
                if (src_y == s->height)
1929
                    dxy &= ~12;
1930
                    
1931
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1932
                if(s->flags&CODEC_FLAG_EMU_EDGE){
1933
                    if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 8 > s->h_edge_pos
1934
                                          || src_y + (motion_y&3) + 8 > s->v_edge_pos){
1935
                        ff_emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1936
                        ptr= s->edge_emu_buffer;
1937
                    }
1938
                }
1939
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1940
                qpix_op[1][dxy](dest, ptr, s->linesize);
1941

    
1942
                mx += s->mv[dir][i][0]/2;
1943
                my += s->mv[dir][i][1]/2;
1944
            }
1945
        }else{
1946
            for(i=0;i<4;i++) {
1947
                motion_x = s->mv[dir][i][0];
1948
                motion_y = s->mv[dir][i][1];
1949

    
1950
                dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1951
                src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;
1952
                src_y = mb_y * 16 + (motion_y >> 1) + (i >>1) * 8;
1953
                    
1954
                /* WARNING: do no forget half pels */
1955
                src_x = clip(src_x, -16, s->width);
1956
                if (src_x == s->width)
1957
                    dxy &= ~1;
1958
                src_y = clip(src_y, -16, s->height);
1959
                if (src_y == s->height)
1960
                    dxy &= ~2;
1961
                    
1962
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1963
                if(s->flags&CODEC_FLAG_EMU_EDGE){
1964
                    if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 8 > s->h_edge_pos
1965
                                          || src_y + (motion_y&1) + 8 > s->v_edge_pos){
1966
                        ff_emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1967
                        ptr= s->edge_emu_buffer;
1968
                    }
1969
                }
1970
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1971
                pix_op[1][dxy](dest, ptr, s->linesize, 8);
1972

    
1973
                mx += s->mv[dir][i][0];
1974
                my += s->mv[dir][i][1];
1975
            }
1976
        }
1977

    
1978
        if(s->flags&CODEC_FLAG_GRAY) break;
1979
        /* In case of 8X8, we construct a single chroma motion vector
1980
           with a special rounding */
1981
        mx= ff_h263_round_chroma(mx);
1982
        my= ff_h263_round_chroma(my);
1983
        dxy = ((my & 1) << 1) | (mx & 1);
1984
        mx >>= 1;
1985
        my >>= 1;
1986

    
1987
        src_x = mb_x * 8 + mx;
1988
        src_y = mb_y * 8 + my;
1989
        src_x = clip(src_x, -8, s->width/2);
1990
        if (src_x == s->width/2)
1991
            dxy &= ~1;
1992
        src_y = clip(src_y, -8, s->height/2);
1993
        if (src_y == s->height/2)
1994
            dxy &= ~2;
1995
        
1996
        offset = (src_y * (s->uvlinesize)) + src_x;
1997
        ptr = ref_picture[1] + offset;
1998
        if(s->flags&CODEC_FLAG_EMU_EDGE){
1999
                if(src_x<0 || src_y<0 || src_x + (dxy &1) + 8 > s->h_edge_pos>>1
2000
                                      || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
2001
                    ff_emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2002
                    ptr= s->edge_emu_buffer;
2003
                    emu=1;
2004
                }
2005
            }
2006
        pix_op[1][dxy](dest_cb, ptr, s->uvlinesize, 8);
2007

    
2008
        ptr = ref_picture[2] + offset;
2009
        if(emu){
2010
            ff_emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2011
            ptr= s->edge_emu_buffer;
2012
        }
2013
        pix_op[1][dxy](dest_cr, ptr, s->uvlinesize, 8);
2014
        break;
2015
    case MV_TYPE_FIELD:
2016
        if (s->picture_structure == PICT_FRAME) {
2017
            if(s->quarter_sample){
2018
                /* top field */
2019
                qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2020
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2021
                            1, pix_op, qpix_op,
2022
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
2023
                /* bottom field */
2024
                qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2025
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2026
                            1, pix_op, qpix_op,
2027
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
2028
            }else{
2029
                /* top field */       
2030
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2031
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2032
                            1, pix_op,
2033
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
2034
                /* bottom field */
2035
                mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2036
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2037
                            1, pix_op,
2038
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
2039
            }
2040
        } else {
2041
            int offset;
2042
            if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2043
                offset= s->field_select[dir][0] ? s->linesize : 0;
2044
            }else{
2045
                ref_picture= s->current_picture.data;
2046
                offset= s->field_select[dir][0] ? s->linesize : -s->linesize; 
2047
            } 
2048

    
2049
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2050
                        ref_picture, offset,
2051
                        0, pix_op,
2052
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2053
        }
2054
        break;
2055
    }
2056
}
2057

    
2058

    
2059
/* put block[] to dest[] */
2060
static inline void put_dct(MpegEncContext *s, 
2061
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
2062
{
2063
    s->dct_unquantize(s, block, i, s->qscale);
2064
    s->dsp.idct_put (dest, line_size, block);
2065
}
2066

    
2067
/* add block[] to dest[] */
2068
static inline void add_dct(MpegEncContext *s, 
2069
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
2070
{
2071
    if (s->block_last_index[i] >= 0) {
2072
        s->dsp.idct_add (dest, line_size, block);
2073
    }
2074
}
2075

    
2076
static inline void add_dequant_dct(MpegEncContext *s, 
2077
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
2078
{
2079
    if (s->block_last_index[i] >= 0) {
2080
        s->dct_unquantize(s, block, i, s->qscale);
2081

    
2082
        s->dsp.idct_add (dest, line_size, block);
2083
    }
2084
}
2085

    
2086
/**
2087
 * cleans dc, ac, coded_block for the current non intra MB
2088
 */
2089
void ff_clean_intra_table_entries(MpegEncContext *s)
2090
{
2091
    int wrap = s->block_wrap[0];
2092
    int xy = s->block_index[0];
2093
    
2094
    s->dc_val[0][xy           ] = 
2095
    s->dc_val[0][xy + 1       ] = 
2096
    s->dc_val[0][xy     + wrap] =
2097
    s->dc_val[0][xy + 1 + wrap] = 1024;
2098
    /* ac pred */
2099
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2100
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2101
    if (s->msmpeg4_version>=3) {
2102
        s->coded_block[xy           ] =
2103
        s->coded_block[xy + 1       ] =
2104
        s->coded_block[xy     + wrap] =
2105
        s->coded_block[xy + 1 + wrap] = 0;
2106
    }
2107
    /* chroma */
2108
    wrap = s->block_wrap[4];
2109
    xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
2110
    s->dc_val[1][xy] =
2111
    s->dc_val[2][xy] = 1024;
2112
    /* ac pred */
2113
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2114
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2115
    
2116
    s->mbintra_table[s->mb_x + s->mb_y*s->mb_stride]= 0;
2117
}
2118

    
2119
/* generic function called after a macroblock has been parsed by the
2120
   decoder or after it has been encoded by the encoder.
2121

2122
   Important variables used:
2123
   s->mb_intra : true if intra macroblock
2124
   s->mv_dir   : motion vector direction
2125
   s->mv_type  : motion vector type
2126
   s->mv       : motion vector
2127
   s->interlaced_dct : true if interlaced dct used (mpeg2)
2128
 */
2129
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
2130
{
2131
    int mb_x, mb_y;
2132
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2133

    
2134
    mb_x = s->mb_x;
2135
    mb_y = s->mb_y;
2136

    
2137
    s->current_picture.qscale_table[mb_xy]= s->qscale;
2138

    
2139
    /* update DC predictors for P macroblocks */
2140
    if (!s->mb_intra) {
2141
        if (s->h263_pred || s->h263_aic) {
2142
            if(s->mbintra_table[mb_xy])
2143
                ff_clean_intra_table_entries(s);
2144
        } else {
2145
            s->last_dc[0] =
2146
            s->last_dc[1] =
2147
            s->last_dc[2] = 128 << s->intra_dc_precision;
2148
        }
2149
    }
2150
    else if (s->h263_pred || s->h263_aic)
2151
        s->mbintra_table[mb_xy]=1;
2152

    
2153
    /* update motion predictor, not for B-frames as they need the motion_val from the last P/S-Frame */
2154
    if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) { //FIXME move into h263.c if possible, format specific stuff shouldnt be here
2155
        //FIXME a lot of thet is only needed for !low_delay
2156
        const int wrap = s->block_wrap[0];
2157
        const int xy = s->block_index[0];
2158
        if(s->mv_type != MV_TYPE_8X8){
2159
            int motion_x, motion_y;
2160
            if (s->mb_intra) {
2161
                motion_x = 0;
2162
                motion_y = 0;
2163
            } else if (s->mv_type == MV_TYPE_16X16) {
2164
                motion_x = s->mv[0][0][0];
2165
                motion_y = s->mv[0][0][1];
2166
            } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
2167
                int i;
2168
                motion_x = s->mv[0][0][0] + s->mv[0][1][0];
2169
                motion_y = s->mv[0][0][1] + s->mv[0][1][1];
2170
                motion_x = (motion_x>>1) | (motion_x&1);
2171
                for(i=0; i<2; i++){
2172
                    s->field_mv_table[mb_xy][i][0]= s->mv[0][i][0];
2173
                    s->field_mv_table[mb_xy][i][1]= s->mv[0][i][1];
2174
                    s->field_select_table[mb_xy][i]= s->field_select[0][i];
2175
                }
2176
            }
2177
            
2178
            /* no update if 8X8 because it has been done during parsing */
2179
            s->motion_val[xy][0] = motion_x;
2180
            s->motion_val[xy][1] = motion_y;
2181
            s->motion_val[xy + 1][0] = motion_x;
2182
            s->motion_val[xy + 1][1] = motion_y;
2183
            s->motion_val[xy + wrap][0] = motion_x;
2184
            s->motion_val[xy + wrap][1] = motion_y;
2185
            s->motion_val[xy + 1 + wrap][0] = motion_x;
2186
            s->motion_val[xy + 1 + wrap][1] = motion_y;
2187
        }
2188

    
2189
        if(s->encoding){ //FIXME encoding MUST be cleaned up
2190
            if (s->mv_type == MV_TYPE_8X8) 
2191
                s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
2192
            else
2193
                s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
2194
        }
2195
    }
2196
    
2197
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
2198
        uint8_t *dest_y, *dest_cb, *dest_cr;
2199
        int dct_linesize, dct_offset;
2200
        op_pixels_func (*op_pix)[4];
2201
        qpel_mc_func (*op_qpix)[16];
2202
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
2203
        const int uvlinesize= s->current_picture.linesize[1];
2204

    
2205
        /* avoid copy if macroblock skipped in last frame too */
2206
        if (s->pict_type != B_TYPE) {
2207
            s->current_picture.mbskip_table[mb_xy]= s->mb_skiped;
2208
        }
2209

    
2210
        /* skip only during decoding as we might trash the buffers during encoding a bit */
2211
        if(!s->encoding){
2212
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2213
            const int age= s->current_picture.age;
2214

    
2215
            assert(age);
2216

    
2217
            if (s->mb_skiped) {
2218
                s->mb_skiped= 0;
2219
                assert(s->pict_type!=I_TYPE);
2220
 
2221
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
2222
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2223

    
2224
                /* if previous was skipped too, then nothing to do !  */
2225
                if (*mbskip_ptr >= age && s->current_picture.reference){
2226
                    return;
2227
                }
2228
            } else if(!s->current_picture.reference){
2229
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2230
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2231
            } else{
2232
                *mbskip_ptr = 0; /* not skipped */
2233
            }
2234
        }else
2235
            s->mb_skiped= 0;
2236

    
2237
        if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){ //FIXME precalc
2238
            dest_y  = s->current_picture.data[0] + mb_x * 16;
2239
            dest_cb = s->current_picture.data[1] + mb_x * 8;
2240
            dest_cr = s->current_picture.data[2] + mb_x * 8;
2241
        }else{
2242
            dest_y  = s->current_picture.data[0] + (mb_y * 16* linesize  ) + mb_x * 16;
2243
            dest_cb = s->current_picture.data[1] + (mb_y * 8 * uvlinesize) + mb_x * 8;
2244
            dest_cr = s->current_picture.data[2] + (mb_y * 8 * uvlinesize) + mb_x * 8;
2245
        }
2246

    
2247
        if (s->interlaced_dct) {
2248
            dct_linesize = linesize * 2;
2249
            dct_offset = linesize;
2250
        } else {
2251
            dct_linesize = linesize;
2252
            dct_offset = linesize * 8;
2253
        }
2254

    
2255
        if (!s->mb_intra) {
2256
            /* motion handling */
2257
            /* decoding or more than one mb_type (MC was allready done otherwise) */
2258
            if((!s->encoding) || (s->mb_type[mb_xy]&(s->mb_type[mb_xy]-1))){
2259
                if ((!s->no_rounding) || s->pict_type==B_TYPE){                
2260
                    op_pix = s->dsp.put_pixels_tab;
2261
                    op_qpix= s->dsp.put_qpel_pixels_tab;
2262
                }else{
2263
                    op_pix = s->dsp.put_no_rnd_pixels_tab;
2264
                    op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2265
                }
2266

    
2267
                if (s->mv_dir & MV_DIR_FORWARD) {
2268
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2269
                    op_pix = s->dsp.avg_pixels_tab;
2270
                    op_qpix= s->dsp.avg_qpel_pixels_tab;
2271
                }
2272
                if (s->mv_dir & MV_DIR_BACKWARD) {
2273
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2274
                }
2275
            }
2276

    
2277
            /* skip dequant / idct if we are really late ;) */
2278
            if(s->hurry_up>1) return;
2279

    
2280
            /* add dct residue */
2281
            if(s->encoding || !(   s->mpeg2 || s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO 
2282
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2283
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
2284
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2285
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2286
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2287

    
2288
                if(!(s->flags&CODEC_FLAG_GRAY)){
2289
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize);
2290
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize);
2291
                }
2292
            } else if(s->codec_id != CODEC_ID_WMV2){
2293
                add_dct(s, block[0], 0, dest_y, dct_linesize);
2294
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2295
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2296
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2297

    
2298
                if(!(s->flags&CODEC_FLAG_GRAY)){
2299
                    add_dct(s, block[4], 4, dest_cb, uvlinesize);
2300
                    add_dct(s, block[5], 5, dest_cr, uvlinesize);
2301
                }
2302
            } 
2303
#ifdef CONFIG_RISKY
2304
            else{
2305
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2306
            }
2307
#endif
2308
        } else {
2309
            /* dct only in intra block */
2310
            if(s->encoding || !(s->mpeg2 || s->codec_id==CODEC_ID_MPEG1VIDEO)){
2311
                put_dct(s, block[0], 0, dest_y, dct_linesize);
2312
                put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2313
                put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2314
                put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2315

    
2316
                if(!(s->flags&CODEC_FLAG_GRAY)){
2317
                    put_dct(s, block[4], 4, dest_cb, uvlinesize);
2318
                    put_dct(s, block[5], 5, dest_cr, uvlinesize);
2319
                }
2320
            }else{
2321
                s->dsp.idct_put(dest_y                 , dct_linesize, block[0]);
2322
                s->dsp.idct_put(dest_y              + 8, dct_linesize, block[1]);
2323
                s->dsp.idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
2324
                s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
2325

    
2326
                if(!(s->flags&CODEC_FLAG_GRAY)){
2327
                    s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2328
                    s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2329
                }
2330
            }
2331
        }
2332
    }
2333
}
2334

    
2335
#ifdef CONFIG_ENCODERS
2336

    
2337
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
2338
{
2339
    static const char tab[64]=
2340
        {3,2,2,1,1,1,1,1,
2341
         1,1,1,1,1,1,1,1,
2342
         1,1,1,1,1,1,1,1,
2343
         0,0,0,0,0,0,0,0,
2344
         0,0,0,0,0,0,0,0,
2345
         0,0,0,0,0,0,0,0,
2346
         0,0,0,0,0,0,0,0,
2347
         0,0,0,0,0,0,0,0};
2348
    int score=0;
2349
    int run=0;
2350
    int i;
2351
    DCTELEM *block= s->block[n];
2352
    const int last_index= s->block_last_index[n];
2353
    int skip_dc;
2354

    
2355
    if(threshold<0){
2356
        skip_dc=0;
2357
        threshold= -threshold;
2358
    }else
2359
        skip_dc=1;
2360

    
2361
    /* are all which we could set to zero are allready zero? */
2362
    if(last_index<=skip_dc - 1) return;
2363

    
2364
    for(i=0; i<=last_index; i++){
2365
        const int j = s->intra_scantable.permutated[i];
2366
        const int level = ABS(block[j]);
2367
        if(level==1){
2368
            if(skip_dc && i==0) continue;
2369
            score+= tab[run];
2370
            run=0;
2371
        }else if(level>1){
2372
            return;
2373
        }else{
2374
            run++;
2375
        }
2376
    }
2377
    if(score >= threshold) return;
2378
    for(i=skip_dc; i<=last_index; i++){
2379
        const int j = s->intra_scantable.permutated[i];
2380
        block[j]=0;
2381
    }
2382
    if(block[0]) s->block_last_index[n]= 0;
2383
    else         s->block_last_index[n]= -1;
2384
}
2385

    
2386
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
2387
{
2388
    int i;
2389
    const int maxlevel= s->max_qcoeff;
2390
    const int minlevel= s->min_qcoeff;
2391
    
2392
    if(s->mb_intra){
2393
        i=1; //skip clipping of intra dc
2394
    }else
2395
        i=0;
2396
    
2397
    for(;i<=last_index; i++){
2398
        const int j= s->intra_scantable.permutated[i];
2399
        int level = block[j];
2400
       
2401
        if     (level>maxlevel) level=maxlevel;
2402
        else if(level<minlevel) level=minlevel;
2403

    
2404
        block[j]= level;
2405
    }
2406
}
2407

    
2408
#if 0
2409
static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
2410
    int score=0;
2411
    int x,y;
2412
    
2413
    for(y=0; y<7; y++){
2414
        for(x=0; x<16; x+=4){
2415
            score+= ABS(s[x  ] - s[x  +stride]) + ABS(s[x+1] - s[x+1+stride]) 
2416
                   +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
2417
        }
2418
        s+= stride;
2419
    }
2420
    
2421
    return score;
2422
}
2423

2424
static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, 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++){
2430
            score+= ABS(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2431
        }
2432
        s1+= stride;
2433
        s2+= stride;
2434
    }
2435
    
2436
    return score;
2437
}
2438
#else
2439
#define SQ(a) ((a)*(a))
2440

    
2441
static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
2442
    int score=0;
2443
    int x,y;
2444
    
2445
    for(y=0; y<7; y++){
2446
        for(x=0; x<16; x+=4){
2447
            score+= SQ(s[x  ] - s[x  +stride]) + SQ(s[x+1] - s[x+1+stride]) 
2448
                   +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
2449
        }
2450
        s+= stride;
2451
    }
2452
    
2453
    return score;
2454
}
2455

    
2456
static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, 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++){
2462
            score+= SQ(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2463
        }
2464
        s1+= stride;
2465
        s2+= stride;
2466
    }
2467
    
2468
    return score;
2469
}
2470

    
2471
#endif
2472

    
2473
#endif //CONFIG_ENCODERS
2474

    
2475
/**
2476
 *
2477
 * @param h is the normal height, this will be reduced automatically if needed for the last row
2478
 */
2479
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2480
    if (    s->avctx->draw_horiz_band 
2481
        && (s->last_picture_ptr || s->low_delay) ) {
2482
        uint8_t *src_ptr[3];
2483
        int offset;
2484
        h= FFMIN(h, s->height - y);
2485

    
2486
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME)
2487
            offset = 0;
2488
        else
2489
            offset = y * s->linesize;
2490

    
2491
        if(s->pict_type==B_TYPE || s->low_delay){
2492
            src_ptr[0] = s->current_picture.data[0] + offset;
2493
            src_ptr[1] = s->current_picture.data[1] + (offset >> 2);
2494
            src_ptr[2] = s->current_picture.data[2] + (offset >> 2);
2495
        } else {
2496
            src_ptr[0] = s->last_picture.data[0] + offset;
2497
            src_ptr[1] = s->last_picture.data[1] + (offset >> 2);
2498
            src_ptr[2] = s->last_picture.data[2] + (offset >> 2);
2499
        }
2500
        emms_c();
2501

    
2502
        s->avctx->draw_horiz_band(s->avctx, src_ptr, s->linesize,
2503
                               y, s->width, h);
2504
    }
2505
}
2506

    
2507
#ifdef CONFIG_ENCODERS
2508

    
2509
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2510
{
2511
    const int mb_x= s->mb_x;
2512
    const int mb_y= s->mb_y;
2513
    int i;
2514
    int skip_dct[6];
2515
    int dct_offset   = s->linesize*8; //default for progressive frames
2516
    
2517
    for(i=0; i<6; i++) skip_dct[i]=0;
2518
    
2519
    if(s->adaptive_quant){
2520
        s->dquant= s->current_picture.qscale_table[mb_x + mb_y*s->mb_stride] - s->qscale;
2521

    
2522
        if(s->out_format==FMT_H263){
2523
            if     (s->dquant> 2) s->dquant= 2;
2524
            else if(s->dquant<-2) s->dquant=-2;
2525
        }
2526
            
2527
        if(s->codec_id==CODEC_ID_MPEG4){        
2528
            if(!s->mb_intra){
2529
                if(s->mv_dir&MV_DIRECT)
2530
                    s->dquant=0;
2531

    
2532
                assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
2533
            }
2534
        }
2535
        s->qscale+= s->dquant;
2536
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2537
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2538
    }
2539

    
2540
    if (s->mb_intra) {
2541
        uint8_t *ptr;
2542
        int wrap_y;
2543
        int emu=0;
2544

    
2545
        wrap_y = s->linesize;
2546
        ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2547

    
2548
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2549
            ff_emulated_edge_mc(s, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2550
            ptr= s->edge_emu_buffer;
2551
            emu=1;
2552
        }
2553
        
2554
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2555
            int progressive_score, interlaced_score;
2556
            
2557
            progressive_score= pix_vcmp16x8(ptr, wrap_y  ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
2558
            interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y  , wrap_y*2);
2559
            
2560
            if(progressive_score > interlaced_score + 100){
2561
                s->interlaced_dct=1;
2562
            
2563
                dct_offset= wrap_y;
2564
                wrap_y<<=1;
2565
            }else
2566
                s->interlaced_dct=0;
2567
        }
2568
        
2569
        s->dsp.get_pixels(s->block[0], ptr                 , wrap_y);
2570
        s->dsp.get_pixels(s->block[1], ptr              + 8, wrap_y);
2571
        s->dsp.get_pixels(s->block[2], ptr + dct_offset    , wrap_y);
2572
        s->dsp.get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
2573

    
2574
        if(s->flags&CODEC_FLAG_GRAY){
2575
            skip_dct[4]= 1;
2576
            skip_dct[5]= 1;
2577
        }else{
2578
            int wrap_c = s->uvlinesize;
2579
            ptr = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2580
            if(emu){
2581
                ff_emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2582
                ptr= s->edge_emu_buffer;
2583
            }
2584
            s->dsp.get_pixels(s->block[4], ptr, wrap_c);
2585

    
2586
            ptr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2587
            if(emu){
2588
                ff_emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2589
                ptr= s->edge_emu_buffer;
2590
            }
2591
            s->dsp.get_pixels(s->block[5], ptr, wrap_c);
2592
        }
2593
    }else{
2594
        op_pixels_func (*op_pix)[4];
2595
        qpel_mc_func (*op_qpix)[16];
2596
        uint8_t *dest_y, *dest_cb, *dest_cr;
2597
        uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2598
        int wrap_y, wrap_c;
2599
        int emu=0;
2600

    
2601
        dest_y  = s->current_picture.data[0] + (mb_y * 16 * s->linesize    ) + mb_x * 16;
2602
        dest_cb = s->current_picture.data[1] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2603
        dest_cr = s->current_picture.data[2] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2604
        wrap_y = s->linesize;
2605
        wrap_c = s->uvlinesize;
2606
        ptr_y  = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2607
        ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2608
        ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2609

    
2610
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
2611
            op_pix = s->dsp.put_pixels_tab;
2612
            op_qpix= s->dsp.put_qpel_pixels_tab;
2613
        }else{
2614
            op_pix = s->dsp.put_no_rnd_pixels_tab;
2615
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2616
        }
2617

    
2618
        if (s->mv_dir & MV_DIR_FORWARD) {
2619
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2620
            op_pix = s->dsp.avg_pixels_tab;
2621
            op_qpix= s->dsp.avg_qpel_pixels_tab;
2622
        }
2623
        if (s->mv_dir & MV_DIR_BACKWARD) {
2624
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2625
        }
2626

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

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

    
2738
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
2739
        s->block_last_index[4]=
2740
        s->block_last_index[5]= 0;
2741
        s->block[4][0]=
2742
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
2743
    }
2744

    
2745
    /* huffman encode */
2746
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2747
    case CODEC_ID_MPEG1VIDEO:
2748
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
2749
#ifdef CONFIG_RISKY
2750
    case CODEC_ID_MPEG4:
2751
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
2752
    case CODEC_ID_MSMPEG4V2:
2753
    case CODEC_ID_MSMPEG4V3:
2754
    case CODEC_ID_WMV1:
2755
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
2756
    case CODEC_ID_WMV2:
2757
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
2758
    case CODEC_ID_H263:
2759
    case CODEC_ID_H263P:
2760
    case CODEC_ID_RV10:
2761
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
2762
#endif
2763
    case CODEC_ID_MJPEG:
2764
        mjpeg_encode_mb(s, s->block); break;
2765
    default:
2766
        assert(0);
2767
    }
2768
}
2769

    
2770
#endif //CONFIG_ENCODERS
2771

    
2772
/**
2773
 * combines the (truncated) bitstream to a complete frame
2774
 * @returns -1 if no complete frame could be created
2775
 */
2776
int ff_combine_frame( MpegEncContext *s, int next, uint8_t **buf, int *buf_size){
2777
    ParseContext *pc= &s->parse_context;
2778
        
2779
    pc->last_index= pc->index;
2780

    
2781
    if(next==-1){
2782
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
2783

    
2784
        memcpy(&pc->buffer[pc->index], *buf, *buf_size);
2785
        pc->index += *buf_size;
2786
        return -1;
2787
    }
2788

    
2789
    if(pc->index){
2790
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
2791

    
2792
        memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
2793
        pc->index = 0;
2794
        *buf= pc->buffer;
2795
        *buf_size= pc->last_index + next;
2796
    }
2797

    
2798
    return 0;
2799
}
2800

    
2801
#ifdef CONFIG_ENCODERS
2802
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
2803
{
2804
    int bytes= length>>4;
2805
    int bits= length&15;
2806
    int i;
2807

    
2808
    if(length==0) return;
2809

    
2810
    for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
2811
    put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
2812
}
2813

    
2814
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2815
    int i;
2816

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

    
2819
    /* mpeg1 */
2820
    d->mb_skip_run= s->mb_skip_run;
2821
    for(i=0; i<3; i++)
2822
        d->last_dc[i]= s->last_dc[i];
2823
    
2824
    /* statistics */
2825
    d->mv_bits= s->mv_bits;
2826
    d->i_tex_bits= s->i_tex_bits;
2827
    d->p_tex_bits= s->p_tex_bits;
2828
    d->i_count= s->i_count;
2829
    d->f_count= s->f_count;
2830
    d->b_count= s->b_count;
2831
    d->skip_count= s->skip_count;
2832
    d->misc_bits= s->misc_bits;
2833
    d->last_bits= 0;
2834

    
2835
    d->mb_skiped= s->mb_skiped;
2836
    d->qscale= s->qscale;
2837
}
2838

    
2839
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2840
    int i;
2841

    
2842
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
2843
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
2844
    
2845
    /* mpeg1 */
2846
    d->mb_skip_run= s->mb_skip_run;
2847
    for(i=0; i<3; i++)
2848
        d->last_dc[i]= s->last_dc[i];
2849
    
2850
    /* statistics */
2851
    d->mv_bits= s->mv_bits;
2852
    d->i_tex_bits= s->i_tex_bits;
2853
    d->p_tex_bits= s->p_tex_bits;
2854
    d->i_count= s->i_count;
2855
    d->f_count= s->f_count;
2856
    d->b_count= s->b_count;
2857
    d->skip_count= s->skip_count;
2858
    d->misc_bits= s->misc_bits;
2859

    
2860
    d->mb_intra= s->mb_intra;
2861
    d->mb_skiped= s->mb_skiped;
2862
    d->mv_type= s->mv_type;
2863
    d->mv_dir= s->mv_dir;
2864
    d->pb= s->pb;
2865
    if(s->data_partitioning){
2866
        d->pb2= s->pb2;
2867
        d->tex_pb= s->tex_pb;
2868
    }
2869
    d->block= s->block;
2870
    for(i=0; i<6; i++)
2871
        d->block_last_index[i]= s->block_last_index[i];
2872
    d->interlaced_dct= s->interlaced_dct;
2873
    d->qscale= s->qscale;
2874
}
2875

    
2876
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
2877
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2878
                           int *dmin, int *next_block, int motion_x, int motion_y)
2879
{
2880
    int bits_count;
2881
    
2882
    copy_context_before_encode(s, backup, type);
2883

    
2884
    s->block= s->blocks[*next_block];
2885
    s->pb= pb[*next_block];
2886
    if(s->data_partitioning){
2887
        s->pb2   = pb2   [*next_block];
2888
        s->tex_pb= tex_pb[*next_block];
2889
    }
2890

    
2891
    encode_mb(s, motion_x, motion_y);
2892

    
2893
    bits_count= get_bit_count(&s->pb);
2894
    if(s->data_partitioning){
2895
        bits_count+= get_bit_count(&s->pb2);
2896
        bits_count+= get_bit_count(&s->tex_pb);
2897
    }
2898

    
2899
    if(bits_count<*dmin){
2900
        *dmin= bits_count;
2901
        *next_block^=1;
2902

    
2903
        copy_context_after_encode(best, s, type);
2904
    }
2905
}
2906
                
2907
static inline int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2908
    uint32_t *sq = squareTbl + 256;
2909
    int acc=0;
2910
    int x,y;
2911
    
2912
    if(w==16 && h==16) 
2913
        return s->dsp.sse[0](NULL, src1, src2, stride);
2914
    else if(w==8 && h==8)
2915
        return s->dsp.sse[1](NULL, src1, src2, stride);
2916
    
2917
    for(y=0; y<h; y++){
2918
        for(x=0; x<w; x++){
2919
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2920
        } 
2921
    }
2922
    
2923
    assert(acc>=0);
2924
    
2925
    return acc;
2926
}
2927

    
2928
static void encode_picture(MpegEncContext *s, int picture_number)
2929
{
2930
    int mb_x, mb_y, pdif = 0;
2931
    int i;
2932
    int bits;
2933
    MpegEncContext best_s, backup_s;
2934
    uint8_t bit_buf[2][3000];
2935
    uint8_t bit_buf2[2][3000];
2936
    uint8_t bit_buf_tex[2][3000];
2937
    PutBitContext pb[2], pb2[2], tex_pb[2];
2938

    
2939
    for(i=0; i<2; i++){
2940
        init_put_bits(&pb    [i], bit_buf    [i], 3000, NULL, NULL);
2941
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000, NULL, NULL);
2942
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
2943
    }
2944

    
2945
    s->picture_number = picture_number;
2946
    
2947
    /* Reset the average MB variance */
2948
    s->current_picture.mb_var_sum = 0;
2949
    s->current_picture.mc_mb_var_sum = 0;
2950

    
2951
#ifdef CONFIG_RISKY
2952
    /* we need to initialize some time vars before we can encode b-frames */
2953
    // RAL: Condition added for MPEG1VIDEO
2954
    if (s->codec_id == CODEC_ID_MPEG1VIDEO || (s->h263_pred && !s->h263_msmpeg4))
2955
        ff_set_mpeg4_time(s, s->picture_number); 
2956
#endif
2957
        
2958
    s->scene_change_score=0;
2959
    
2960
    s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
2961
    
2962
    if(s->pict_type==I_TYPE){
2963
        if(s->msmpeg4_version >= 3) s->no_rounding=1;
2964
        else                        s->no_rounding=0;
2965
    }else if(s->pict_type!=B_TYPE){
2966
        if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
2967
            s->no_rounding ^= 1;          
2968
    }
2969
    
2970
    /* Estimate motion for every MB */
2971
    s->mb_intra=0; //for the rate distoration & bit compare functions
2972
    if(s->pict_type != I_TYPE){
2973
        if(s->pict_type != B_TYPE){
2974
            if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
2975
                s->me.pre_pass=1;
2976
                s->me.dia_size= s->avctx->pre_dia_size;
2977

    
2978
                for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) {
2979
                    for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) {
2980
                        s->mb_x = mb_x;
2981
                        s->mb_y = mb_y;
2982
                        ff_pre_estimate_p_frame_motion(s, mb_x, mb_y);
2983
                    }
2984
                }
2985
                s->me.pre_pass=0;
2986
            }
2987
        }
2988

    
2989
        s->me.dia_size= s->avctx->dia_size;
2990
        for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2991
            s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
2992
            s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
2993
            s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
2994
            s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
2995
            for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2996
                s->mb_x = mb_x;
2997
                s->mb_y = mb_y;
2998
                s->block_index[0]+=2;
2999
                s->block_index[1]+=2;
3000
                s->block_index[2]+=2;
3001
                s->block_index[3]+=2;
3002
                
3003
                /* compute motion vector & mb_type and store in context */
3004
                if(s->pict_type==B_TYPE)
3005
                    ff_estimate_b_frame_motion(s, mb_x, mb_y);
3006
                else
3007
                    ff_estimate_p_frame_motion(s, mb_x, mb_y);
3008
            }
3009
        }
3010
    }else /* if(s->pict_type == I_TYPE) */{
3011
        /* I-Frame */
3012
        //FIXME do we need to zero them?
3013
        memset(s->motion_val[0], 0, sizeof(int16_t)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
3014
        memset(s->p_mv_table   , 0, sizeof(int16_t)*(s->mb_stride)*s->mb_height*2);
3015
        memset(s->mb_type      , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3016
        
3017
        if(!s->fixed_qscale){
3018
            /* finding spatial complexity for I-frame rate control */
3019
            for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3020
                for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3021
                    int xx = mb_x * 16;
3022
                    int yy = mb_y * 16;
3023
                    uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
3024
                    int varc;
3025
                    int sum = s->dsp.pix_sum(pix, s->linesize);
3026
    
3027
                    varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
3028

    
3029
                    s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
3030
                    s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
3031
                    s->current_picture.mb_var_sum    += varc;
3032
                }
3033
            }
3034
        }
3035
    }
3036
    emms_c();
3037

    
3038
    if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
3039
        s->pict_type= I_TYPE;
3040
        memset(s->mb_type   , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3041
//printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3042
    }
3043

    
3044
    if(!s->umvplus){
3045
        if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
3046
            s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
3047
        
3048
            ff_fix_long_p_mvs(s);
3049
        }
3050

    
3051
        if(s->pict_type==B_TYPE){
3052
            int a, b;
3053

    
3054
            a = ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
3055
            b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, MB_TYPE_BIDIR);
3056
            s->f_code = FFMAX(a, b);
3057

    
3058
            a = ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
3059
            b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, MB_TYPE_BIDIR);
3060
            s->b_code = FFMAX(a, b);
3061

    
3062
            ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
3063
            ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
3064
            ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
3065
            ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
3066
        }
3067
    }
3068
    
3069
    if (s->fixed_qscale) 
3070
        s->frame_qscale = s->current_picture.quality;
3071
    else
3072
        s->frame_qscale = ff_rate_estimate_qscale(s);
3073

    
3074
    if(s->adaptive_quant){
3075
#ifdef CONFIG_RISKY
3076
        switch(s->codec_id){
3077
        case CODEC_ID_MPEG4:
3078
            ff_clean_mpeg4_qscales(s);
3079
            break;
3080
        case CODEC_ID_H263:
3081
        case CODEC_ID_H263P:
3082
            ff_clean_h263_qscales(s);
3083
            break;
3084
        }
3085
#endif
3086

    
3087
        s->qscale= s->current_picture.qscale_table[0];
3088
    }else
3089
        s->qscale= (int)(s->frame_qscale + 0.5);
3090
        
3091
    if (s->out_format == FMT_MJPEG) {
3092
        /* for mjpeg, we do include qscale in the matrix */
3093
        s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
3094
        for(i=1;i<64;i++){
3095
            int j= s->dsp.idct_permutation[i];
3096

    
3097
            s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3098
        }
3099
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, 
3100
                       s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
3101
    }
3102
    
3103
    //FIXME var duplication
3104
    s->current_picture.key_frame= s->pict_type == I_TYPE;
3105
    s->current_picture.pict_type= s->pict_type;
3106

    
3107
    if(s->current_picture.key_frame)
3108
        s->picture_in_gop_number=0;
3109

    
3110
    s->last_bits= get_bit_count(&s->pb);
3111
    switch(s->out_format) {
3112
    case FMT_MJPEG:
3113
        mjpeg_picture_header(s);
3114
        break;
3115
#ifdef CONFIG_RISKY
3116
    case FMT_H263:
3117
        if (s->codec_id == CODEC_ID_WMV2) 
3118
            ff_wmv2_encode_picture_header(s, picture_number);
3119
        else if (s->h263_msmpeg4) 
3120
            msmpeg4_encode_picture_header(s, picture_number);
3121
        else if (s->h263_pred)
3122
            mpeg4_encode_picture_header(s, picture_number);
3123
        else if (s->h263_rv10) 
3124
            rv10_encode_picture_header(s, picture_number);
3125
        else
3126
            h263_encode_picture_header(s, picture_number);
3127
        break;
3128
#endif
3129
    case FMT_MPEG1:
3130
        mpeg1_encode_picture_header(s, picture_number);
3131
        break;
3132
    }
3133
    bits= get_bit_count(&s->pb);
3134
    s->header_bits= bits - s->last_bits;
3135
    s->last_bits= bits;
3136
    s->mv_bits=0;
3137
    s->misc_bits=0;
3138
    s->i_tex_bits=0;
3139
    s->p_tex_bits=0;
3140
    s->i_count=0;
3141
    s->f_count=0;
3142
    s->b_count=0;
3143
    s->skip_count=0;
3144

    
3145
    for(i=0; i<3; i++){
3146
        /* init last dc values */
3147
        /* note: quant matrix value (8) is implied here */
3148
        s->last_dc[i] = 128;
3149
        
3150
        s->current_picture_ptr->error[i] = 0;
3151
    }
3152
    s->mb_skip_run = 0;
3153
    s->last_mv[0][0][0] = 0;
3154
    s->last_mv[0][0][1] = 0;
3155
    s->last_mv[1][0][0] = 0;
3156
    s->last_mv[1][0][1] = 0;
3157
     
3158
    s->last_mv_dir = 0;
3159

    
3160
#ifdef CONFIG_RISKY
3161
    if (s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P)
3162
        s->gob_index = ff_h263_get_gob_height(s);
3163

    
3164
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3165
        ff_mpeg4_init_partitions(s);
3166
#endif
3167

    
3168
    s->resync_mb_x=0;
3169
    s->resync_mb_y=0;
3170
    s->first_slice_line = 1;
3171
    s->ptr_lastgob = s->pb.buf;
3172
    for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3173
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
3174
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
3175
        
3176
        s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3177
        s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3178
        s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3179
        s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3180
        s->block_index[4]= s->block_wrap[4]*(mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2);
3181
        s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
3182
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3183
            const int xy= mb_y*s->mb_stride + mb_x;
3184
            int mb_type= s->mb_type[xy];
3185
//            int d;
3186
            int dmin=10000000;
3187

    
3188
            s->mb_x = mb_x;
3189
            s->mb_y = mb_y;
3190
            s->block_index[0]+=2;
3191
            s->block_index[1]+=2;
3192
            s->block_index[2]+=2;
3193
            s->block_index[3]+=2;
3194
            s->block_index[4]++;
3195
            s->block_index[5]++;
3196

    
3197
            /* write gob / video packet header  */
3198
#ifdef CONFIG_RISKY
3199
            if(s->rtp_mode){
3200
                int current_packet_size, is_gob_start;
3201
                
3202
                current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
3203
                is_gob_start=0;
3204
                
3205
                if(s->codec_id==CODEC_ID_MPEG4){
3206
                    if(current_packet_size >= s->rtp_payload_size
3207
                       && s->mb_y + s->mb_x>0){
3208

    
3209
                        if(s->partitioned_frame){
3210
                            ff_mpeg4_merge_partitions(s);
3211
                            ff_mpeg4_init_partitions(s);
3212
                        }
3213
                        ff_mpeg4_encode_video_packet_header(s);
3214

    
3215
                        if(s->flags&CODEC_FLAG_PASS1){
3216
                            int bits= get_bit_count(&s->pb);
3217
                            s->misc_bits+= bits - s->last_bits;
3218
                            s->last_bits= bits;
3219
                        }
3220
                        ff_mpeg4_clean_buffers(s);
3221
                        is_gob_start=1;
3222
                    }
3223
                }else if(s->codec_id==CODEC_ID_MPEG1VIDEO){
3224
                    if(   current_packet_size >= s->rtp_payload_size 
3225
                       && s->mb_y + s->mb_x>0 && s->mb_skip_run==0){
3226
                        ff_mpeg1_encode_slice_header(s);
3227
                        ff_mpeg1_clean_buffers(s);
3228
                        is_gob_start=1;
3229
                    }
3230
                }else{
3231
                    if(current_packet_size >= s->rtp_payload_size
3232
                       && s->mb_x==0 && s->mb_y>0 && s->mb_y%s->gob_index==0){
3233
                       
3234
                        h263_encode_gob_header(s, mb_y);                       
3235
                        is_gob_start=1;
3236
                    }
3237
                }
3238

    
3239
                if(is_gob_start){
3240
                    s->ptr_lastgob = pbBufPtr(&s->pb);
3241
                    s->first_slice_line=1;
3242
                    s->resync_mb_x=mb_x;
3243
                    s->resync_mb_y=mb_y;
3244
                }
3245
            }
3246
#endif
3247

    
3248
            if(  (s->resync_mb_x   == s->mb_x)
3249
               && s->resync_mb_y+1 == s->mb_y){
3250
                s->first_slice_line=0; 
3251
            }
3252

    
3253
            if(mb_type & (mb_type-1)){ // more than 1 MB type possible
3254
                int next_block=0;
3255
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3256

    
3257
                copy_context_before_encode(&backup_s, s, -1);
3258
                backup_s.pb= s->pb;
3259
                best_s.data_partitioning= s->data_partitioning;
3260
                best_s.partitioned_frame= s->partitioned_frame;
3261
                if(s->data_partitioning){
3262
                    backup_s.pb2= s->pb2;
3263
                    backup_s.tex_pb= s->tex_pb;
3264
                }
3265

    
3266
                if(mb_type&MB_TYPE_INTER){
3267
                    s->mv_dir = MV_DIR_FORWARD;
3268
                    s->mv_type = MV_TYPE_16X16;
3269
                    s->mb_intra= 0;
3270
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
3271
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
3272
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb, 
3273
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3274
                }
3275
                if(mb_type&MB_TYPE_INTER4V){                 
3276
                    s->mv_dir = MV_DIR_FORWARD;
3277
                    s->mv_type = MV_TYPE_8X8;
3278
                    s->mb_intra= 0;
3279
                    for(i=0; i<4; i++){
3280
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3281
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3282
                    }
3283
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb, 
3284
                                 &dmin, &next_block, 0, 0);
3285
                }
3286
                if(mb_type&MB_TYPE_FORWARD){
3287
                    s->mv_dir = MV_DIR_FORWARD;
3288
                    s->mv_type = MV_TYPE_16X16;
3289
                    s->mb_intra= 0;
3290
                    s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3291
                    s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3292
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb, 
3293
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3294
                }
3295
                if(mb_type&MB_TYPE_BACKWARD){
3296
                    s->mv_dir = MV_DIR_BACKWARD;
3297
                    s->mv_type = MV_TYPE_16X16;
3298
                    s->mb_intra= 0;
3299
                    s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3300
                    s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3301
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb, 
3302
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3303
                }
3304
                if(mb_type&MB_TYPE_BIDIR){
3305
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3306
                    s->mv_type = MV_TYPE_16X16;
3307
                    s->mb_intra= 0;
3308
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3309
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3310
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3311
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3312
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb, 
3313
                                 &dmin, &next_block, 0, 0);
3314
                }
3315
                if(mb_type&MB_TYPE_DIRECT){
3316
                    int mx= s->b_direct_mv_table[xy][0];
3317
                    int my= s->b_direct_mv_table[xy][1];
3318
                    
3319
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3320
                    s->mb_intra= 0;
3321
#ifdef CONFIG_RISKY
3322
                    ff_mpeg4_set_direct_mv(s, mx, my);
3323
#endif
3324
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb, 
3325
                                 &dmin, &next_block, mx, my);
3326
                }
3327
                if(mb_type&MB_TYPE_INTRA){
3328
                    s->mv_dir = 0;
3329
                    s->mv_type = MV_TYPE_16X16;
3330
                    s->mb_intra= 1;
3331
                    s->mv[0][0][0] = 0;
3332
                    s->mv[0][0][1] = 0;
3333
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb, 
3334
                                 &dmin, &next_block, 0, 0);
3335
                    /* force cleaning of ac/dc pred stuff if needed ... */
3336
                    if(s->h263_pred || s->h263_aic)
3337
                        s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
3338
                }
3339
                copy_context_after_encode(s, &best_s, -1);
3340
                
3341
                pb_bits_count= get_bit_count(&s->pb);
3342
                flush_put_bits(&s->pb);
3343
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3344
                s->pb= backup_s.pb;
3345
                
3346
                if(s->data_partitioning){
3347
                    pb2_bits_count= get_bit_count(&s->pb2);
3348
                    flush_put_bits(&s->pb2);
3349
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3350
                    s->pb2= backup_s.pb2;
3351
                    
3352
                    tex_pb_bits_count= get_bit_count(&s->tex_pb);
3353
                    flush_put_bits(&s->tex_pb);
3354
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3355
                    s->tex_pb= backup_s.tex_pb;
3356
                }
3357
                s->last_bits= get_bit_count(&s->pb);
3358
            } else {
3359
                int motion_x, motion_y;
3360
                int intra_score;
3361
                int inter_score= s->current_picture.mb_cmp_score[mb_x + mb_y*s->mb_stride];
3362
                
3363
              if(!(s->flags&CODEC_FLAG_HQ) && s->pict_type==P_TYPE){
3364
                /* get luma score */
3365
                if((s->avctx->mb_cmp&0xFF)==FF_CMP_SSE){
3366
                    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
3367
                }else{
3368
                    uint8_t *dest_y;
3369

    
3370
                    int mean= s->current_picture.mb_mean[mb_x + mb_y*s->mb_stride]; //FIXME
3371
                    mean*= 0x01010101;
3372
                    
3373
                    dest_y  = s->new_picture.data[0] + (mb_y * 16 * s->linesize    ) + mb_x * 16;
3374
                
3375
                    for(i=0; i<16; i++){
3376
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 0]) = mean;
3377
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 4]) = mean;
3378
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 8]) = mean;
3379
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+12]) = mean;
3380
                    }
3381

    
3382
                    s->mb_intra=1;
3383
                    intra_score= s->dsp.mb_cmp[0](s, s->me.scratchpad, dest_y, s->linesize);
3384
                                        
3385
/*                    printf("intra:%7d inter:%7d var:%7d mc_var.%7d\n", intra_score>>8, inter_score>>8, 
3386
                        s->current_picture.mb_var[mb_x + mb_y*s->mb_stride],
3387
                        s->current_picture.mc_mb_var[mb_x + mb_y*s->mb_stride]);*/
3388
                }
3389
                
3390
                /* get chroma score */
3391
                if(s->avctx->mb_cmp&FF_CMP_CHROMA){
3392
                    int i;
3393
                    
3394
                    s->mb_intra=1;
3395
                    for(i=1; i<3; i++){
3396
                        uint8_t *dest_c;
3397
                        int mean;
3398
                        
3399
                        if(s->out_format == FMT_H263){
3400
                            mean= (s->dc_val[i][mb_x + (mb_y+1)*(s->mb_width+2)] + 4)>>3; //FIXME not exact but simple ;)
3401
                        }else{
3402
                            mean= (s->last_dc[i] + 4)>>3;
3403
                        }
3404
                        dest_c = s->new_picture.data[i] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
3405
                        
3406
                        mean*= 0x01010101;
3407
                        for(i=0; i<8; i++){
3408
                            *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 0]) = mean;
3409
                            *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 4]) = mean;
3410
                        }
3411
                        
3412
                        intra_score+= s->dsp.mb_cmp[1](s, s->me.scratchpad, dest_c, s->uvlinesize);
3413
                    }                
3414
                }
3415

    
3416
                /* bias */
3417
                switch(s->avctx->mb_cmp&0xFF){
3418
                default:
3419
                case FF_CMP_SAD:
3420
                    intra_score+= 32*s->qscale;
3421
                    break;
3422
                case FF_CMP_SSE:
3423
                    intra_score+= 24*s->qscale*s->qscale;
3424
                    break;
3425
                case FF_CMP_SATD:
3426
                    intra_score+= 96*s->qscale;
3427
                    break;
3428
                case FF_CMP_DCT:
3429
                    intra_score+= 48*s->qscale;
3430
                    break;
3431
                case FF_CMP_BIT:
3432
                    intra_score+= 16;
3433
                    break;
3434
                case FF_CMP_PSNR:
3435
                case FF_CMP_RD:
3436
                    intra_score+= (s->qscale*s->qscale*109*8 + 64)>>7;
3437
                    break;
3438
                }
3439

    
3440
                if(intra_score < inter_score)
3441
                    mb_type= MB_TYPE_INTRA;
3442
              }  
3443
                
3444
                s->mv_type=MV_TYPE_16X16;
3445
                // only one MB-Type possible
3446
                
3447
                switch(mb_type){
3448
                case MB_TYPE_INTRA:
3449
                    s->mv_dir = 0;
3450
                    s->mb_intra= 1;
3451
                    motion_x= s->mv[0][0][0] = 0;
3452
                    motion_y= s->mv[0][0][1] = 0;
3453
                    break;
3454
                case MB_TYPE_INTER:
3455
                    s->mv_dir = MV_DIR_FORWARD;
3456
                    s->mb_intra= 0;
3457
                    motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3458
                    motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3459
                    break;
3460
                case MB_TYPE_INTER4V:
3461
                    s->mv_dir = MV_DIR_FORWARD;
3462
                    s->mv_type = MV_TYPE_8X8;
3463
                    s->mb_intra= 0;
3464
                    for(i=0; i<4; i++){
3465
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3466
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3467
                    }
3468
                    motion_x= motion_y= 0;
3469
                    break;
3470
                case MB_TYPE_DIRECT:
3471
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3472
                    s->mb_intra= 0;
3473
                    motion_x=s->b_direct_mv_table[xy][0];
3474
                    motion_y=s->b_direct_mv_table[xy][1];
3475
#ifdef CONFIG_RISKY
3476
                    ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3477
#endif
3478
                    break;
3479
                case MB_TYPE_BIDIR:
3480
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3481
                    s->mb_intra= 0;
3482
                    motion_x=0;
3483
                    motion_y=0;
3484
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3485
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3486
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3487
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3488
                    break;
3489
                case MB_TYPE_BACKWARD:
3490
                    s->mv_dir = MV_DIR_BACKWARD;
3491
                    s->mb_intra= 0;
3492
                    motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3493
                    motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3494
                    break;
3495
                case MB_TYPE_FORWARD:
3496
                    s->mv_dir = MV_DIR_FORWARD;
3497
                    s->mb_intra= 0;
3498
                    motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3499
                    motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3500
//                    printf(" %d %d ", motion_x, motion_y);
3501
                    break;
3502
                default:
3503
                    motion_x=motion_y=0; //gcc warning fix
3504
                    printf("illegal MB type\n");
3505
                }
3506

    
3507
                encode_mb(s, motion_x, motion_y);
3508

    
3509
                // RAL: Update last macrobloc type
3510
                s->last_mv_dir = s->mv_dir;
3511
            }
3512

    
3513
            /* clean the MV table in IPS frames for direct mode in B frames */
3514
            if(s->mb_intra /* && I,P,S_TYPE */){
3515
                s->p_mv_table[xy][0]=0;
3516
                s->p_mv_table[xy][1]=0;
3517
            }
3518

    
3519
            MPV_decode_mb(s, s->block);
3520
            
3521
            if(s->flags&CODEC_FLAG_PSNR){
3522
                int w= 16;
3523
                int h= 16;
3524

    
3525
                if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3526
                if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3527

    
3528
                s->current_picture_ptr->error[0] += sse(
3529
                    s,
3530
                    s->new_picture    .data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3531
                    s->current_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3532
                    w, h, s->linesize);
3533
                s->current_picture_ptr->error[1] += sse(
3534
                    s,
3535
                    s->new_picture    .data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3536
                    s->current_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3537
                    w>>1, h>>1, s->uvlinesize);
3538
                s->current_picture_ptr->error[2] += sse(
3539
                    s,
3540
                    s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3541
                    s->current_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3542
                    w>>1, h>>1, s->uvlinesize);
3543
            }
3544
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, get_bit_count(&s->pb));
3545
        }
3546
    }
3547
    emms_c();
3548

    
3549
#ifdef CONFIG_RISKY
3550
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3551
        ff_mpeg4_merge_partitions(s);
3552

    
3553
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
3554
        msmpeg4_encode_ext_header(s);
3555

    
3556
    if(s->codec_id==CODEC_ID_MPEG4) 
3557
        ff_mpeg4_stuffing(&s->pb);
3558
#endif
3559

    
3560
    //if (s->gob_number)
3561
    //    fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
3562
    
3563
    /* Send the last GOB if RTP */    
3564
    if (s->rtp_mode) {
3565
        flush_put_bits(&s->pb);
3566
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
3567
        /* Call the RTP callback to send the last GOB */
3568
        if (s->rtp_callback)
3569
            s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
3570
        s->ptr_lastgob = pbBufPtr(&s->pb);
3571
        //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
3572
    }
3573
}
3574

    
3575
static int dct_quantize_trellis_c(MpegEncContext *s, 
3576
                        DCTELEM *block, int n,
3577
                        int qscale, int *overflow){
3578
    const int *qmat;
3579
    const uint8_t *scantable= s->intra_scantable.scantable;
3580
    int max=0;
3581
    unsigned int threshold1, threshold2;
3582
    int bias=0;
3583
    int run_tab[65];
3584
    int level_tab[65];
3585
    int score_tab[65];
3586
    int last_run=0;
3587
    int last_level=0;
3588
    int last_score= 0;
3589
    int last_i= 0;
3590
    int coeff[3][64];
3591
    int coeff_count[64];
3592
    int lambda, qmul, qadd, start_i, last_non_zero, i;
3593
    const int esc_length= s->ac_esc_length;
3594
    uint8_t * length;
3595
    uint8_t * last_length;
3596
    int score_limit=0;
3597
    int left_limit= 0;
3598
        
3599
    s->dsp.fdct (block);
3600

    
3601
    qmul= qscale*16;
3602
    qadd= ((qscale-1)|1)*8;
3603

    
3604
    if (s->mb_intra) {
3605
        int q;
3606
        if (!s->h263_aic) {
3607
            if (n < 4)
3608
                q = s->y_dc_scale;
3609
            else
3610
                q = s->c_dc_scale;
3611
            q = q << 3;
3612
        } else{
3613
            /* For AIC we skip quant/dequant of INTRADC */
3614
            q = 1 << 3;
3615
            qadd=0;
3616
        }
3617
            
3618
        /* note: block[0] is assumed to be positive */
3619
        block[0] = (block[0] + (q >> 1)) / q;
3620
        start_i = 1;
3621
        last_non_zero = 0;
3622
        qmat = s->q_intra_matrix[qscale];
3623
        if(s->mpeg_quant || s->codec_id== CODEC_ID_MPEG1VIDEO)
3624
            bias= 1<<(QMAT_SHIFT-1);
3625
        length     = s->intra_ac_vlc_length;
3626
        last_length= s->intra_ac_vlc_last_length;
3627
    } else {
3628
        start_i = 0;
3629
        last_non_zero = -1;
3630
        qmat = s->q_inter_matrix[qscale];
3631
        length     = s->inter_ac_vlc_length;
3632
        last_length= s->inter_ac_vlc_last_length;
3633
    }
3634

    
3635
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
3636
    threshold2= (threshold1<<1);
3637

    
3638
    for(i=start_i; i<64; i++) {
3639
        const int j = scantable[i];
3640
        const int k= i-start_i;
3641
        int level = block[j];
3642
        level = level * qmat[j];
3643

    
3644
//        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
3645
//           || bias-level >= (1<<(QMAT_SHIFT - 3))){
3646
        if(((unsigned)(level+threshold1))>threshold2){
3647
            if(level>0){
3648
                level= (bias + level)>>QMAT_SHIFT;
3649
                coeff[0][k]= level;
3650
                coeff[1][k]= level-1;
3651
//                coeff[2][k]= level-2;
3652
            }else{
3653
                level= (bias - level)>>QMAT_SHIFT;
3654
                coeff[0][k]= -level;
3655
                coeff[1][k]= -level+1;
3656
//                coeff[2][k]= -level+2;
3657
            }
3658
            coeff_count[k]= FFMIN(level, 2);
3659
            max |=level;
3660
            last_non_zero = i;
3661
        }else{
3662
            coeff[0][k]= (level>>31)|1;
3663
            coeff_count[k]= 1;
3664
        }
3665
    }
3666
    
3667
    *overflow= s->max_qcoeff < max; //overflow might have happend
3668
    
3669
    if(last_non_zero < start_i){
3670
        memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3671
        return last_non_zero;
3672
    }
3673

    
3674
    lambda= (qscale*qscale*64*105 + 64)>>7; //FIXME finetune
3675
        
3676
    score_tab[0]= 0;
3677
    for(i=0; i<=last_non_zero - start_i; i++){
3678
        int level_index, run, j;
3679
        const int dct_coeff= block[ scantable[i + start_i] ];
3680
        const int zero_distoration= dct_coeff*dct_coeff;
3681
        int best_score=256*256*256*120;
3682

    
3683
        last_score += zero_distoration;
3684
        for(level_index=0; level_index < coeff_count[i]; level_index++){
3685
            int distoration;
3686
            int level= coeff[level_index][i];
3687
            int unquant_coeff;
3688
            
3689
            assert(level);
3690

    
3691
            if(s->out_format == FMT_H263){
3692
                if(level>0){
3693
                    unquant_coeff= level*qmul + qadd;
3694
                }else{
3695
                    unquant_coeff= level*qmul - qadd;
3696
                }
3697
            }else{ //MPEG1
3698
                j= s->dsp.idct_permutation[ scantable[i + start_i] ]; //FIXME optimize
3699
                if(s->mb_intra){
3700
                    if (level < 0) {
3701
                        unquant_coeff = (int)((-level) * qscale * s->intra_matrix[j]) >> 3;
3702
                        unquant_coeff = -((unquant_coeff - 1) | 1);
3703
                    } else {
3704
                        unquant_coeff = (int)(  level  * qscale * s->intra_matrix[j]) >> 3;
3705
                        unquant_coeff =   (unquant_coeff - 1) | 1;
3706
                    }
3707
                }else{
3708
                    if (level < 0) {
3709
                        unquant_coeff = ((((-level) << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3710
                        unquant_coeff = -((unquant_coeff - 1) | 1);
3711
                    } else {
3712
                        unquant_coeff = (((  level  << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3713
                        unquant_coeff =   (unquant_coeff - 1) | 1;
3714
                    }
3715
                }
3716
                unquant_coeff<<= 3;
3717
            }
3718

    
3719
            distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff);
3720
            level+=64;
3721
            if((level&(~127)) == 0){
3722
                for(run=0; run<=i - left_limit; run++){
3723
                    int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3724
                    score += score_tab[i-run];
3725
                    
3726
                    if(score < best_score){
3727
                        best_score= 
3728
                        score_tab[i+1]= score;
3729
                        run_tab[i+1]= run;
3730
                        level_tab[i+1]= level-64;
3731
                    }
3732
                }
3733

    
3734
                if(s->out_format == FMT_H263){
3735
                    for(run=0; run<=i - left_limit; run++){
3736
                        int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3737
                        score += score_tab[i-run];
3738
                        if(score < last_score){
3739
                            last_score= score;
3740
                            last_run= run;
3741
                            last_level= level-64;
3742
                            last_i= i+1;
3743
                        }
3744
                    }
3745
                }
3746
            }else{
3747
                distoration += esc_length*lambda;
3748
                for(run=0; run<=i - left_limit; run++){
3749
                    int score= distoration + score_tab[i-run];
3750
                    
3751
                    if(score < best_score){
3752
                        best_score= 
3753
                        score_tab[i+1]= score;
3754
                        run_tab[i+1]= run;
3755
                        level_tab[i+1]= level-64;
3756
                    }
3757
                }
3758

    
3759
                if(s->out_format == FMT_H263){
3760
                    for(run=0; run<=i - left_limit; run++){
3761
                        int score= distoration + score_tab[i-run];
3762
                        if(score < last_score){
3763
                            last_score= score;
3764
                            last_run= run;
3765
                            last_level= level-64;
3766
                            last_i= i+1;
3767
                        }
3768
                    }
3769
                }
3770
            }
3771
        }
3772

    
3773
        for(j=left_limit; j<=i; j++){
3774
            score_tab[j] += zero_distoration;
3775
        }
3776
        score_limit+= zero_distoration;
3777
        if(score_tab[i+1] < score_limit)
3778
            score_limit= score_tab[i+1];
3779
        
3780
        //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3781
        while(score_tab[ left_limit ] > score_limit + lambda) left_limit++;
3782
    }
3783

    
3784
        //FIXME add some cbp penalty
3785

    
3786
    if(s->out_format != FMT_H263){
3787
        last_score= 256*256*256*120;
3788
        for(i= left_limit; i<=last_non_zero - start_i + 1; i++){
3789
            int score= score_tab[i];
3790
            if(i) score += lambda*2; //FIXME exacter?
3791

    
3792
            if(score < last_score){
3793
                last_score= score;
3794
                last_i= i;
3795
                last_level= level_tab[i];
3796
                last_run= run_tab[i];
3797
            }
3798
        }
3799
    }
3800
    
3801
    last_non_zero= last_i - 1 + start_i;
3802
    memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3803
    
3804
    if(last_non_zero < start_i)
3805
        return last_non_zero;
3806
    
3807
    i= last_i;
3808
    assert(last_level);
3809
//FIXME use permutated scantable
3810
    block[ s->dsp.idct_permutation[ scantable[last_non_zero] ] ]= last_level;
3811
    i -= last_run + 1;
3812
    
3813
    for(;i>0 ; i -= run_tab[i] + 1){
3814
        const int j= s->dsp.idct_permutation[ scantable[i - 1 + start_i] ];
3815
    
3816
        block[j]= level_tab[i];
3817
        assert(block[j]);
3818
    }
3819

    
3820
    return last_non_zero;
3821
}
3822

    
3823
static int dct_quantize_c(MpegEncContext *s, 
3824
                        DCTELEM *block, int n,
3825
                        int qscale, int *overflow)
3826
{
3827
    int i, j, level, last_non_zero, q;
3828
    const int *qmat;
3829
    const uint8_t *scantable= s->intra_scantable.scantable;
3830
    int bias;
3831
    int max=0;
3832
    unsigned int threshold1, threshold2;
3833

    
3834
    s->dsp.fdct (block);
3835

    
3836
    if (s->mb_intra) {
3837
        if (!s->h263_aic) {
3838
            if (n < 4)
3839
                q = s->y_dc_scale;
3840
            else
3841
                q = s->c_dc_scale;
3842
            q = q << 3;
3843
        } else
3844
            /* For AIC we skip quant/dequant of INTRADC */
3845
            q = 1 << 3;
3846
            
3847
        /* note: block[0] is assumed to be positive */
3848
        block[0] = (block[0] + (q >> 1)) / q;
3849
        i = 1;
3850
        last_non_zero = 0;
3851
        qmat = s->q_intra_matrix[qscale];
3852
        bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
3853
    } else {
3854
        i = 0;
3855
        last_non_zero = -1;
3856
        qmat = s->q_inter_matrix[qscale];
3857
        bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
3858
    }
3859
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
3860
    threshold2= (threshold1<<1);
3861

    
3862
    for(;i<64;i++) {
3863
        j = scantable[i];
3864
        level = block[j];
3865
        level = level * qmat[j];
3866

    
3867
//        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
3868
//           || bias-level >= (1<<(QMAT_SHIFT - 3))){
3869
        if(((unsigned)(level+threshold1))>threshold2){
3870
            if(level>0){
3871
                level= (bias + level)>>QMAT_SHIFT;
3872
                block[j]= level;
3873
            }else{
3874
                level= (bias - level)>>QMAT_SHIFT;
3875
                block[j]= -level;
3876
            }
3877
            max |=level;
3878
            last_non_zero = i;
3879
        }else{
3880
            block[j]=0;
3881
        }
3882
    }
3883
    *overflow= s->max_qcoeff < max; //overflow might have happend
3884
    
3885
    /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
3886
    if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
3887
        ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
3888

    
3889
    return last_non_zero;
3890
}
3891

    
3892
#endif //CONFIG_ENCODERS
3893

    
3894
static void dct_unquantize_mpeg1_c(MpegEncContext *s, 
3895
                                   DCTELEM *block, int n, int qscale)
3896
{
3897
    int i, level, nCoeffs;
3898
    const uint16_t *quant_matrix;
3899

    
3900
    nCoeffs= s->block_last_index[n];
3901
    
3902
    if (s->mb_intra) {
3903
        if (n < 4) 
3904
            block[0] = block[0] * s->y_dc_scale;
3905
        else
3906
            block[0] = block[0] * s->c_dc_scale;
3907
        /* XXX: only mpeg1 */
3908
        quant_matrix = s->intra_matrix;
3909
        for(i=1;i<=nCoeffs;i++) {
3910
            int j= s->intra_scantable.permutated[i];
3911
            level = block[j];
3912
            if (level) {
3913
                if (level < 0) {
3914
                    level = -level;
3915
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3916
                    level = (level - 1) | 1;
3917
                    level = -level;
3918
                } else {
3919
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3920
                    level = (level - 1) | 1;
3921
                }
3922
#ifdef PARANOID
3923
                if (level < -2048 || level > 2047)
3924
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3925
#endif
3926
                block[j] = level;
3927
            }
3928
        }
3929
    } else {
3930
        i = 0;
3931
        quant_matrix = s->inter_matrix;
3932
        for(;i<=nCoeffs;i++) {
3933
            int j= s->intra_scantable.permutated[i];
3934
            level = block[j];
3935
            if (level) {
3936
                if (level < 0) {
3937
                    level = -level;
3938
                    level = (((level << 1) + 1) * qscale *
3939
                             ((int) (quant_matrix[j]))) >> 4;
3940
                    level = (level - 1) | 1;
3941
                    level = -level;
3942
                } else {
3943
                    level = (((level << 1) + 1) * qscale *
3944
                             ((int) (quant_matrix[j]))) >> 4;
3945
                    level = (level - 1) | 1;
3946
                }
3947
#ifdef PARANOID
3948
                if (level < -2048 || level > 2047)
3949
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3950
#endif
3951
                block[j] = level;
3952
            }
3953
        }
3954
    }
3955
}
3956

    
3957
static void dct_unquantize_mpeg2_c(MpegEncContext *s, 
3958
                                   DCTELEM *block, int n, int qscale)
3959
{
3960
    int i, level, nCoeffs;
3961
    const uint16_t *quant_matrix;
3962

    
3963
    if(s->alternate_scan) nCoeffs= 63;
3964
    else nCoeffs= s->block_last_index[n];
3965
    
3966
    if (s->mb_intra) {
3967
        if (n < 4) 
3968
            block[0] = block[0] * s->y_dc_scale;
3969
        else
3970
            block[0] = block[0] * s->c_dc_scale;
3971
        quant_matrix = s->intra_matrix;
3972
        for(i=1;i<=nCoeffs;i++) {
3973
            int j= s->intra_scantable.permutated[i];
3974
            level = block[j];
3975
            if (level) {
3976
                if (level < 0) {
3977
                    level = -level;
3978
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3979
                    level = -level;
3980
                } else {
3981
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3982
                }
3983
#ifdef PARANOID
3984
                if (level < -2048 || level > 2047)
3985
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3986
#endif
3987
                block[j] = level;
3988
            }
3989
        }
3990
    } else {
3991
        int sum=-1;
3992
        i = 0;
3993
        quant_matrix = s->inter_matrix;
3994
        for(;i<=nCoeffs;i++) {
3995
            int j= s->intra_scantable.permutated[i];
3996
            level = block[j];
3997
            if (level) {
3998
                if (level < 0) {
3999
                    level = -level;
4000
                    level = (((level << 1) + 1) * qscale *
4001
                             ((int) (quant_matrix[j]))) >> 4;
4002
                    level = -level;
4003
                } else {
4004
                    level = (((level << 1) + 1) * qscale *
4005
                             ((int) (quant_matrix[j]))) >> 4;
4006
                }
4007
#ifdef PARANOID
4008
                if (level < -2048 || level > 2047)
4009
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4010
#endif
4011
                block[j] = level;
4012
                sum+=level;
4013
            }
4014
        }
4015
        block[63]^=sum&1;
4016
    }
4017
}
4018

    
4019

    
4020
static void dct_unquantize_h263_c(MpegEncContext *s, 
4021
                                  DCTELEM *block, int n, int qscale)
4022
{
4023
    int i, level, qmul, qadd;
4024
    int nCoeffs;
4025
    
4026
    assert(s->block_last_index[n]>=0);
4027
    
4028
    qadd = (qscale - 1) | 1;
4029
    qmul = qscale << 1;
4030
    
4031
    if (s->mb_intra) {
4032
        if (!s->h263_aic) {
4033
            if (n < 4) 
4034
                block[0] = block[0] * s->y_dc_scale;
4035
            else
4036
                block[0] = block[0] * s->c_dc_scale;
4037
        }else
4038
            qadd = 0;
4039
        i = 1;
4040
        nCoeffs= 63; //does not allways use zigzag table 
4041
    } else {
4042
        i = 0;
4043
        nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
4044
    }
4045

    
4046
    for(;i<=nCoeffs;i++) {
4047
        level = block[i];
4048
        if (level) {
4049
            if (level < 0) {
4050
                level = level * qmul - qadd;
4051
            } else {
4052
                level = level * qmul + qadd;
4053
            }
4054
#ifdef PARANOID
4055
                if (level < -2048 || level > 2047)
4056
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4057
#endif
4058
            block[i] = level;
4059
        }
4060
    }
4061
}
4062

    
4063

    
4064
char ff_get_pict_type_char(int pict_type){
4065
    switch(pict_type){
4066
    case I_TYPE: return 'I'; 
4067
    case P_TYPE: return 'P'; 
4068
    case B_TYPE: return 'B'; 
4069
    case S_TYPE: return 'S'; 
4070
    case SI_TYPE:return 'i'; 
4071
    case SP_TYPE:return 'p'; 
4072
    default:     return '?';
4073
    }
4074
}
4075

    
4076
static const AVOption mpeg4_options[] =
4077
{
4078
    AVOPTION_CODEC_INT("bitrate", "desired video bitrate", bit_rate, 4, 240000000, 800000),
4079
    AVOPTION_CODEC_FLAG("vhq", "very high quality", flags, CODEC_FLAG_HQ, 0),
4080
    AVOPTION_CODEC_INT("ratetol", "number of bits the bitstream is allowed to diverge from the reference"
4081
                       "the reference can be CBR (for CBR pass1) or VBR (for pass2)",
4082
                       bit_rate_tolerance, 4, 240000000, 8000),
4083
    AVOPTION_CODEC_INT("qmin", "minimum quantizer", qmin, 1, 31, 2),
4084
    AVOPTION_CODEC_INT("qmax", "maximum quantizer", qmax, 1, 31, 31),
4085
    AVOPTION_CODEC_STRING("rc_eq", "rate control equation",
4086
                          rc_eq, "tex^qComp,option1,options2", 0),
4087
    AVOPTION_CODEC_INT("rc_minrate", "rate control minimum bitrate",
4088
                       rc_min_rate, 4, 24000000, 0),
4089
    AVOPTION_CODEC_INT("rc_maxrate", "rate control maximum bitrate",
4090
                       rc_max_rate, 4, 24000000, 0),
4091
    AVOPTION_CODEC_DOUBLE("rc_buf_aggresivity", "rate control buffer aggresivity",
4092
                          rc_buffer_aggressivity, 4, 24000000, 0),
4093
    AVOPTION_CODEC_DOUBLE("rc_initial_cplx", "initial complexity for pass1 ratecontrol",
4094
                          rc_initial_cplx, 0., 9999999., 0),
4095
    AVOPTION_CODEC_DOUBLE("i_quant_factor", "qscale factor between p and i frames",
4096
                          i_quant_factor, 0., 0., 0),
4097
    AVOPTION_CODEC_DOUBLE("i_quant_offset", "qscale offset between p and i frames",
4098
                          i_quant_factor, -999999., 999999., 0),
4099
    AVOPTION_CODEC_INT("dct_algo", "dct alghorithm",
4100
                       dct_algo, 0, 5, 0), // fixme - "Auto,FastInt,Int,MMX,MLib,Altivec"
4101
    AVOPTION_CODEC_DOUBLE("lumi_masking", "luminance masking",
4102
                          lumi_masking, 0., 999999., 0),
4103
    AVOPTION_CODEC_DOUBLE("temporal_cplx_masking", "temporary complexity masking",
4104
                          temporal_cplx_masking, 0., 999999., 0),
4105
    AVOPTION_CODEC_DOUBLE("spatial_cplx_masking", "spatial complexity masking",
4106
                          spatial_cplx_masking, 0., 999999., 0),
4107
    AVOPTION_CODEC_DOUBLE("p_masking", "p block masking",
4108
                          p_masking, 0., 999999., 0),
4109
    AVOPTION_CODEC_DOUBLE("dark_masking", "darkness masking",
4110
                          dark_masking, 0., 999999., 0),
4111
    AVOPTION_CODEC_INT("idct_algo", "idct alghorithm",
4112
                       idct_algo, 0, 8, 0), // fixme - "Auto,Int,Simple,SimpleMMX,LibMPEG2MMX,PS2,MLib,ARM,Altivec"
4113

    
4114
    AVOPTION_CODEC_INT("mb_qmin", "minimum MB quantizer",
4115
                       mb_qmin, 0, 8, 0),
4116
    AVOPTION_CODEC_INT("mb_qmax", "maximum MB quantizer",
4117
                       mb_qmin, 0, 8, 0),
4118

    
4119
    AVOPTION_CODEC_INT("me_cmp", "ME compare function",
4120
                       me_cmp, 0, 24000000, 0),
4121
    AVOPTION_CODEC_INT("me_sub_cmp", "subpixel ME compare function",
4122
                       me_sub_cmp, 0, 24000000, 0),
4123

    
4124

    
4125
    AVOPTION_CODEC_INT("dia_size", "ME diamond size & shape",
4126
                       dia_size, 0, 24000000, 0),
4127
    AVOPTION_CODEC_INT("last_predictor_count", "amount of previous MV predictors",
4128
                       last_predictor_count, 0, 24000000, 0),
4129

    
4130
    AVOPTION_CODEC_INT("pre_me", "pre pass for ME",
4131
                       pre_me, 0, 24000000, 0),
4132
    AVOPTION_CODEC_INT("me_pre_cmp", "ME pre pass compare function",
4133
                       me_pre_cmp, 0, 24000000, 0),
4134

    
4135
    AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4136
                       me_range, 0, 24000000, 0),
4137
    AVOPTION_CODEC_INT("pre_dia_size", "ME pre pass diamod size & shape",
4138
                       pre_dia_size, 0, 24000000, 0),
4139
    AVOPTION_CODEC_INT("me_subpel_quality", "subpel ME quality",
4140
                       me_subpel_quality, 0, 24000000, 0),
4141
    AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4142
                       me_range, 0, 24000000, 0),
4143
    AVOPTION_CODEC_FLAG("psnr", "calculate PSNR of compressed frames",
4144
                        flags, CODEC_FLAG_PSNR, 0),
4145
    AVOPTION_CODEC_RCOVERRIDE("rc_override", "ratecontrol override (=startframe,endframe,qscale,quality_factor)",
4146
                              rc_override),
4147
    AVOPTION_SUB(avoptions_common),
4148
    AVOPTION_END()
4149
};
4150

    
4151
#ifdef CONFIG_ENCODERS
4152

    
4153
AVCodec mpeg1video_encoder = {
4154
    "mpeg1video",
4155
    CODEC_TYPE_VIDEO,
4156
    CODEC_ID_MPEG1VIDEO,
4157
    sizeof(MpegEncContext),
4158
    MPV_encode_init,
4159
    MPV_encode_picture,
4160
    MPV_encode_end,
4161
};
4162

    
4163
#ifdef CONFIG_RISKY
4164

    
4165
AVCodec h263_encoder = {
4166
    "h263",
4167
    CODEC_TYPE_VIDEO,
4168
    CODEC_ID_H263,
4169
    sizeof(MpegEncContext),
4170
    MPV_encode_init,
4171
    MPV_encode_picture,
4172
    MPV_encode_end,
4173
};
4174

    
4175
AVCodec h263p_encoder = {
4176
    "h263p",
4177
    CODEC_TYPE_VIDEO,
4178
    CODEC_ID_H263P,
4179
    sizeof(MpegEncContext),
4180
    MPV_encode_init,
4181
    MPV_encode_picture,
4182
    MPV_encode_end,
4183
};
4184

    
4185
AVCodec rv10_encoder = {
4186
    "rv10",
4187
    CODEC_TYPE_VIDEO,
4188
    CODEC_ID_RV10,
4189
    sizeof(MpegEncContext),
4190
    MPV_encode_init,
4191
    MPV_encode_picture,
4192
    MPV_encode_end,
4193
};
4194

    
4195
AVCodec mpeg4_encoder = {
4196
    "mpeg4",
4197
    CODEC_TYPE_VIDEO,
4198
    CODEC_ID_MPEG4,
4199
    sizeof(MpegEncContext),
4200
    MPV_encode_init,
4201
    MPV_encode_picture,
4202
    MPV_encode_end,
4203
    .options = mpeg4_options,
4204
};
4205

    
4206
AVCodec msmpeg4v1_encoder = {
4207
    "msmpeg4v1",
4208
    CODEC_TYPE_VIDEO,
4209
    CODEC_ID_MSMPEG4V1,
4210
    sizeof(MpegEncContext),
4211
    MPV_encode_init,
4212
    MPV_encode_picture,
4213
    MPV_encode_end,
4214
    .options = mpeg4_options,
4215
};
4216

    
4217
AVCodec msmpeg4v2_encoder = {
4218
    "msmpeg4v2",
4219
    CODEC_TYPE_VIDEO,
4220
    CODEC_ID_MSMPEG4V2,
4221
    sizeof(MpegEncContext),
4222
    MPV_encode_init,
4223
    MPV_encode_picture,
4224
    MPV_encode_end,
4225
    .options = mpeg4_options,
4226
};
4227

    
4228
AVCodec msmpeg4v3_encoder = {
4229
    "msmpeg4",
4230
    CODEC_TYPE_VIDEO,
4231
    CODEC_ID_MSMPEG4V3,
4232
    sizeof(MpegEncContext),
4233
    MPV_encode_init,
4234
    MPV_encode_picture,
4235
    MPV_encode_end,
4236
    .options = mpeg4_options,
4237
};
4238

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

    
4250
#endif
4251

    
4252
AVCodec mjpeg_encoder = {
4253
    "mjpeg",
4254
    CODEC_TYPE_VIDEO,
4255
    CODEC_ID_MJPEG,
4256
    sizeof(MpegEncContext),
4257
    MPV_encode_init,
4258
    MPV_encode_picture,
4259
    MPV_encode_end,
4260
};
4261

    
4262
#endif //CONFIG_ENCODERS
4263