Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ c009df3f

History | View | Annotate | Download (154 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(uint8_t *permutation, 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] = 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->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
206
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
207
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
208
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
209

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
471

    
472
//extern int sads;
473

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

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

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

    
524
#ifdef CONFIG_ENCODERS
525

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

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

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

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

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

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

    
592
    if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
593
        fprintf(stderr, "data partitioning not supporetd by codec\n");
594
        return -1;
595
    }
596
    
597
    if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO){
598
        fprintf(stderr, "b frames not supporetd by codec\n");
599
        return -1;
600
    }
601
    
602
    if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
603
        fprintf(stderr, "mpeg2 style quantization not supporetd by codec\n");
604
        return -1;
605
    }
606
        
607
    if(s->codec_id==CODEC_ID_MJPEG){
608
        s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
609
        s->inter_quant_bias= 0;
610
    }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO){
611
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
612
        s->inter_quant_bias= 0;
613
    }else{
614
        s->intra_quant_bias=0;
615
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
616
    }
617
    
618
    if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
619
        s->intra_quant_bias= avctx->intra_quant_bias;
620
    if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
621
        s->inter_quant_bias= avctx->inter_quant_bias;
622
        
623
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
624

    
625
    switch(avctx->codec->id) {
626
    case CODEC_ID_MPEG1VIDEO:
627
        s->out_format = FMT_MPEG1;
628
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
629
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
630
        break;
631
    case CODEC_ID_LJPEG:
632
    case CODEC_ID_MJPEG:
633
        s->out_format = FMT_MJPEG;
634
        s->intra_only = 1; /* force intra only for jpeg */
635
        s->mjpeg_write_tables = 1; /* write all tables */
636
        s->mjpeg_data_only_frames = 0; /* write all the needed headers */
637
        s->mjpeg_vsample[0] = 1<<chroma_v_shift;
638
        s->mjpeg_vsample[1] = 1;
639
        s->mjpeg_vsample[2] = 1; 
640
        s->mjpeg_hsample[0] = 1<<chroma_h_shift;
641
        s->mjpeg_hsample[1] = 1; 
642
        s->mjpeg_hsample[2] = 1; 
643
        if (mjpeg_init(s) < 0)
644
            return -1;
645
        avctx->delay=0;
646
        s->low_delay=1;
647
        break;
648
#ifdef CONFIG_RISKY
649
    case CODEC_ID_H263:
650
        if (h263_get_picture_format(s->width, s->height) == 7) {
651
            printf("Input picture size isn't suitable for h263 codec! try h263+\n");
652
            return -1;
653
        }
654
        s->out_format = FMT_H263;
655
        avctx->delay=0;
656
        s->low_delay=1;
657
        break;
658
    case CODEC_ID_H263P:
659
        s->out_format = FMT_H263;
660
        s->h263_plus = 1;
661
        /* Fx */
662
        s->unrestricted_mv=(avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
663
        s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
664
        /* /Fx */
665
        /* These are just to be sure */
666
        s->umvplus = 1;
667
        avctx->delay=0;
668
        s->low_delay=1;
669
        break;
670
    case CODEC_ID_RV10:
671
        s->out_format = FMT_H263;
672
        s->h263_rv10 = 1;
673
        avctx->delay=0;
674
        s->low_delay=1;
675
        break;
676
    case CODEC_ID_MPEG4:
677
        s->out_format = FMT_H263;
678
        s->h263_pred = 1;
679
        s->unrestricted_mv = 1;
680
        s->low_delay= s->max_b_frames ? 0 : 1;
681
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
682
        break;
683
    case CODEC_ID_MSMPEG4V1:
684
        s->out_format = FMT_H263;
685
        s->h263_msmpeg4 = 1;
686
        s->h263_pred = 1;
687
        s->unrestricted_mv = 1;
688
        s->msmpeg4_version= 1;
689
        avctx->delay=0;
690
        s->low_delay=1;
691
        break;
692
    case CODEC_ID_MSMPEG4V2:
693
        s->out_format = FMT_H263;
694
        s->h263_msmpeg4 = 1;
695
        s->h263_pred = 1;
696
        s->unrestricted_mv = 1;
697
        s->msmpeg4_version= 2;
698
        avctx->delay=0;
699
        s->low_delay=1;
700
        break;
701
    case CODEC_ID_MSMPEG4V3:
702
        s->out_format = FMT_H263;
703
        s->h263_msmpeg4 = 1;
704
        s->h263_pred = 1;
705
        s->unrestricted_mv = 1;
706
        s->msmpeg4_version= 3;
707
        s->flipflop_rounding=1;
708
        avctx->delay=0;
709
        s->low_delay=1;
710
        break;
711
    case CODEC_ID_WMV1:
712
        s->out_format = FMT_H263;
713
        s->h263_msmpeg4 = 1;
714
        s->h263_pred = 1;
715
        s->unrestricted_mv = 1;
716
        s->msmpeg4_version= 4;
717
        s->flipflop_rounding=1;
718
        avctx->delay=0;
719
        s->low_delay=1;
720
        break;
721
    case CODEC_ID_WMV2:
722
        s->out_format = FMT_H263;
723
        s->h263_msmpeg4 = 1;
724
        s->h263_pred = 1;
725
        s->unrestricted_mv = 1;
726
        s->msmpeg4_version= 5;
727
        s->flipflop_rounding=1;
728
        avctx->delay=0;
729
        s->low_delay=1;
730
        break;
731
#endif
732
    default:
733
        return -1;
734
    }
735
    
736
    { /* set up some save defaults, some codecs might override them later */
737
        static int done=0;
738
        if(!done){
739
            int i;
740
            done=1;
741

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

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

    
760
    s->encoding = 1;
761

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

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

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

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

    
806
    if(ff_rate_control_init(s) < 0)
807
        return -1;
808

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

    
816
    return 0;
817
}
818

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

    
823
#ifdef STATS
824
    print_stats();
825
#endif
826

    
827
    ff_rate_control_uninit(s);
828

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

    
836
#endif //CONFIG_ENCODERS
837

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

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

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

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

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

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

    
921
    assert(i<MAX_PICTURE_COUNT);
922
    return i;
923
}
924

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

    
931
    s->mb_skiped = 0;
932

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

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

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

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

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

    
969
        s->current_picture_ptr= &s->picture[i];
970
    }
971

    
972
    s->current_picture_ptr->pict_type= s->pict_type;
973
    s->current_picture_ptr->quality= s->qscale;
974
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
975

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

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

    
1020
    return 0;
1021
}
1022

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

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

    
1068
/**
1069
 * draws an line from (ex, ey) -> (sx, sy).
1070
 * @param w width of the image
1071
 * @param h height of the image
1072
 * @param stride stride/linesize of the image
1073
 * @param color color of the arrow
1074
 */
1075
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1076
    int t, x, y, f;
1077
    
1078
    sx= clip(sx, 0, w-1);
1079
    sy= clip(sy, 0, h-1);
1080
    ex= clip(ex, 0, w-1);
1081
    ey= clip(ey, 0, h-1);
1082
    
1083
    buf[sy*stride + sx]+= color;
1084
    
1085
    if(ABS(ex - sx) > ABS(ey - sy)){
1086
        if(sx > ex){
1087
            t=sx; sx=ex; ex=t;
1088
            t=sy; sy=ey; ey=t;
1089
        }
1090
        buf+= sx + sy*stride;
1091
        ex-= sx;
1092
        f= ((ey-sy)<<16)/ex;
1093
        for(x= 0; x <= ex; x++){
1094
            y= ((x*f) + (1<<15))>>16;
1095
            buf[y*stride + x]+= color;
1096
        }
1097
    }else{
1098
        if(sy > ey){
1099
            t=sx; sx=ex; ex=t;
1100
            t=sy; sy=ey; ey=t;
1101
        }
1102
        buf+= sx + sy*stride;
1103
        ey-= sy;
1104
        if(ey) f= ((ex-sx)<<16)/ey;
1105
        else   f= 0;
1106
        for(y= 0; y <= ey; y++){
1107
            x= ((y*f) + (1<<15))>>16;
1108
            buf[y*stride + x]+= color;
1109
        }
1110
    }
1111
}
1112

    
1113
/**
1114
 * draws an arrow from (ex, ey) -> (sx, sy).
1115
 * @param w width of the image
1116
 * @param h height of the image
1117
 * @param stride stride/linesize of the image
1118
 * @param color color of the arrow
1119
 */
1120
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1121
    int dx,dy;
1122

    
1123
    sx= clip(sx, -100, w+100);
1124
    sy= clip(sy, -100, h+100);
1125
    ex= clip(ex, -100, w+100);
1126
    ey= clip(ey, -100, h+100);
1127
    
1128
    dx= ex - sx;
1129
    dy= ey - sy;
1130
    
1131
    if(dx*dx + dy*dy > 3*3){
1132
        int rx=  dx + dy;
1133
        int ry= -dx + dy;
1134
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1135
        
1136
        //FIXME subpixel accuracy
1137
        rx= ROUNDED_DIV(rx*3<<4, length);
1138
        ry= ROUNDED_DIV(ry*3<<4, length);
1139
        
1140
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1141
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1142
    }
1143
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1144
}
1145

    
1146
/**
1147
 * prints debuging info for the given picture.
1148
 */
1149
void ff_print_debug_info(MpegEncContext *s, Picture *pict){
1150

    
1151
    if(!pict || !pict->mb_type) return;
1152

    
1153
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1154
        int x,y;
1155

    
1156
        for(y=0; y<s->mb_height; y++){
1157
            for(x=0; x<s->mb_width; x++){
1158
                if(s->avctx->debug&FF_DEBUG_SKIP){
1159
                    int count= s->mbskip_table[x + y*s->mb_stride];
1160
                    if(count>9) count=9;
1161
                    printf("%1d", count);
1162
                }
1163
                if(s->avctx->debug&FF_DEBUG_QP){
1164
                    printf("%2d", pict->qscale_table[x + y*s->mb_stride]);
1165
                }
1166
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1167
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
1168
                    
1169
                    //Type & MV direction
1170
                    if(IS_PCM(mb_type))
1171
                        printf("P");
1172
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1173
                        printf("A");
1174
                    else if(IS_INTRA4x4(mb_type))
1175
                        printf("i");
1176
                    else if(IS_INTRA16x16(mb_type))
1177
                        printf("I");
1178
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1179
                        printf("d");
1180
                    else if(IS_DIRECT(mb_type))
1181
                        printf("D");
1182
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1183
                        printf("g");
1184
                    else if(IS_GMC(mb_type))
1185
                        printf("G");
1186
                    else if(IS_SKIP(mb_type))
1187
                        printf("S");
1188
                    else if(!USES_LIST(mb_type, 1))
1189
                        printf(">");
1190
                    else if(!USES_LIST(mb_type, 0))
1191
                        printf("<");
1192
                    else{
1193
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1194
                        printf("X");
1195
                    }
1196
                    
1197
                    //segmentation
1198
                    if(IS_8X8(mb_type))
1199
                        printf("+");
1200
                    else if(IS_16X8(mb_type))
1201
                        printf("-");
1202
                    else if(IS_8X16(mb_type))
1203
                        printf("?");
1204
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1205
                        printf(" ");
1206
                    else
1207
                        printf("?");
1208
                    
1209
                        
1210
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1211
                        printf("=");
1212
                    else
1213
                        printf(" ");
1214
                }
1215
//                printf(" ");
1216
            }
1217
            printf("\n");
1218
        }
1219
    }
1220
    
1221
    if((s->avctx->debug&FF_DEBUG_VIS_MV) && s->motion_val){
1222
        const int shift= 1 + s->quarter_sample;
1223
        int mb_y;
1224
        uint8_t *ptr= pict->data[0];
1225
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1226

    
1227
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1228
            int mb_x;
1229
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1230
                const int mb_index= mb_x + mb_y*s->mb_stride;
1231
                if(IS_8X8(s->current_picture.mb_type[mb_index])){
1232
                    int i;
1233
                    for(i=0; i<4; i++){
1234
                        int sx= mb_x*16 + 4 + 8*(i&1);
1235
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1236
                        int xy= 1 + mb_x*2 + (i&1) + (mb_y*2 + 1 + (i>>1))*(s->mb_width*2 + 2);
1237
                        int mx= (s->motion_val[xy][0]>>shift) + sx;
1238
                        int my= (s->motion_val[xy][1]>>shift) + sy;
1239
                        draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1240
                    }
1241
                }else{
1242
                    int sx= mb_x*16 + 8;
1243
                    int sy= mb_y*16 + 8;
1244
                    int xy= 1 + mb_x*2 + (mb_y*2 + 1)*(s->mb_width*2 + 2);
1245
                    int mx= (s->motion_val[xy][0]>>shift) + sx;
1246
                    int my= (s->motion_val[xy][1]>>shift) + sy;
1247
                    draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1248
                }
1249
                s->mbskip_table[mb_index]=0;
1250
            }
1251
        }
1252
    }
1253
}
1254

    
1255
#ifdef CONFIG_ENCODERS
1256

    
1257
static int get_sae(uint8_t *src, int ref, int stride){
1258
    int x,y;
1259
    int acc=0;
1260
    
1261
    for(y=0; y<16; y++){
1262
        for(x=0; x<16; x++){
1263
            acc+= ABS(src[x+y*stride] - ref);
1264
        }
1265
    }
1266
    
1267
    return acc;
1268
}
1269

    
1270
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1271
    int x, y, w, h;
1272
    int acc=0;
1273
    
1274
    w= s->width &~15;
1275
    h= s->height&~15;
1276
    
1277
    for(y=0; y<h; y+=16){
1278
        for(x=0; x<w; x+=16){
1279
            int offset= x + y*stride;
1280
            int sad = s->dsp.pix_abs16x16(src + offset, ref + offset, stride);
1281
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1282
            int sae = get_sae(src + offset, mean, stride);
1283
            
1284
            acc+= sae + 500 < sad;
1285
        }
1286
    }
1287
    return acc;
1288
}
1289

    
1290

    
1291
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1292
    AVFrame *pic;
1293
    int i;
1294
    const int encoding_delay= s->max_b_frames;
1295
    int direct=1;
1296

    
1297
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1298
    if(pic_arg->linesize[0] != s->linesize) direct=0;
1299
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1300
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1301
  
1302
//    printf("%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1303
    
1304
    if(direct){
1305
        i= find_unused_picture(s, 1);
1306

    
1307
        pic= (AVFrame*)&s->picture[i];
1308
        pic->reference= 3;
1309
    
1310
        for(i=0; i<4; i++){
1311
            pic->data[i]= pic_arg->data[i];
1312
            pic->linesize[i]= pic_arg->linesize[i];
1313
        }
1314
        alloc_picture(s, (Picture*)pic, 1);
1315
    }else{
1316
        i= find_unused_picture(s, 0);
1317

    
1318
        pic= (AVFrame*)&s->picture[i];
1319
        pic->reference= 3;
1320

    
1321
        alloc_picture(s, (Picture*)pic, 0);
1322
        for(i=0; i<4; i++){
1323
            /* the input will be 16 pixels to the right relative to the actual buffer start
1324
             * and the current_pic, so the buffer can be reused, yes its not beatifull 
1325
             */
1326
            pic->data[i]+= 16; 
1327
        }
1328

    
1329
        if(   pic->data[0] == pic_arg->data[0] 
1330
           && pic->data[1] == pic_arg->data[1]
1331
           && pic->data[2] == pic_arg->data[2]){
1332
       // empty
1333
        }else{
1334
            int h_chroma_shift, v_chroma_shift;
1335
        
1336
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1337
        
1338
            for(i=0; i<3; i++){
1339
                int src_stride= pic_arg->linesize[i];
1340
                int dst_stride= i ? s->uvlinesize : s->linesize;
1341
                int h_shift= i ? h_chroma_shift : 0;
1342
                int v_shift= i ? v_chroma_shift : 0;
1343
                int w= s->width >>h_shift;
1344
                int h= s->height>>v_shift;
1345
                uint8_t *src= pic_arg->data[i];
1346
                uint8_t *dst= pic->data[i];
1347
            
1348
                if(src_stride==dst_stride)
1349
                    memcpy(dst, src, src_stride*h);
1350
                else{
1351
                    while(h--){
1352
                        memcpy(dst, src, w);
1353
                        dst += dst_stride;
1354
                        src += src_stride;
1355
                    }
1356
                }
1357
            }
1358
        }
1359
    }
