Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 7bc9090a

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

    
721
            default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
722
            memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
723
            memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
724

    
725
            for(i=-16; i<16; i++){
726
                default_fcode_tab[i + MAX_MV]= 1;
727
            }
728
        }
729
    }
730
    s->me.mv_penalty= default_mv_penalty;
731
    s->fcode_tab= default_fcode_tab;
732
    s->y_dc_scale_table=
733
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
734
 
735
    /* dont use mv_penalty table for crap MV as it would be confused */
736
    //FIXME remove after fixing / removing old ME
737
    if (s->me_method < ME_EPZS) s->me.mv_penalty = default_mv_penalty;
738

    
739
    s->encoding = 1;
740

    
741
    /* init */
742
    if (MPV_common_init(s) < 0)
743
        return -1;
744
    
745
    ff_init_me(s);
746

    
747
#ifdef CONFIG_ENCODERS
748
#ifdef CONFIG_RISKY
749
    if (s->out_format == FMT_H263)
750
        h263_encode_init(s);
751
    if(s->msmpeg4_version)
752
        ff_msmpeg4_encode_init(s);
753
#endif
754
    if (s->out_format == FMT_MPEG1)
755
        ff_mpeg1_encode_init(s);
756
#endif
757

    
758
    /* init default q matrix */
759
    for(i=0;i<64;i++) {
760
        int j= s->dsp.idct_permutation[i];
761
#ifdef CONFIG_RISKY
762
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
763
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
764
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
765
        }else if(s->out_format == FMT_H263){
766
            s->intra_matrix[j] =
767
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
768
        }else
769
#endif
770
        { /* mpeg1 */
771
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
772
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
773
        }
774
    }
775

    
776
    /* precompute matrix */
777
    /* for mjpeg, we do include qscale in the matrix */
778
    if (s->out_format != FMT_MJPEG) {
779
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, s->q_intra_matrix16_bias, 
780
                       s->intra_matrix, s->intra_quant_bias, 1, 31);
781
        convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16, s->q_inter_matrix16_bias, 
782
                       s->inter_matrix, s->inter_quant_bias, 1, 31);
783
    }
784

    
785
    if(ff_rate_control_init(s) < 0)
786
        return -1;
787

    
788
    s->picture_number = 0;
789
    s->picture_in_gop_number = 0;
790
    s->fake_picture_number = 0;
791
    /* motion detector init */
792
    s->f_code = 1;
793
    s->b_code = 1;
794

    
795
    return 0;
796
}
797

    
798
int MPV_encode_end(AVCodecContext *avctx)
799
{
800
    MpegEncContext *s = avctx->priv_data;
801

    
802
#ifdef STATS
803
    print_stats();
804
#endif
805

    
806
    ff_rate_control_uninit(s);
807

    
808
    MPV_common_end(s);
809
    if (s->out_format == FMT_MJPEG)
810
        mjpeg_close(s);
811
      
812
    return 0;
813
}
814

    
815
#endif //CONFIG_ENCODERS
816

    
817
void init_rl(RLTable *rl)
818
{
819
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
820
    uint8_t index_run[MAX_RUN+1];
821
    int last, run, level, start, end, i;
822

    
823
    /* compute max_level[], max_run[] and index_run[] */
824
    for(last=0;last<2;last++) {
825
        if (last == 0) {
826
            start = 0;
827
            end = rl->last;
828
        } else {
829
            start = rl->last;
830
            end = rl->n;
831
        }
832

    
833
        memset(max_level, 0, MAX_RUN + 1);
834
        memset(max_run, 0, MAX_LEVEL + 1);
835
        memset(index_run, rl->n, MAX_RUN + 1);
836
        for(i=start;i<end;i++) {
837
            run = rl->table_run[i];
838
            level = rl->table_level[i];
839
            if (index_run[run] == rl->n)
840
                index_run[run] = i;
841
            if (level > max_level[run])
842
                max_level[run] = level;
843
            if (run > max_run[level])
844
                max_run[level] = run;
845
        }
846
        rl->max_level[last] = av_malloc(MAX_RUN + 1);
847
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
848
        rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
849
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
850
        rl->index_run[last] = av_malloc(MAX_RUN + 1);
851
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
852
    }
853
}
854

    
855
/* draw the edges of width 'w' of an image of size width, height */
856
//FIXME check that this is ok for mpeg4 interlaced
857
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
858
{
859
    uint8_t *ptr, *last_line;
860
    int i;
861

    
862
    last_line = buf + (height - 1) * wrap;
863
    for(i=0;i<w;i++) {
864
        /* top and bottom */
865
        memcpy(buf - (i + 1) * wrap, buf, width);
866
        memcpy(last_line + (i + 1) * wrap, last_line, width);
867
    }
868
    /* left and right */
869
    ptr = buf;
870
    for(i=0;i<height;i++) {
871
        memset(ptr - w, ptr[0], w);
872
        memset(ptr + width, ptr[width-1], w);
873
        ptr += wrap;
874
    }
875
    /* corners */
876
    for(i=0;i<w;i++) {
877
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
878
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
879
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
880
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
881
    }
882
}
883

    
884
static int find_unused_picture(MpegEncContext *s, int shared){
885
    int i;
886
    
887
    if(shared){
888
        for(i=0; i<MAX_PICTURE_COUNT; i++){
889
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) break;
890
        }
891
    }else{
892
        for(i=0; i<MAX_PICTURE_COUNT; i++){
893
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) break; //FIXME
894
        }
895
        for(i=0; i<MAX_PICTURE_COUNT; i++){
896
            if(s->picture[i].data[0]==NULL) break;
897
        }
898
    }
899

    
900
    assert(i<MAX_PICTURE_COUNT);
901
    return i;
902
}
903

    
904
/* generic function for encode/decode called before a frame is coded/decoded */
905
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
906
{
907
    int i;
908
    AVFrame *pic;
909

    
910
    s->mb_skiped = 0;
911

    
912
    assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264);
913
        
914
    /* mark&release old frames */
915
    if (s->pict_type != B_TYPE && s->last_picture_ptr) {
916
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
917

    
918
        /* release forgotten pictures */
919
        /* if(mpeg124/h263) */
920
        if(!s->encoding){
921
            for(i=0; i<MAX_PICTURE_COUNT; i++){
922
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
923
                    fprintf(stderr, "releasing zombie picture\n");
924
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
925
                }
926
            }
927
        }
928
    }
929
    
930
alloc:
931
    if(!s->encoding){
932
        i= find_unused_picture(s, 0);
933
    
934
        pic= (AVFrame*)&s->picture[i];
935
        pic->reference= s->pict_type != B_TYPE ? 3 : 0;
936

    
937
        if(s->current_picture_ptr)
938
            pic->coded_picture_number= s->current_picture_ptr->coded_picture_number+1;
939
        
940
        alloc_picture(s, (Picture*)pic, 0);
941

    
942
        s->current_picture_ptr= &s->picture[i];
943
    }
944

    
945
    s->current_picture_ptr->pict_type= s->pict_type;
946
    s->current_picture_ptr->quality= s->qscale;
947
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
948

    
949
    s->current_picture= *s->current_picture_ptr;
950
  
951
  if(s->out_format != FMT_H264){
952
    if (s->pict_type != B_TYPE) {
953
        s->last_picture_ptr= s->next_picture_ptr;
954
        s->next_picture_ptr= s->current_picture_ptr;
955
    }
956
    if(s->last_picture_ptr) s->last_picture= *s->last_picture_ptr;
957
    if(s->next_picture_ptr) s->next_picture= *s->next_picture_ptr;
958
    if(s->new_picture_ptr ) s->new_picture = *s->new_picture_ptr;
959
    
960
    if(s->picture_structure!=PICT_FRAME){
961
        int i;
962
        for(i=0; i<4; i++){
963
            if(s->picture_structure == PICT_BOTTOM_FIELD){
964
                 s->current_picture.data[i] += s->current_picture.linesize[i];
965
            } 
966
            s->current_picture.linesize[i] *= 2;
967
            s->last_picture.linesize[i] *=2;
968
            s->next_picture.linesize[i] *=2;
969
        }
970
    }
971
    
972
    if(s->pict_type != I_TYPE && s->last_picture_ptr==NULL){
973
        fprintf(stderr, "warning: first frame is no keyframe\n");
974
        assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
975
        goto alloc;
976
    }
977
  }
978
   
979
    s->hurry_up= s->avctx->hurry_up;
980
    s->error_resilience= avctx->error_resilience;
981

    
982
    /* set dequantizer, we cant do it during init as it might change for mpeg4
983
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
984
    if(s->out_format == FMT_H263){
985
        if(s->mpeg_quant)
986
            s->dct_unquantize = s->dct_unquantize_mpeg2;
987
        else
988
            s->dct_unquantize = s->dct_unquantize_h263;
989
    }else 
990
        s->dct_unquantize = s->dct_unquantize_mpeg1;
991

    
992
    return 0;
993
}
994

    
995
/* generic function for encode/decode called after a frame has been coded/decoded */
996
void MPV_frame_end(MpegEncContext *s)
997
{
998
    int i;
999
    /* draw edge for correct motion prediction if outside */
1000
    if(s->codec_id!=CODEC_ID_SVQ1){
1001
        if (s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1002
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1003
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1004
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1005
        }
1006
    }
1007
    emms_c();
1008
    
1009
    s->last_pict_type    = s->pict_type;
1010
    if(s->pict_type!=B_TYPE){
1011
        s->last_non_b_pict_type= s->pict_type;
1012
    }
1013
#if 0
1014
        /* copy back current_picture variables */
1015
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1016
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1017
            s->picture[i]= s->current_picture;
1018
            break;
1019
        }    
1020
    }
1021
    assert(i<MAX_PICTURE_COUNT);
1022
#endif    
1023

    
1024
    /* release non refernce frames */
1025
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1026
        if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/)
1027
            s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1028
    }
1029
    
1030
    // clear copies, to avoid confusion
1031
#if 0
1032
    memset(&s->last_picture, 0, sizeof(Picture));
1033
    memset(&s->next_picture, 0, sizeof(Picture));
1034
    memset(&s->current_picture, 0, sizeof(Picture));
1035
#endif
1036
}
1037

    
1038
/**
1039
 * prints debuging info for the given picture.
1040
 */
1041
void ff_print_debug_info(MpegEncContext *s, Picture *pict){
1042

    
1043
    if(!pict || !pict->mb_type) return;
1044

    
1045
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1046
        int x,y;
1047

    
1048
        for(y=0; y<s->mb_height; y++){
1049
            for(x=0; x<s->mb_width; x++){
1050
                if(s->avctx->debug&FF_DEBUG_SKIP){
1051
                    int count= s->mbskip_table[x + y*s->mb_stride];
1052
                    if(count>9) count=9;
1053
                    printf("%1d", count);
1054
                }
1055
                if(s->avctx->debug&FF_DEBUG_QP){
1056
                    printf("%2d", pict->qscale_table[x + y*s->mb_stride]);
1057
                }
1058
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1059
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
1060
                    
1061
                    //Type & MV direction
1062
                    if(IS_PCM(mb_type))
1063
                        printf("P");
1064
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1065
                        printf("A");
1066
                    else if(IS_INTRA4x4(mb_type))
1067
                        printf("i");
1068
                    else if(IS_INTRA16x16(mb_type))
1069
                        printf("I");
1070
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1071
                        printf("d");
1072
                    else if(IS_DIRECT(mb_type))
1073
                        printf("D");
1074
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1075
                        printf("g");
1076
                    else if(IS_GMC(mb_type))
1077
                        printf("G");
1078
                    else if(IS_SKIP(mb_type))
1079
                        printf("S");
1080
                    else if(!USES_LIST(mb_type, 1))
1081
                        printf(">");
1082
                    else if(!USES_LIST(mb_type, 0))
1083
                        printf("<");
1084
                    else{
1085
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1086
                        printf("X");
1087
                    }
1088
                    
1089
                    //segmentation
1090
                    if(IS_8X8(mb_type))
1091
                        printf("+");
1092
                    else if(IS_16X8(mb_type))
1093
                        printf("-");
1094
                    else if(IS_8X16(mb_type))
1095
                        printf("?");
1096
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1097
                        printf(" ");
1098
                    else
1099
                        printf("?");
1100
                    
1101
                        
1102
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1103
                        printf("=");
1104
                    else
1105
                        printf(" ");
1106
                }
1107
//                printf(" ");
1108
            }
1109
            printf("\n");
1110
        }
1111
    }
1112
}
1113

    
1114
#ifdef CONFIG_ENCODERS
1115

    
1116
static int get_sae(uint8_t *src, int ref, int stride){
1117
    int x,y;
1118
    int acc=0;
1119
    
1120
    for(y=0; y<16; y++){
1121
        for(x=0; x<16; x++){
1122
            acc+= ABS(src[x+y*stride] - ref);
1123
        }
1124
    }
1125
    
1126
    return acc;
1127
}
1128

    
1129
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1130
    int x, y, w, h;
1131
    int acc=0;
1132
    
1133
    w= s->width &~15;
1134
    h= s->height&~15;
1135
    
1136
    for(y=0; y<h; y+=16){
1137
        for(x=0; x<w; x+=16){
1138
            int offset= x + y*stride;
1139
            int sad = s->dsp.pix_abs16x16(src + offset, ref + offset, stride);
1140
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1141
            int sae = get_sae(src + offset, mean, stride);
1142
            
1143
            acc+= sae + 500 < sad;
1144
        }
1145
    }
1146
    return acc;
1147
}
1148

    
1149

    
1150
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1151
    AVFrame *pic;
1152
    int i;
1153
    const int encoding_delay= s->max_b_frames;
1154
    int direct=1;
1155

    
1156
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1157
    if(pic_arg->linesize[0] != s->linesize) direct=0;
1158
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1159
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1160
  
1161
//    printf("%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1162
    
1163
    if(direct){
1164
        i= find_unused_picture(s, 1);
1165

    
1166
        pic= (AVFrame*)&s->picture[i];
1167
        pic->reference= 3;
1168
    
1169
        for(i=0; i<4; i++){
1170
            pic->data[i]= pic_arg->data[i];
1171
            pic->linesize[i]= pic_arg->linesize[i];
1172
        }
1173
        alloc_picture(s, (Picture*)pic, 1);
1174
    }else{
1175
        i= find_unused_picture(s, 0);
1176

    
1177
        pic= (AVFrame*)&s->picture[i];
1178
        pic->reference= 3;
1179

    
1180
        alloc_picture(s, (Picture*)pic, 0);
1181
        for(i=0; i<4; i++){
1182
            /* the input will be 16 pixels to the right relative to the actual buffer start
1183
             * and the current_pic, so the buffer can be reused, yes its not beatifull 
1184
             */
1185
            pic->data[i]+= 16; 
1186
        }
1187

    
1188
        if(   pic->data[0] == pic_arg->data[0] 
1189
           && pic->data[1] == pic_arg->data[1]
1190
           && pic->data[2] == pic_arg->data[2]){
1191
       // empty
1192
        }else{
1193
            int h_chroma_shift, v_chroma_shift;
1194
        
1195
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1196
        
1197
            for(i=0; i<3; i++){
1198
                int src_stride= pic_arg->linesize[i];
1199
                int dst_stride= i ? s->uvlinesize : s->linesize;
1200
                int h_shift= i ? h_chroma_shift : 0;
1201
                int v_shift= i ? v_chroma_shift : 0;
1202
                int w= s->width >>h_shift;
1203
                int h= s->height>>v_shift;
1204
                uint8_t *src= pic_arg->data[i];
1205
                uint8_t *dst= pic->data[i];
1206
            
1207
                if(src_stride==dst_stride)
1208
                    memcpy(dst, src, src_stride*h);
1209
                else{
1210
                    while(h--){
1211
                        memcpy(dst, src, w);
1212
                        dst += dst_stride;
1213
                        src += src_stride;
1214
                    }
1215
                }
1216
            }
1217
        }
1218
    }