1360
    pic->quality= pic_arg->quality;
1361
    pic->pict_type= pic_arg->pict_type;
1362
    pic->pts = pic_arg->pts;
1363
    
1364
    if(s->input_picture[encoding_delay])
1365
        pic->display_picture_number= s->input_picture[encoding_delay]->display_picture_number + 1;
1366

    
1367
    /* shift buffer entries */
1368
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1369
        s->input_picture[i-1]= s->input_picture[i];
1370
        
1371
    s->input_picture[encoding_delay]= (Picture*)pic;
1372

    
1373
    return 0;
1374
}
1375

    
1376
static void select_input_picture(MpegEncContext *s){
1377
    int i;
1378
    const int encoding_delay= s->max_b_frames;
1379
    int coded_pic_num=0;    
1380

    
1381
    if(s->reordered_input_picture[0])
1382
        coded_pic_num= s->reordered_input_picture[0]->coded_picture_number + 1;
1383

    
1384
    for(i=1; i<MAX_PICTURE_COUNT; i++)
1385
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1386
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1387

    
1388
    /* set next picture types & ordering */
1389
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1390
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
1391
            s->reordered_input_picture[0]= s->input_picture[0];
1392
            s->reordered_input_picture[0]->pict_type= I_TYPE;
1393
            s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1394
        }else{
1395
            int b_frames;
1396
            
1397
            if(s->flags&CODEC_FLAG_PASS2){
1398
                for(i=0; i<s->max_b_frames+1; i++){
1399
                    int pict_num= s->input_picture[0]->display_picture_number + i;
1400
                    int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1401
                    s->input_picture[i]->pict_type= pict_type;
1402
                    
1403
                    if(i + 1 >= s->rc_context.num_entries) break;
1404
                }
1405
            }
1406

    
1407
            if(s->input_picture[0]->pict_type){
1408
                /* user selected pict_type */
1409
                for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
1410
                    if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
1411
                }
1412
            
1413
                if(b_frames > s->max_b_frames){
1414
                    fprintf(stderr, "warning, too many bframes in a row\n");
1415
                    b_frames = s->max_b_frames;
1416
                }
1417
            }else if(s->b_frame_strategy==0){
1418
                b_frames= s->max_b_frames;
1419
            }else if(s->b_frame_strategy==1){
1420
                for(i=1; i<s->max_b_frames+1; i++){
1421
                    if(s->input_picture[i]->b_frame_score==0){
1422
                        s->input_picture[i]->b_frame_score= 
1423
                            get_intra_count(s, s->input_picture[i  ]->data[0], 
1424
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
1425
                    }
1426
                }
1427
                for(i=0; i<s->max_b_frames; i++){
1428
                    if(s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
1429
                }
1430
                                
1431
                b_frames= FFMAX(0, i-1);
1432
                
1433
                /* reset scores */
1434
                for(i=0; i<b_frames+1; i++){
1435
                    s->input_picture[i]->b_frame_score=0;
1436
                }
1437
            }else{
1438
                fprintf(stderr, "illegal b frame strategy\n");
1439
                b_frames=0;
1440
            }
1441

    
1442
            emms_c();
1443
//static int b_count=0;
1444
//b_count+= b_frames;
1445
//printf("b_frames: %d\n", b_count);
1446
                        
1447
            s->reordered_input_picture[0]= s->input_picture[b_frames];
1448
            if(   s->picture_in_gop_number + b_frames >= s->gop_size 
1449
               || s->reordered_input_picture[0]->pict_type== I_TYPE)
1450
                s->reordered_input_picture[0]->pict_type= I_TYPE;
1451
            else
1452
                s->reordered_input_picture[0]->pict_type= P_TYPE;
1453
            s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1454
            for(i=0; i<b_frames; i++){
1455
                coded_pic_num++;
1456
                s->reordered_input_picture[i+1]= s->input_picture[i];
1457
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
1458
                s->reordered_input_picture[i+1]->coded_picture_number= coded_pic_num;
1459
            }
1460
        }
1461
    }
1462
    
1463
    if(s->reordered_input_picture[0]){
1464
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
1465

    
1466
        s->new_picture= *s->reordered_input_picture[0];
1467

    
1468
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
1469
            // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
1470
        
1471
            int i= find_unused_picture(s, 0);
1472
            Picture *pic= &s->picture[i];
1473

    
1474
            /* mark us unused / free shared pic */
1475
            for(i=0; i<4; i++)
1476
                s->reordered_input_picture[0]->data[i]= NULL;
1477
            s->reordered_input_picture[0]->type= 0;
1478
            
1479
            //FIXME bad, copy * except
1480
            pic->pict_type = s->reordered_input_picture[0]->pict_type;
1481
            pic->quality   = s->reordered_input_picture[0]->quality;
1482
            pic->coded_picture_number = s->reordered_input_picture[0]->coded_picture_number;
1483
            pic->reference = s->reordered_input_picture[0]->reference;
1484
            
1485
            alloc_picture(s, pic, 0);
1486

    
1487
            s->current_picture_ptr= pic;
1488
        }else{
1489
            // input is not a shared pix -> reuse buffer for current_pix
1490

    
1491
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
1492
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
1493
            
1494
            s->current_picture_ptr= s->reordered_input_picture[0];
1495
            for(i=0; i<4; i++){
1496
                //reverse the +16 we did before storing the input
1497
                s->current_picture_ptr->data[i]-=16;
1498
            }
1499
        }
1500
        s->current_picture= *s->current_picture_ptr;
1501
    
1502
        s->picture_number= s->new_picture.display_picture_number;
1503
//printf("dpn:%d\n", s->picture_number);
1504
    }else{
1505
       memset(&s->new_picture, 0, sizeof(Picture));
1506
    }
1507
}
1508

    
1509
int MPV_encode_picture(AVCodecContext *avctx,
1510
                       unsigned char *buf, int buf_size, void *data)
1511
{
1512
    MpegEncContext *s = avctx->priv_data;
1513
    AVFrame *pic_arg = data;
1514
    int i;
1515

    
1516
    init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
1517

    
1518
    s->picture_in_gop_number++;
1519

    
1520
    load_input_picture(s, pic_arg);
1521
    
1522
    select_input_picture(s);
1523
    
1524
    /* output? */
1525
    if(s->new_picture.data[0]){
1526

    
1527
        s->pict_type= s->new_picture.pict_type;
1528
        if (s->fixed_qscale){ /* the ratecontrol needs the last qscale so we dont touch it for CBR */
1529
            s->qscale= (int)(s->new_picture.quality+0.5);
1530
            assert(s->qscale);
1531
        }
1532
//emms_c();
1533
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
1534
        MPV_frame_start(s, avctx);
1535

    
1536
        encode_picture(s, s->picture_number);
1537
        
1538
        avctx->real_pict_num  = s->picture_number;
1539
        avctx->header_bits = s->header_bits;
1540
        avctx->mv_bits     = s->mv_bits;
1541
        avctx->misc_bits   = s->misc_bits;
1542
        avctx->i_tex_bits  = s->i_tex_bits;
1543
        avctx->p_tex_bits  = s->p_tex_bits;
1544
        avctx->i_count     = s->i_count;
1545
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
1546
        avctx->skip_count  = s->skip_count;
1547

    
1548
        MPV_frame_end(s);
1549

    
1550
        if (s->out_format == FMT_MJPEG)
1551
            mjpeg_picture_trailer(s);
1552
        
1553
        if(s->flags&CODEC_FLAG_PASS1)
1554
            ff_write_pass1_stats(s);
1555

    
1556
        for(i=0; i<4; i++){
1557
            avctx->error[i] += s->current_picture_ptr->error[i];
1558
        }
1559
    }
1560

    
1561
    s->input_picture_number++;
1562

    
1563
    flush_put_bits(&s->pb);
1564
    s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1565
    
1566
    s->total_bits += s->frame_bits;
1567
    avctx->frame_bits  = s->frame_bits;
1568
    
1569
    return pbBufPtr(&s->pb) - s->pb.buf;
1570
}
1571

    
1572
#endif //CONFIG_ENCODERS
1573

    
1574
static inline void gmc1_motion(MpegEncContext *s,
1575
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1576
                               int dest_offset,
1577
                               uint8_t **ref_picture, int src_offset)
1578
{
1579
    uint8_t *ptr;
1580
    int offset, src_x, src_y, linesize, uvlinesize;
1581
    int motion_x, motion_y;
1582
    int emu=0;
1583

    
1584
    motion_x= s->sprite_offset[0][0];
1585
    motion_y= s->sprite_offset[0][1];
1586
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1587
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1588
    motion_x<<=(3-s->sprite_warping_accuracy);
1589
    motion_y<<=(3-s->sprite_warping_accuracy);
1590
    src_x = clip(src_x, -16, s->width);
1591
    if (src_x == s->width)
1592
        motion_x =0;
1593
    src_y = clip(src_y, -16, s->height);
1594
    if (src_y == s->height)
1595
        motion_y =0;
1596

    
1597
    linesize = s->linesize;
1598
    uvlinesize = s->uvlinesize;
1599
    
1600
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1601

    
1602
    dest_y+=dest_offset;
1603
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1604
        if(src_x<0 || src_y<0 || src_x + 17 >= s->h_edge_pos
1605
                              || src_y + 17 >= s->v_edge_pos){
1606
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1607
            ptr= s->edge_emu_buffer;
1608
        }
1609
    }
1610
    
1611
    if((motion_x|motion_y)&7){
1612
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1613
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1614
    }else{
1615
        int dxy;
1616
        
1617
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
1618
        if (s->no_rounding){
1619
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
1620
        }else{
1621
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
1622
        }
1623
    }
1624
    
1625
    if(s->flags&CODEC_FLAG_GRAY) return;
1626

    
1627
    motion_x= s->sprite_offset[1][0];
1628
    motion_y= s->sprite_offset[1][1];
1629
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
1630
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
1631
    motion_x<<=(3-s->sprite_warping_accuracy);
1632
    motion_y<<=(3-s->sprite_warping_accuracy);
1633
    src_x = clip(src_x, -8, s->width>>1);
1634
    if (src_x == s->width>>1)
1635
        motion_x =0;
1636
    src_y = clip(src_y, -8, s->height>>1);
1637
    if (src_y == s->height>>1)
1638
        motion_y =0;
1639

    
1640
    offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
1641
    ptr = ref_picture[1] + offset;
1642
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1643
        if(src_x<0 || src_y<0 || src_x + 9 >= s->h_edge_pos>>1
1644
                              || src_y + 9 >= s->v_edge_pos>>1){
1645
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1646
            ptr= s->edge_emu_buffer;
1647
            emu=1;
1648
        }
1649
    }
1650
    s->dsp.gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1651
    
1652
    ptr = ref_picture[2] + offset;
1653
    if(emu){
1654
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1655
        ptr= s->edge_emu_buffer;
1656
    }
1657
    s->dsp.gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1658
    
1659
    return;
1660
}
1661

    
1662
static inline void gmc_motion(MpegEncContext *s,
1663
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1664
                               int dest_offset,
1665
                               uint8_t **ref_picture, int src_offset)
1666
{
1667
    uint8_t *ptr;
1668
    int linesize, uvlinesize;
1669
    const int a= s->sprite_warping_accuracy;
1670
    int ox, oy;
1671

    
1672
    linesize = s->linesize;
1673
    uvlinesize = s->uvlinesize;
1674

    
1675
    ptr = ref_picture[0] + src_offset;
1676

    
1677
    dest_y+=dest_offset;
1678
    
1679
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
1680
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
1681

    
1682
    s->dsp.gmc(dest_y, ptr, linesize, 16,
1683
           ox, 
1684
           oy, 
1685
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1686
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1687
           a+1, (1<<(2*a+1)) - s->no_rounding,
1688
           s->h_edge_pos, s->v_edge_pos);
1689
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
1690
           ox + s->sprite_delta[0][0]*8, 
1691
           oy + s->sprite_delta[1][0]*8, 
1692
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1693
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1694
           a+1, (1<<(2*a+1)) - s->no_rounding,
1695
           s->h_edge_pos, s->v_edge_pos);
1696

    
1697
    if(s->flags&CODEC_FLAG_GRAY) return;
1698

    
1699

    
1700
    dest_cb+=dest_offset>>1;
1701
    dest_cr+=dest_offset>>1;
1702
    
1703
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
1704
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
1705

    
1706
    ptr = ref_picture[1] + (src_offset>>1);
1707
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
1708
           ox, 
1709
           oy, 
1710
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1711
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1712
           a+1, (1<<(2*a+1)) - s->no_rounding,
1713
           s->h_edge_pos>>1, s->v_edge_pos>>1);
1714
    
1715
    ptr = ref_picture[2] + (src_offset>>1);
1716
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
1717
           ox, 
1718
           oy, 
1719
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1720
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1721
           a+1, (1<<(2*a+1)) - s->no_rounding,
1722
           s->h_edge_pos>>1, s->v_edge_pos>>1);
1723
}
1724

    
1725
/**
1726
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
1727
 * @param buf destination buffer
1728
 * @param src source buffer
1729
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
1730
 * @param block_w width of block
1731
 * @param block_h height of block
1732
 * @param src_x x coordinate of the top left sample of the block in the source buffer
1733
 * @param src_y y coordinate of the top left sample of the block in the source buffer
1734
 * @param w width of the source buffer
1735
 * @param h height of the source buffer
1736
 */
1737
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
1738
                                    int src_x, int src_y, int w, int h){
1739
    int x, y;
1740
    int start_y, start_x, end_y, end_x;
1741

    
1742
    if(src_y>= h){
1743
        src+= (h-1-src_y)*linesize;
1744
        src_y=h-1;
1745
    }else if(src_y<=-block_h){
1746
        src+= (1-block_h-src_y)*linesize;
1747
        src_y=1-block_h;
1748
    }
1749
    if(src_x>= w){
1750
        src+= (w-1-src_x);
1751
        src_x=w-1;
1752
    }else if(src_x<=-block_w){
1753
        src+= (1-block_w-src_x);
1754
        src_x=1-block_w;
1755
    }
1756

    
1757
    start_y= FFMAX(0, -src_y);
1758
    start_x= FFMAX(0, -src_x);
1759
    end_y= FFMIN(block_h, h-src_y);
1760
    end_x= FFMIN(block_w, w-src_x);
1761

    
1762
    // copy existing part
1763
    for(y=start_y; y<end_y; y++){
1764
        for(x=start_x; x<end_x; x++){
1765
            buf[x + y*linesize]= src[x + y*linesize];
1766
        }
1767
    }
1768

    
1769
    //top
1770
    for(y=0; y<start_y; y++){
1771
        for(x=start_x; x<end_x; x++){
1772
            buf[x + y*linesize]= buf[x + start_y*linesize];
1773
        }
1774
    }
1775

    
1776
    //bottom
1777
    for(y=end_y; y<block_h; y++){
1778
        for(x=start_x; x<end_x; x++){
1779
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1780
        }
1781
    }
1782
                                    
1783
    for(y=0; y<block_h; y++){
1784
       //left
1785
        for(x=0; x<start_x; x++){
1786
            buf[x + y*linesize]= buf[start_x + y*linesize];
1787
        }
1788
       
1789
       //right
1790
        for(x=end_x; x<block_w; x++){
1791
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1792
        }
1793
    }
1794
}
1795

    
1796

    
1797
/* apply one mpeg motion vector to the three components */
1798
static inline void mpeg_motion(MpegEncContext *s,
1799
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1800
                               int dest_offset,
1801
                               uint8_t **ref_picture, int src_offset,
1802
                               int field_based, op_pixels_func (*pix_op)[4],
1803
                               int motion_x, int motion_y, int h)