1219
    pic->quality= pic_arg->quality;
1220
    pic->pict_type= pic_arg->pict_type;
1221
    pic->pts = pic_arg->pts;
1222
    
1223
    if(s->input_picture[encoding_delay])
1224
        pic->display_picture_number= s->input_picture[encoding_delay]->display_picture_number + 1;
1225

    
1226
    /* shift buffer entries */
1227
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1228
        s->input_picture[i-1]= s->input_picture[i];
1229
        
1230
    s->input_picture[encoding_delay]= (Picture*)pic;
1231

    
1232
    return 0;
1233
}
1234

    
1235
static void select_input_picture(MpegEncContext *s){
1236
    int i;
1237
    const int encoding_delay= s->max_b_frames;
1238
    int coded_pic_num=0;    
1239

    
1240
    if(s->reordered_input_picture[0])
1241
        coded_pic_num= s->reordered_input_picture[0]->coded_picture_number + 1;
1242

    
1243
    for(i=1; i<MAX_PICTURE_COUNT; i++)
1244
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1245
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1246

    
1247
    /* set next picture types & ordering */
1248
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1249
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
1250
            s->reordered_input_picture[0]= s->input_picture[0];
1251
            s->reordered_input_picture[0]->pict_type= I_TYPE;
1252
            s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1253
        }else{
1254
            int b_frames;
1255
            
1256
            if(s->flags&CODEC_FLAG_PASS2){
1257
                for(i=0; i<s->max_b_frames+1; i++){
1258
                    int pict_num= s->input_picture[0]->display_picture_number + i;
1259
                    int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1260
                    s->input_picture[i]->pict_type= pict_type;
1261
                    
1262
                    if(i + 1 >= s->rc_context.num_entries) break;
1263
                }
1264
            }
1265

    
1266
            if(s->input_picture[0]->pict_type){
1267
                /* user selected pict_type */
1268
                for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
1269
                    if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
1270
                }
1271
            
1272
                if(b_frames > s->max_b_frames){
1273
                    fprintf(stderr, "warning, too many bframes in a row\n");
1274
                    b_frames = s->max_b_frames;
1275
                }
1276
            }else if(s->b_frame_strategy==0){
1277
                b_frames= s->max_b_frames;
1278
            }else if(s->b_frame_strategy==1){
1279
                for(i=1; i<s->max_b_frames+1; i++){
1280
                    if(s->input_picture[i]->b_frame_score==0){
1281
                        s->input_picture[i]->b_frame_score= 
1282
                            get_intra_count(s, s->input_picture[i  ]->data[0], 
1283
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
1284
                    }
1285
                }
1286
                for(i=0; i<s->max_b_frames; i++){
1287
                    if(s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
1288
                }
1289
                                
1290
                b_frames= FFMAX(0, i-1);
1291
                
1292
                /* reset scores */
1293
                for(i=0; i<b_frames+1; i++){
1294
                    s->input_picture[i]->b_frame_score=0;
1295
                }
1296
            }else{
1297
                fprintf(stderr, "illegal b frame strategy\n");
1298
                b_frames=0;
1299
            }
1300

    
1301
            emms_c();
1302
//static int b_count=0;
1303
//b_count+= b_frames;
1304
//printf("b_frames: %d\n", b_count);
1305
                        
1306
            s->reordered_input_picture[0]= s->input_picture[b_frames];
1307
            if(   s->picture_in_gop_number + b_frames >= s->gop_size 
1308
               || s->reordered_input_picture[0]->pict_type== I_TYPE)
1309
                s->reordered_input_picture[0]->pict_type= I_TYPE;
1310
            else
1311
                s->reordered_input_picture[0]->pict_type= P_TYPE;
1312
            s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1313
            for(i=0; i<b_frames; i++){
1314
                coded_pic_num++;
1315
                s->reordered_input_picture[i+1]= s->input_picture[i];
1316
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
1317
                s->reordered_input_picture[i+1]->coded_picture_number= coded_pic_num;
1318
            }
1319
        }
1320
    }
1321
    
1322
    if(s->reordered_input_picture[0]){
1323
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
1324

    
1325
        s->new_picture= *s->reordered_input_picture[0];
1326

    
1327
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
1328
            // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
1329
        
1330
            int i= find_unused_picture(s, 0);
1331
            Picture *pic= &s->picture[i];
1332

    
1333
            /* mark us unused / free shared pic */
1334
            for(i=0; i<4; i++)
1335
                s->reordered_input_picture[0]->data[i]= NULL;
1336
            s->reordered_input_picture[0]->type= 0;
1337
            
1338
            //FIXME bad, copy * except
1339
            pic->pict_type = s->reordered_input_picture[0]->pict_type;
1340
            pic->quality   = s->reordered_input_picture[0]->quality;
1341
            pic->coded_picture_number = s->reordered_input_picture[0]->coded_picture_number;
1342
            pic->reference = s->reordered_input_picture[0]->reference;
1343
            
1344
            alloc_picture(s, pic, 0);
1345

    
1346
            s->current_picture_ptr= pic;
1347
        }else{
1348
            // input is not a shared pix -> reuse buffer for current_pix
1349

    
1350
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
1351
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
1352
            
1353
            s->current_picture_ptr= s->reordered_input_picture[0];
1354
            for(i=0; i<4; i++){
1355
                //reverse the +16 we did before storing the input
1356
                s->current_picture_ptr->data[i]-=16;
1357
            }
1358
        }
1359
        s->current_picture= *s->current_picture_ptr;
1360
    
1361
        s->picture_number= s->new_picture.display_picture_number;
1362
//printf("dpn:%d\n", s->picture_number);
1363
    }else{
1364
       memset(&s->new_picture, 0, sizeof(Picture));
1365
    }
1366
}
1367

    
1368
int MPV_encode_picture(AVCodecContext *avctx,
1369
                       unsigned char *buf, int buf_size, void *data)
1370
{
1371
    MpegEncContext *s = avctx->priv_data;
1372
    AVFrame *pic_arg = data;
1373
    int i;
1374

    
1375
    init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
1376

    
1377
    s->picture_in_gop_number++;
1378

    
1379
    load_input_picture(s, pic_arg);
1380
    
1381
    select_input_picture(s);
1382
    
1383
    /* output? */
1384
    if(s->new_picture.data[0]){
1385

    
1386
        s->pict_type= s->new_picture.pict_type;
1387
        if (s->fixed_qscale){ /* the ratecontrol needs the last qscale so we dont touch it for CBR */
1388
            s->qscale= (int)(s->new_picture.quality+0.5);
1389
            assert(s->qscale);
1390
        }
1391
//emms_c();
1392
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
1393
        MPV_frame_start(s, avctx);
1394

    
1395
        encode_picture(s, s->picture_number);
1396
        
1397
        avctx->real_pict_num  = s->picture_number;
1398
        avctx->header_bits = s->header_bits;
1399
        avctx->mv_bits     = s->mv_bits;
1400
        avctx->misc_bits   = s->misc_bits;
1401
        avctx->i_tex_bits  = s->i_tex_bits;
1402
        avctx->p_tex_bits  = s->p_tex_bits;
1403
        avctx->i_count     = s->i_count;
1404
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
1405
        avctx->skip_count  = s->skip_count;
1406

    
1407
        MPV_frame_end(s);
1408

    
1409
        if (s->out_format == FMT_MJPEG)
1410
            mjpeg_picture_trailer(s);
1411
        
1412
        if(s->flags&CODEC_FLAG_PASS1)
1413
            ff_write_pass1_stats(s);
1414

    
1415
        for(i=0; i<4; i++){
1416
            avctx->error[i] += s->current_picture_ptr->error[i];
1417
        }
1418
    }
1419

    
1420
    s->input_picture_number++;
1421

    
1422
    flush_put_bits(&s->pb);
1423
    s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1424
    
1425
    s->total_bits += s->frame_bits;
1426
    avctx->frame_bits  = s->frame_bits;
1427
    
1428
    return pbBufPtr(&s->pb) - s->pb.buf;
1429
}
1430

    
1431
#endif //CONFIG_ENCODERS
1432

    
1433
static inline void gmc1_motion(MpegEncContext *s,
1434
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1435
                               int dest_offset,
1436
                               uint8_t **ref_picture, int src_offset)
1437
{
1438
    uint8_t *ptr;
1439
    int offset, src_x, src_y, linesize, uvlinesize;
1440
    int motion_x, motion_y;
1441
    int emu=0;
1442

    
1443
    motion_x= s->sprite_offset[0][0];
1444
    motion_y= s->sprite_offset[0][1];
1445
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1446
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1447
    motion_x<<=(3-s->sprite_warping_accuracy);
1448
    motion_y<<=(3-s->sprite_warping_accuracy);
1449
    src_x = clip(src_x, -16, s->width);
1450
    if (src_x == s->width)
1451
        motion_x =0;
1452
    src_y = clip(src_y, -16, s->height);
1453
    if (src_y == s->height)
1454
        motion_y =0;
1455

    
1456
    linesize = s->linesize;
1457
    uvlinesize = s->uvlinesize;
1458
    
1459
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1460

    
1461
    dest_y+=dest_offset;
1462
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1463
        if(src_x<0 || src_y<0 || src_x + 17 >= s->h_edge_pos
1464
                              || src_y + 17 >= s->v_edge_pos){
1465
            ff_emulated_edge_mc(s, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1466
            ptr= s->edge_emu_buffer;
1467
        }
1468
    }
1469
    
1470
    if((motion_x|motion_y)&7){
1471
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1472
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1473
    }else{
1474
        int dxy;
1475
        
1476
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
1477
        if (s->no_rounding){
1478
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
1479
        }else{
1480
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
1481
        }
1482
    }
1483
    
1484
    if(s->flags&CODEC_FLAG_GRAY) return;
1485

    
1486
    motion_x= s->sprite_offset[1][0];
1487
    motion_y= s->sprite_offset[1][1];
1488
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
1489
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
1490
    motion_x<<=(3-s->sprite_warping_accuracy);
1491
    motion_y<<=(3-s->sprite_warping_accuracy);
1492
    src_x = clip(src_x, -8, s->width>>1);
1493
    if (src_x == s->width>>1)
1494
        motion_x =0;
1495
    src_y = clip(src_y, -8, s->height>>1);
1496
    if (src_y == s->height>>1)
1497
        motion_y =0;
1498

    
1499
    offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
1500
    ptr = ref_picture[1] + offset;
1501
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1502
        if(src_x<0 || src_y<0 || src_x + 9 >= s->h_edge_pos>>1
1503
                              || src_y + 9 >= s->v_edge_pos>>1){
1504
            ff_emulated_edge_mc(s, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1505
            ptr= s->edge_emu_buffer;
1506
            emu=1;
1507
        }
1508
    }
1509
    s->dsp.gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1510
    
1511
    ptr = ref_picture[2] + offset;
1512
    if(emu){
1513
        ff_emulated_edge_mc(s, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1514
        ptr= s->edge_emu_buffer;
1515
    }
1516
    s->dsp.gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1517
    
1518
    return;
1519
}
1520

    
1521
static inline void gmc_motion(MpegEncContext *s,
1522
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1523
                               int dest_offset,
1524
                               uint8_t **ref_picture, int src_offset)
1525
{
1526
    uint8_t *ptr;
1527
    int linesize, uvlinesize;
1528
    const int a= s->sprite_warping_accuracy;
1529
    int ox, oy;
1530

    
1531
    linesize = s->linesize;
1532
    uvlinesize = s->uvlinesize;
1533

    
1534
    ptr = ref_picture[0] + src_offset;
1535

    
1536
    dest_y+=dest_offset;
1537
    
1538
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
1539
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
1540

    
1541
    s->dsp.gmc(dest_y, ptr, linesize, 16,
1542
           ox, 
1543
           oy, 
1544
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1545
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1546
           a+1, (1<<(2*a+1)) - s->no_rounding,
1547
           s->h_edge_pos, s->v_edge_pos);
1548
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
1549
           ox + s->sprite_delta[0][0]*8, 
1550
           oy + s->sprite_delta[1][0]*8, 
1551
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1552
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1553
           a+1, (1<<(2*a+1)) - s->no_rounding,
1554
           s->h_edge_pos, s->v_edge_pos);
1555

    
1556
    if(s->flags&CODEC_FLAG_GRAY) return;
1557

    
1558

    
1559
    dest_cb+=dest_offset>>1;
1560
    dest_cr+=dest_offset>>1;
1561
    
1562
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
1563
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
1564

    
1565
    ptr = ref_picture[1] + (src_offset>>1);
1566
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
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>>1, s->v_edge_pos>>1);
1573
    
1574
    ptr = ref_picture[2] + (src_offset>>1);
1575
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
1576
           ox, 
1577
           oy, 
1578
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1579
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1580
           a+1, (1<<(2*a+1)) - s->no_rounding,
1581
           s->h_edge_pos>>1, s->v_edge_pos>>1);
1582
}
1583

    
1584

    
1585
void ff_emulated_edge_mc(MpegEncContext *s, uint8_t *src, int linesize, int block_w, int block_h, 
1586
                                    int src_x, int src_y, int w, int h){
1587
    int x, y;
1588
    int start_y, start_x, end_y, end_x;
1589
    uint8_t *buf= s->edge_emu_buffer;
1590

    
1591
    if(src_y>= h){
1592
        src+= (h-1-src_y)*linesize;
1593
        src_y=h-1;
1594
    }else if(src_y<=-block_h){
1595
        src+= (1-block_h-src_y)*linesize;
1596
        src_y=1-block_h;
1597
    }
1598
    if(src_x>= w){
1599
        src+= (w-1-src_x);
1600
        src_x=w-1;
1601
    }else if(src_x<=-block_w){
1602
        src+= (1-block_w-src_x);
1603
        src_x=1-block_w;
1604
    }
1605

    
1606
    start_y= FFMAX(0, -src_y);
1607
    start_x= FFMAX(0, -src_x);
1608
    end_y= FFMIN(block_h, h-src_y);
1609
    end_x= FFMIN(block_w, w-src_x);
1610

    
1611
    // copy existing part
1612
    for(y=start_y; y<end_y; y++){
1613
        for(x=start_x; x<end_x; x++){
1614
            buf[x + y*linesize]= src[x + y*linesize];
1615
        }
1616
    }
1617

    
1618
    //top
1619
    for(y=0; y<start_y; y++){
1620
        for(x=start_x; x<end_x; x++){
1621
            buf[x + y*linesize]= buf[x + start_y*linesize];
1622
        }
1623
    }
1624

    
1625
    //bottom
1626
    for(y=end_y; y<block_h; y++){
1627
        for(x=start_x; x<end_x; x++){
1628
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1629
        }
1630
    }
1631
                                    
1632
    for(y=0; y<block_h; y++){
1633
       //left
1634
        for(x=0; x<start_x; x++){
1635
            buf[x + y*linesize]= buf[start_x + y*linesize];
1636
        }
1637
       
1638
       //right
1639
        for(x=end_x; x<block_w; x++){
1640
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1641
        }
1642
    }
1643
}
1644

    
1645

    
1646
/* apply one mpeg motion vector to the three components */
1647
static inline void mpeg_motion(MpegEncContext *s,
1648
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1649
                               int dest_offset,
1650
                               uint8_t **ref_picture, int src_offset,
1651
                               int field_based, op_pixels_func (*pix_op)[4],
1652
                               int motion_x, int motion_y, int h)