1804
{
1805
    uint8_t *ptr;
1806
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1807
    int emu=0;
1808
#if 0    
1809
if(s->quarter_sample)
1810
{
1811
    motion_x>>=1;
1812
    motion_y>>=1;
1813
}
1814
#endif
1815
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1816
    src_x = s->mb_x * 16 + (motion_x >> 1);
1817
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 1);
1818
                
1819
    /* WARNING: do no forget half pels */
1820
    height = s->height >> field_based;
1821
    v_edge_pos = s->v_edge_pos >> field_based;
1822
    src_x = clip(src_x, -16, s->width);
1823
    if (src_x == s->width)
1824
        dxy &= ~1;
1825
    src_y = clip(src_y, -16, height);
1826
    if (src_y == height)
1827
        dxy &= ~2;
1828
    linesize   = s->current_picture.linesize[0] << field_based;
1829
    uvlinesize = s->current_picture.linesize[1] << field_based;
1830
    ptr = ref_picture[0] + (src_y * linesize) + (src_x) + src_offset;
1831
    dest_y += dest_offset;
1832

    
1833
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1834
        if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 16 > s->h_edge_pos
1835
                              || src_y + (motion_y&1) + h  > v_edge_pos){
1836
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr - src_offset, s->linesize, 17, 17+field_based,  //FIXME linesize? and uv below
1837
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1838
            ptr= s->edge_emu_buffer + src_offset;
1839
            emu=1;
1840
        }
1841
    }
1842
    pix_op[0][dxy](dest_y, ptr, linesize, h);
1843

    
1844
    if(s->flags&CODEC_FLAG_GRAY) return;
1845

    
1846
    if (s->out_format == FMT_H263) {
1847
        dxy = 0;
1848
        if ((motion_x & 3) != 0)
1849
            dxy |= 1;
1850
        if ((motion_y & 3) != 0)
1851
            dxy |= 2;
1852
        mx = motion_x >> 2;
1853
        my = motion_y >> 2;
1854
    } else {
1855
        mx = motion_x / 2;
1856
        my = motion_y / 2;
1857
        dxy = ((my & 1) << 1) | (mx & 1);
1858
        mx >>= 1;
1859
        my >>= 1;
1860
    }
1861
    
1862
    src_x = s->mb_x * 8 + mx;
1863
    src_y = s->mb_y * (8 >> field_based) + my;
1864
    src_x = clip(src_x, -8, s->width >> 1);
1865
    if (src_x == (s->width >> 1))
1866
        dxy &= ~1;
1867
    src_y = clip(src_y, -8, height >> 1);
1868
    if (src_y == (height >> 1))
1869
        dxy &= ~2;
1870
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1871
    ptr = ref_picture[1] + offset;
1872
    if(emu){
1873
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
1874
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1875
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1876
    }
1877
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1878

    
1879
    ptr = ref_picture[2] + offset;
1880
    if(emu){
1881
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
1882
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1883
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1884
    }
1885
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1886
}
1887

    
1888
static inline void qpel_motion(MpegEncContext *s,
1889
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1890
                               int dest_offset,
1891
                               uint8_t **ref_picture, int src_offset,
1892
                               int field_based, op_pixels_func (*pix_op)[4],
1893
                               qpel_mc_func (*qpix_op)[16],
1894
                               int motion_x, int motion_y, int h)
1895
{
1896
    uint8_t *ptr;
1897
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1898
    int emu=0;
1899

    
1900
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1901
    src_x = s->mb_x * 16 + (motion_x >> 2);
1902
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
1903

    
1904
    height = s->height >> field_based;
1905
    v_edge_pos = s->v_edge_pos >> field_based;
1906
    src_x = clip(src_x, -16, s->width);
1907
    if (src_x == s->width)
1908
        dxy &= ~3;
1909
    src_y = clip(src_y, -16, height);
1910
    if (src_y == height)
1911
        dxy &= ~12;
1912
    linesize = s->linesize << field_based;
1913
    uvlinesize = s->uvlinesize << field_based;
1914
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1915
    dest_y += dest_offset;
1916
//printf("%d %d %d\n", src_x, src_y, dxy);
1917
    
1918
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1919
        if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 16 > s->h_edge_pos
1920
                              || src_y + (motion_y&3) + h  > v_edge_pos){
1921
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr - src_offset, s->linesize, 17, 17+field_based, 
1922
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1923
            ptr= s->edge_emu_buffer + src_offset;
1924
            emu=1;
1925
        }
1926
    }
1927
    if(!field_based)
1928
        qpix_op[0][dxy](dest_y, ptr, linesize);
1929
    else{
1930
        //damn interlaced mode
1931
        //FIXME boundary mirroring is not exactly correct here
1932
        qpix_op[1][dxy](dest_y  , ptr  , linesize);
1933
        qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
1934
    }
1935

    
1936
    if(s->flags&CODEC_FLAG_GRAY) return;
1937

    
1938
    if(field_based){
1939
        mx= motion_x/2;
1940
        my= motion_y>>1;
1941
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
1942
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
1943
        mx= (motion_x>>1) + rtab[motion_x&7];
1944
        my= (motion_y>>1) + rtab[motion_y&7];
1945
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
1946
        mx= (motion_x>>1)|(motion_x&1);
1947
        my= (motion_y>>1)|(motion_y&1);
1948
    }else{
1949
        mx= motion_x/2;
1950
        my= motion_y/2;
1951
    }
1952
    mx= (mx>>1)|(mx&1);
1953
    my= (my>>1)|(my&1);
1954

    
1955
    dxy= (mx&1) | ((my&1)<<1);
1956
    mx>>=1;
1957
    my>>=1;
1958

    
1959
    src_x = s->mb_x * 8 + mx;
1960
    src_y = s->mb_y * (8 >> field_based) + my;
1961
    src_x = clip(src_x, -8, s->width >> 1);
1962
    if (src_x == (s->width >> 1))
1963
        dxy &= ~1;
1964
    src_y = clip(src_y, -8, height >> 1);
1965
    if (src_y == (height >> 1))
1966
        dxy &= ~2;
1967

    
1968
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1969
    ptr = ref_picture[1] + offset;
1970
    if(emu){
1971
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
1972
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1973
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1974
    }
1975
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1976
    
1977
    ptr = ref_picture[2] + offset;
1978
    if(emu){
1979
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
1980
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1981
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1982
    }
1983
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1984
}
1985

    
1986
inline int ff_h263_round_chroma(int x){
1987
    if (x >= 0)
1988
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
1989
    else {
1990
        x = -x;
1991
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
1992
    }
1993
}
1994

    
1995
/**
1996
 * motion compesation of a single macroblock
1997
 * @param s context
1998
 * @param dest_y luma destination pointer
1999
 * @param dest_cb chroma cb/u destination pointer
2000
 * @param dest_cr chroma cr/v destination pointer
2001
 * @param dir direction (0->forward, 1->backward)
2002
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2003
 * @param pic_op halfpel motion compensation function (average or put normally)
2004
 * @param pic_op qpel motion compensation function (average or put normally)
2005
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2006
 */
2007
static inline void MPV_motion(MpegEncContext *s, 
2008
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2009
                              int dir, uint8_t **ref_picture, 
2010
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
2011
{
2012
    int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
2013
    int mb_x, mb_y, i;
2014
    uint8_t *ptr, *dest;
2015
    int emu=0;
2016

    
2017
    mb_x = s->mb_x;
2018
    mb_y = s->mb_y;
2019

    
2020
    switch(s->mv_type) {
2021
    case MV_TYPE_16X16:
2022
#ifdef CONFIG_RISKY
2023
        if(s->mcsel){
2024
            if(s->real_sprite_warping_points==1){
2025
                gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
2026
                            ref_picture, 0);
2027
            }else{
2028
                gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
2029
                            ref_picture, 0);
2030
            }
2031
        }else if(s->quarter_sample){
2032
            qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2033
                        ref_picture, 0,
2034
                        0, pix_op, qpix_op,
2035
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2036
        }else if(s->mspel){
2037
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
2038
                        ref_picture, pix_op,
2039
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2040
        }else
2041
#endif
2042
        {
2043
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2044
                        ref_picture, 0,
2045
                        0, pix_op,
2046
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2047
        }           
2048
        break;
2049
    case MV_TYPE_8X8:
2050
        mx = 0;
2051
        my = 0;
2052
        if(s->quarter_sample){
2053
            for(i=0;i<4;i++) {
2054
                motion_x = s->mv[dir][i][0];
2055
                motion_y = s->mv[dir][i][1];
2056

    
2057
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2058
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
2059
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
2060
                    
2061
                /* WARNING: do no forget half pels */
2062
                src_x = clip(src_x, -16, s->width);
2063
                if (src_x == s->width)
2064
                    dxy &= ~3;
2065
                src_y = clip(src_y, -16, s->height);
2066
                if (src_y == s->height)
2067
                    dxy &= ~12;
2068
                    
2069
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2070
                if(s->flags&CODEC_FLAG_EMU_EDGE){
2071
                    if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 8 > s->h_edge_pos
2072
                                          || src_y + (motion_y&3) + 8 > s->v_edge_pos){
2073
                        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2074
                        ptr= s->edge_emu_buffer;
2075
                    }
2076
                }
2077
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2078
                qpix_op[1][dxy](dest, ptr, s->linesize);
2079

    
2080
                mx += s->mv[dir][i][0]/2;
2081
                my += s->mv[dir][i][1]/2;
2082
            }
2083
        }else{
2084
            for(i=0;i<4;i++) {
2085
                motion_x = s->mv[dir][i][0];
2086
                motion_y = s->mv[dir][i][1];
2087

    
2088
                dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2089
                src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;
2090
                src_y = mb_y * 16 + (motion_y >> 1) + (i >>1) * 8;
2091
                    
2092
                /* WARNING: do no forget half pels */
2093
                src_x = clip(src_x, -16, s->width);
2094
                if (src_x == s->width)
2095
                    dxy &= ~1;
2096
                src_y = clip(src_y, -16, s->height);
2097
                if (src_y == s->height)
2098
                    dxy &= ~2;
2099
                    
2100
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2101
                if(s->flags&CODEC_FLAG_EMU_EDGE){
2102
                    if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 8 > s->h_edge_pos
2103
                                          || src_y + (motion_y&1) + 8 > s->v_edge_pos){
2104
                        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2105
                        ptr= s->edge_emu_buffer;
2106
                    }
2107
                }
2108
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2109
                pix_op[1][dxy](dest, ptr, s->linesize, 8);
2110

    
2111
                mx += s->mv[dir][i][0];
2112
                my += s->mv[dir][i][1];
2113
            }
2114
        }
2115

    
2116
        if(s->flags&CODEC_FLAG_GRAY) break;
2117
        /* In case of 8X8, we construct a single chroma motion vector
2118
           with a special rounding */
2119
        mx= ff_h263_round_chroma(mx);
2120
        my= ff_h263_round_chroma(my);
2121
        dxy = ((my & 1) << 1) | (mx & 1);
2122
        mx >>= 1;
2123
        my >>= 1;
2124

    
2125
        src_x = mb_x * 8 + mx;
2126
        src_y = mb_y * 8 + my;
2127
        src_x = clip(src_x, -8, s->width/2);
2128
        if (src_x == s->width/2)
2129
            dxy &= ~1;
2130
        src_y = clip(src_y, -8, s->height/2);
2131
        if (src_y == s->height/2)
2132
            dxy &= ~2;
2133
        
2134
        offset = (src_y * (s->uvlinesize)) + src_x;
2135
        ptr = ref_picture[1] + offset;
2136
        if(s->flags&CODEC_FLAG_EMU_EDGE){
2137
                if(src_x<0 || src_y<0 || src_x + (dxy &1) + 8 > s->h_edge_pos>>1
2138
                                      || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
2139
                    ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2140
                    ptr= s->edge_emu_buffer;
2141
                    emu=1;
2142
                }
2143
            }
2144
        pix_op[1][dxy](dest_cb, ptr, s->uvlinesize, 8);
2145

    
2146
        ptr = ref_picture[2] + offset;
2147
        if(emu){
2148
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2149
            ptr= s->edge_emu_buffer;
2150
        }
2151
        pix_op[1][dxy](dest_cr, ptr, s->uvlinesize, 8);
2152
        break;
2153
    case MV_TYPE_FIELD:
2154
        if (s->picture_structure == PICT_FRAME) {
2155
            if(s->quarter_sample){
2156
                /* top field */
2157
                qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2158
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2159
                            1, pix_op, qpix_op,
2160
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
2161
                /* bottom field */
2162
                qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2163
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2164
                            1, pix_op, qpix_op,
2165
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
2166
            }else{
2167
                /* top field */       
2168
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2169
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2170
                            1, pix_op,
2171
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
2172
                /* bottom field */
2173
                mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2174
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2175
                            1, pix_op,
2176
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
2177
            }
2178
        } else {
2179
            int offset;
2180
            if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2181
                offset= s->field_select[dir][0] ? s->linesize : 0;
2182
            }else{
2183
                ref_picture= s->current_picture.data;
2184
                offset= s->field_select[dir][0] ? s->linesize : -s->linesize; 
2185
            } 
2186

    
2187
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2188
                        ref_picture, offset,
2189
                        0, pix_op,
2190
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2191
        }
2192
        break;
2193
    }
2194
}
2195

    
2196

    
2197
/* put block[] to dest[] */
2198
static inline void put_dct(MpegEncContext *s, 
2199
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
2200
{
2201
    s->dct_unquantize(s, block, i, s->qscale);
2202
    s->dsp.idct_put (dest, line_size, block);
2203
}
2204

    
2205
/* add block[] to dest[] */
2206
static inline void add_dct(MpegEncContext *s, 
2207
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
2208
{
2209
    if (s->block_last_index[i] >= 0) {
2210
        s->dsp.idct_add (dest, line_size, block);
2211
    }
2212
}
2213

    
2214
static inline void add_dequant_dct(MpegEncContext *s, 
2215
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
2216
{
2217
    if (s->block_last_index[i] >= 0) {
2218
        s->dct_unquantize(s, block, i, s->qscale);
2219

    
2220
        s->dsp.idct_add (dest, line_size, block);
2221
    }
2222
}
2223

    
2224
/**
2225
 * cleans dc, ac, coded_block for the current non intra MB
2226
 */
2227
void ff_clean_intra_table_entries(MpegEncContext *s)
2228
{
2229
    int wrap = s->block_wrap[0];
2230
    int xy = s->block_index[0];
2231
    
2232
    s->dc_val[0][xy           ] = 
2233
    s->dc_val[0][xy + 1       ] = 
2234
    s->dc_val[0][xy     + wrap] =
2235
    s->dc_val[0][xy + 1 + wrap] = 1024;
2236
    /* ac pred */
2237
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2238
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2239
    if (s->msmpeg4_version>=3) {
2240
        s->coded_block[xy           ] =
2241
        s->coded_block[xy + 1       ] =
2242
        s->coded_block[xy     + wrap] =
2243
        s->coded_block[xy + 1 + wrap] = 0;
2244
    }
2245
    /* chroma */
2246
    wrap = s->block_wrap[4];
2247
    xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
2248
    s->dc_val[1][xy] =
2249
    s->dc_val[2][xy] = 1024;
2250
    /* ac pred */
2251
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2252
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2253
    
2254
    s->mbintra_table[s->mb_x + s->mb_y*s->mb_stride]= 0;
2255
}
2256

    
2257
/* generic function called after a macroblock has been parsed by the
2258
   decoder or after it has been encoded by the encoder.
2259

2260
   Important variables used:
2261
   s->mb_intra : true if intra macroblock
2262
   s->mv_dir   : motion vector direction
2263
   s->mv_type  : motion vector type
2264
   s->mv       : motion vector
2265
   s->interlaced_dct : true if interlaced dct used (mpeg2)
2266
 */
2267
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
2268
{
2269
    int mb_x, mb_y;
2270
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2271

    
2272
    mb_x = s->mb_x;
2273
    mb_y = s->mb_y;
2274

    
2275
    s->current_picture.qscale_table[mb_xy]= s->qscale;
2276

    
2277
    /* update DC predictors for P macroblocks */
2278
    if (!s->mb_intra) {
2279
        if (s->h263_pred || s->h263_aic) {
2280
            if(s->mbintra_table[mb_xy])
2281
                ff_clean_intra_table_entries(s);
2282
        } else {
2283
            s->last_dc[0] =
2284
            s->last_dc[1] =
2285
            s->last_dc[2] = 128 << s->intra_dc_precision;
2286
        }
2287
    }
2288
    else if (s->h263_pred || s->h263_aic)
2289
        s->mbintra_table[mb_xy]=1;
2290

    
2291
    /* update motion predictor, not for B-frames as they need the motion_val from the last P/S-Frame */
2292
    if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) { //FIXME move into h263.c if possible, format specific stuff shouldnt be here
2293
        //FIXME a lot of thet is only needed for !low_delay
2294
        const int wrap = s->block_wrap[0];
2295
        const int xy = s->block_index[0];
2296
        if(s->mv_type != MV_TYPE_8X8){
2297
            int motion_x, motion_y;
2298
            if (s->mb_intra) {
2299
                motion_x = 0;
2300
                motion_y = 0;
2301
            } else if (s->mv_type == MV_TYPE_16X16) {
2302
                motion_x = s->mv[0][0][0];
2303
                motion_y = s->mv[0][0][1];
2304
            } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
2305
                int i;
2306
                motion_x = s->mv[0][0][0] + s->mv[0][1][0];
2307
                motion_y = s->mv[0][0][1] + s->mv[0][1][1];
2308
                motion_x = (motion_x>>1) | (motion_x&1);
2309
                for(i=0; i<2; i++){
2310
                    s->field_mv_table[mb_xy][i][0]= s->mv[0][i][0];
2311
                    s->field_mv_table[mb_xy][i][1]= s->mv[0][i][1];
2312
                    s->field_select_table[mb_xy][i]= s->field_select[0][i];
2313
                }
2314
            }
2315
            
2316
            /* no update if 8X8 because it has been done during parsing */
2317
            s->motion_val[xy][0] = motion_x;
2318
            s->motion_val[xy][1] = motion_y;
2319
            s->motion_val[xy + 1][0] = motion_x;
2320
            s->motion_val[xy + 1][1] = motion_y;
2321
            s->motion_val[xy + wrap][0] = motion_x;
2322
            s->motion_val[xy + wrap][1] = motion_y;
2323
            s->motion_val[xy + 1 + wrap][0] = motion_x;
2324
            s->motion_val[xy + 1 + wrap][1] = motion_y;
2325
        }
2326

    
2327
        if(s->encoding){ //FIXME encoding MUST be cleaned up
2328
            if (s->mv_type == MV_TYPE_8X8) 
2329
                s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
2330
            else
2331
                s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
2332
        }
2333
    }
2334
    
2335
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
2336
        uint8_t *dest_y, *dest_cb, *dest_cr;
2337
        int dct_linesize, dct_offset;
2338
        op_pixels_func (*op_pix)[4];
2339
        qpel_mc_func (*op_qpix)[16];
2340
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
2341
        const int uvlinesize= s->current_picture.linesize[1];
2342

    
2343
        /* avoid copy if macroblock skipped in last frame too */
2344
        if (s->pict_type != B_TYPE) {
2345
            s->current_picture.mbskip_table[mb_xy]= s->mb_skiped;
2346
        }
2347

    
2348
        /* skip only during decoding as we might trash the buffers during encoding a bit */
2349
        if(!s->encoding){
2350
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2351
            const int age= s->current_picture.age;
2352

    
2353
            assert(age);
2354

    
2355
            if (s->mb_skiped) {
2356
                s->mb_skiped= 0;
2357
                assert(s->pict_type!=I_TYPE);
2358
 
2359
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
2360
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2361

    
2362
                /* if previous was skipped too, then nothing to do !  */
2363
                if (*mbskip_ptr >= age && s->current_picture.reference){
2364
                    return;
2365
                }
2366
            } else if(!s->current_picture.reference){
2367
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2368
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2369
            } else{
2370
                *mbskip_ptr = 0; /* not skipped */
2371
            }
2372
        }else
2373
            s->mb_skiped= 0;
2374

    
2375
        if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){ //FIXME precalc
2376
            dest_y  = s->current_picture.data[0] + mb_x * 16;
2377
            dest_cb = s->current_picture.data[1] + mb_x * 8;
2378
            dest_cr = s->current_picture.data[2] + mb_x * 8;
2379
        }else{
2380
            dest_y  = s->current_picture.data[0] + (mb_y * 16* linesize  ) + mb_x * 16;
2381
            dest_cb = s->current_picture.data[1] + (mb_y * 8 * uvlinesize) + mb_x * 8;
2382
            dest_cr = s->current_picture.data[2] + (mb_y * 8 * uvlinesize) + mb_x * 8;
2383
        }
2384

    
2385
        if (s->interlaced_dct) {
2386
            dct_linesize = linesize * 2;
2387
            dct_offset = linesize;
2388
        } else {
2389
            dct_linesize = linesize;
2390
            dct_offset = linesize * 8;
2391
        }
2392

    
2393
        if (!s->mb_intra) {
2394
            /* motion handling */
2395
            /* decoding or more than one mb_type (MC was allready done otherwise) */
2396
            if((!s->encoding) || (s->mb_type[mb_xy]&(s->mb_type[mb_xy]-1))){
2397
                if ((!s->no_rounding) || s->pict_type==B_TYPE){                
2398
                    op_pix = s->dsp.put_pixels_tab;
2399
                    op_qpix= s->dsp.put_qpel_pixels_tab;
2400
                }else{
2401
                    op_pix = s->dsp.put_no_rnd_pixels_tab;
2402
                    op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2403
                }
2404

    
2405
                if (s->mv_dir & MV_DIR_FORWARD) {
2406
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2407
                    op_pix = s->dsp.avg_pixels_tab;
2408
                    op_qpix= s->dsp.avg_qpel_pixels_tab;
2409
                }
2410
                if (s->mv_dir & MV_DIR_BACKWARD) {
2411
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2412
                }
2413
            }
2414

    
2415
            /* skip dequant / idct if we are really late ;) */
2416
            if(s->hurry_up>1) return;
2417

    
2418
            /* add dct residue */
2419
            if(s->encoding || !(   s->mpeg2 || s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO 
2420
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2421
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
2422
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2423
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2424
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2425

    
2426
                if(!(s->flags&CODEC_FLAG_GRAY)){
2427
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize);
2428
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize);
2429
                }
2430
            } else if(s->codec_id != CODEC_ID_WMV2){
2431
                add_dct(s, block[0], 0, dest_y, dct_linesize);
2432
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2433
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2434
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2435

    
2436
                if(!(s->flags&CODEC_FLAG_GRAY)){
2437
                    add_dct(s, block[4], 4, dest_cb, uvlinesize);
2438
                    add_dct(s, block[5], 5, dest_cr, uvlinesize);
2439
                }
2440
            } 
2441
#ifdef CONFIG_RISKY
2442
            else{
2443
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2444
            }
2445
#endif
2446
        } else {
2447
            /* dct only in intra block */
2448
            if(s->encoding || !(s->mpeg2 || s->codec_id==CODEC_ID_MPEG1VIDEO)){
2449
                put_dct(s, block[0], 0, dest_y, dct_linesize);
2450
                put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2451
                put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2452
                put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2453

    
2454
                if(!(s->flags&CODEC_FLAG_GRAY)){
2455
                    put_dct(s, block[4], 4, dest_cb, uvlinesize);
2456
                    put_dct(s, block[5], 5, dest_cr, uvlinesize);
2457
                }
2458
            }else{
2459
                s->dsp.idct_put(dest_y                 , dct_linesize, block[0]);
2460
                s->dsp.idct_put(dest_y              + 8, dct_linesize, block[1]);
2461
                s->dsp.idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
2462
                s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
2463

    
2464
                if(!(s->flags&CODEC_FLAG_GRAY)){
2465
                    s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2466
                    s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2467
                }
2468
            }
2469
        }
2470
    }
2471
}
2472

    
2473
#ifdef CONFIG_ENCODERS
2474

    
2475
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
2476
{
2477
    static const char tab[64]=
2478
        {3,2,2,1,1,1,1,1,
2479
         1,1,1,1,1,1,1,1,
2480
         1,1,1,1,1,1,1,1,
2481
         0,0,0,0,0,0,0,0,
2482
         0,0,0,0,0,0,0,0,
2483
         0,0,0,0,0,0,0,0,
2484
         0,0,0,0,0,0,0,0,
2485
         0,0,0,0,0,0,0,0};
2486
    int score=0;
2487
    int run=0;
2488
    int i;
2489
    DCTELEM *block= s->block[n];
2490
    const int last_index= s->block_last_index[n];
2491
    int skip_dc;
2492

    
2493
    if(threshold<0){
2494
        skip_dc=0;
2495
        threshold= -threshold;
2496
    }else
2497
        skip_dc=1;
2498

    
2499
    /* are all which we could set to zero are allready zero? */
2500
    if(last_index<=skip_dc - 1) return;
2501

    
2502
    for(i=0; i<=last_index; i++){
2503
        const int j = s->intra_scantable.permutated[i];
2504
        const int level = ABS(block[j]);
2505
        if(level==1){
2506
            if(skip_dc && i==0) continue;
2507
            score+= tab[run];
2508
            run=0;
2509
        }else if(level>1){
2510
            return;
2511
        }else{
2512
            run++;
2513
        }
2514
    }
2515
    if(score >= threshold) return;
2516
    for(i=skip_dc; i<=last_index; i++){
2517
        const int j = s->intra_scantable.permutated[i];
2518
        block[j]=0;
2519
    }
2520
    if(block[0]) s->block_last_index[n]= 0;
2521
    else         s->block_last_index[n]= -1;
2522
}
2523

    
2524
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
2525
{
2526
    int i;
2527
    const int maxlevel= s->max_qcoeff;
2528
    const int minlevel= s->min_qcoeff;
2529
    
2530
    if(s->mb_intra){
2531
        i=1; //skip clipping of intra dc
2532
    }else
2533
        i=0;
2534
    
2535
    for(;i<=last_index; i++){
2536
        const int j= s->intra_scantable.permutated[i];
2537
        int level = block[j];
2538
       
2539
        if     (level>maxlevel) level=maxlevel;
2540
        else if(level<minlevel) level=minlevel;
2541

    
2542
        block[j]= level;
2543
    }
2544
}
2545

    
2546
#if 0
2547
static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
2548
    int score=0;
2549
    int x,y;
2550
    
2551
    for(y=0; y<7; y++){
2552
        for(x=0; x<16; x+=4){
2553
            score+= ABS(s[x  ] - s[x  +stride]) + ABS(s[x+1] - s[x+1+stride]) 
2554
                   +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
2555
        }
2556
        s+= stride;
2557
    }
2558
    
2559
    return score;
2560
}
2561

2562
static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
2563
    int score=0;
2564
    int x,y;
2565
    
2566
    for(y=0; y<7; y++){
2567
        for(x=0; x<16; x++){
2568
            score+= ABS(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2569
        }
2570
        s1+= stride;
2571
        s2+= stride;
2572
    }
2573
    
2574
    return score;
2575
}
2576
#else
2577
#define SQ(a) ((a)*(a))
2578

    
2579
static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
2580
    int score=0;
2581
    int x,y;
2582
    
2583
    for(y=0; y<7; y++){
2584
        for(x=0; x<16; x+=4){
2585
            score+= SQ(s[x  ] - s[x  +stride]) + SQ(s[x+1] - s[x+1+stride]) 
2586
                   +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
2587
        }
2588
        s+= stride;
2589
    }
2590
    
2591
    return score;
2592
}
2593

    
2594
static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
2595
    int score=0;
2596
    int x,y;
2597
    
2598
    for(y=0; y<7; y++){
2599
        for(x=0; x<16; x++){
2600
            score+= SQ(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2601
        }
2602
        s1+= stride;
2603
        s2+= stride;
2604
    }
2605
    
2606
    return score;
2607
}
2608

    
2609
#endif
2610

    
2611
#endif //CONFIG_ENCODERS
2612

    
2613
/**
2614
 *
2615
 * @param h is the normal height, this will be reduced automatically if needed for the last row
2616
 */
2617
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2618
    if (    s->avctx->draw_horiz_band 
2619
        && (s->last_picture_ptr || s->low_delay) ) {
2620
        uint8_t *src_ptr[3];
2621
        int offset;
2622
        h= FFMIN(h, s->height - y);
2623

    
2624
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME)
2625
            offset = 0;
2626
        else
2627
            offset = y * s->linesize;
2628

    
2629
        if(s->pict_type==B_TYPE || s->low_delay){
2630
            src_ptr[0] = s->current_picture.data[0] + offset;
2631
            src_ptr[1] = s->current_picture.data[1] + (offset >> 2);
2632
            src_ptr[2] = s->current_picture.data[2] + (offset >> 2);
2633
        } else {
2634
            src_ptr[0] = s->last_picture.data[0] + offset;
2635
            src_ptr[1] = s->last_picture.data[1] + (offset >> 2);
2636
            src_ptr[2] = s->last_picture.data[2] + (offset >> 2);
2637
        }
2638
        emms_c();
2639

    
2640
        s->avctx->draw_horiz_band(s->avctx, src_ptr, s->linesize,
2641
                               y, s->width, h);
2642
    }
2643
}
2644

    
2645
#ifdef CONFIG_ENCODERS
2646

    
2647
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2648
{
2649
    const int mb_x= s->mb_x;
2650
    const int mb_y= s->mb_y;
2651
    int i;
2652
    int skip_dct[6];
2653
    int dct_offset   = s->linesize*8; //default for progressive frames
2654
    
2655
    for(i=0; i<6; i++) skip_dct[i]=0;
2656
    
2657
    if(s->adaptive_quant){
2658
        s->dquant= s->current_picture.qscale_table[mb_x + mb_y*s->mb_stride] - s->qscale;
2659

    
2660
        if(s->out_format==FMT_H263){
2661
            if     (s->dquant> 2) s->dquant= 2;
2662
            else if(s->dquant<-2) s->dquant=-2;
2663
        }
2664
            
2665
        if(s->codec_id==CODEC_ID_MPEG4){        
2666
            if(!s->mb_intra){
2667
                if(s->mv_dir&MV_DIRECT)
2668
                    s->dquant=0;
2669

    
2670
                assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
2671
            }
2672
        }
2673
        s->qscale+= s->dquant;
2674
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2675
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2676
    }
2677

    
2678
    if (s->mb_intra) {
2679
        uint8_t *ptr;
2680
        int wrap_y;
2681
        int emu=0;
2682

    
2683
        wrap_y = s->linesize;
2684
        ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2685

    
2686
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2687
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2688
            ptr= s->edge_emu_buffer;
2689
            emu=1;
2690
        }
2691
        
2692
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2693
            int progressive_score, interlaced_score;
2694
            
2695
            progressive_score= pix_vcmp16x8(ptr, wrap_y  ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
2696
            interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y  , wrap_y*2);
2697
            
2698
            if(progressive_score > interlaced_score + 100){
2699
                s->interlaced_dct=1;
2700
            
2701
                dct_offset= wrap_y;
2702
                wrap_y<<=1;
2703
            }else
2704
                s->interlaced_dct=0;
2705
        }