1653
{
1654
    uint8_t *ptr;
1655
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1656
    int emu=0;
1657
#if 0    
1658
if(s->quarter_sample)
1659
{
1660
    motion_x>>=1;
1661
    motion_y>>=1;
1662
}
1663
#endif
1664
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1665
    src_x = s->mb_x * 16 + (motion_x >> 1);
1666
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 1);
1667
                
1668
    /* WARNING: do no forget half pels */
1669
    height = s->height >> field_based;
1670
    v_edge_pos = s->v_edge_pos >> field_based;
1671
    src_x = clip(src_x, -16, s->width);
1672
    if (src_x == s->width)
1673
        dxy &= ~1;
1674
    src_y = clip(src_y, -16, height);
1675
    if (src_y == height)
1676
        dxy &= ~2;
1677
    linesize   = s->current_picture.linesize[0] << field_based;
1678
    uvlinesize = s->current_picture.linesize[1] << field_based;
1679
    ptr = ref_picture[0] + (src_y * linesize) + (src_x) + src_offset;
1680
    dest_y += dest_offset;
1681

    
1682
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1683
        if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 16 > s->h_edge_pos
1684
                              || src_y + (motion_y&1) + h  > v_edge_pos){
1685
            ff_emulated_edge_mc(s, ptr - src_offset, s->linesize, 17, 17+field_based,  //FIXME linesize? and uv below
1686
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1687
            ptr= s->edge_emu_buffer + src_offset;
1688
            emu=1;
1689
        }
1690
    }
1691
    pix_op[0][dxy](dest_y, ptr, linesize, h);
1692

    
1693
    if(s->flags&CODEC_FLAG_GRAY) return;
1694

    
1695
    if (s->out_format == FMT_H263) {
1696
        dxy = 0;
1697
        if ((motion_x & 3) != 0)
1698
            dxy |= 1;
1699
        if ((motion_y & 3) != 0)
1700
            dxy |= 2;
1701
        mx = motion_x >> 2;
1702
        my = motion_y >> 2;
1703
    } else {
1704
        mx = motion_x / 2;
1705
        my = motion_y / 2;
1706
        dxy = ((my & 1) << 1) | (mx & 1);
1707
        mx >>= 1;
1708
        my >>= 1;
1709
    }
1710
    
1711
    src_x = s->mb_x * 8 + mx;
1712
    src_y = s->mb_y * (8 >> field_based) + my;
1713
    src_x = clip(src_x, -8, s->width >> 1);
1714
    if (src_x == (s->width >> 1))
1715
        dxy &= ~1;
1716
    src_y = clip(src_y, -8, height >> 1);
1717
    if (src_y == (height >> 1))
1718
        dxy &= ~2;
1719
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1720
    ptr = ref_picture[1] + offset;
1721
    if(emu){
1722
        ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
1723
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1724
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1725
    }
1726
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1727

    
1728
    ptr = ref_picture[2] + offset;
1729
    if(emu){
1730
        ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
1731
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1732
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1733
    }
1734
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1735
}
1736

    
1737
static inline void qpel_motion(MpegEncContext *s,
1738
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1739
                               int dest_offset,
1740
                               uint8_t **ref_picture, int src_offset,
1741
                               int field_based, op_pixels_func (*pix_op)[4],
1742
                               qpel_mc_func (*qpix_op)[16],
1743
                               int motion_x, int motion_y, int h)
1744
{
1745
    uint8_t *ptr;
1746
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1747
    int emu=0;
1748

    
1749
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1750
    src_x = s->mb_x * 16 + (motion_x >> 2);
1751
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
1752

    
1753
    height = s->height >> field_based;
1754
    v_edge_pos = s->v_edge_pos >> field_based;
1755
    src_x = clip(src_x, -16, s->width);
1756
    if (src_x == s->width)
1757
        dxy &= ~3;
1758
    src_y = clip(src_y, -16, height);
1759
    if (src_y == height)
1760
        dxy &= ~12;
1761
    linesize = s->linesize << field_based;
1762
    uvlinesize = s->uvlinesize << field_based;
1763
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1764
    dest_y += dest_offset;
1765
//printf("%d %d %d\n", src_x, src_y, dxy);
1766
    
1767
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1768
        if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 16 > s->h_edge_pos
1769
                              || src_y + (motion_y&3) + h  > v_edge_pos){
1770
            ff_emulated_edge_mc(s, ptr - src_offset, s->linesize, 17, 17+field_based, 
1771
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1772
            ptr= s->edge_emu_buffer + src_offset;
1773
            emu=1;
1774
        }
1775
    }
1776
    if(!field_based)
1777
        qpix_op[0][dxy](dest_y, ptr, linesize);
1778
    else{
1779
        //damn interlaced mode
1780
        //FIXME boundary mirroring is not exactly correct here
1781
        qpix_op[1][dxy](dest_y  , ptr  , linesize);
1782
        qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
1783
    }
1784

    
1785
    if(s->flags&CODEC_FLAG_GRAY) return;
1786

    
1787
    if(field_based){
1788
        mx= motion_x/2;
1789
        my= motion_y>>1;
1790
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
1791
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
1792
        mx= (motion_x>>1) + rtab[motion_x&7];
1793
        my= (motion_y>>1) + rtab[motion_y&7];
1794
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
1795
        mx= (motion_x>>1)|(motion_x&1);
1796
        my= (motion_y>>1)|(motion_y&1);
1797
    }else{
1798
        mx= motion_x/2;
1799
        my= motion_y/2;
1800
    }
1801
    mx= (mx>>1)|(mx&1);
1802
    my= (my>>1)|(my&1);
1803

    
1804
    dxy= (mx&1) | ((my&1)<<1);
1805
    mx>>=1;
1806
    my>>=1;
1807

    
1808
    src_x = s->mb_x * 8 + mx;
1809
    src_y = s->mb_y * (8 >> field_based) + my;
1810
    src_x = clip(src_x, -8, s->width >> 1);
1811
    if (src_x == (s->width >> 1))
1812
        dxy &= ~1;
1813
    src_y = clip(src_y, -8, height >> 1);
1814
    if (src_y == (height >> 1))
1815
        dxy &= ~2;
1816

    
1817
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1818
    ptr = ref_picture[1] + offset;
1819
    if(emu){
1820
        ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
1821
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1822
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1823
    }
1824
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1825
    
1826
    ptr = ref_picture[2] + offset;
1827
    if(emu){
1828
        ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
1829
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1830
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1831
    }
1832
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1833
}
1834

    
1835
inline int ff_h263_round_chroma(int x){
1836
    if (x >= 0)
1837
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
1838
    else {
1839
        x = -x;
1840
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
1841
    }
1842
}
1843

    
1844
static inline void MPV_motion(MpegEncContext *s, 
1845
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1846
                              int dir, uint8_t **ref_picture, 
1847
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
1848
{
1849
    int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
1850
    int mb_x, mb_y, i;
1851
    uint8_t *ptr, *dest;
1852
    int emu=0;
1853

    
1854
    mb_x = s->mb_x;
1855
    mb_y = s->mb_y;
1856

    
1857
    switch(s->mv_type) {
1858
    case MV_TYPE_16X16:
1859
#ifdef CONFIG_RISKY
1860
        if(s->mcsel){
1861
            if(s->real_sprite_warping_points==1){
1862
                gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
1863
                            ref_picture, 0);
1864
            }else{
1865
                gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
1866
                            ref_picture, 0);
1867
            }
1868
        }else if(s->quarter_sample){
1869
            qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1870
                        ref_picture, 0,
1871
                        0, pix_op, qpix_op,
1872
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1873
        }else if(s->mspel){
1874
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
1875
                        ref_picture, pix_op,
1876
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1877
        }else
1878
#endif
1879
        {
1880
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1881
                        ref_picture, 0,
1882
                        0, pix_op,
1883
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1884
        }           
1885
        break;
1886
    case MV_TYPE_8X8:
1887
        mx = 0;
1888
        my = 0;
1889
        if(s->quarter_sample){
1890
            for(i=0;i<4;i++) {
1891
                motion_x = s->mv[dir][i][0];
1892
                motion_y = s->mv[dir][i][1];
1893

    
1894
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1895
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
1896
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
1897
                    
1898
                /* WARNING: do no forget half pels */
1899
                src_x = clip(src_x, -16, s->width);
1900
                if (src_x == s->width)
1901
                    dxy &= ~3;
1902
                src_y = clip(src_y, -16, s->height);
1903
                if (src_y == s->height)
1904
                    dxy &= ~12;
1905
                    
1906
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1907
                if(s->flags&CODEC_FLAG_EMU_EDGE){
1908
                    if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 8 > s->h_edge_pos
1909
                                          || src_y + (motion_y&3) + 8 > s->v_edge_pos){
1910
                        ff_emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1911
                        ptr= s->edge_emu_buffer;
1912
                    }
1913
                }
1914
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1915
                qpix_op[1][dxy](dest, ptr, s->linesize);
1916

    
1917
                mx += s->mv[dir][i][0]/2;
1918
                my += s->mv[dir][i][1]/2;
1919
            }
1920
        }else{
1921
            for(i=0;i<4;i++) {
1922
                motion_x = s->mv[dir][i][0];
1923
                motion_y = s->mv[dir][i][1];
1924

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

    
1948
                mx += s->mv[dir][i][0];
1949
                my += s->mv[dir][i][1];
1950
            }
1951
        }
1952

    
1953
        if(s->flags&CODEC_FLAG_GRAY) break;
1954
        /* In case of 8X8, we construct a single chroma motion vector
1955
           with a special rounding */
1956
        mx= ff_h263_round_chroma(mx);
1957
        my= ff_h263_round_chroma(my);
1958
        dxy = ((my & 1) << 1) | (mx & 1);
1959
        mx >>= 1;
1960
        my >>= 1;
1961

    
1962
        src_x = mb_x * 8 + mx;
1963
        src_y = mb_y * 8 + my;
1964
        src_x = clip(src_x, -8, s->width/2);
1965
        if (src_x == s->width/2)
1966
            dxy &= ~1;
1967
        src_y = clip(src_y, -8, s->height/2);
1968
        if (src_y == s->height/2)
1969
            dxy &= ~2;
1970
        
1971
        offset = (src_y * (s->uvlinesize)) + src_x;
1972
        ptr = ref_picture[1] + offset;
1973
        if(s->flags&CODEC_FLAG_EMU_EDGE){
1974
                if(src_x<0 || src_y<0 || src_x + (dxy &1) + 8 > s->h_edge_pos>>1
1975
                                      || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
1976
                    ff_emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1977
                    ptr= s->edge_emu_buffer;
1978
                    emu=1;
1979
                }
1980
            }
1981
        pix_op[1][dxy](dest_cb, ptr, s->uvlinesize, 8);
1982

    
1983
        ptr = ref_picture[2] + offset;
1984
        if(emu){
1985
            ff_emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1986
            ptr= s->edge_emu_buffer;
1987
        }
1988
        pix_op[1][dxy](dest_cr, ptr, s->uvlinesize, 8);
1989
        break;
1990
    case MV_TYPE_FIELD:
1991
        if (s->picture_structure == PICT_FRAME) {
1992
            if(s->quarter_sample){
1993
                /* top field */
1994
                qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1995
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
1996
                            1, pix_op, qpix_op,
1997
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
1998
                /* bottom field */
1999
                qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2000
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2001
                            1, pix_op, qpix_op,
2002
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
2003
            }else{
2004
                /* top field */       
2005
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2006
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2007
                            1, pix_op,
2008
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
2009
                /* bottom field */
2010
                mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2011
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2012
                            1, pix_op,
2013
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
2014
            }
2015
        } else {
2016
            int offset;
2017
            if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2018
                offset= s->field_select[dir][0] ? s->linesize : 0;
2019
            }else{
2020
                ref_picture= s->current_picture.data;
2021
                offset= s->field_select[dir][0] ? s->linesize : -s->linesize; 
2022
            } 
2023

    
2024
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2025
                        ref_picture, offset,
2026
                        0, pix_op,
2027
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2028
        }
2029
        break;
2030
    }