2706
        
2707
        s->dsp.get_pixels(s->block[0], ptr                 , wrap_y);
2708
        s->dsp.get_pixels(s->block[1], ptr              + 8, wrap_y);
2709
        s->dsp.get_pixels(s->block[2], ptr + dct_offset    , wrap_y);
2710
        s->dsp.get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
2711

    
2712
        if(s->flags&CODEC_FLAG_GRAY){
2713
            skip_dct[4]= 1;
2714
            skip_dct[5]= 1;
2715
        }else{
2716
            int wrap_c = s->uvlinesize;
2717
            ptr = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2718
            if(emu){
2719
                ff_emulated_edge_mc(s->edge_emu_buffer, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2720
                ptr= s->edge_emu_buffer;
2721
            }
2722
            s->dsp.get_pixels(s->block[4], ptr, wrap_c);
2723

    
2724
            ptr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2725
            if(emu){
2726
                ff_emulated_edge_mc(s->edge_emu_buffer, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2727
                ptr= s->edge_emu_buffer;
2728
            }
2729
            s->dsp.get_pixels(s->block[5], ptr, wrap_c);
2730
        }
2731
    }else{
2732
        op_pixels_func (*op_pix)[4];
2733
        qpel_mc_func (*op_qpix)[16];
2734
        uint8_t *dest_y, *dest_cb, *dest_cr;
2735
        uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2736
        int wrap_y, wrap_c;
2737
        int emu=0;
2738

    
2739
        dest_y  = s->current_picture.data[0] + (mb_y * 16 * s->linesize    ) + mb_x * 16;
2740
        dest_cb = s->current_picture.data[1] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2741
        dest_cr = s->current_picture.data[2] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2742
        wrap_y = s->linesize;
2743
        wrap_c = s->uvlinesize;
2744
        ptr_y  = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2745
        ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2746
        ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2747

    
2748
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
2749
            op_pix = s->dsp.put_pixels_tab;
2750
            op_qpix= s->dsp.put_qpel_pixels_tab;
2751
        }else{
2752
            op_pix = s->dsp.put_no_rnd_pixels_tab;
2753
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2754
        }
2755

    
2756
        if (s->mv_dir & MV_DIR_FORWARD) {
2757
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2758
            op_pix = s->dsp.avg_pixels_tab;
2759
            op_qpix= s->dsp.avg_qpel_pixels_tab;
2760
        }
2761
        if (s->mv_dir & MV_DIR_BACKWARD) {
2762
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2763
        }
2764

    
2765
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2766
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2767
            ptr_y= s->edge_emu_buffer;
2768
            emu=1;
2769
        }
2770
        
2771
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2772
            int progressive_score, interlaced_score;
2773
            
2774
            progressive_score= pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y  ) 
2775
                             + pix_diff_vcmp16x8(ptr_y + wrap_y*8, dest_y + wrap_y*8, wrap_y  );
2776
            interlaced_score = pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y*2)
2777
                             + pix_diff_vcmp16x8(ptr_y + wrap_y  , dest_y + wrap_y  , wrap_y*2);
2778
            
2779
            if(progressive_score > interlaced_score + 600){
2780
                s->interlaced_dct=1;
2781
            
2782
                dct_offset= wrap_y;
2783
                wrap_y<<=1;
2784
            }else
2785
                s->interlaced_dct=0;
2786
        }
2787
        
2788
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
2789
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
2790
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
2791
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
2792
        
2793
        if(s->flags&CODEC_FLAG_GRAY){
2794
            skip_dct[4]= 1;
2795
            skip_dct[5]= 1;
2796
        }else{
2797
            if(emu){
2798
                ff_emulated_edge_mc(s->edge_emu_buffer, ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2799
                ptr_cb= s->edge_emu_buffer;
2800
            }
2801
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2802
            if(emu){
2803
                ff_emulated_edge_mc(s->edge_emu_buffer, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2804
                ptr_cr= s->edge_emu_buffer;
2805
            }
2806
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2807
        }
2808
        /* pre quantization */         
2809
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
2810
            //FIXME optimize
2811
            if(s->dsp.pix_abs8x8(ptr_y               , dest_y               , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
2812
            if(s->dsp.pix_abs8x8(ptr_y            + 8, dest_y            + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
2813
            if(s->dsp.pix_abs8x8(ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
2814
            if(s->dsp.pix_abs8x8(ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
2815
            if(s->dsp.pix_abs8x8(ptr_cb              , dest_cb              , wrap_c) < 20*s->qscale) skip_dct[4]= 1;
2816
            if(s->dsp.pix_abs8x8(ptr_cr              , dest_cr              , wrap_c) < 20*s->qscale) skip_dct[5]= 1;
2817
#if 0
2818
{
2819
 static int stat[7];
2820
 int num=0;
2821
 for(i=0; i<6; i++)
2822
  if(skip_dct[i]) num++;
2823
 stat[num]++;
2824
 
2825
 if(s->mb_x==0 && s->mb_y==0){
2826
  for(i=0; i<7; i++){
2827
   printf("%6d %1d\n", stat[i], i);
2828
  }
2829
 }
2830
}
2831
#endif
2832
        }
2833

    
2834
    }
2835
            
2836
#if 0
2837
            {
2838
                float adap_parm;
2839
                
2840
                adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_stride*mb_y+mb_x] + 1.0) /
2841
                            ((s->mb_var[s->mb_stride*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);
2842
            
2843
                printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d", 
2844
                        (s->mb_type[s->mb_stride*mb_y+mb_x] > 0) ? 'I' : 'P', 
2845
                        s->qscale, adap_parm, s->qscale*adap_parm,
2846
                        s->mb_var[s->mb_stride*mb_y+mb_x], s->avg_mb_var);
2847
            }
2848
#endif
2849
    /* DCT & quantize */
2850
    if(s->out_format==FMT_MJPEG){
2851
        for(i=0;i<6;i++) {
2852
            int overflow;
2853
            s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
2854
            if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2855
        }
2856
    }else{
2857
        for(i=0;i<6;i++) {
2858
            if(!skip_dct[i]){
2859
                int overflow;
2860
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2861
            // FIXME we could decide to change to quantizer instead of clipping
2862
            // JS: I don't think that would be a good idea it could lower quality instead
2863
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
2864
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2865
            }else
2866
                s->block_last_index[i]= -1;
2867
        }
2868
        if(s->luma_elim_threshold && !s->mb_intra)
2869
            for(i=0; i<4; i++)
2870
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2871
        if(s->chroma_elim_threshold && !s->mb_intra)
2872
            for(i=4; i<6; i++)
2873
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2874
    }
2875

    
2876
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
2877
        s->block_last_index[4]=
2878
        s->block_last_index[5]= 0;
2879
        s->block[4][0]=
2880
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
2881
    }
2882

    
2883
    /* huffman encode */
2884
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2885
    case CODEC_ID_MPEG1VIDEO:
2886
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
2887
#ifdef CONFIG_RISKY
2888
    case CODEC_ID_MPEG4:
2889
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
2890
    case CODEC_ID_MSMPEG4V2:
2891
    case CODEC_ID_MSMPEG4V3:
2892
    case CODEC_ID_WMV1:
2893
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
2894
    case CODEC_ID_WMV2:
2895
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
2896
    case CODEC_ID_H263:
2897
    case CODEC_ID_H263P:
2898
    case CODEC_ID_RV10:
2899
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
2900
#endif
2901
    case CODEC_ID_MJPEG:
2902
        mjpeg_encode_mb(s, s->block); break;
2903
    default:
2904
        assert(0);
2905
    }
2906
}
2907

    
2908
#endif //CONFIG_ENCODERS
2909

    
2910
/**
2911
 * combines the (truncated) bitstream to a complete frame
2912
 * @returns -1 if no complete frame could be created
2913
 */
2914
int ff_combine_frame( MpegEncContext *s, int next, uint8_t **buf, int *buf_size){
2915
    ParseContext *pc= &s->parse_context;
2916

    
2917
#if 0
2918
    if(pc->overread){
2919
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
2920
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
2921
    }
2922
#endif
2923

    
2924
    /* copy overreaded byes from last frame into buffer */
2925
    for(; pc->overread>0; pc->overread--){
2926
        pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
2927
    }
2928
    
2929
    pc->last_index= pc->index;
2930

    
2931
    /* copy into buffer end return */
2932
    if(next == END_NOT_FOUND){
2933
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
2934

    
2935
        memcpy(&pc->buffer[pc->index], *buf, *buf_size);
2936
        pc->index += *buf_size;
2937
        return -1;
2938
    }
2939

    
2940
    *buf_size=
2941
    pc->overread_index= pc->index + next;
2942
    
2943
    /* append to buffer */
2944
    if(pc->index){
2945
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
2946

    
2947
        memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
2948
        pc->index = 0;
2949
        *buf= pc->buffer;
2950
    }
2951

    
2952
    /* store overread bytes */
2953
    for(;next < 0; next++){
2954
        pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
2955
        pc->overread++;
2956
    }
2957

    
2958
#if 0
2959
    if(pc->overread){
2960
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
2961
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
2962
    }
2963
#endif
2964

    
2965
    return 0;
2966
}
2967

    
2968
#ifdef CONFIG_ENCODERS
2969
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
2970
{
2971
    int bytes= length>>4;
2972
    int bits= length&15;
2973
    int i;
2974

    
2975
    if(length==0) return;
2976

    
2977
    for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
2978
    put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
2979
}
2980

    
2981
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2982
    int i;
2983

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

    
2986
    /* mpeg1 */
2987
    d->mb_skip_run= s->mb_skip_run;
2988
    for(i=0; i<3; i++)
2989
        d->last_dc[i]= s->last_dc[i];
2990
    
2991
    /* statistics */
2992
    d->mv_bits= s->mv_bits;
2993
    d->i_tex_bits= s->i_tex_bits;
2994
    d->p_tex_bits= s->p_tex_bits;
2995
    d->i_count= s->i_count;
2996
    d->f_count= s->f_count;
2997
    d->b_count= s->b_count;
2998
    d->skip_count= s->skip_count;
2999
    d->misc_bits= s->misc_bits;
3000
    d->last_bits= 0;
3001

    
3002
    d->mb_skiped= s->mb_skiped;
3003
    d->qscale= s->qscale;
3004
}
3005

    
3006
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
3007
    int i;
3008

    
3009
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
3010
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
3011
    
3012
    /* mpeg1 */
3013
    d->mb_skip_run= s->mb_skip_run;
3014
    for(i=0; i<3; i++)
3015
        d->last_dc[i]= s->last_dc[i];
3016
    
3017
    /* statistics */
3018
    d->mv_bits= s->mv_bits;
3019
    d->i_tex_bits= s->i_tex_bits;
3020
    d->p_tex_bits= s->p_tex_bits;
3021
    d->i_count= s->i_count;
3022
    d->f_count= s->f_count;
3023
    d->b_count= s->b_count;
3024
    d->skip_count= s->skip_count;
3025
    d->misc_bits= s->misc_bits;
3026

    
3027
    d->mb_intra= s->mb_intra;
3028
    d->mb_skiped= s->mb_skiped;
3029
    d->mv_type= s->mv_type;
3030
    d->mv_dir= s->mv_dir;
3031
    d->pb= s->pb;
3032
    if(s->data_partitioning){
3033
        d->pb2= s->pb2;
3034
        d->tex_pb= s->tex_pb;
3035
    }
3036
    d->block= s->block;
3037
    for(i=0; i<6; i++)
3038
        d->block_last_index[i]= s->block_last_index[i];
3039
    d->interlaced_dct= s->interlaced_dct;
3040
    d->qscale= s->qscale;
3041
}
3042

    
3043
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
3044
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
3045
                           int *dmin, int *next_block, int motion_x, int motion_y)
3046
{
3047
    int bits_count;
3048
    
3049
    copy_context_before_encode(s, backup, type);
3050

    
3051
    s->block= s->blocks[*next_block];
3052
    s->pb= pb[*next_block];
3053
    if(s->data_partitioning){
3054
        s->pb2   = pb2   [*next_block];
3055
        s->tex_pb= tex_pb[*next_block];
3056
    }
3057

    
3058
    encode_mb(s, motion_x, motion_y);
3059

    
3060
    bits_count= get_bit_count(&s->pb);
3061
    if(s->data_partitioning){
3062
        bits_count+= get_bit_count(&s->pb2);
3063
        bits_count+= get_bit_count(&s->tex_pb);
3064
    }
3065

    
3066
    if(bits_count<*dmin){
3067
        *dmin= bits_count;
3068
        *next_block^=1;
3069

    
3070
        copy_context_after_encode(best, s, type);
3071
    }
3072
}
3073
                
3074
static inline int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
3075
    uint32_t *sq = squareTbl + 256;
3076
    int acc=0;
3077
    int x,y;
3078
    
3079
    if(w==16 && h==16) 
3080
        return s->dsp.sse[0](NULL, src1, src2, stride);
3081
    else if(w==8 && h==8)
3082
        return s->dsp.sse[1](NULL, src1, src2, stride);
3083
    
3084
    for(y=0; y<h; y++){
3085
        for(x=0; x<w; x++){
3086
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
3087
        } 
3088
    }
3089
    
3090
    assert(acc>=0);
3091
    
3092
    return acc;
3093
}
3094

    
3095
static void encode_picture(MpegEncContext *s, int picture_number)
3096
{
3097
    int mb_x, mb_y, pdif = 0;
3098
    int i;
3099
    int bits;
3100
    MpegEncContext best_s, backup_s;
3101
    uint8_t bit_buf[2][3000];
3102
    uint8_t bit_buf2[2][3000];
3103
    uint8_t bit_buf_tex[2][3000];
3104
    PutBitContext pb[2], pb2[2], tex_pb[2];
3105

    
3106
    for(i=0; i<2; i++){
3107
        init_put_bits(&pb    [i], bit_buf    [i], 3000, NULL, NULL);
3108
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000, NULL, NULL);
3109
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
3110
    }
3111

    
3112
    s->picture_number = picture_number;
3113
    
3114
    /* Reset the average MB variance */
3115
    s->current_picture.mb_var_sum = 0;
3116
    s->current_picture.mc_mb_var_sum = 0;
3117

    
3118
#ifdef CONFIG_RISKY
3119
    /* we need to initialize some time vars before we can encode b-frames */
3120
    // RAL: Condition added for MPEG1VIDEO
3121
    if (s->codec_id == CODEC_ID_MPEG1VIDEO || (s->h263_pred && !s->h263_msmpeg4))
3122
        ff_set_mpeg4_time(s, s->picture_number); 
3123
#endif
3124
        
3125
    s->scene_change_score=0;
3126
    
3127
    s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
3128
    
3129
    if(s->pict_type==I_TYPE){
3130
        if(s->msmpeg4_version >= 3) s->no_rounding=1;
3131
        else                        s->no_rounding=0;
3132
    }else if(s->pict_type!=B_TYPE){
3133
        if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
3134
            s->no_rounding ^= 1;          
3135
    }
3136
    
3137
    /* Estimate motion for every MB */
3138
    s->mb_intra=0; //for the rate distoration & bit compare functions
3139
    if(s->pict_type != I_TYPE){
3140
        if(s->pict_type != B_TYPE){
3141
            if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
3142
                s->me.pre_pass=1;
3143
                s->me.dia_size= s->avctx->pre_dia_size;
3144

    
3145
                for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) {
3146
                    for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) {
3147
                        s->mb_x = mb_x;
3148
                        s->mb_y = mb_y;
3149
                        ff_pre_estimate_p_frame_motion(s, mb_x, mb_y);
3150
                    }
3151
                }
3152
                s->me.pre_pass=0;
3153
            }
3154
        }
3155

    
3156
        s->me.dia_size= s->avctx->dia_size;