2031
}
2032

    
2033

    
2034
/* put block[] to dest[] */
2035
static inline void put_dct(MpegEncContext *s, 
2036
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
2037
{
2038
    s->dct_unquantize(s, block, i, s->qscale);
2039
    s->dsp.idct_put (dest, line_size, block);
2040
}
2041

    
2042
/* add block[] to dest[] */
2043
static inline void add_dct(MpegEncContext *s, 
2044
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
2045
{
2046
    if (s->block_last_index[i] >= 0) {
2047
        s->dsp.idct_add (dest, line_size, block);
2048
    }
2049
}
2050

    
2051
static inline void add_dequant_dct(MpegEncContext *s, 
2052
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
2053
{
2054
    if (s->block_last_index[i] >= 0) {
2055
        s->dct_unquantize(s, block, i, s->qscale);
2056

    
2057
        s->dsp.idct_add (dest, line_size, block);
2058
    }
2059
}
2060

    
2061
/**
2062
 * cleans dc, ac, coded_block for the current non intra MB
2063
 */
2064
void ff_clean_intra_table_entries(MpegEncContext *s)
2065
{
2066
    int wrap = s->block_wrap[0];
2067
    int xy = s->block_index[0];
2068
    
2069
    s->dc_val[0][xy           ] = 
2070
    s->dc_val[0][xy + 1       ] = 
2071
    s->dc_val[0][xy     + wrap] =
2072
    s->dc_val[0][xy + 1 + wrap] = 1024;
2073
    /* ac pred */
2074
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2075
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2076
    if (s->msmpeg4_version>=3) {
2077
        s->coded_block[xy           ] =
2078
        s->coded_block[xy + 1       ] =
2079
        s->coded_block[xy     + wrap] =
2080
        s->coded_block[xy + 1 + wrap] = 0;
2081
    }
2082
    /* chroma */
2083
    wrap = s->block_wrap[4];
2084
    xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
2085
    s->dc_val[1][xy] =
2086
    s->dc_val[2][xy] = 1024;
2087
    /* ac pred */
2088
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2089
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2090
    
2091
    s->mbintra_table[s->mb_x + s->mb_y*s->mb_stride]= 0;
2092
}
2093

    
2094
/* generic function called after a macroblock has been parsed by the
2095
   decoder or after it has been encoded by the encoder.
2096

2097
   Important variables used:
2098
   s->mb_intra : true if intra macroblock
2099
   s->mv_dir   : motion vector direction
2100
   s->mv_type  : motion vector type
2101
   s->mv       : motion vector
2102
   s->interlaced_dct : true if interlaced dct used (mpeg2)
2103
 */
2104
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
2105
{
2106
    int mb_x, mb_y;
2107
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2108

    
2109
    mb_x = s->mb_x;
2110
    mb_y = s->mb_y;
2111

    
2112
    s->current_picture.qscale_table[mb_xy]= s->qscale;
2113

    
2114
    /* update DC predictors for P macroblocks */
2115
    if (!s->mb_intra) {
2116
        if (s->h263_pred || s->h263_aic) {
2117
            if(s->mbintra_table[mb_xy])
2118
                ff_clean_intra_table_entries(s);
2119
        } else {
2120
            s->last_dc[0] =
2121
            s->last_dc[1] =
2122
            s->last_dc[2] = 128 << s->intra_dc_precision;
2123
        }
2124
    }
2125
    else if (s->h263_pred || s->h263_aic)
2126
        s->mbintra_table[mb_xy]=1;
2127

    
2128
    /* update motion predictor, not for B-frames as they need the motion_val from the last P/S-Frame */
2129
    if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) { //FIXME move into h263.c if possible, format specific stuff shouldnt be here
2130
        //FIXME a lot of thet is only needed for !low_delay
2131
        const int wrap = s->block_wrap[0];
2132
        const int xy = s->block_index[0];
2133
        if(s->mv_type != MV_TYPE_8X8){
2134
            int motion_x, motion_y;
2135
            if (s->mb_intra) {
2136
                motion_x = 0;
2137
                motion_y = 0;
2138
            } else if (s->mv_type == MV_TYPE_16X16) {
2139
                motion_x = s->mv[0][0][0];
2140
                motion_y = s->mv[0][0][1];
2141
            } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
2142
                int i;
2143
                motion_x = s->mv[0][0][0] + s->mv[0][1][0];
2144
                motion_y = s->mv[0][0][1] + s->mv[0][1][1];
2145
                motion_x = (motion_x>>1) | (motion_x&1);
2146
                for(i=0; i<2; i++){
2147
                    s->field_mv_table[mb_xy][i][0]= s->mv[0][i][0];
2148
                    s->field_mv_table[mb_xy][i][1]= s->mv[0][i][1];
2149
                    s->field_select_table[mb_xy][i]= s->field_select[0][i];
2150
                }
2151
            }
2152
            
2153
            /* no update if 8X8 because it has been done during parsing */
2154
            s->motion_val[xy][0] = motion_x;
2155
            s->motion_val[xy][1] = motion_y;
2156
            s->motion_val[xy + 1][0] = motion_x;
2157
            s->motion_val[xy + 1][1] = motion_y;
2158
            s->motion_val[xy + wrap][0] = motion_x;
2159
            s->motion_val[xy + wrap][1] = motion_y;
2160
            s->motion_val[xy + 1 + wrap][0] = motion_x;
2161
            s->motion_val[xy + 1 + wrap][1] = motion_y;
2162
        }
2163

    
2164
        if(s->encoding){ //FIXME encoding MUST be cleaned up
2165
            if (s->mv_type == MV_TYPE_8X8) 
2166
                s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
2167
            else
2168
                s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
2169
        }
2170
    }
2171
    
2172
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
2173
        uint8_t *dest_y, *dest_cb, *dest_cr;
2174
        int dct_linesize, dct_offset;
2175
        op_pixels_func (*op_pix)[4];
2176
        qpel_mc_func (*op_qpix)[16];
2177
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
2178
        const int uvlinesize= s->current_picture.linesize[1];
2179

    
2180
        /* avoid copy if macroblock skipped in last frame too */
2181
        if (s->pict_type != B_TYPE) {
2182
            s->current_picture.mbskip_table[mb_xy]= s->mb_skiped;
2183
        }
2184

    
2185
        /* skip only during decoding as we might trash the buffers during encoding a bit */
2186
        if(!s->encoding){
2187
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2188
            const int age= s->current_picture.age;
2189

    
2190
            assert(age);
2191

    
2192
            if (s->mb_skiped) {
2193
                s->mb_skiped= 0;
2194
                assert(s->pict_type!=I_TYPE);
2195
 
2196
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
2197
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2198

    
2199
                /* if previous was skipped too, then nothing to do !  */
2200
                if (*mbskip_ptr >= age && s->current_picture.reference){
2201
                    return;
2202
                }
2203
            } else if(!s->current_picture.reference){
2204
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2205
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2206
            } else{
2207
                *mbskip_ptr = 0; /* not skipped */
2208
            }
2209
        }else
2210
            s->mb_skiped= 0;
2211

    
2212
        if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){ //FIXME precalc
2213
            dest_y  = s->current_picture.data[0] + mb_x * 16;
2214
            dest_cb = s->current_picture.data[1] + mb_x * 8;
2215
            dest_cr = s->current_picture.data[2] + mb_x * 8;
2216
        }else{
2217
            dest_y  = s->current_picture.data[0] + (mb_y * 16* linesize  ) + mb_x * 16;
2218
            dest_cb = s->current_picture.data[1] + (mb_y * 8 * uvlinesize) + mb_x * 8;
2219
            dest_cr = s->current_picture.data[2] + (mb_y * 8 * uvlinesize) + mb_x * 8;
2220
        }
2221

    
2222
        if (s->interlaced_dct) {
2223
            dct_linesize = linesize * 2;
2224
            dct_offset = linesize;
2225
        } else {
2226
            dct_linesize = linesize;
2227
            dct_offset = linesize * 8;
2228
        }
2229

    
2230
        if (!s->mb_intra) {
2231
            /* motion handling */
2232
            /* decoding or more than one mb_type (MC was allready done otherwise) */
2233
            if((!s->encoding) || (s->mb_type[mb_xy]&(s->mb_type[mb_xy]-1))){
2234
                if ((!s->no_rounding) || s->pict_type==B_TYPE){                
2235
                    op_pix = s->dsp.put_pixels_tab;
2236
                    op_qpix= s->dsp.put_qpel_pixels_tab;
2237
                }else{
2238
                    op_pix = s->dsp.put_no_rnd_pixels_tab;
2239
                    op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2240
                }
2241

    
2242
                if (s->mv_dir & MV_DIR_FORWARD) {
2243
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2244
                    op_pix = s->dsp.avg_pixels_tab;
2245
                    op_qpix= s->dsp.avg_qpel_pixels_tab;
2246
                }
2247
                if (s->mv_dir & MV_DIR_BACKWARD) {
2248
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2249
                }
2250
            }
2251

    
2252
            /* skip dequant / idct if we are really late ;) */
2253
            if(s->hurry_up>1) return;
2254

    
2255
            /* add dct residue */
2256
            if(s->encoding || !(   s->mpeg2 || s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO 
2257
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2258
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
2259
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2260
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2261
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2262

    
2263
                if(!(s->flags&CODEC_FLAG_GRAY)){
2264
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize);
2265
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize);
2266
                }
2267
            } else if(s->codec_id != CODEC_ID_WMV2){
2268
                add_dct(s, block[0], 0, dest_y, dct_linesize);
2269
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2270
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2271
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2272

    
2273
                if(!(s->flags&CODEC_FLAG_GRAY)){
2274
                    add_dct(s, block[4], 4, dest_cb, uvlinesize);
2275
                    add_dct(s, block[5], 5, dest_cr, uvlinesize);
2276
                }
2277
            } 
2278
#ifdef CONFIG_RISKY
2279
            else{
2280
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2281
            }
2282
#endif
2283
        } else {
2284
            /* dct only in intra block */
2285
            if(s->encoding || !(s->mpeg2 || s->codec_id==CODEC_ID_MPEG1VIDEO)){
2286
                put_dct(s, block[0], 0, dest_y, dct_linesize);
2287
                put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2288
                put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2289
                put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2290

    
2291
                if(!(s->flags&CODEC_FLAG_GRAY)){
2292
                    put_dct(s, block[4], 4, dest_cb, uvlinesize);
2293
                    put_dct(s, block[5], 5, dest_cr, uvlinesize);
2294
                }
2295
            }else{
2296
                s->dsp.idct_put(dest_y                 , dct_linesize, block[0]);
2297
                s->dsp.idct_put(dest_y              + 8, dct_linesize, block[1]);
2298
                s->dsp.idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
2299
                s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
2300

    
2301
                if(!(s->flags&CODEC_FLAG_GRAY)){
2302
                    s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2303
                    s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2304
                }
2305
            }
2306
        }
2307
    }
2308
}
2309

    
2310
#ifdef CONFIG_ENCODERS
2311

    
2312
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
2313
{
2314
    static const char tab[64]=
2315
        {3,2,2,1,1,1,1,1,
2316
         1,1,1,1,1,1,1,1,
2317
         1,1,1,1,1,1,1,1,
2318
         0,0,0,0,0,0,0,0,
2319
         0,0,0,0,0,0,0,0,
2320
         0,0,0,0,0,0,0,0,
2321
         0,0,0,0,0,0,0,0,
2322
         0,0,0,0,0,0,0,0};
2323
    int score=0;
2324
    int run=0;
2325
    int i;
2326
    DCTELEM *block= s->block[n];
2327
    const int last_index= s->block_last_index[n];
2328
    int skip_dc;
2329

    
2330
    if(threshold<0){
2331
        skip_dc=0;
2332
        threshold= -threshold;
2333
    }else
2334
        skip_dc=1;
2335

    
2336
    /* are all which we could set to zero are allready zero? */
2337
    if(last_index<=skip_dc - 1) return;
2338

    
2339
    for(i=0; i<=last_index; i++){
2340
        const int j = s->intra_scantable.permutated[i];
2341
        const int level = ABS(block[j]);
2342
        if(level==1){
2343
            if(skip_dc && i==0) continue;
2344
            score+= tab[run];
2345
            run=0;
2346
        }else if(level>1){
2347
            return;
2348
        }else{
2349
            run++;
2350
        }
2351
    }
2352
    if(score >= threshold) return;
2353
    for(i=skip_dc; i<=last_index; i++){
2354
        const int j = s->intra_scantable.permutated[i];
2355
        block[j]=0;
2356
    }
2357
    if(block[0]) s->block_last_index[n]= 0;
2358
    else         s->block_last_index[n]= -1;
2359
}
2360

    
2361
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
2362
{
2363
    int i;
2364
    const int maxlevel= s->max_qcoeff;
2365
    const int minlevel= s->min_qcoeff;
2366
    
2367
    if(s->mb_intra){
2368
        i=1; //skip clipping of intra dc
2369
    }else
2370
        i=0;
2371
    
2372
    for(;i<=last_index; i++){
2373
        const int j= s->intra_scantable.permutated[i];
2374
        int level = block[j];
2375
       
2376
        if     (level>maxlevel) level=maxlevel;
2377
        else if(level<minlevel) level=minlevel;
2378

    
2379
        block[j]= level;
2380
    }
2381
}
2382

    
2383
#if 0
2384
static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
2385
    int score=0;
2386
    int x,y;
2387
    
2388
    for(y=0; y<7; y++){
2389
        for(x=0; x<16; x+=4){
2390
            score+= ABS(s[x  ] - s[x  +stride]) + ABS(s[x+1] - s[x+1+stride]) 
2391
                   +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
2392
        }
2393
        s+= stride;
2394
    }
2395
    
2396
    return score;
2397
}
2398

2399
static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
2400
    int score=0;
2401
    int x,y;
2402
    
2403
    for(y=0; y<7; y++){
2404
        for(x=0; x<16; x++){
2405
            score+= ABS(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2406
        }
2407
        s1+= stride;
2408
        s2+= stride;
2409
    }
2410
    
2411
    return score;
2412
}
2413
#else
2414
#define SQ(a) ((a)*(a))
2415

    
2416
static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
2417
    int score=0;
2418
    int x,y;
2419
    
2420
    for(y=0; y<7; y++){
2421
        for(x=0; x<16; x+=4){
2422
            score+= SQ(s[x  ] - s[x  +stride]) + SQ(s[x+1] - s[x+1+stride]) 
2423
                   +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
2424
        }
2425
        s+= stride;
2426
    }
2427
    
2428
    return score;
2429
}
2430

    
2431
static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
2432
    int score=0;
2433
    int x,y;
2434
    
2435
    for(y=0; y<7; y++){
2436
        for(x=0; x<16; x++){
2437
            score+= SQ(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2438
        }
2439
        s1+= stride;
2440
        s2+= stride;
2441
    }
2442
    
2443
    return score;
2444
}
2445

    
2446
#endif
2447

    
2448
#endif //CONFIG_ENCODERS
2449

    
2450
/**
2451
 *
2452
 * @param h is the normal height, this will be reduced automatically if needed for the last row
2453
 */
2454
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2455
    if (    s->avctx->draw_horiz_band 
2456
        && (s->last_picture_ptr || s->low_delay) ) {
2457
        uint8_t *src_ptr[3];
2458
        int offset;
2459
        h= FFMIN(h, s->height - y);
2460

    
2461
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME)
2462
            offset = 0;
2463
        else
2464
            offset = y * s->linesize;
2465

    
2466
        if(s->pict_type==B_TYPE || s->low_delay){
2467
            src_ptr[0] = s->current_picture.data[0] + offset;
2468
            src_ptr[1] = s->current_picture.data[1] + (offset >> 2);
2469
            src_ptr[2] = s->current_picture.data[2] + (offset >> 2);
2470
        } else {
2471
            src_ptr[0] = s->last_picture.data[0] + offset;
2472
            src_ptr[1] = s->last_picture.data[1] + (offset >> 2);
2473
            src_ptr[2] = s->last_picture.data[2] + (offset >> 2);
2474
        }
2475
        emms_c();
2476

    
2477
        s->avctx->draw_horiz_band(s->avctx, src_ptr, s->linesize,
2478
                               y, s->width, h);
2479
    }
2480
}
2481

    
2482
#ifdef CONFIG_ENCODERS
2483

    
2484
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2485
{
2486
    const int mb_x= s->mb_x;
2487
    const int mb_y= s->mb_y;
2488
    int i;
2489
    int skip_dct[6];
2490
    int dct_offset   = s->linesize*8; //default for progressive frames
2491
    
2492
    for(i=0; i<6; i++) skip_dct[i]=0;
2493
    
2494
    if(s->adaptive_quant){
2495
        s->dquant= s->current_picture.qscale_table[mb_x + mb_y*s->mb_stride] - s->qscale;
2496

    
2497
        if(s->out_format==FMT_H263){
2498
            if     (s->dquant> 2) s->dquant= 2;
2499
            else if(s->dquant<-2) s->dquant=-2;
2500
        }
2501
            
2502
        if(s->codec_id==CODEC_ID_MPEG4){        
2503
            if(!s->mb_intra){
2504
                if(s->mv_dir&MV_DIRECT)
2505
                    s->dquant=0;
2506

    
2507
                assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
2508
            }
2509
        }
2510
        s->qscale+= s->dquant;
2511
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2512
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2513
    }
2514

    
2515
    if (s->mb_intra) {
2516
        uint8_t *ptr;
2517
        int wrap_y;
2518
        int emu=0;
2519

    
2520
        wrap_y = s->linesize;
2521
        ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2522

    
2523
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2524
            ff_emulated_edge_mc(s, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2525
            ptr= s->edge_emu_buffer;
2526
            emu=1;
2527
        }
2528
        
2529
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2530
            int progressive_score, interlaced_score;
2531
            
2532
            progressive_score= pix_vcmp16x8(ptr, wrap_y  ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
2533
            interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y  , wrap_y*2);
2534
            
2535
            if(progressive_score > interlaced_score + 100){
2536
                s->interlaced_dct=1;
2537
            
2538
                dct_offset= wrap_y;
2539
                wrap_y<<=1;
2540
            }else
2541
                s->interlaced_dct=0;
2542
        }
2543
        
2544
        s->dsp.get_pixels(s->block[0], ptr                 , wrap_y);
2545
        s->dsp.get_pixels(s->block[1], ptr              + 8, wrap_y);
2546
        s->dsp.get_pixels(s->block[2], ptr + dct_offset    , wrap_y);
2547
        s->dsp.get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
2548

    
2549
        if(s->flags&CODEC_FLAG_GRAY){
2550
            skip_dct[4]= 1;
2551
            skip_dct[5]= 1;
2552
        }else{
2553
            int wrap_c = s->uvlinesize;
2554
            ptr = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2555
            if(emu){
2556
                ff_emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2557
                ptr= s->edge_emu_buffer;
2558
            }
2559
            s->dsp.get_pixels(s->block[4], ptr, wrap_c);
2560

    
2561
            ptr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2562
            if(emu){
2563
                ff_emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2564
                ptr= s->edge_emu_buffer;
2565
            }
2566
            s->dsp.get_pixels(s->block[5], ptr, wrap_c);
2567
        }
2568
    }else{
2569
        op_pixels_func (*op_pix)[4];
2570
        qpel_mc_func (*op_qpix)[16];
2571
        uint8_t *dest_y, *dest_cb, *dest_cr;
2572
        uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2573
        int wrap_y, wrap_c;
2574
        int emu=0;
2575

    
2576
        dest_y  = s->current_picture.data[0] + (mb_y * 16 * s->linesize    ) + mb_x * 16;
2577
        dest_cb = s->current_picture.data[1] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2578
        dest_cr = s->current_picture.data[2] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2579
        wrap_y = s->linesize;
2580
        wrap_c = s->uvlinesize;
2581
        ptr_y  = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2582
        ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2583
        ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2584

    
2585
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
2586
            op_pix = s->dsp.put_pixels_tab;
2587
            op_qpix= s->dsp.put_qpel_pixels_tab;
2588
        }else{
2589
            op_pix = s->dsp.put_no_rnd_pixels_tab;
2590
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2591
        }
2592

    
2593
        if (s->mv_dir & MV_DIR_FORWARD) {
2594
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2595
            op_pix = s->dsp.avg_pixels_tab;
2596
            op_qpix= s->dsp.avg_qpel_pixels_tab;
2597
        }
2598
        if (s->mv_dir & MV_DIR_BACKWARD) {
2599
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2600
        }
2601

    
2602
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2603
            ff_emulated_edge_mc(s, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2604
            ptr_y= s->edge_emu_buffer;
2605
            emu=1;
2606
        }
2607
        
2608
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2609
            int progressive_score, interlaced_score;
2610
            
2611
            progressive_score= pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y  ) 
2612
                             + pix_diff_vcmp16x8(ptr_y + wrap_y*8, dest_y + wrap_y*8, wrap_y  );
2613
            interlaced_score = pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y*2)
2614
                             + pix_diff_vcmp16x8(ptr_y + wrap_y  , dest_y + wrap_y  , wrap_y*2);
2615
            
2616
            if(progressive_score > interlaced_score + 600){
2617
                s->interlaced_dct=1;
2618
            
2619
                dct_offset= wrap_y;
2620
                wrap_y<<=1;
2621
            }else
2622
                s->interlaced_dct=0;
2623
        }
2624
        
2625
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
2626
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
2627
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
2628
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
2629
        
2630
        if(s->flags&CODEC_FLAG_GRAY){
2631
            skip_dct[4]= 1;
2632
            skip_dct[5]= 1;
2633
        }else{
2634
            if(emu){
2635
                ff_emulated_edge_mc(s, ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2636
                ptr_cb= s->edge_emu_buffer;
2637
            }
2638
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2639
            if(emu){
2640
                ff_emulated_edge_mc(s, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2641
                ptr_cr= s->edge_emu_buffer;
2642
            }
2643
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2644
        }
2645
        /* pre quantization */         
2646
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
2647
            //FIXME optimize
2648
            if(s->dsp.pix_abs8x8(ptr_y               , dest_y               , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
2649
            if(s->dsp.pix_abs8x8(ptr_y            + 8, dest_y            + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
2650
            if(s->dsp.pix_abs8x8(ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
2651
            if(s->dsp.pix_abs8x8(ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
2652
            if(s->dsp.pix_abs8x8(ptr_cb              , dest_cb              , wrap_c) < 20*s->qscale) skip_dct[4]= 1;
2653
            if(s->dsp.pix_abs8x8(ptr_cr              , dest_cr              , wrap_c) < 20*s->qscale) skip_dct[5]= 1;
2654
#if 0
2655
{
2656
 static int stat[7];
2657
 int num=0;
2658
 for(i=0; i<6; i++)
2659
  if(skip_dct[i]) num++;
2660
 stat[num]++;
2661
 
2662
 if(s->mb_x==0 && s->mb_y==0){
2663
  for(i=0; i<7; i++){
2664
   printf("%6d %1d\n", stat[i], i);
2665
  }
2666
 }
2667
}
2668
#endif
2669
        }
2670

    
2671
    }
2672
            
2673
#if 0
2674
            {
2675
                float adap_parm;
2676
                
2677
                adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_stride*mb_y+mb_x] + 1.0) /
2678
                            ((s->mb_var[s->mb_stride*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);
2679
            
2680
                printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d", 
2681
                        (s->mb_type[s->mb_stride*mb_y+mb_x] > 0) ? 'I' : 'P', 
2682
                        s->qscale, adap_parm, s->qscale*adap_parm,
2683
                        s->mb_var[s->mb_stride*mb_y+mb_x], s->avg_mb_var);
2684
            }
2685
#endif
2686
    /* DCT & quantize */
2687
    if(s->out_format==FMT_MJPEG){
2688
        for(i=0;i<6;i++) {
2689
            int overflow;
2690
            s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
2691
            if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2692
        }
2693
    }else{
2694
        for(i=0;i<6;i++) {
2695
            if(!skip_dct[i]){
2696
                int overflow;
2697
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2698
            // FIXME we could decide to change to quantizer instead of clipping
2699
            // JS: I don't think that would be a good idea it could lower quality instead
2700
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
2701
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2702
            }else
2703
                s->block_last_index[i]= -1;
2704
        }
2705
        if(s->luma_elim_threshold && !s->mb_intra)
2706
            for(i=0; i<4; i++)
2707
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2708
        if(s->chroma_elim_threshold && !s->mb_intra)
2709
            for(i=4; i<6; i++)
2710
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2711
    }
2712

    
2713
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
2714
        s->block_last_index[4]=
2715
        s->block_last_index[5]= 0;
2716
        s->block[4][0]=
2717
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
2718
    }
2719

    
2720
    /* huffman encode */
2721
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2722
    case CODEC_ID_MPEG1VIDEO:
2723
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
2724
#ifdef CONFIG_RISKY
2725
    case CODEC_ID_MPEG4:
2726
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
2727
    case CODEC_ID_MSMPEG4V2:
2728
    case CODEC_ID_MSMPEG4V3:
2729
    case CODEC_ID_WMV1:
2730
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
2731
    case CODEC_ID_WMV2:
2732
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
2733
    case CODEC_ID_H263:
2734
    case CODEC_ID_H263P:
2735
    case CODEC_ID_RV10:
2736
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
2737
#endif
2738
    case CODEC_ID_MJPEG:
2739
        mjpeg_encode_mb(s, s->block); break;
2740
    default:
2741
        assert(0);
2742
    }
2743
}
2744

    
2745
#endif //CONFIG_ENCODERS
2746

    
2747
/**
2748
 * combines the (truncated) bitstream to a complete frame
2749
 * @returns -1 if no complete frame could be created
2750
 */
2751
int ff_combine_frame( MpegEncContext *s, int next, uint8_t **buf, int *buf_size){
2752
    ParseContext *pc= &s->parse_context;
2753
        
2754
    pc->last_index= pc->index;
2755

    
2756
    if(next==-1){
2757
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
2758

    
2759
        memcpy(&pc->buffer[pc->index], *buf, *buf_size);
2760
        pc->index += *buf_size;
2761
        return -1;
2762
    }
2763

    
2764
    if(pc->index){
2765
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
2766

    
2767
        memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
2768
        pc->index = 0;
2769
        *buf= pc->buffer;
2770
        *buf_size= pc->last_index + next;
2771
    }
2772

    
2773
    return 0;
2774
}
2775

    
2776
#ifdef CONFIG_ENCODERS
2777
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
2778
{
2779
    int bytes= length>>4;
2780
    int bits= length&15;
2781
    int i;
2782

    
2783
    if(length==0) return;
2784

    
2785
    for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
2786
    put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
2787
}
2788

    
2789
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2790
    int i;
2791

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

    
2794
    /* mpeg1 */
2795
    d->mb_skip_run= s->mb_skip_run;
2796
    for(i=0; i<3; i++)
2797
        d->last_dc[i]= s->last_dc[i];
2798
    
2799
    /* statistics */
2800
    d->mv_bits= s->mv_bits;
2801
    d->i_tex_bits= s->i_tex_bits;
2802
    d->p_tex_bits= s->p_tex_bits;
2803
    d->i_count= s->i_count;
2804
    d->f_count= s->f_count;
2805
    d->b_count= s->b_count;
2806
    d->skip_count= s->skip_count;
2807
    d->misc_bits= s->misc_bits;
2808
    d->last_bits= 0;
2809

    
2810
    d->mb_skiped= s->mb_skiped;
2811
    d->qscale= s->qscale;
2812
}
2813

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

    
2817
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
2818
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
2819
    
2820
    /* mpeg1 */
2821
    d->mb_skip_run= s->mb_skip_run;
2822
    for(i=0; i<3; i++)
2823
        d->last_dc[i]= s->last_dc[i];
2824
    
2825
    /* statistics */
2826
    d->mv_bits= s->mv_bits;
2827
    d->i_tex_bits= s->i_tex_bits;
2828
    d->p_tex_bits= s->p_tex_bits;
2829
    d->i_count= s->i_count;
2830
    d->f_count= s->f_count;
2831
    d->b_count= s->b_count;
2832
    d->skip_count= s->skip_count;
2833
    d->misc_bits= s->misc_bits;
2834

    
2835
    d->mb_intra= s->mb_intra;
2836
    d->mb_skiped= s->mb_skiped;
2837
    d->mv_type= s->mv_type;
2838
    d->mv_dir= s->mv_dir;
2839
    d->pb= s->pb;
2840
    if(s->data_partitioning){
2841
        d->pb2= s->pb2;
2842
        d->tex_pb= s->tex_pb;
2843
    }
2844
    d->block= s->block;
2845
    for(i=0; i<6; i++)
2846
        d->block_last_index[i]= s->block_last_index[i];
2847
    d->interlaced_dct= s->interlaced_dct;
2848
    d->qscale= s->qscale;
2849
}
2850

    
2851
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
2852
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2853
                           int *dmin, int *next_block, int motion_x, int motion_y)
2854
{
2855
    int bits_count;
2856
    
2857
    copy_context_before_encode(s, backup, type);
2858

    
2859
    s->block= s->blocks[*next_block];
2860
    s->pb= pb[*next_block];
2861
    if(s->data_partitioning){
2862
        s->pb2   = pb2   [*next_block];
2863
        s->tex_pb= tex_pb[*next_block];
2864
    }
2865

    
2866
    encode_mb(s, motion_x, motion_y);
2867

    
2868
    bits_count= get_bit_count(&s->pb);
2869
    if(s->data_partitioning){
2870
        bits_count+= get_bit_count(&s->pb2);
2871
        bits_count+= get_bit_count(&s->tex_pb);
2872
    }
2873

    
2874
    if(bits_count<*dmin){
2875
        *dmin= bits_count;
2876
        *next_block^=1;
2877

    
2878
        copy_context_after_encode(best, s, type);
2879
    }
2880
}
2881
                
2882
static inline int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2883
    uint32_t *sq = squareTbl + 256;
2884
    int acc=0;
2885
    int x,y;
2886
    
2887
    if(w==16 && h==16) 
2888
        return s->dsp.sse[0](NULL, src1, src2, stride);
2889
    else if(w==8 && h==8)
2890
        return s->dsp.sse[1](NULL, src1, src2, stride);
2891
    
2892
    for(y=0; y<h; y++){
2893
        for(x=0; x<w; x++){
2894
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2895
        } 
2896
    }
2897
    
2898
    assert(acc>=0);
2899
    
2900
    return acc;
2901
}
2902

    
2903
static void encode_picture(MpegEncContext *s, int picture_number)
2904
{
2905
    int mb_x, mb_y, pdif = 0;
2906
    int i;
2907
    int bits;
2908
    MpegEncContext best_s, backup_s;
2909
    uint8_t bit_buf[2][3000];
2910
    uint8_t bit_buf2[2][3000];
2911
    uint8_t bit_buf_tex[2][3000];
2912
    PutBitContext pb[2], pb2[2], tex_pb[2];
2913

    
2914
    for(i=0; i<2; i++){
2915
        init_put_bits(&pb    [i], bit_buf    [i], 3000, NULL, NULL);
2916
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000, NULL, NULL);
2917
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
2918
    }
2919

    
2920
    s->picture_number = picture_number;
2921
    
2922
    /* Reset the average MB variance */
2923
    s->current_picture.mb_var_sum = 0;
2924
    s->current_picture.mc_mb_var_sum = 0;
2925

    
2926
#ifdef CONFIG_RISKY
2927
    /* we need to initialize some time vars before we can encode b-frames */
2928
    // RAL: Condition added for MPEG1VIDEO
2929
    if (s->codec_id == CODEC_ID_MPEG1VIDEO || (s->h263_pred && !s->h263_msmpeg4))
2930
        ff_set_mpeg4_time(s, s->picture_number); 
2931
#endif
2932
        
2933
    s->scene_change_score=0;
2934
    
2935
    s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
2936
    
2937
    if(s->pict_type==I_TYPE){
2938
        if(s->msmpeg4_version >= 3) s->no_rounding=1;
2939
        else                        s->no_rounding=0;
2940
    }else if(s->pict_type!=B_TYPE){
2941
        if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
2942
            s->no_rounding ^= 1;          
2943
    }
2944
    
2945
    /* Estimate motion for every MB */
2946
    s->mb_intra=0; //for the rate distoration & bit compare functions
2947
    if(s->pict_type != I_TYPE){
2948
        if(s->pict_type != B_TYPE){
2949
            if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
2950
                s->me.pre_pass=1;
2951
                s->me.dia_size= s->avctx->pre_dia_size;
2952

    
2953
                for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) {
2954
                    for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) {
2955
                        s->mb_x = mb_x;
2956
                        s->mb_y = mb_y;
2957
                        ff_pre_estimate_p_frame_motion(s, mb_x, mb_y);
2958
                    }
2959
                }
2960
                s->me.pre_pass=0;
2961
            }
2962
        }
2963

    
2964
        s->me.dia_size= s->avctx->dia_size;