3157
        for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3158
            s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3159
            s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3160
            s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3161
            s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3162
            for(mb_x=0; mb_x < s->mb_width; mb_x++) {
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
                
3170
                /* compute motion vector & mb_type and store in context */
3171
                if(s->pict_type==B_TYPE)
3172
                    ff_estimate_b_frame_motion(s, mb_x, mb_y);
3173
                else
3174
                    ff_estimate_p_frame_motion(s, mb_x, mb_y);
3175
            }
3176
        }
3177
    }else /* if(s->pict_type == I_TYPE) */{
3178
        /* I-Frame */
3179
        //FIXME do we need to zero them?
3180
        memset(s->motion_val[0], 0, sizeof(int16_t)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
3181
        memset(s->p_mv_table   , 0, sizeof(int16_t)*(s->mb_stride)*s->mb_height*2);
3182
        memset(s->mb_type      , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3183
        
3184
        if(!s->fixed_qscale){
3185
            /* finding spatial complexity for I-frame rate control */
3186
            for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3187
                for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3188
                    int xx = mb_x * 16;
3189
                    int yy = mb_y * 16;
3190
                    uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
3191
                    int varc;
3192
                    int sum = s->dsp.pix_sum(pix, s->linesize);
3193
    
3194
                    varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
3195

    
3196
                    s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
3197
                    s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
3198
                    s->current_picture.mb_var_sum    += varc;
3199
                }
3200
            }
3201
        }
3202
    }
3203
    emms_c();
3204

    
3205
    if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
3206
        s->pict_type= I_TYPE;
3207
        memset(s->mb_type   , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3208
//printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3209
    }
3210

    
3211
    if(!s->umvplus){
3212
        if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
3213
            s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
3214
        
3215
            ff_fix_long_p_mvs(s);
3216
        }
3217

    
3218
        if(s->pict_type==B_TYPE){
3219
            int a, b;
3220

    
3221
            a = ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
3222
            b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, MB_TYPE_BIDIR);
3223
            s->f_code = FFMAX(a, b);
3224

    
3225
            a = ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
3226
            b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, MB_TYPE_BIDIR);
3227
            s->b_code = FFMAX(a, b);
3228

    
3229
            ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
3230
            ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
3231
            ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
3232
            ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
3233
        }
3234
    }
3235
    
3236
    if (s->fixed_qscale) 
3237
        s->frame_qscale = s->current_picture.quality;
3238
    else
3239
        s->frame_qscale = ff_rate_estimate_qscale(s);
3240

    
3241
    if(s->adaptive_quant){
3242
#ifdef CONFIG_RISKY
3243
        switch(s->codec_id){
3244
        case CODEC_ID_MPEG4:
3245
            ff_clean_mpeg4_qscales(s);
3246
            break;
3247
        case CODEC_ID_H263:
3248
        case CODEC_ID_H263P:
3249
            ff_clean_h263_qscales(s);
3250
            break;
3251
        }
3252
#endif
3253

    
3254
        s->qscale= s->current_picture.qscale_table[0];
3255
    }else
3256
        s->qscale= (int)(s->frame_qscale + 0.5);
3257
        
3258
    if (s->out_format == FMT_MJPEG) {
3259
        /* for mjpeg, we do include qscale in the matrix */
3260
        s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
3261
        for(i=1;i<64;i++){
3262
            int j= s->dsp.idct_permutation[i];
3263

    
3264
            s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3265
        }
3266
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, 
3267
                       s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
3268
    }
3269
    
3270
    //FIXME var duplication
3271
    s->current_picture.key_frame= s->pict_type == I_TYPE;
3272
    s->current_picture.pict_type= s->pict_type;
3273

    
3274
    if(s->current_picture.key_frame)
3275
        s->picture_in_gop_number=0;
3276

    
3277
    s->last_bits= get_bit_count(&s->pb);
3278
    switch(s->out_format) {
3279
    case FMT_MJPEG:
3280
        mjpeg_picture_header(s);
3281
        break;
3282
#ifdef CONFIG_RISKY
3283
    case FMT_H263:
3284
        if (s->codec_id == CODEC_ID_WMV2) 
3285
            ff_wmv2_encode_picture_header(s, picture_number);
3286
        else if (s->h263_msmpeg4) 
3287
            msmpeg4_encode_picture_header(s, picture_number);
3288
        else if (s->h263_pred)
3289
            mpeg4_encode_picture_header(s, picture_number);
3290
        else if (s->h263_rv10) 
3291
            rv10_encode_picture_header(s, picture_number);
3292
        else
3293
            h263_encode_picture_header(s, picture_number);
3294
        break;
3295
#endif
3296
    case FMT_MPEG1:
3297
        mpeg1_encode_picture_header(s, picture_number);
3298
        break;
3299
    }
3300
    bits= get_bit_count(&s->pb);
3301
    s->header_bits= bits - s->last_bits;
3302
    s->last_bits= bits;
3303
    s->mv_bits=0;
3304
    s->misc_bits=0;
3305
    s->i_tex_bits=0;
3306
    s->p_tex_bits=0;
3307
    s->i_count=0;
3308
    s->f_count=0;
3309
    s->b_count=0;
3310
    s->skip_count=0;
3311

    
3312
    for(i=0; i<3; i++){
3313
        /* init last dc values */
3314
        /* note: quant matrix value (8) is implied here */
3315
        s->last_dc[i] = 128;
3316
        
3317
        s->current_picture_ptr->error[i] = 0;
3318
    }
3319
    s->mb_skip_run = 0;
3320
    s->last_mv[0][0][0] = 0;
3321
    s->last_mv[0][0][1] = 0;
3322
    s->last_mv[1][0][0] = 0;
3323
    s->last_mv[1][0][1] = 0;
3324
     
3325
    s->last_mv_dir = 0;
3326

    
3327
#ifdef CONFIG_RISKY
3328
    if (s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P)
3329
        s->gob_index = ff_h263_get_gob_height(s);
3330

    
3331
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3332
        ff_mpeg4_init_partitions(s);
3333
#endif
3334

    
3335
    s->resync_mb_x=0;
3336
    s->resync_mb_y=0;
3337
    s->first_slice_line = 1;
3338
    s->ptr_lastgob = s->pb.buf;
3339
    for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3340
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
3341
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
3342
        
3343
        s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3344
        s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3345
        s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3346
        s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3347
        s->block_index[4]= s->block_wrap[4]*(mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2);
3348
        s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
3349
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3350
            const int xy= mb_y*s->mb_stride + mb_x;
3351
            int mb_type= s->mb_type[xy];
3352
//            int d;
3353
            int dmin=10000000;
3354

    
3355
            s->mb_x = mb_x;
3356
            s->mb_y = mb_y;
3357
            s->block_index[0]+=2;
3358
            s->block_index[1]+=2;
3359
            s->block_index[2]+=2;
3360
            s->block_index[3]+=2;
3361
            s->block_index[4]++;
3362
            s->block_index[5]++;
3363

    
3364
            /* write gob / video packet header  */
3365
#ifdef CONFIG_RISKY
3366
            if(s->rtp_mode){
3367
                int current_packet_size, is_gob_start;
3368
                
3369
                current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
3370
                is_gob_start=0;
3371
                
3372
                if(s->codec_id==CODEC_ID_MPEG4){
3373
                    if(current_packet_size >= s->rtp_payload_size
3374
                       && s->mb_y + s->mb_x>0){
3375

    
3376
                        if(s->partitioned_frame){
3377
                            ff_mpeg4_merge_partitions(s);
3378
                            ff_mpeg4_init_partitions(s);
3379
                        }
3380
                        ff_mpeg4_encode_video_packet_header(s);
3381

    
3382
                        if(s->flags&CODEC_FLAG_PASS1){
3383
                            int bits= get_bit_count(&s->pb);
3384
                            s->misc_bits+= bits - s->last_bits;
3385
                            s->last_bits= bits;
3386
                        }
3387
                        ff_mpeg4_clean_buffers(s);
3388
                        is_gob_start=1;
3389
                    }
3390
                }else if(s->codec_id==CODEC_ID_MPEG1VIDEO){
3391
                    if(   current_packet_size >= s->rtp_payload_size 
3392
                       && s->mb_y + s->mb_x>0 && s->mb_skip_run==0){
3393
                        ff_mpeg1_encode_slice_header(s);
3394
                        ff_mpeg1_clean_buffers(s);
3395
                        is_gob_start=1;
3396
                    }
3397
                }else{
3398
                    if(current_packet_size >= s->rtp_payload_size
3399
                       && s->mb_x==0 && s->mb_y>0 && s->mb_y%s->gob_index==0){
3400
                       
3401
                        h263_encode_gob_header(s, mb_y);                       
3402
                        is_gob_start=1;
3403
                    }
3404
                }
3405

    
3406
                if(is_gob_start){
3407
                    s->ptr_lastgob = pbBufPtr(&s->pb);
3408
                    s->first_slice_line=1;
3409
                    s->resync_mb_x=mb_x;
3410
                    s->resync_mb_y=mb_y;
3411
                }
3412
            }
3413
#endif
3414

    
3415
            if(  (s->resync_mb_x   == s->mb_x)
3416
               && s->resync_mb_y+1 == s->mb_y){
3417
                s->first_slice_line=0; 
3418
            }
3419

    
3420
            if(mb_type & (mb_type-1)){ // more than 1 MB type possible
3421
                int next_block=0;
3422
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3423

    
3424
                copy_context_before_encode(&backup_s, s, -1);
3425
                backup_s.pb= s->pb;
3426
                best_s.data_partitioning= s->data_partitioning;
3427
                best_s.partitioned_frame= s->partitioned_frame;
3428
                if(s->data_partitioning){
3429
                    backup_s.pb2= s->pb2;
3430
                    backup_s.tex_pb= s->tex_pb;
3431
                }
3432

    
3433
                if(mb_type&MB_TYPE_INTER){
3434
                    s->mv_dir = MV_DIR_FORWARD;
3435
                    s->mv_type = MV_TYPE_16X16;
3436
                    s->mb_intra= 0;
3437
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
3438
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
3439
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb, 
3440
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3441
                }
3442
                if(mb_type&MB_TYPE_INTER4V){                 
3443
                    s->mv_dir = MV_DIR_FORWARD;
3444
                    s->mv_type = MV_TYPE_8X8;
3445
                    s->mb_intra= 0;
3446
                    for(i=0; i<4; i++){
3447
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3448
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3449
                    }
3450
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb, 
3451
                                 &dmin, &next_block, 0, 0);
3452
                }
3453
                if(mb_type&MB_TYPE_FORWARD){
3454
                    s->mv_dir = MV_DIR_FORWARD;
3455
                    s->mv_type = MV_TYPE_16X16;
3456
                    s->mb_intra= 0;
3457
                    s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3458
                    s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3459
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb, 
3460
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3461
                }
3462
                if(mb_type&MB_TYPE_BACKWARD){
3463
                    s->mv_dir = MV_DIR_BACKWARD;
3464
                    s->mv_type = MV_TYPE_16X16;
3465
                    s->mb_intra= 0;
3466
                    s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3467
                    s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3468
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb, 
3469
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3470
                }
3471
                if(mb_type&MB_TYPE_BIDIR){
3472
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3473
                    s->mv_type = MV_TYPE_16X16;
3474
                    s->mb_intra= 0;
3475
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3476
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3477
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3478
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3479
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb, 
3480
                                 &dmin, &next_block, 0, 0);
3481
                }
3482
                if(mb_type&MB_TYPE_DIRECT){
3483
                    int mx= s->b_direct_mv_table[xy][0];
3484
                    int my= s->b_direct_mv_table[xy][1];
3485
                    
3486
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3487
                    s->mb_intra= 0;
3488
#ifdef CONFIG_RISKY
3489
                    ff_mpeg4_set_direct_mv(s, mx, my);
3490
#endif
3491
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb, 
3492
                                 &dmin, &next_block, mx, my);
3493
                }
3494
                if(mb_type&MB_TYPE_INTRA){
3495
                    s->mv_dir = 0;
3496
                    s->mv_type = MV_TYPE_16X16;
3497
                    s->mb_intra= 1;
3498
                    s->mv[0][0][0] = 0;
3499
                    s->mv[0][0][1] = 0;
3500
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb, 
3501
                                 &dmin, &next_block, 0, 0);
3502
                    /* force cleaning of ac/dc pred stuff if needed ... */
3503
                    if(s->h263_pred || s->h263_aic)
3504
                        s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
3505
                }
3506
                copy_context_after_encode(s, &best_s, -1);
3507
                
3508
                pb_bits_count= get_bit_count(&s->pb);
3509
                flush_put_bits(&s->pb);
3510
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3511
                s->pb= backup_s.pb;
3512
                
3513
                if(s->data_partitioning){
3514
                    pb2_bits_count= get_bit_count(&s->pb2);
3515
                    flush_put_bits(&s->pb2);
3516
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3517
                    s->pb2= backup_s.pb2;
3518
                    
3519
                    tex_pb_bits_count= get_bit_count(&s->tex_pb);
3520
                    flush_put_bits(&s->tex_pb);
3521
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3522
                    s->tex_pb= backup_s.tex_pb;
3523
                }
3524
                s->last_bits= get_bit_count(&s->pb);
3525
            } else {
3526
                int motion_x, motion_y;
3527
                int intra_score;
3528
                int inter_score= s->current_picture.mb_cmp_score[mb_x + mb_y*s->mb_stride];
3529
                
3530
              if(!(s->flags&CODEC_FLAG_HQ) && s->pict_type==P_TYPE){
3531
                /* get luma score */
3532
                if((s->avctx->mb_cmp&0xFF)==FF_CMP_SSE){
3533
                    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
3534
                }else{
3535
                    uint8_t *dest_y;
3536

    
3537
                    int mean= s->current_picture.mb_mean[mb_x + mb_y*s->mb_stride]; //FIXME
3538
                    mean*= 0x01010101;
3539
                    
3540
                    dest_y  = s->new_picture.data[0] + (mb_y * 16 * s->linesize    ) + mb_x * 16;
3541
                
3542
                    for(i=0; i<16; i++){
3543
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 0]) = mean;
3544
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 4]) = mean;
3545
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 8]) = mean;
3546
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+12]) = mean;
3547
                    }
3548

    
3549
                    s->mb_intra=1;
3550
                    intra_score= s->dsp.mb_cmp[0](s, s->me.scratchpad, dest_y, s->linesize);
3551
                                        
3552
/*                    printf("intra:%7d inter:%7d var:%7d mc_var.%7d\n", intra_score>>8, inter_score>>8, 
3553
                        s->current_picture.mb_var[mb_x + mb_y*s->mb_stride],
3554
                        s->current_picture.mc_mb_var[mb_x + mb_y*s->mb_stride]);*/
3555
                }
3556
                
3557
                /* get chroma score */
3558
                if(s->avctx->mb_cmp&FF_CMP_CHROMA){
3559
                    int i;
3560
                    
3561
                    s->mb_intra=1;
3562
                    for(i=1; i<3; i++){
3563
                        uint8_t *dest_c;
3564
                        int mean;
3565
                        
3566
                        if(s->out_format == FMT_H263){
3567
                            mean= (s->dc_val[i][mb_x + (mb_y+1)*(s->mb_width+2)] + 4)>>3; //FIXME not exact but simple ;)
3568
                        }else{
3569
                            mean= (s->last_dc[i] + 4)>>3;
3570
                        }
3571
                        dest_c = s->new_picture.data[i] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
3572
                        
3573
                        mean*= 0x01010101;
3574
                        for(i=0; i<8; i++){
3575
                            *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 0]) = mean;
3576
                            *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 4]) = mean;
3577
                        }
3578
                        
3579
                        intra_score+= s->dsp.mb_cmp[1](s, s->me.scratchpad, dest_c, s->uvlinesize);
3580
                    }                
3581
                }
3582

    
3583
                /* bias */