2965
        for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2966
            s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
2967
            s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
2968
            s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
2969
            s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
2970
            for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2971
                s->mb_x = mb_x;
2972
                s->mb_y = mb_y;
2973
                s->block_index[0]+=2;
2974
                s->block_index[1]+=2;
2975
                s->block_index[2]+=2;
2976
                s->block_index[3]+=2;
2977
                
2978
                /* compute motion vector & mb_type and store in context */
2979
                if(s->pict_type==B_TYPE)
2980
                    ff_estimate_b_frame_motion(s, mb_x, mb_y);
2981
                else
2982
                    ff_estimate_p_frame_motion(s, mb_x, mb_y);
2983
            }
2984
        }
2985
    }else /* if(s->pict_type == I_TYPE) */{
2986
        /* I-Frame */
2987
        //FIXME do we need to zero them?
2988
        memset(s->motion_val[0], 0, sizeof(int16_t)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
2989
        memset(s->p_mv_table   , 0, sizeof(int16_t)*(s->mb_stride)*s->mb_height*2);
2990
        memset(s->mb_type      , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
2991
        
2992
        if(!s->fixed_qscale){
2993
            /* finding spatial complexity for I-frame rate control */
2994
            for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2995
                for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2996
                    int xx = mb_x * 16;
2997
                    int yy = mb_y * 16;
2998
                    uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
2999
                    int varc;
3000
                    int sum = s->dsp.pix_sum(pix, s->linesize);
3001
    
3002
                    varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
3003

    
3004
                    s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
3005
                    s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
3006
                    s->current_picture.mb_var_sum    += varc;
3007
                }
3008
            }
3009
        }
3010
    }
3011
    emms_c();
3012

    
3013
    if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
3014
        s->pict_type= I_TYPE;
3015
        memset(s->mb_type   , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3016
//printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3017
    }
3018

    
3019
    if(!s->umvplus){
3020
        if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
3021
            s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
3022
        
3023
            ff_fix_long_p_mvs(s);
3024
        }
3025

    
3026
        if(s->pict_type==B_TYPE){
3027
            int a, b;
3028

    
3029
            a = ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
3030
            b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, MB_TYPE_BIDIR);
3031
            s->f_code = FFMAX(a, b);
3032

    
3033
            a = ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
3034
            b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, MB_TYPE_BIDIR);
3035
            s->b_code = FFMAX(a, b);
3036

    
3037
            ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
3038
            ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
3039
            ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
3040
            ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
3041
        }
3042
    }
3043
    
3044
    if (s->fixed_qscale) 
3045
        s->frame_qscale = s->current_picture.quality;
3046
    else
3047
        s->frame_qscale = ff_rate_estimate_qscale(s);
3048

    
3049
    if(s->adaptive_quant){
3050
#ifdef CONFIG_RISKY
3051
        switch(s->codec_id){
3052
        case CODEC_ID_MPEG4:
3053
            ff_clean_mpeg4_qscales(s);
3054
            break;
3055
        case CODEC_ID_H263:
3056
        case CODEC_ID_H263P:
3057
            ff_clean_h263_qscales(s);
3058
            break;
3059
        }
3060
#endif
3061

    
3062
        s->qscale= s->current_picture.qscale_table[0];
3063
    }else
3064
        s->qscale= (int)(s->frame_qscale + 0.5);
3065
        
3066
    if (s->out_format == FMT_MJPEG) {
3067
        /* for mjpeg, we do include qscale in the matrix */
3068
        s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
3069
        for(i=1;i<64;i++){
3070
            int j= s->dsp.idct_permutation[i];
3071

    
3072
            s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3073
        }
3074
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, 
3075
                       s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
3076
    }
3077
    
3078
    //FIXME var duplication
3079
    s->current_picture.key_frame= s->pict_type == I_TYPE;
3080
    s->current_picture.pict_type= s->pict_type;
3081

    
3082
    if(s->current_picture.key_frame)
3083
        s->picture_in_gop_number=0;
3084

    
3085
    s->last_bits= get_bit_count(&s->pb);
3086
    switch(s->out_format) {
3087
    case FMT_MJPEG:
3088
        mjpeg_picture_header(s);
3089
        break;
3090
#ifdef CONFIG_RISKY
3091
    case FMT_H263:
3092
        if (s->codec_id == CODEC_ID_WMV2) 
3093
            ff_wmv2_encode_picture_header(s, picture_number);
3094
        else if (s->h263_msmpeg4) 
3095
            msmpeg4_encode_picture_header(s, picture_number);
3096
        else if (s->h263_pred)
3097
            mpeg4_encode_picture_header(s, picture_number);
3098
        else if (s->h263_rv10) 
3099
            rv10_encode_picture_header(s, picture_number);
3100
        else
3101
            h263_encode_picture_header(s, picture_number);
3102
        break;
3103
#endif
3104
    case FMT_MPEG1:
3105
        mpeg1_encode_picture_header(s, picture_number);
3106
        break;
3107
    }
3108
    bits= get_bit_count(&s->pb);
3109
    s->header_bits= bits - s->last_bits;
3110
    s->last_bits= bits;
3111
    s->mv_bits=0;
3112
    s->misc_bits=0;
3113
    s->i_tex_bits=0;
3114
    s->p_tex_bits=0;
3115
    s->i_count=0;
3116
    s->f_count=0;
3117
    s->b_count=0;
3118
    s->skip_count=0;
3119

    
3120
    for(i=0; i<3; i++){
3121
        /* init last dc values */
3122
        /* note: quant matrix value (8) is implied here */
3123
        s->last_dc[i] = 128;
3124
        
3125
        s->current_picture_ptr->error[i] = 0;
3126
    }
3127
    s->mb_skip_run = 0;
3128
    s->last_mv[0][0][0] = 0;
3129
    s->last_mv[0][0][1] = 0;
3130
    s->last_mv[1][0][0] = 0;
3131
    s->last_mv[1][0][1] = 0;
3132
     
3133
    s->last_mv_dir = 0;
3134

    
3135
#ifdef CONFIG_RISKY
3136
    if (s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P)
3137
        s->gob_index = ff_h263_get_gob_height(s);
3138

    
3139
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3140
        ff_mpeg4_init_partitions(s);
3141
#endif
3142

    
3143
    s->resync_mb_x=0;
3144
    s->resync_mb_y=0;
3145
    s->first_slice_line = 1;
3146
    s->ptr_lastgob = s->pb.buf;
3147
    for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3148
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
3149
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
3150
        
3151
        s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3152
        s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3153
        s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3154
        s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3155
        s->block_index[4]= s->block_wrap[4]*(mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2);
3156
        s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
3157
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3158
            const int xy= mb_y*s->mb_stride + mb_x;
3159
            int mb_type= s->mb_type[xy];
3160
//            int d;
3161
            int dmin=10000000;
3162

    
3163
            s->mb_x = mb_x;
3164
            s->mb_y = mb_y;
3165
            s->block_index[0]+=2;
3166
            s->block_index[1]+=2;
3167
            s->block_index[2]+=2;
3168
            s->block_index[3]+=2;
3169
            s->block_index[4]++;
3170
            s->block_index[5]++;
3171

    
3172
            /* write gob / video packet header  */
3173
#ifdef CONFIG_RISKY
3174
            if(s->rtp_mode){
3175
                int current_packet_size, is_gob_start;
3176
                
3177
                current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
3178
                is_gob_start=0;
3179
                
3180
                if(s->codec_id==CODEC_ID_MPEG4){
3181
                    if(current_packet_size >= s->rtp_payload_size
3182
                       && s->mb_y + s->mb_x>0){
3183

    
3184
                        if(s->partitioned_frame){
3185
                            ff_mpeg4_merge_partitions(s);
3186
                            ff_mpeg4_init_partitions(s);
3187
                        }
3188
                        ff_mpeg4_encode_video_packet_header(s);
3189

    
3190
                        if(s->flags&CODEC_FLAG_PASS1){
3191
                            int bits= get_bit_count(&s->pb);
3192
                            s->misc_bits+= bits - s->last_bits;
3193
                            s->last_bits= bits;
3194
                        }
3195
                        ff_mpeg4_clean_buffers(s);
3196
                        is_gob_start=1;
3197
                    }
3198
                }else if(s->codec_id==CODEC_ID_MPEG1VIDEO){
3199
                    if(   current_packet_size >= s->rtp_payload_size 
3200
                       && s->mb_y + s->mb_x>0 && s->mb_skip_run==0){
3201
                        ff_mpeg1_encode_slice_header(s);
3202
                        ff_mpeg1_clean_buffers(s);
3203
                        is_gob_start=1;
3204
                    }
3205
                }else{
3206
                    if(current_packet_size >= s->rtp_payload_size
3207
                       && s->mb_x==0 && s->mb_y>0 && s->mb_y%s->gob_index==0){
3208
                       
3209
                        h263_encode_gob_header(s, mb_y);                       
3210
                        is_gob_start=1;
3211
                    }
3212
                }
3213

    
3214
                if(is_gob_start){
3215
                    s->ptr_lastgob = pbBufPtr(&s->pb);
3216
                    s->first_slice_line=1;
3217
                    s->resync_mb_x=mb_x;
3218
                    s->resync_mb_y=mb_y;
3219
                }
3220
            }
3221
#endif
3222

    
3223
            if(  (s->resync_mb_x   == s->mb_x)
3224
               && s->resync_mb_y+1 == s->mb_y){
3225
                s->first_slice_line=0; 
3226
            }
3227

    
3228
            if(mb_type & (mb_type-1)){ // more than 1 MB type possible
3229
                int next_block=0;
3230
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3231

    
3232
                copy_context_before_encode(&backup_s, s, -1);
3233
                backup_s.pb= s->pb;
3234
                best_s.data_partitioning= s->data_partitioning;
3235
                best_s.partitioned_frame= s->partitioned_frame;
3236
                if(s->data_partitioning){
3237
                    backup_s.pb2= s->pb2;
3238
                    backup_s.tex_pb= s->tex_pb;
3239
                }
3240

    
3241
                if(mb_type&MB_TYPE_INTER){
3242
                    s->mv_dir = MV_DIR_FORWARD;
3243
                    s->mv_type = MV_TYPE_16X16;
3244
                    s->mb_intra= 0;
3245
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
3246
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
3247
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb, 
3248
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3249
                }
3250
                if(mb_type&MB_TYPE_INTER4V){                 
3251
                    s->mv_dir = MV_DIR_FORWARD;
3252
                    s->mv_type = MV_TYPE_8X8;
3253
                    s->mb_intra= 0;
3254
                    for(i=0; i<4; i++){
3255
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3256
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3257
                    }
3258
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb, 
3259
                                 &dmin, &next_block, 0, 0);
3260
                }
3261
                if(mb_type&MB_TYPE_FORWARD){
3262
                    s->mv_dir = MV_DIR_FORWARD;
3263
                    s->mv_type = MV_TYPE_16X16;
3264
                    s->mb_intra= 0;
3265
                    s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3266
                    s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3267
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb, 
3268
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3269
                }
3270
                if(mb_type&MB_TYPE_BACKWARD){
3271
                    s->mv_dir = MV_DIR_BACKWARD;
3272
                    s->mv_type = MV_TYPE_16X16;
3273
                    s->mb_intra= 0;
3274
                    s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3275
                    s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3276
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb, 
3277
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3278
                }
3279
                if(mb_type&MB_TYPE_BIDIR){
3280
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3281
                    s->mv_type = MV_TYPE_16X16;
3282
                    s->mb_intra= 0;
3283
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3284
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3285
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3286
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3287
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb, 
3288
                                 &dmin, &next_block, 0, 0);
3289
                }
3290
                if(mb_type&MB_TYPE_DIRECT){
3291
                    int mx= s->b_direct_mv_table[xy][0];
3292
                    int my= s->b_direct_mv_table[xy][1];
3293
                    
3294
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3295
                    s->mb_intra= 0;
3296
#ifdef CONFIG_RISKY
3297
                    ff_mpeg4_set_direct_mv(s, mx, my);
3298
#endif
3299
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb, 
3300
                                 &dmin, &next_block, mx, my);
3301
                }
3302
                if(mb_type&MB_TYPE_INTRA){
3303
                    s->mv_dir = 0;
3304
                    s->mv_type = MV_TYPE_16X16;
3305
                    s->mb_intra= 1;
3306
                    s->mv[0][0][0] = 0;
3307
                    s->mv[0][0][1] = 0;
3308
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb, 
3309
                                 &dmin, &next_block, 0, 0);
3310
                    /* force cleaning of ac/dc pred stuff if needed ... */
3311
                    if(s->h263_pred || s->h263_aic)
3312
                        s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
3313
                }
3314
                copy_context_after_encode(s, &best_s, -1);
3315
                
3316
                pb_bits_count= get_bit_count(&s->pb);
3317
                flush_put_bits(&s->pb);
3318
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3319
                s->pb= backup_s.pb;
3320
                
3321
                if(s->data_partitioning){
3322
                    pb2_bits_count= get_bit_count(&s->pb2);
3323
                    flush_put_bits(&s->pb2);
3324
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3325
                    s->pb2= backup_s.pb2;
3326
                    
3327
                    tex_pb_bits_count= get_bit_count(&s->tex_pb);
3328
                    flush_put_bits(&s->tex_pb);
3329
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3330
                    s->tex_pb= backup_s.tex_pb;
3331
                }
3332
                s->last_bits= get_bit_count(&s->pb);
3333
            } else {
3334
                int motion_x, motion_y;
3335
                int intra_score;
3336
                int inter_score= s->current_picture.mb_cmp_score[mb_x + mb_y*s->mb_stride];
3337
                
3338
              if(!(s->flags&CODEC_FLAG_HQ) && s->pict_type==P_TYPE){
3339
                /* get luma score */
3340
                if((s->avctx->mb_cmp&0xFF)==FF_CMP_SSE){
3341
                    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
3342
                }else{
3343
                    uint8_t *dest_y;
3344

    
3345
                    int mean= s->current_picture.mb_mean[mb_x + mb_y*s->mb_stride]; //FIXME
3346
                    mean*= 0x01010101;
3347
                    
3348
                    dest_y  = s->new_picture.data[0] + (mb_y * 16 * s->linesize    ) + mb_x * 16;
3349
                
3350
                    for(i=0; i<16; i++){
3351
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 0]) = mean;
3352
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 4]) = mean;
3353
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 8]) = mean;
3354
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+12]) = mean;
3355
                    }
3356

    
3357
                    s->mb_intra=1;
3358
                    intra_score= s->dsp.mb_cmp[0](s, s->me.scratchpad, dest_y, s->linesize);
3359
                                        
3360
/*                    printf("intra:%7d inter:%7d var:%7d mc_var.%7d\n", intra_score>>8, inter_score>>8, 
3361
                        s->current_picture.mb_var[mb_x + mb_y*s->mb_stride],
3362
                        s->current_picture.mc_mb_var[mb_x + mb_y*s->mb_stride]);*/
3363
                }
3364
                
3365
                /* get chroma score */
3366
                if(s->avctx->mb_cmp&FF_CMP_CHROMA){
3367
                    int i;
3368
                    
3369
                    s->mb_intra=1;
3370
                    for(i=1; i<3; i++){
3371
                        uint8_t *dest_c;
3372
                        int mean;
3373
                        
3374
                        if(s->out_format == FMT_H263){
3375
                            mean= (s->dc_val[i][mb_x + (mb_y+1)*(s->mb_width+2)] + 4)>>3; //FIXME not exact but simple ;)
3376
                        }else{
3377
                            mean= (s->last_dc[i] + 4)>>3;
3378
                        }
3379
                        dest_c = s->new_picture.data[i] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
3380
                        
3381
                        mean*= 0x01010101;
3382
                        for(i=0; i<8; i++){
3383
                            *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 0]) = mean;
3384
                            *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 4]) = mean;
3385
                        }
3386
                        
3387
                        intra_score+= s->dsp.mb_cmp[1](s, s->me.scratchpad, dest_c, s->uvlinesize);
3388
                    }                
3389
                }
3390

    
3391
                /* bias */
3392
                switch(s->avctx->mb_cmp&0xFF){
3393
                default:
3394
                case FF_CMP_SAD:
3395
                    intra_score+= 32*s->qscale;
3396
                    break;
3397
                case FF_CMP_SSE:
3398
                    intra_score+= 24*s->qscale*s->qscale;
3399
                    break;
3400
                case FF_CMP_SATD:
3401
                    intra_score+= 96*s->qscale;
3402
                    break;
3403
                case FF_CMP_DCT:
3404
                    intra_score+= 48*s->qscale;
3405
                    break;
3406
                case FF_CMP_BIT:
3407
                    intra_score+= 16;
3408
                    break;
3409
                case FF_CMP_PSNR:
3410
                case FF_CMP_RD:
3411
                    intra_score+= (s->qscale*s->qscale*109*8 + 64)>>7;
3412
                    break;
3413
                }
3414

    
3415
                if(intra_score < inter_score)
3416
                    mb_type= MB_TYPE_INTRA;
3417
              }  
3418
                
3419
                s->mv_type=MV_TYPE_16X16;
3420
                // only one MB-Type possible
3421
                
3422
                switch(mb_type){
3423
                case MB_TYPE_INTRA:
3424
                    s->mv_dir = 0;
3425
                    s->mb_intra= 1;
3426
                    motion_x= s->mv[0][0][0] = 0;
3427
                    motion_y= s->mv[0][0][1] = 0;
3428
                    break;
3429
                case MB_TYPE_INTER:
3430
                    s->mv_dir = MV_DIR_FORWARD;
3431
                    s->mb_intra= 0;
3432
                    motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3433
                    motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3434
                    break;
3435
                case MB_TYPE_INTER4V:
3436
                    s->mv_dir = MV_DIR_FORWARD;
3437
                    s->mv_type = MV_TYPE_8X8;
3438
                    s->mb_intra= 0;
3439
                    for(i=0; i<4; i++){
3440
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3441
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3442
                    }
3443
                    motion_x= motion_y= 0;
3444
                    break;
3445
                case MB_TYPE_DIRECT:
3446
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3447
                    s->mb_intra= 0;
3448
                    motion_x=s->b_direct_mv_table[xy][0];
3449
                    motion_y=s->b_direct_mv_table[xy][1];
3450
#ifdef CONFIG_RISKY
3451
                    ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3452
#endif
3453
                    break;
3454
                case MB_TYPE_BIDIR:
3455
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3456
                    s->mb_intra= 0;
3457
                    motion_x=0;
3458
                    motion_y=0;
3459
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3460
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3461
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3462
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3463
                    break;
3464
                case MB_TYPE_BACKWARD:
3465
                    s->mv_dir = MV_DIR_BACKWARD;
3466
                    s->mb_intra= 0;
3467
                    motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3468
                    motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3469
                    break;
3470
                case MB_TYPE_FORWARD:
3471
                    s->mv_dir = MV_DIR_FORWARD;
3472
                    s->mb_intra= 0;
3473
                    motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3474
                    motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3475
//                    printf(" %d %d ", motion_x, motion_y);
3476
                    break;
3477
                default:
3478
                    motion_x=motion_y=0; //gcc warning fix
3479
                    printf("illegal MB type\n");
3480
                }
3481

    
3482
                encode_mb(s, motion_x, motion_y);
3483

    
3484
                // RAL: Update last macrobloc type
3485
                s->last_mv_dir = s->mv_dir;
3486
            }
3487

    
3488
            /* clean the MV table in IPS frames for direct mode in B frames */
3489
            if(s->mb_intra /* && I,P,S_TYPE */){
3490
                s->p_mv_table[xy][0]=0;
3491
                s->p_mv_table[xy][1]=0;
3492
            }
3493

    
3494
            MPV_decode_mb(s, s->block);
3495
            
3496
            if(s->flags&CODEC_FLAG_PSNR){
3497
                int w= 16;
3498
                int h= 16;
3499

    
3500
                if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3501
                if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3502

    
3503
                s->current_picture_ptr->error[0] += sse(
3504
                    s,
3505
                    s->new_picture    .data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3506
                    s->current_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3507
                    w, h, s->linesize);
3508
                s->current_picture_ptr->error[1] += sse(
3509
                    s,
3510
                    s->new_picture    .data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3511
                    s->current_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3512
                    w>>1, h>>1, s->uvlinesize);
3513
                s->current_picture_ptr->error[2] += sse(
3514
                    s,
3515
                    s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3516
                    s->current_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3517
                    w>>1, h>>1, s->uvlinesize);
3518
            }
3519
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, get_bit_count(&s->pb));
3520
        }
3521
    }
3522
    emms_c();
3523

    
3524
#ifdef CONFIG_RISKY
3525
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3526
        ff_mpeg4_merge_partitions(s);
3527

    
3528
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
3529
        msmpeg4_encode_ext_header(s);
3530

    
3531
    if(s->codec_id==CODEC_ID_MPEG4) 
3532
        ff_mpeg4_stuffing(&s->pb);
3533
#endif
3534

    
3535
    //if (s->gob_number)
3536
    //    fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
3537
    
3538
    /* Send the last GOB if RTP */    
3539
    if (s->rtp_mode) {
3540
        flush_put_bits(&s->pb);
3541
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
3542
        /* Call the RTP callback to send the last GOB */
3543
        if (s->rtp_callback)
3544
            s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
3545
        s->ptr_lastgob = pbBufPtr(&s->pb);
3546
        //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
3547
    }