3584
                switch(s->avctx->mb_cmp&0xFF){
3585
                default:
3586
                case FF_CMP_SAD:
3587
                    intra_score+= 32*s->qscale;
3588
                    break;
3589
                case FF_CMP_SSE:
3590
                    intra_score+= 24*s->qscale*s->qscale;
3591
                    break;
3592
                case FF_CMP_SATD:
3593
                    intra_score+= 96*s->qscale;
3594
                    break;
3595
                case FF_CMP_DCT:
3596
                    intra_score+= 48*s->qscale;
3597
                    break;
3598
                case FF_CMP_BIT:
3599
                    intra_score+= 16;
3600
                    break;
3601
                case FF_CMP_PSNR:
3602
                case FF_CMP_RD:
3603
                    intra_score+= (s->qscale*s->qscale*109*8 + 64)>>7;
3604
                    break;
3605
                }
3606

    
3607
                if(intra_score < inter_score)
3608
                    mb_type= MB_TYPE_INTRA;
3609
              }  
3610
                
3611
                s->mv_type=MV_TYPE_16X16;
3612
                // only one MB-Type possible
3613
                
3614
                switch(mb_type){
3615
                case MB_TYPE_INTRA:
3616
                    s->mv_dir = 0;
3617
                    s->mb_intra= 1;
3618
                    motion_x= s->mv[0][0][0] = 0;
3619
                    motion_y= s->mv[0][0][1] = 0;
3620
                    break;
3621
                case MB_TYPE_INTER:
3622
                    s->mv_dir = MV_DIR_FORWARD;
3623
                    s->mb_intra= 0;
3624
                    motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3625
                    motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3626
                    break;
3627
                case MB_TYPE_INTER4V:
3628
                    s->mv_dir = MV_DIR_FORWARD;
3629
                    s->mv_type = MV_TYPE_8X8;
3630
                    s->mb_intra= 0;
3631
                    for(i=0; i<4; i++){
3632
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3633
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3634
                    }
3635
                    motion_x= motion_y= 0;
3636
                    break;
3637
                case MB_TYPE_DIRECT:
3638
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3639
                    s->mb_intra= 0;
3640
                    motion_x=s->b_direct_mv_table[xy][0];
3641
                    motion_y=s->b_direct_mv_table[xy][1];
3642
#ifdef CONFIG_RISKY
3643
                    ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3644
#endif
3645
                    break;
3646
                case MB_TYPE_BIDIR:
3647
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3648
                    s->mb_intra= 0;
3649
                    motion_x=0;
3650
                    motion_y=0;
3651
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3652
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3653
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3654
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3655
                    break;
3656
                case MB_TYPE_BACKWARD:
3657
                    s->mv_dir = MV_DIR_BACKWARD;
3658
                    s->mb_intra= 0;
3659
                    motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3660
                    motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3661
                    break;
3662
                case MB_TYPE_FORWARD:
3663
                    s->mv_dir = MV_DIR_FORWARD;
3664
                    s->mb_intra= 0;
3665
                    motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3666
                    motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3667
//                    printf(" %d %d ", motion_x, motion_y);
3668
                    break;
3669
                default:
3670
                    motion_x=motion_y=0; //gcc warning fix
3671
                    printf("illegal MB type\n");
3672
                }
3673

    
3674
                encode_mb(s, motion_x, motion_y);
3675

    
3676
                // RAL: Update last macrobloc type
3677
                s->last_mv_dir = s->mv_dir;
3678
            }
3679

    
3680
            /* clean the MV table in IPS frames for direct mode in B frames */
3681
            if(s->mb_intra /* && I,P,S_TYPE */){
3682
                s->p_mv_table[xy][0]=0;
3683
                s->p_mv_table[xy][1]=0;
3684
            }
3685

    
3686
            MPV_decode_mb(s, s->block);
3687
            
3688
            if(s->flags&CODEC_FLAG_PSNR){
3689
                int w= 16;
3690
                int h= 16;
3691

    
3692
                if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3693
                if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3694

    
3695
                s->current_picture_ptr->error[0] += sse(
3696
                    s,
3697
                    s->new_picture    .data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3698
                    s->current_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3699
                    w, h, s->linesize);
3700
                s->current_picture_ptr->error[1] += sse(
3701
                    s,
3702
                    s->new_picture    .data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3703
                    s->current_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3704
                    w>>1, h>>1, s->uvlinesize);
3705
                s->current_picture_ptr->error[2] += sse(
3706
                    s,
3707
                    s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3708
                    s->current_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3709
                    w>>1, h>>1, s->uvlinesize);
3710
            }
3711
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, get_bit_count(&s->pb));
3712
        }
3713
    }
3714
    emms_c();
3715

    
3716
#ifdef CONFIG_RISKY
3717
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3718
        ff_mpeg4_merge_partitions(s);
3719

    
3720
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
3721
        msmpeg4_encode_ext_header(s);
3722

    
3723
    if(s->codec_id==CODEC_ID_MPEG4) 
3724
        ff_mpeg4_stuffing(&s->pb);
3725
#endif
3726

    
3727
    //if (s->gob_number)
3728
    //    fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
3729
    
3730
    /* Send the last GOB if RTP */    
3731
    if (s->rtp_mode) {
3732
        flush_put_bits(&s->pb);
3733
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
3734
        /* Call the RTP callback to send the last GOB */
3735
        if (s->rtp_callback)
3736
            s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
3737
        s->ptr_lastgob = pbBufPtr(&s->pb);
3738
        //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
3739
    }