3548
}
3549

    
3550
static int dct_quantize_trellis_c(MpegEncContext *s, 
3551
                        DCTELEM *block, int n,
3552
                        int qscale, int *overflow){
3553
    const int *qmat;
3554
    const uint8_t *scantable= s->intra_scantable.scantable;
3555
    int max=0;
3556
    unsigned int threshold1, threshold2;
3557
    int bias=0;
3558
    int run_tab[65];
3559
    int level_tab[65];
3560
    int score_tab[65];
3561
    int last_run=0;
3562
    int last_level=0;
3563
    int last_score= 0;
3564
    int last_i= 0;
3565
    int coeff[3][64];
3566
    int coeff_count[64];
3567
    int lambda, qmul, qadd, start_i, last_non_zero, i;
3568
    const int esc_length= s->ac_esc_length;
3569
    uint8_t * length;
3570
    uint8_t * last_length;
3571
    int score_limit=0;
3572
    int left_limit= 0;
3573
        
3574
    s->dsp.fdct (block);
3575

    
3576
    qmul= qscale*16;
3577
    qadd= ((qscale-1)|1)*8;
3578

    
3579
    if (s->mb_intra) {
3580
        int q;
3581
        if (!s->h263_aic) {
3582
            if (n < 4)
3583
                q = s->y_dc_scale;
3584
            else
3585
                q = s->c_dc_scale;
3586
            q = q << 3;
3587
        } else{
3588
            /* For AIC we skip quant/dequant of INTRADC */
3589
            q = 1 << 3;
3590
            qadd=0;
3591
        }
3592
            
3593
        /* note: block[0] is assumed to be positive */
3594
        block[0] = (block[0] + (q >> 1)) / q;
3595
        start_i = 1;
3596
        last_non_zero = 0;
3597
        qmat = s->q_intra_matrix[qscale];
3598
        if(s->mpeg_quant || s->codec_id== CODEC_ID_MPEG1VIDEO)
3599
            bias= 1<<(QMAT_SHIFT-1);
3600
        length     = s->intra_ac_vlc_length;
3601
        last_length= s->intra_ac_vlc_last_length;
3602
    } else {
3603
        start_i = 0;
3604
        last_non_zero = -1;
3605
        qmat = s->q_inter_matrix[qscale];
3606
        length     = s->inter_ac_vlc_length;
3607
        last_length= s->inter_ac_vlc_last_length;
3608
    }
3609

    
3610
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
3611
    threshold2= (threshold1<<1);
3612

    
3613
    for(i=start_i; i<64; i++) {
3614
        const int j = scantable[i];
3615
        const int k= i-start_i;
3616
        int level = block[j];
3617
        level = level * qmat[j];
3618

    
3619
//        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
3620
//           || bias-level >= (1<<(QMAT_SHIFT - 3))){
3621
        if(((unsigned)(level+threshold1))>threshold2){
3622
            if(level>0){
3623
                level= (bias + level)>>QMAT_SHIFT;
3624
                coeff[0][k]= level;
3625
                coeff[1][k]= level-1;
3626
//                coeff[2][k]= level-2;
3627
            }else{
3628
                level= (bias - level)>>QMAT_SHIFT;
3629
                coeff[0][k]= -level;
3630
                coeff[1][k]= -level+1;
3631
//                coeff[2][k]= -level+2;
3632
            }
3633
            coeff_count[k]= FFMIN(level, 2);
3634
            max |=level;
3635
            last_non_zero = i;
3636
        }else{
3637
            coeff[0][k]= (level>>31)|1;
3638
            coeff_count[k]= 1;
3639
        }
3640
    }
3641
    
3642
    *overflow= s->max_qcoeff < max; //overflow might have happend
3643
    
3644
    if(last_non_zero < start_i){
3645
        memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3646
        return last_non_zero;
3647
    }
3648

    
3649
    lambda= (qscale*qscale*64*105 + 64)>>7; //FIXME finetune
3650
        
3651
    score_tab[0]= 0;
3652
    for(i=0; i<=last_non_zero - start_i; i++){
3653
        int level_index, run, j;
3654
        const int dct_coeff= block[ scantable[i + start_i] ];
3655
        const int zero_distoration= dct_coeff*dct_coeff;
3656
        int best_score=256*256*256*120;
3657

    
3658
        last_score += zero_distoration;
3659
        for(level_index=0; level_index < coeff_count[i]; level_index++){
3660
            int distoration;
3661
            int level= coeff[level_index][i];
3662
            int unquant_coeff;
3663
            
3664
            assert(level);
3665

    
3666
            if(s->out_format == FMT_H263){
3667
                if(level>0){
3668
                    unquant_coeff= level*qmul + qadd;
3669
                }else{
3670
                    unquant_coeff= level*qmul - qadd;
3671
                }
3672
            }else{ //MPEG1
3673
                j= s->dsp.idct_permutation[ scantable[i + start_i] ]; //FIXME optimize
3674
                if(s->mb_intra){
3675
                    if (level < 0) {
3676
                        unquant_coeff = (int)((-level) * qscale * s->intra_matrix[j]) >> 3;
3677
                        unquant_coeff = -((unquant_coeff - 1) | 1);
3678
                    } else {
3679
                        unquant_coeff = (int)(  level  * qscale * s->intra_matrix[j]) >> 3;
3680
                        unquant_coeff =   (unquant_coeff - 1) | 1;
3681
                    }
3682
                }else{
3683
                    if (level < 0) {
3684
                        unquant_coeff = ((((-level) << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3685
                        unquant_coeff = -((unquant_coeff - 1) | 1);
3686
                    } else {
3687
                        unquant_coeff = (((  level  << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3688
                        unquant_coeff =   (unquant_coeff - 1) | 1;
3689
                    }
3690
                }
3691
                unquant_coeff<<= 3;
3692
            }
3693

    
3694
            distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff);
3695
            level+=64;
3696
            if((level&(~127)) == 0){
3697
                for(run=0; run<=i - left_limit; run++){
3698
                    int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3699
                    score += score_tab[i-run];
3700
                    
3701
                    if(score < best_score){
3702
                        best_score= 
3703
                        score_tab[i+1]= score;
3704
                        run_tab[i+1]= run;
3705
                        level_tab[i+1]= level-64;
3706
                    }
3707
                }
3708

    
3709
                if(s->out_format == FMT_H263){
3710
                    for(run=0; run<=i - left_limit; run++){
3711
                        int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3712
                        score += score_tab[i-run];
3713
                        if(score < last_score){
3714
                            last_score= score;
3715
                            last_run= run;
3716
                            last_level= level-64;
3717
                            last_i= i+1;
3718
                        }
3719
                    }
3720
                }
3721
            }else{
3722
                distoration += esc_length*lambda;
3723
                for(run=0; run<=i - left_limit; run++){
3724
                    int score= distoration + 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 + score_tab[i-run];
3737
                        if(score < last_score){
3738
                            last_score= score;
3739
                            last_run= run;
3740
                            last_level= level-64;
3741
                            last_i= i+1;
3742
                        }
3743
                    }
3744
                }
3745
            }
3746
        }
3747

    
3748
        for(j=left_limit; j<=i; j++){
3749
            score_tab[j] += zero_distoration;
3750
        }
3751
        score_limit+= zero_distoration;
3752
        if(score_tab[i+1] < score_limit)
3753
            score_limit= score_tab[i+1];
3754
        
3755
        //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3756
        while(score_tab[ left_limit ] > score_limit + lambda) left_limit++;
3757
    }
3758

    
3759
        //FIXME add some cbp penalty
3760

    
3761
    if(s->out_format != FMT_H263){
3762
        last_score= 256*256*256*120;
3763
        for(i= left_limit; i<=last_non_zero - start_i + 1; i++){
3764
            int score= score_tab[i];
3765
            if(i) score += lambda*2; //FIXME exacter?
3766

    
3767
            if(score < last_score){
3768
                last_score= score;
3769
                last_i= i;
3770
                last_level= level_tab[i];
3771
                last_run= run_tab[i];
3772
            }
3773
        }
3774
    }
3775
    
3776
    last_non_zero= last_i - 1 + start_i;
3777
    memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3778
    
3779
    if(last_non_zero < start_i)
3780
        return last_non_zero;
3781
    
3782
    i= last_i;
3783
    assert(last_level);
3784
//FIXME use permutated scantable
3785
    block[ s->dsp.idct_permutation[ scantable[last_non_zero] ] ]= last_level;
3786
    i -= last_run + 1;
3787
    
3788
    for(;i>0 ; i -= run_tab[i] + 1){
3789
        const int j= s->dsp.idct_permutation[ scantable[i - 1 + start_i] ];
3790
    
3791
        block[j]= level_tab[i];
3792
        assert(block[j]);
3793
    }
3794

    
3795
    return last_non_zero;
3796
}
3797

    
3798
static int dct_quantize_c(MpegEncContext *s, 
3799
                        DCTELEM *block, int n,
3800
                        int qscale, int *overflow)
3801
{
3802
    int i, j, level, last_non_zero, q;
3803
    const int *qmat;
3804
    const uint8_t *scantable= s->intra_scantable.scantable;
3805
    int bias;
3806
    int max=0;
3807
    unsigned int threshold1, threshold2;
3808

    
3809
    s->dsp.fdct (block);
3810

    
3811
    if (s->mb_intra) {
3812
        if (!s->h263_aic) {
3813
            if (n < 4)
3814
                q = s->y_dc_scale;
3815
            else
3816
                q = s->c_dc_scale;
3817
            q = q << 3;
3818
        } else
3819
            /* For AIC we skip quant/dequant of INTRADC */
3820
            q = 1 << 3;
3821
            
3822
        /* note: block[0] is assumed to be positive */
3823
        block[0] = (block[0] + (q >> 1)) / q;
3824
        i = 1;
3825
        last_non_zero = 0;
3826
        qmat = s->q_intra_matrix[qscale];
3827
        bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
3828
    } else {
3829
        i = 0;
3830
        last_non_zero = -1;
3831
        qmat = s->q_inter_matrix[qscale];
3832
        bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
3833
    }
3834
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
3835
    threshold2= (threshold1<<1);
3836

    
3837
    for(;i<64;i++) {
3838
        j = scantable[i];
3839
        level = block[j];
3840
        level = level * qmat[j];
3841

    
3842
//        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
3843
//           || bias-level >= (1<<(QMAT_SHIFT - 3))){
3844
        if(((unsigned)(level+threshold1))>threshold2){
3845
            if(level>0){
3846
                level= (bias + level)>>QMAT_SHIFT;
3847
                block[j]= level;
3848
            }else{
3849
                level= (bias - level)>>QMAT_SHIFT;
3850
                block[j]= -level;
3851
            }
3852
            max |=level;
3853
            last_non_zero = i;
3854
        }else{
3855
            block[j]=0;
3856
        }
3857
    }
3858
    *overflow= s->max_qcoeff < max; //overflow might have happend
3859
    
3860
    /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
3861
    if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
3862
        ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
3863

    
3864
    return last_non_zero;
3865
}
3866

    
3867
#endif //CONFIG_ENCODERS
3868

    
3869
static void dct_unquantize_mpeg1_c(MpegEncContext *s, 
3870
                                   DCTELEM *block, int n, int qscale)
3871
{
3872
    int i, level, nCoeffs;
3873
    const uint16_t *quant_matrix;
3874

    
3875
    nCoeffs= s->block_last_index[n];
3876
    
3877
    if (s->mb_intra) {
3878
        if (n < 4) 
3879
            block[0] = block[0] * s->y_dc_scale;
3880
        else
3881
            block[0] = block[0] * s->c_dc_scale;
3882
        /* XXX: only mpeg1 */
3883
        quant_matrix = s->intra_matrix;
3884
        for(i=1;i<=nCoeffs;i++) {
3885
            int j= s->intra_scantable.permutated[i];
3886
            level = block[j];
3887
            if (level) {
3888
                if (level < 0) {
3889
                    level = -level;
3890
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3891
                    level = (level - 1) | 1;
3892
                    level = -level;
3893
                } else {
3894
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3895
                    level = (level - 1) | 1;
3896
                }
3897
#ifdef PARANOID
3898
                if (level < -2048 || level > 2047)
3899
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3900
#endif
3901
                block[j] = level;
3902
            }
3903
        }
3904
    } else {
3905
        i = 0;
3906
        quant_matrix = s->inter_matrix;
3907
        for(;i<=nCoeffs;i++) {
3908
            int j= s->intra_scantable.permutated[i];
3909
            level = block[j];
3910
            if (level) {
3911
                if (level < 0) {
3912
                    level = -level;
3913
                    level = (((level << 1) + 1) * qscale *
3914
                             ((int) (quant_matrix[j]))) >> 4;
3915
                    level = (level - 1) | 1;
3916
                    level = -level;
3917
                } else {
3918
                    level = (((level << 1) + 1) * qscale *
3919
                             ((int) (quant_matrix[j]))) >> 4;
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
    }
3930
}
3931

    
3932
static void dct_unquantize_mpeg2_c(MpegEncContext *s, 
3933
                                   DCTELEM *block, int n, int qscale)
3934
{
3935
    int i, level, nCoeffs;
3936
    const uint16_t *quant_matrix;
3937

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

    
3994

    
3995
static void dct_unquantize_h263_c(MpegEncContext *s, 
3996
                                  DCTELEM *block, int n, int qscale)
3997
{
3998
    int i, level, qmul, qadd;
3999
    int nCoeffs;
4000
    
4001
    assert(s->block_last_index[n]>=0);
4002
    
4003
    qadd = (qscale - 1) | 1;
4004
    qmul = qscale << 1;
4005
    
4006
    if (s->mb_intra) {
4007
        if (!s->h263_aic) {
4008
            if (n < 4) 
4009
                block[0] = block[0] * s->y_dc_scale;
4010
            else
4011
                block[0] = block[0] * s->c_dc_scale;
4012
        }else
4013
            qadd = 0;
4014
        i = 1;
4015
        nCoeffs= 63; //does not allways use zigzag table 
4016
    } else {
4017
        i = 0;
4018
        nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
4019
    }
4020

    
4021
    for(;i<=nCoeffs;i++) {
4022
        level = block[i];
4023
        if (level) {
4024
            if (level < 0) {
4025
                level = level * qmul - qadd;
4026
            } else {
4027
                level = level * qmul + qadd;
4028
            }
4029
#ifdef PARANOID
4030
                if (level < -2048 || level > 2047)
4031
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4032
#endif
4033
            block[i] = level;
4034
        }
4035
    }
4036
}
4037

    
4038

    
4039
char ff_get_pict_type_char(int pict_type){
4040
    switch(pict_type){
4041
    case I_TYPE: return 'I'; 
4042
    case P_TYPE: return 'P'; 
4043
    case B_TYPE: return 'B'; 
4044
    case S_TYPE: return 'S'; 
4045
    case SI_TYPE:return 'i'; 
4046
    case SP_TYPE:return 'p'; 
4047
    default:     return '?';
4048
    }
4049
}
4050

    
4051
static const AVOption mpeg4_options[] =
4052
{
4053
    AVOPTION_CODEC_INT("bitrate", "desired video bitrate", bit_rate, 4, 240000000, 800000),
4054
    AVOPTION_CODEC_FLAG("vhq", "very high quality", flags, CODEC_FLAG_HQ, 0),
4055
    AVOPTION_CODEC_INT("ratetol", "number of bits the bitstream is allowed to diverge from the reference"
4056
                       "the reference can be CBR (for CBR pass1) or VBR (for pass2)",
4057
                       bit_rate_tolerance, 4, 240000000, 8000),
4058
    AVOPTION_CODEC_INT("qmin", "minimum quantizer", qmin, 1, 31, 2),
4059
    AVOPTION_CODEC_INT("qmax", "maximum quantizer", qmax, 1, 31, 31),
4060
    AVOPTION_CODEC_STRING("rc_eq", "rate control equation",
4061
                          rc_eq, "tex^qComp,option1,options2", 0),
4062
    AVOPTION_CODEC_INT("rc_minrate", "rate control minimum bitrate",
4063
                       rc_min_rate, 4, 24000000, 0),
4064
    AVOPTION_CODEC_INT("rc_maxrate", "rate control maximum bitrate",
4065
                       rc_max_rate, 4, 24000000, 0),
4066
    AVOPTION_CODEC_DOUBLE("rc_buf_aggresivity", "rate control buffer aggresivity",
4067
                          rc_buffer_aggressivity, 4, 24000000, 0),
4068
    AVOPTION_CODEC_DOUBLE("rc_initial_cplx", "initial complexity for pass1 ratecontrol",
4069
                          rc_initial_cplx, 0., 9999999., 0),
4070
    AVOPTION_CODEC_DOUBLE("i_quant_factor", "qscale factor between p and i frames",
4071
                          i_quant_factor, 0., 0., 0),
4072
    AVOPTION_CODEC_DOUBLE("i_quant_offset", "qscale offset between p and i frames",
4073
                          i_quant_factor, -999999., 999999., 0),
4074
    AVOPTION_CODEC_INT("dct_algo", "dct alghorithm",
4075
                       dct_algo, 0, 5, 0), // fixme - "Auto,FastInt,Int,MMX,MLib,Altivec"
4076
    AVOPTION_CODEC_DOUBLE("lumi_masking", "luminance masking",
4077
                          lumi_masking, 0., 999999., 0),
4078
    AVOPTION_CODEC_DOUBLE("temporal_cplx_masking", "temporary complexity masking",
4079
                          temporal_cplx_masking, 0., 999999., 0),
4080
    AVOPTION_CODEC_DOUBLE("spatial_cplx_masking", "spatial complexity masking",
4081
                          spatial_cplx_masking, 0., 999999., 0),
4082
    AVOPTION_CODEC_DOUBLE("p_masking", "p block masking",
4083
                          p_masking, 0., 999999., 0),
4084
    AVOPTION_CODEC_DOUBLE("dark_masking", "darkness masking",
4085
                          dark_masking, 0., 999999., 0),
4086
    AVOPTION_CODEC_INT("idct_algo", "idct alghorithm",
4087
                       idct_algo, 0, 8, 0), // fixme - "Auto,Int,Simple,SimpleMMX,LibMPEG2MMX,PS2,MLib,ARM,Altivec"
4088

    
4089
    AVOPTION_CODEC_INT("mb_qmin", "minimum MB quantizer",
4090
                       mb_qmin, 0, 8, 0),
4091
    AVOPTION_CODEC_INT("mb_qmax", "maximum MB quantizer",
4092
                       mb_qmin, 0, 8, 0),
4093

    
4094
    AVOPTION_CODEC_INT("me_cmp", "ME compare function",
4095
                       me_cmp, 0, 24000000, 0),
4096
    AVOPTION_CODEC_INT("me_sub_cmp", "subpixel ME compare function",
4097
                       me_sub_cmp, 0, 24000000, 0),
4098

    
4099

    
4100
    AVOPTION_CODEC_INT("dia_size", "ME diamond size & shape",
4101
                       dia_size, 0, 24000000, 0),
4102
    AVOPTION_CODEC_INT("last_predictor_count", "amount of previous MV predictors",
4103
                       last_predictor_count, 0, 24000000, 0),
4104

    
4105
    AVOPTION_CODEC_INT("pre_me", "pre pass for ME",
4106
                       pre_me, 0, 24000000, 0),
4107
    AVOPTION_CODEC_INT("me_pre_cmp", "ME pre pass compare function",
4108
                       me_pre_cmp, 0, 24000000, 0),
4109

    
4110
    AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4111
                       me_range, 0, 24000000, 0),
4112
    AVOPTION_CODEC_INT("pre_dia_size", "ME pre pass diamod size & shape",
4113
                       pre_dia_size, 0, 24000000, 0),
4114
    AVOPTION_CODEC_INT("me_subpel_quality", "subpel ME quality",
4115
                       me_subpel_quality, 0, 24000000, 0),
4116
    AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4117
                       me_range, 0, 24000000, 0),
4118
    AVOPTION_CODEC_FLAG("psnr", "calculate PSNR of compressed frames",
4119
                        flags, CODEC_FLAG_PSNR, 0),
4120
    AVOPTION_CODEC_RCOVERRIDE("rc_override", "ratecontrol override (=startframe,endframe,qscale,quality_factor)",
4121
                              rc_override),
4122
    AVOPTION_SUB(avoptions_common),
4123
    AVOPTION_END()
4124
};
4125

    
4126
#ifdef CONFIG_ENCODERS
4127

    
4128
AVCodec mpeg1video_encoder = {
4129
    "mpeg1video",
4130
    CODEC_TYPE_VIDEO,
4131
    CODEC_ID_MPEG1VIDEO,
4132
    sizeof(MpegEncContext),
4133
    MPV_encode_init,
4134
    MPV_encode_picture,
4135
    MPV_encode_end,
4136
};
4137

    
4138
#ifdef CONFIG_RISKY
4139

    
4140
AVCodec h263_encoder = {
4141
    "h263",
4142
    CODEC_TYPE_VIDEO,
4143
    CODEC_ID_H263,
4144
    sizeof(MpegEncContext),
4145
    MPV_encode_init,
4146
    MPV_encode_picture,
4147
    MPV_encode_end,
4148
};
4149

    
4150
AVCodec h263p_encoder = {
4151
    "h263p",
4152
    CODEC_TYPE_VIDEO,
4153
    CODEC_ID_H263P,
4154
    sizeof(MpegEncContext),
4155
    MPV_encode_init,
4156
    MPV_encode_picture,
4157
    MPV_encode_end,
4158
};
4159

    
4160
AVCodec rv10_encoder = {
4161
    "rv10",
4162
    CODEC_TYPE_VIDEO,
4163
    CODEC_ID_RV10,
4164
    sizeof(MpegEncContext),
4165
    MPV_encode_init,
4166
    MPV_encode_picture,
4167
    MPV_encode_end,
4168
};
4169

    
4170
AVCodec mpeg4_encoder = {
4171
    "mpeg4",
4172
    CODEC_TYPE_VIDEO,
4173
    CODEC_ID_MPEG4,
4174
    sizeof(MpegEncContext),
4175
    MPV_encode_init,
4176
    MPV_encode_picture,
4177
    MPV_encode_end,
4178
    .options = mpeg4_options,
4179
};
4180

    
4181
AVCodec msmpeg4v1_encoder = {
4182
    "msmpeg4v1",
4183
    CODEC_TYPE_VIDEO,
4184
    CODEC_ID_MSMPEG4V1,
4185
    sizeof(MpegEncContext),
4186
    MPV_encode_init,
4187
    MPV_encode_picture,
4188
    MPV_encode_end,
4189
    .options = mpeg4_options,
4190
};
4191

    
4192
AVCodec msmpeg4v2_encoder = {
4193
    "msmpeg4v2",
4194
    CODEC_TYPE_VIDEO,
4195
    CODEC_ID_MSMPEG4V2,
4196
    sizeof(MpegEncContext),
4197
    MPV_encode_init,
4198
    MPV_encode_picture,
4199
    MPV_encode_end,
4200
    .options = mpeg4_options,
4201
};
4202

    
4203
AVCodec msmpeg4v3_encoder = {
4204
    "msmpeg4",
4205
    CODEC_TYPE_VIDEO,
4206
    CODEC_ID_MSMPEG4V3,
4207
    sizeof(MpegEncContext),
4208
    MPV_encode_init,
4209
    MPV_encode_picture,
4210
    MPV_encode_end,
4211
    .options = mpeg4_options,
4212
};
4213

    
4214
AVCodec wmv1_encoder = {
4215
    "wmv1",
4216
    CODEC_TYPE_VIDEO,
4217
    CODEC_ID_WMV1,
4218
    sizeof(MpegEncContext),
4219
    MPV_encode_init,
4220
    MPV_encode_picture,
4221
    MPV_encode_end,
4222
    .options = mpeg4_options,
4223
};
4224

    
4225
#endif
4226

    
4227
AVCodec mjpeg_encoder = {
4228
    "mjpeg",
4229
    CODEC_TYPE_VIDEO,
4230
    CODEC_ID_MJPEG,
4231
    sizeof(MpegEncContext),
4232
    MPV_encode_init,
4233
    MPV_encode_picture,
4234
    MPV_encode_end,
4235
};
4236

    
4237
#endif //CONFIG_ENCODERS
4238