3740
}
3741

    
3742
static int dct_quantize_trellis_c(MpegEncContext *s, 
3743
                        DCTELEM *block, int n,
3744
                        int qscale, int *overflow){
3745
    const int *qmat;
3746
    const uint8_t *scantable= s->intra_scantable.scantable;
3747
    int max=0;
3748
    unsigned int threshold1, threshold2;
3749
    int bias=0;
3750
    int run_tab[65];
3751
    int level_tab[65];
3752
    int score_tab[65];
3753
    int last_run=0;
3754
    int last_level=0;
3755
    int last_score= 0;
3756
    int last_i= 0;
3757
    int coeff[3][64];
3758
    int coeff_count[64];
3759
    int lambda, qmul, qadd, start_i, last_non_zero, i;
3760
    const int esc_length= s->ac_esc_length;
3761
    uint8_t * length;
3762
    uint8_t * last_length;
3763
    int score_limit=0;
3764
    int left_limit= 0;
3765
        
3766
    s->dsp.fdct (block);
3767

    
3768
    qmul= qscale*16;
3769
    qadd= ((qscale-1)|1)*8;
3770

    
3771
    if (s->mb_intra) {
3772
        int q;
3773
        if (!s->h263_aic) {
3774
            if (n < 4)
3775
                q = s->y_dc_scale;
3776
            else
3777
                q = s->c_dc_scale;
3778
            q = q << 3;
3779
        } else{
3780
            /* For AIC we skip quant/dequant of INTRADC */
3781
            q = 1 << 3;
3782
            qadd=0;
3783
        }
3784
            
3785
        /* note: block[0] is assumed to be positive */
3786
        block[0] = (block[0] + (q >> 1)) / q;
3787
        start_i = 1;
3788
        last_non_zero = 0;
3789
        qmat = s->q_intra_matrix[qscale];
3790
        if(s->mpeg_quant || s->codec_id== CODEC_ID_MPEG1VIDEO)
3791
            bias= 1<<(QMAT_SHIFT-1);
3792
        length     = s->intra_ac_vlc_length;
3793
        last_length= s->intra_ac_vlc_last_length;
3794
    } else {
3795
        start_i = 0;
3796
        last_non_zero = -1;
3797
        qmat = s->q_inter_matrix[qscale];
3798
        length     = s->inter_ac_vlc_length;
3799
        last_length= s->inter_ac_vlc_last_length;
3800
    }
3801

    
3802
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
3803
    threshold2= (threshold1<<1);
3804

    
3805
    for(i=start_i; i<64; i++) {
3806
        const int j = scantable[i];
3807
        const int k= i-start_i;
3808
        int level = block[j];
3809
        level = level * qmat[j];
3810

    
3811
//        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
3812
//           || bias-level >= (1<<(QMAT_SHIFT - 3))){
3813
        if(((unsigned)(level+threshold1))>threshold2){
3814
            if(level>0){
3815
                level= (bias + level)>>QMAT_SHIFT;
3816
                coeff[0][k]= level;
3817
                coeff[1][k]= level-1;
3818
//                coeff[2][k]= level-2;
3819
            }else{
3820
                level= (bias - level)>>QMAT_SHIFT;
3821
                coeff[0][k]= -level;
3822
                coeff[1][k]= -level+1;
3823
//                coeff[2][k]= -level+2;
3824
            }
3825
            coeff_count[k]= FFMIN(level, 2);
3826
            max |=level;
3827
            last_non_zero = i;
3828
        }else{
3829
            coeff[0][k]= (level>>31)|1;
3830
            coeff_count[k]= 1;
3831
        }
3832
    }
3833
    
3834
    *overflow= s->max_qcoeff < max; //overflow might have happend
3835
    
3836
    if(last_non_zero < start_i){
3837
        memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3838
        return last_non_zero;
3839
    }
3840

    
3841
    lambda= (qscale*qscale*64*105 + 64)>>7; //FIXME finetune
3842
        
3843
    score_tab[0]= 0;
3844
    for(i=0; i<=last_non_zero - start_i; i++){
3845
        int level_index, run, j;
3846
        const int dct_coeff= block[ scantable[i + start_i] ];
3847
        const int zero_distoration= dct_coeff*dct_coeff;
3848
        int best_score=256*256*256*120;
3849

    
3850
        last_score += zero_distoration;
3851
        for(level_index=0; level_index < coeff_count[i]; level_index++){
3852
            int distoration;
3853
            int level= coeff[level_index][i];
3854
            int unquant_coeff;
3855
            
3856
            assert(level);
3857

    
3858
            if(s->out_format == FMT_H263){
3859
                if(level>0){
3860
                    unquant_coeff= level*qmul + qadd;
3861
                }else{
3862
                    unquant_coeff= level*qmul - qadd;
3863
                }
3864
            }else{ //MPEG1
3865
                j= s->dsp.idct_permutation[ scantable[i + start_i] ]; //FIXME optimize
3866
                if(s->mb_intra){
3867
                    if (level < 0) {
3868
                        unquant_coeff = (int)((-level) * qscale * s->intra_matrix[j]) >> 3;
3869
                        unquant_coeff = -((unquant_coeff - 1) | 1);
3870
                    } else {
3871
                        unquant_coeff = (int)(  level  * qscale * s->intra_matrix[j]) >> 3;
3872
                        unquant_coeff =   (unquant_coeff - 1) | 1;
3873
                    }
3874
                }else{
3875
                    if (level < 0) {
3876
                        unquant_coeff = ((((-level) << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3877
                        unquant_coeff = -((unquant_coeff - 1) | 1);
3878
                    } else {
3879
                        unquant_coeff = (((  level  << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3880
                        unquant_coeff =   (unquant_coeff - 1) | 1;
3881
                    }
3882
                }
3883
                unquant_coeff<<= 3;
3884
            }
3885

    
3886
            distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff);
3887
            level+=64;
3888
            if((level&(~127)) == 0){
3889
                for(run=0; run<=i - left_limit; run++){
3890
                    int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3891
                    score += score_tab[i-run];
3892
                    
3893
                    if(score < best_score){
3894
                        best_score= 
3895
                        score_tab[i+1]= score;
3896
                        run_tab[i+1]= run;
3897
                        level_tab[i+1]= level-64;
3898
                    }
3899
                }
3900

    
3901
                if(s->out_format == FMT_H263){
3902
                    for(run=0; run<=i - left_limit; run++){
3903
                        int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3904
                        score += score_tab[i-run];
3905
                        if(score < last_score){
3906
                            last_score= score;
3907
                            last_run= run;
3908
                            last_level= level-64;
3909
                            last_i= i+1;
3910
                        }
3911
                    }
3912
                }
3913
            }else{
3914
                distoration += esc_length*lambda;
3915
                for(run=0; run<=i - left_limit; run++){
3916
                    int score= distoration + score_tab[i-run];
3917
                    
3918
                    if(score < best_score){
3919
                        best_score= 
3920
                        score_tab[i+1]= score;
3921
                        run_tab[i+1]= run;
3922
                        level_tab[i+1]= level-64;
3923
                    }
3924
                }
3925

    
3926
                if(s->out_format == FMT_H263){
3927
                    for(run=0; run<=i - left_limit; run++){
3928
                        int score= distoration + score_tab[i-run];
3929
                        if(score < last_score){
3930
                            last_score= score;
3931
                            last_run= run;
3932
                            last_level= level-64;
3933
                            last_i= i+1;
3934
                        }
3935
                    }
3936
                }
3937
            }
3938
        }
3939

    
3940
        for(j=left_limit; j<=i; j++){
3941
            score_tab[j] += zero_distoration;
3942
        }
3943
        score_limit+= zero_distoration;
3944
        if(score_tab[i+1] < score_limit)
3945
            score_limit= score_tab[i+1];
3946
        
3947
        //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3948
        while(score_tab[ left_limit ] > score_limit + lambda) left_limit++;
3949
    }
3950

    
3951
        //FIXME add some cbp penalty
3952

    
3953
    if(s->out_format != FMT_H263){
3954
        last_score= 256*256*256*120;
3955
        for(i= left_limit; i<=last_non_zero - start_i + 1; i++){
3956
            int score= score_tab[i];
3957
            if(i) score += lambda*2; //FIXME exacter?
3958

    
3959
            if(score < last_score){
3960
                last_score= score;
3961
                last_i= i;
3962
                last_level= level_tab[i];
3963
                last_run= run_tab[i];
3964
            }
3965
        }
3966
    }
3967
    
3968
    last_non_zero= last_i - 1 + start_i;
3969
    memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3970
    
3971
    if(last_non_zero < start_i)
3972
        return last_non_zero;
3973
    
3974
    i= last_i;
3975
    assert(last_level);
3976
//FIXME use permutated scantable
3977
    block[ s->dsp.idct_permutation[ scantable[last_non_zero] ] ]= last_level;
3978
    i -= last_run + 1;
3979
    
3980
    for(;i>0 ; i -= run_tab[i] + 1){
3981
        const int j= s->dsp.idct_permutation[ scantable[i - 1 + start_i] ];
3982
    
3983
        block[j]= level_tab[i];
3984
        assert(block[j]);
3985
    }
3986

    
3987
    return last_non_zero;
3988
}
3989

    
3990
static int dct_quantize_c(MpegEncContext *s, 
3991
                        DCTELEM *block, int n,
3992
                        int qscale, int *overflow)
3993
{
3994
    int i, j, level, last_non_zero, q;
3995
    const int *qmat;
3996
    const uint8_t *scantable= s->intra_scantable.scantable;
3997
    int bias;
3998
    int max=0;
3999
    unsigned int threshold1, threshold2;
4000

    
4001
    s->dsp.fdct (block);
4002

    
4003
    if (s->mb_intra) {
4004
        if (!s->h263_aic) {
4005
            if (n < 4)
4006
                q = s->y_dc_scale;
4007
            else
4008
                q = s->c_dc_scale;
4009
            q = q << 3;
4010
        } else
4011
            /* For AIC we skip quant/dequant of INTRADC */
4012
            q = 1 << 3;
4013
            
4014
        /* note: block[0] is assumed to be positive */
4015
        block[0] = (block[0] + (q >> 1)) / q;
4016
        i = 1;
4017
        last_non_zero = 0;
4018
        qmat = s->q_intra_matrix[qscale];
4019
        bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4020
    } else {
4021
        i = 0;
4022
        last_non_zero = -1;
4023
        qmat = s->q_inter_matrix[qscale];
4024
        bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4025
    }
4026
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
4027
    threshold2= (threshold1<<1);
4028

    
4029
    for(;i<64;i++) {
4030
        j = scantable[i];
4031
        level = block[j];
4032
        level = level * qmat[j];
4033

    
4034
//        if(   bias+level >= (1<<QMAT_SHIFT)
4035
//           || bias-level >= (1<<QMAT_SHIFT)){
4036
        if(((unsigned)(level+threshold1))>threshold2){
4037
            if(level>0){
4038
                level= (bias + level)>>QMAT_SHIFT;
4039
                block[j]= level;
4040
            }else{
4041
                level= (bias - level)>>QMAT_SHIFT;
4042
                block[j]= -level;
4043
            }
4044
            max |=level;
4045
            last_non_zero = i;
4046
        }else{
4047
            block[j]=0;
4048
        }
4049
    }
4050
    *overflow= s->max_qcoeff < max; //overflow might have happend
4051
    
4052
    /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4053
    if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
4054
        ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4055

    
4056
    return last_non_zero;
4057
}
4058

    
4059
#endif //CONFIG_ENCODERS
4060

    
4061
static void dct_unquantize_mpeg1_c(MpegEncContext *s, 
4062
                                   DCTELEM *block, int n, int qscale)
4063
{
4064
    int i, level, nCoeffs;
4065
    const uint16_t *quant_matrix;
4066

    
4067
    nCoeffs= s->block_last_index[n];
4068
    
4069
    if (s->mb_intra) {
4070
        if (n < 4) 
4071
            block[0] = block[0] * s->y_dc_scale;
4072
        else
4073
            block[0] = block[0] * s->c_dc_scale;
4074
        /* XXX: only mpeg1 */
4075
        quant_matrix = s->intra_matrix;
4076
        for(i=1;i<=nCoeffs;i++) {
4077
            int j= s->intra_scantable.permutated[i];
4078
            level = block[j];
4079
            if (level) {
4080
                if (level < 0) {
4081
                    level = -level;
4082
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
4083
                    level = (level - 1) | 1;
4084
                    level = -level;
4085
                } else {
4086
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
4087
                    level = (level - 1) | 1;
4088
                }
4089
#ifdef PARANOID
4090
                if (level < -2048 || level > 2047)
4091
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4092
#endif
4093
                block[j] = level;
4094
            }
4095
        }
4096
    } else {
4097
        i = 0;
4098
        quant_matrix = s->inter_matrix;
4099
        for(;i<=nCoeffs;i++) {
4100
            int j= s->intra_scantable.permutated[i];
4101
            level = block[j];
4102
            if (level) {
4103
                if (level < 0) {
4104
                    level = -level;
4105
                    level = (((level << 1) + 1) * qscale *
4106
                             ((int) (quant_matrix[j]))) >> 4;
4107
                    level = (level - 1) | 1;
4108
                    level = -level;
4109
                } else {
4110
                    level = (((level << 1) + 1) * qscale *
4111
                             ((int) (quant_matrix[j]))) >> 4;
4112
                    level = (level - 1) | 1;
4113
                }
4114
#ifdef PARANOID
4115
                if (level < -2048 || level > 2047)
4116
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4117
#endif
4118
                block[j] = level;
4119
            }
4120
        }
4121
    }
4122
}
4123

    
4124
static void dct_unquantize_mpeg2_c(MpegEncContext *s, 
4125
                                   DCTELEM *block, int n, int qscale)
4126
{
4127
    int i, level, nCoeffs;
4128
    const uint16_t *quant_matrix;
4129

    
4130
    if(s->alternate_scan) nCoeffs= 63;
4131
    else nCoeffs= s->block_last_index[n];
4132
    
4133
    if (s->mb_intra) {
4134
        if (n < 4) 
4135
            block[0] = block[0] * s->y_dc_scale;
4136
        else
4137
            block[0] = block[0] * s->c_dc_scale;
4138
        quant_matrix = s->intra_matrix;
4139
        for(i=1;i<=nCoeffs;i++) {
4140
            int j= s->intra_scantable.permutated[i];
4141
            level = block[j];
4142
            if (level) {
4143
                if (level < 0) {
4144
                    level = -level;
4145
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
4146
                    level = -level;
4147
                } else {
4148
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
4149
                }
4150
#ifdef PARANOID
4151
                if (level < -2048 || level > 2047)
4152
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4153
#endif
4154
                block[j] = level;
4155
            }
4156
        }
4157
    } else {
4158
        int sum=-1;
4159
        i = 0;
4160
        quant_matrix = s->inter_matrix;
4161
        for(;i<=nCoeffs;i++) {
4162
            int j= s->intra_scantable.permutated[i];
4163
            level = block[j];
4164
            if (level) {
4165
                if (level < 0) {
4166
                    level = -level;
4167
                    level = (((level << 1) + 1) * qscale *
4168
                             ((int) (quant_matrix[j]))) >> 4;
4169
                    level = -level;
4170
                } else {
4171
                    level = (((level << 1) + 1) * qscale *
4172
                             ((int) (quant_matrix[j]))) >> 4;
4173
                }
4174
#ifdef PARANOID
4175
                if (level < -2048 || level > 2047)
4176
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4177
#endif
4178
                block[j] = level;
4179
                sum+=level;
4180
            }
4181
        }
4182
        block[63]^=sum&1;
4183
    }
4184
}
4185

    
4186

    
4187
static void dct_unquantize_h263_c(MpegEncContext *s, 
4188
                                  DCTELEM *block, int n, int qscale)
4189
{
4190
    int i, level, qmul, qadd;
4191
    int nCoeffs;
4192
    
4193
    assert(s->block_last_index[n]>=0);
4194
    
4195
    qadd = (qscale - 1) | 1;
4196
    qmul = qscale << 1;
4197
    
4198
    if (s->mb_intra) {
4199
        if (!s->h263_aic) {
4200
            if (n < 4) 
4201
                block[0] = block[0] * s->y_dc_scale;
4202
            else
4203
                block[0] = block[0] * s->c_dc_scale;
4204
        }else
4205
            qadd = 0;
4206
        i = 1;
4207
        nCoeffs= 63; //does not allways use zigzag table 
4208
    } else {
4209
        i = 0;
4210
        nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
4211
    }
4212

    
4213
    for(;i<=nCoeffs;i++) {
4214
        level = block[i];
4215
        if (level) {
4216
            if (level < 0) {
4217
                level = level * qmul - qadd;
4218
            } else {
4219
                level = level * qmul + qadd;
4220
            }
4221
#ifdef PARANOID
4222
                if (level < -2048 || level > 2047)
4223
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4224
#endif
4225
            block[i] = level;
4226
        }
4227
    }
4228
}
4229

    
4230

    
4231
static const AVOption mpeg4_options[] =
4232
{
4233
    AVOPTION_CODEC_INT("bitrate", "desired video bitrate", bit_rate, 4, 240000000, 800000),
4234
    AVOPTION_CODEC_FLAG("vhq", "very high quality", flags, CODEC_FLAG_HQ, 0),
4235
    AVOPTION_CODEC_INT("ratetol", "number of bits the bitstream is allowed to diverge from the reference"
4236
                       "the reference can be CBR (for CBR pass1) or VBR (for pass2)",
4237
                       bit_rate_tolerance, 4, 240000000, 8000),
4238
    AVOPTION_CODEC_INT("qmin", "minimum quantizer", qmin, 1, 31, 2),
4239
    AVOPTION_CODEC_INT("qmax", "maximum quantizer", qmax, 1, 31, 31),
4240
    AVOPTION_CODEC_STRING("rc_eq", "rate control equation",
4241
                          rc_eq, "tex^qComp,option1,options2", 0),
4242
    AVOPTION_CODEC_INT("rc_minrate", "rate control minimum bitrate",
4243
                       rc_min_rate, 4, 24000000, 0),
4244
    AVOPTION_CODEC_INT("rc_maxrate", "rate control maximum bitrate",
4245
                       rc_max_rate, 4, 24000000, 0),
4246
    AVOPTION_CODEC_DOUBLE("rc_buf_aggresivity", "rate control buffer aggresivity",
4247
                          rc_buffer_aggressivity, 4, 24000000, 0),
4248
    AVOPTION_CODEC_DOUBLE("rc_initial_cplx", "initial complexity for pass1 ratecontrol",
4249
                          rc_initial_cplx, 0., 9999999., 0),
4250
    AVOPTION_CODEC_DOUBLE("i_quant_factor", "qscale factor between p and i frames",
4251
                          i_quant_factor, 0., 0., 0),
4252
    AVOPTION_CODEC_DOUBLE("i_quant_offset", "qscale offset between p and i frames",
4253
                          i_quant_factor, -999999., 999999., 0),
4254
    AVOPTION_CODEC_INT("dct_algo", "dct alghorithm",
4255
                       dct_algo, 0, 5, 0), // fixme - "Auto,FastInt,Int,MMX,MLib,Altivec"
4256
    AVOPTION_CODEC_DOUBLE("lumi_masking", "luminance masking",
4257
                          lumi_masking, 0., 999999., 0),
4258
    AVOPTION_CODEC_DOUBLE("temporal_cplx_masking", "temporary complexity masking",
4259
                          temporal_cplx_masking, 0., 999999., 0),
4260
    AVOPTION_CODEC_DOUBLE("spatial_cplx_masking", "spatial complexity masking",
4261
                          spatial_cplx_masking, 0., 999999., 0),
4262
    AVOPTION_CODEC_DOUBLE("p_masking", "p block masking",
4263
                          p_masking, 0., 999999., 0),
4264
    AVOPTION_CODEC_DOUBLE("dark_masking", "darkness masking",
4265
                          dark_masking, 0., 999999., 0),
4266
    AVOPTION_CODEC_INT("idct_algo", "idct alghorithm",
4267
                       idct_algo, 0, 8, 0), // fixme - "Auto,Int,Simple,SimpleMMX,LibMPEG2MMX,PS2,MLib,ARM,Altivec"
4268

    
4269
    AVOPTION_CODEC_INT("mb_qmin", "minimum MB quantizer",
4270
                       mb_qmin, 0, 8, 0),
4271
    AVOPTION_CODEC_INT("mb_qmax", "maximum MB quantizer",
4272
                       mb_qmin, 0, 8, 0),
4273

    
4274
    AVOPTION_CODEC_INT("me_cmp", "ME compare function",
4275
                       me_cmp, 0, 24000000, 0),
4276
    AVOPTION_CODEC_INT("me_sub_cmp", "subpixel ME compare function",
4277
                       me_sub_cmp, 0, 24000000, 0),
4278

    
4279

    
4280
    AVOPTION_CODEC_INT("dia_size", "ME diamond size & shape",
4281
                       dia_size, 0, 24000000, 0),
4282
    AVOPTION_CODEC_INT("last_predictor_count", "amount of previous MV predictors",
4283
                       last_predictor_count, 0, 24000000, 0),
4284

    
4285
    AVOPTION_CODEC_INT("pre_me", "pre pass for ME",
4286
                       pre_me, 0, 24000000, 0),
4287
    AVOPTION_CODEC_INT("me_pre_cmp", "ME pre pass compare function",
4288
                       me_pre_cmp, 0, 24000000, 0),
4289

    
4290
    AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4291
                       me_range, 0, 24000000, 0),
4292
    AVOPTION_CODEC_INT("pre_dia_size", "ME pre pass diamod size & shape",
4293
                       pre_dia_size, 0, 24000000, 0),
4294
    AVOPTION_CODEC_INT("me_subpel_quality", "subpel ME quality",
4295
                       me_subpel_quality, 0, 24000000, 0),
4296
    AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4297
                       me_range, 0, 24000000, 0),
4298
    AVOPTION_CODEC_FLAG("psnr", "calculate PSNR of compressed frames",
4299
                        flags, CODEC_FLAG_PSNR, 0),
4300
    AVOPTION_CODEC_RCOVERRIDE("rc_override", "ratecontrol override (=startframe,endframe,qscale,quality_factor)",
4301
                              rc_override),
4302
    AVOPTION_SUB(avoptions_common),
4303
    AVOPTION_END()
4304
};
4305

    
4306
#ifdef CONFIG_ENCODERS
4307

    
4308
AVCodec mpeg1video_encoder = {
4309
    "mpeg1video",
4310
    CODEC_TYPE_VIDEO,
4311
    CODEC_ID_MPEG1VIDEO,
4312
    sizeof(MpegEncContext),
4313
    MPV_encode_init,
4314
    MPV_encode_picture,
4315
    MPV_encode_end,
4316
};
4317

    
4318
#ifdef CONFIG_RISKY
4319

    
4320
AVCodec h263_encoder = {
4321
    "h263",
4322
    CODEC_TYPE_VIDEO,
4323
    CODEC_ID_H263,
4324
    sizeof(MpegEncContext),
4325
    MPV_encode_init,
4326
    MPV_encode_picture,
4327
    MPV_encode_end,
4328
};
4329

    
4330
AVCodec h263p_encoder = {
4331
    "h263p",
4332
    CODEC_TYPE_VIDEO,
4333
    CODEC_ID_H263P,
4334
    sizeof(MpegEncContext),
4335
    MPV_encode_init,
4336
    MPV_encode_picture,
4337
    MPV_encode_end,
4338
};
4339

    
4340
AVCodec rv10_encoder = {
4341
    "rv10",
4342
    CODEC_TYPE_VIDEO,
4343
    CODEC_ID_RV10,
4344
    sizeof(MpegEncContext),
4345
    MPV_encode_init,
4346
    MPV_encode_picture,
4347
    MPV_encode_end,
4348
};
4349

    
4350
AVCodec mpeg4_encoder = {
4351
    "mpeg4",
4352
    CODEC_TYPE_VIDEO,
4353
    CODEC_ID_MPEG4,
4354
    sizeof(MpegEncContext),
4355
    MPV_encode_init,
4356
    MPV_encode_picture,
4357
    MPV_encode_end,
4358
    .options = mpeg4_options,
4359
};
4360

    
4361
AVCodec msmpeg4v1_encoder = {
4362
    "msmpeg4v1",
4363
    CODEC_TYPE_VIDEO,
4364
    CODEC_ID_MSMPEG4V1,
4365
    sizeof(MpegEncContext),
4366
    MPV_encode_init,
4367
    MPV_encode_picture,
4368
    MPV_encode_end,
4369
    .options = mpeg4_options,
4370
};
4371

    
4372
AVCodec msmpeg4v2_encoder = {
4373
    "msmpeg4v2",
4374
    CODEC_TYPE_VIDEO,
4375
    CODEC_ID_MSMPEG4V2,
4376
    sizeof(MpegEncContext),
4377
    MPV_encode_init,
4378
    MPV_encode_picture,
4379
    MPV_encode_end,
4380
    .options = mpeg4_options,
4381
};
4382

    
4383
AVCodec msmpeg4v3_encoder = {
4384
    "msmpeg4",
4385
    CODEC_TYPE_VIDEO,
4386
    CODEC_ID_MSMPEG4V3,
4387
    sizeof(MpegEncContext),
4388
    MPV_encode_init,
4389
    MPV_encode_picture,
4390
    MPV_encode_end,
4391
    .options = mpeg4_options,
4392
};
4393

    
4394
AVCodec wmv1_encoder = {
4395
    "wmv1",
4396
    CODEC_TYPE_VIDEO,
4397
    CODEC_ID_WMV1,
4398
    sizeof(MpegEncContext),
4399
    MPV_encode_init,
4400
    MPV_encode_picture,
4401
    MPV_encode_end,
4402
    .options = mpeg4_options,
4403
};
4404

    
4405
#endif
4406

    
4407
AVCodec mjpeg_encoder = {
4408
    "mjpeg",
4409
    CODEC_TYPE_VIDEO,
4410
    CODEC_ID_MJPEG,
4411
    sizeof(MpegEncContext),
4412
    MPV_encode_init,
4413
    MPV_encode_picture,
4414
    MPV_encode_end,
4415
};
4416

    
4417
#endif //CONFIG_ENCODERS
4418