Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 3bb07d61

History | View | Annotate | Download (159 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->parse_context.buffer);
480
    s->parse_context.buffer_size=0;
481

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

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

    
527
#ifdef CONFIG_ENCODERS
528

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

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

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

    
571
    s->me_method = avctx->me_method;
572

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

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

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

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

    
753
            default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
754
            memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
755
            memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
756

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

    
771
    s->encoding = 1;
772

    
773
    /* init */
774
    if (MPV_common_init(s) < 0)
775
        return -1;
776
    
777
    ff_init_me(s);
778

    
779
#ifdef CONFIG_ENCODERS
780
#ifdef CONFIG_RISKY
781
    if (s->out_format == FMT_H263)
782
        h263_encode_init(s);
783
    if(s->msmpeg4_version)
784
        ff_msmpeg4_encode_init(s);
785
#endif
786
    if (s->out_format == FMT_MPEG1)
787
        ff_mpeg1_encode_init(s);
788
#endif
789

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

    
808
    /* precompute matrix */
809
    /* for mjpeg, we do include qscale in the matrix */
810
    if (s->out_format != FMT_MJPEG) {
811
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, s->q_intra_matrix16_bias, 
812
                       s->intra_matrix, s->intra_quant_bias, 1, 31);
813
        convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16, s->q_inter_matrix16_bias, 
814
                       s->inter_matrix, s->inter_quant_bias, 1, 31);
815
    }
816

    
817
    if(ff_rate_control_init(s) < 0)
818
        return -1;
819

    
820
    s->picture_number = 0;
821
    s->picture_in_gop_number = 0;
822
    s->fake_picture_number = 0;
823
    /* motion detector init */
824
    s->f_code = 1;
825
    s->b_code = 1;
826

    
827
    return 0;
828
}
829

    
830
int MPV_encode_end(AVCodecContext *avctx)
831
{
832
    MpegEncContext *s = avctx->priv_data;
833

    
834
#ifdef STATS
835
    print_stats();
836
#endif
837

    
838
    ff_rate_control_uninit(s);
839

    
840
    MPV_common_end(s);
841
    if (s->out_format == FMT_MJPEG)
842
        mjpeg_close(s);
843
      
844
    return 0;
845
}
846

    
847
#endif //CONFIG_ENCODERS
848

    
849
void init_rl(RLTable *rl)
850
{
851
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
852
    uint8_t index_run[MAX_RUN+1];
853
    int last, run, level, start, end, i;
854

    
855
    /* compute max_level[], max_run[] and index_run[] */
856
    for(last=0;last<2;last++) {
857
        if (last == 0) {
858
            start = 0;
859
            end = rl->last;
860
        } else {
861
            start = rl->last;
862
            end = rl->n;
863
        }
864

    
865
        memset(max_level, 0, MAX_RUN + 1);
866
        memset(max_run, 0, MAX_LEVEL + 1);
867
        memset(index_run, rl->n, MAX_RUN + 1);
868
        for(i=start;i<end;i++) {
869
            run = rl->table_run[i];
870
            level = rl->table_level[i];
871
            if (index_run[run] == rl->n)
872
                index_run[run] = i;
873
            if (level > max_level[run])
874
                max_level[run] = level;
875
            if (run > max_run[level])
876
                max_run[level] = run;
877
        }
878
        rl->max_level[last] = av_malloc(MAX_RUN + 1);
879
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
880
        rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
881
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
882
        rl->index_run[last] = av_malloc(MAX_RUN + 1);
883
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
884
    }
885
}
886

    
887
/* draw the edges of width 'w' of an image of size width, height */
888
//FIXME check that this is ok for mpeg4 interlaced
889
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
890
{
891
    uint8_t *ptr, *last_line;
892
    int i;
893

    
894
    last_line = buf + (height - 1) * wrap;
895
    for(i=0;i<w;i++) {
896
        /* top and bottom */
897
        memcpy(buf - (i + 1) * wrap, buf, width);
898
        memcpy(last_line + (i + 1) * wrap, last_line, width);
899
    }
900
    /* left and right */
901
    ptr = buf;
902
    for(i=0;i<height;i++) {
903
        memset(ptr - w, ptr[0], w);
904
        memset(ptr + width, ptr[width-1], w);
905
        ptr += wrap;
906
    }
907
    /* corners */
908
    for(i=0;i<w;i++) {
909
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
910
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
911
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
912
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
913
    }
914
}
915

    
916
static int find_unused_picture(MpegEncContext *s, int shared){
917
    int i;
918
    
919
    if(shared){
920
        for(i=0; i<MAX_PICTURE_COUNT; i++){
921
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) break;
922
        }
923
    }else{
924
        for(i=0; i<MAX_PICTURE_COUNT; i++){
925
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) break; //FIXME
926
        }
927
        for(i=0; i<MAX_PICTURE_COUNT; i++){
928
            if(s->picture[i].data[0]==NULL) break;
929
        }
930
    }
931

    
932
    assert(i<MAX_PICTURE_COUNT);
933
    return i;
934
}
935

    
936
/* generic function for encode/decode called before a frame is coded/decoded */
937
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
938
{
939
    int i;
940
    AVFrame *pic;
941

    
942
    s->mb_skiped = 0;
943

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

    
946
    /* mark&release old frames */
947
    if (s->pict_type != B_TYPE && s->last_picture_ptr) {
948
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
949

    
950
        /* release forgotten pictures */
951
        /* if(mpeg124/h263) */
952
        if(!s->encoding){
953
            for(i=0; i<MAX_PICTURE_COUNT; i++){
954
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
955
                    fprintf(stderr, "releasing zombie picture\n");
956
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
957
                }
958
            }
959
        }
960
    }
961
alloc:
962
    if(!s->encoding){
963
        /* release non refernce frames */
964
        for(i=0; i<MAX_PICTURE_COUNT; i++){
965
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
966
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
967
            }
968
        }
969

    
970
        i= find_unused_picture(s, 0);
971
    
972
        pic= (AVFrame*)&s->picture[i];
973
        pic->reference= s->pict_type != B_TYPE ? 3 : 0;
974

    
975
        if(s->current_picture_ptr)
976
            pic->coded_picture_number= s->current_picture_ptr->coded_picture_number+1;
977
        
978
        alloc_picture(s, (Picture*)pic, 0);
979

    
980
        s->current_picture_ptr= &s->picture[i];
981
    }
982

    
983
    s->current_picture_ptr->pict_type= s->pict_type;
984
    s->current_picture_ptr->quality= s->qscale;
985
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
986

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

    
1021
    /* set dequantizer, we cant do it during init as it might change for mpeg4
1022
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1023
    if(s->out_format == FMT_H263){
1024
        if(s->mpeg_quant)
1025
            s->dct_unquantize = s->dct_unquantize_mpeg2;
1026
        else
1027
            s->dct_unquantize = s->dct_unquantize_h263;
1028
    }else 
1029
        s->dct_unquantize = s->dct_unquantize_mpeg1;
1030

    
1031
    return 0;
1032
}
1033

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

    
1063
    if(s->encoding){
1064
        /* release non refernce frames */
1065
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1066
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1067
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1068
            }
1069
        }
1070
    }
1071
    // clear copies, to avoid confusion
1072
#if 0
1073
    memset(&s->last_picture, 0, sizeof(Picture));
1074
    memset(&s->next_picture, 0, sizeof(Picture));
1075
    memset(&s->current_picture, 0, sizeof(Picture));
1076
#endif
1077
}
1078

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

    
1124
/**
1125
 * draws an arrow from (ex, ey) -> (sx, sy).
1126
 * @param w width of the image
1127
 * @param h height of the image
1128
 * @param stride stride/linesize of the image
1129
 * @param color color of the arrow
1130
 */
1131
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1132
    int dx,dy;
1133

    
1134
    sx= clip(sx, -100, w+100);
1135
    sy= clip(sy, -100, h+100);
1136
    ex= clip(ex, -100, w+100);
1137
    ey= clip(ey, -100, h+100);
1138
    
1139
    dx= ex - sx;
1140
    dy= ey - sy;
1141
    
1142
    if(dx*dx + dy*dy > 3*3){
1143
        int rx=  dx + dy;
1144
        int ry= -dx + dy;
1145
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1146
        
1147
        //FIXME subpixel accuracy
1148
        rx= ROUNDED_DIV(rx*3<<4, length);
1149
        ry= ROUNDED_DIV(ry*3<<4, length);
1150
        
1151
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1152
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1153
    }
1154
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1155
}
1156

    
1157
/**
1158
 * prints debuging info for the given picture.
1159
 */
1160
void ff_print_debug_info(MpegEncContext *s, Picture *pict){
1161

    
1162
    if(!pict || !pict->mb_type) return;
1163

    
1164
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1165
        int x,y;
1166

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

    
1238
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1239
            int mb_x;
1240
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1241
                const int mb_index= mb_x + mb_y*s->mb_stride;
1242
                if(IS_8X8(s->current_picture.mb_type[mb_index])){
1243
                    int i;
1244
                    for(i=0; i<4; i++){
1245
                        int sx= mb_x*16 + 4 + 8*(i&1);
1246
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1247
                        int xy= 1 + mb_x*2 + (i&1) + (mb_y*2 + 1 + (i>>1))*(s->mb_width*2 + 2);
1248
                        int mx= (s->motion_val[xy][0]>>shift) + sx;
1249
                        int my= (s->motion_val[xy][1]>>shift) + sy;
1250
                        draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1251
                    }
1252
                }else{
1253
                    int sx= mb_x*16 + 8;
1254
                    int sy= mb_y*16 + 8;
1255
                    int xy= 1 + mb_x*2 + (mb_y*2 + 1)*(s->mb_width*2 + 2);
1256
                    int mx= (s->motion_val[xy][0]>>shift) + sx;
1257
                    int my= (s->motion_val[xy][1]>>shift) + sy;
1258
                    draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1259
                }
1260
                s->mbskip_table[mb_index]=0;
1261
            }
1262
        }
1263
    }
1264
}
1265

    
1266
#ifdef CONFIG_ENCODERS
1267

    
1268
static int get_sae(uint8_t *src, int ref, int stride){
1269
    int x,y;
1270
    int acc=0;
1271
    
1272
    for(y=0; y<16; y++){
1273
        for(x=0; x<16; x++){
1274
            acc+= ABS(src[x+y*stride] - ref);
1275
        }
1276
    }
1277
    
1278
    return acc;
1279
}
1280

    
1281
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1282
    int x, y, w, h;
1283
    int acc=0;
1284
    
1285
    w= s->width &~15;
1286
    h= s->height&~15;
1287
    
1288
    for(y=0; y<h; y+=16){
1289
        for(x=0; x<w; x+=16){
1290
            int offset= x + y*stride;
1291
            int sad = s->dsp.pix_abs16x16(src + offset, ref + offset, stride);
1292
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1293
            int sae = get_sae(src + offset, mean, stride);
1294
            
1295
            acc+= sae + 500 < sad;
1296
        }
1297
    }
1298
    return acc;
1299
}
1300

    
1301

    
1302
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1303
    AVFrame *pic;
1304
    int i;
1305
    const int encoding_delay= s->max_b_frames;
1306
    int direct=1;
1307

    
1308
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1309
    if(pic_arg->linesize[0] != s->linesize) direct=0;
1310
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1311
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1312
  
1313
//    printf("%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1314
    
1315
    if(direct){
1316
        i= find_unused_picture(s, 1);
1317

    
1318
        pic= (AVFrame*)&s->picture[i];
1319
        pic->reference= 3;
1320
    
1321
        for(i=0; i<4; i++){
1322
            pic->data[i]= pic_arg->data[i];
1323
            pic->linesize[i]= pic_arg->linesize[i];
1324
        }
1325
        alloc_picture(s, (Picture*)pic, 1);
1326
    }else{
1327
        i= find_unused_picture(s, 0);
1328

    
1329
        pic= (AVFrame*)&s->picture[i];
1330
        pic->reference= 3;
1331

    
1332
        alloc_picture(s, (Picture*)pic, 0);
1333
        for(i=0; i<4; i++){
1334
            /* the input will be 16 pixels to the right relative to the actual buffer start
1335
             * and the current_pic, so the buffer can be reused, yes its not beatifull 
1336
             */
1337
            pic->data[i]+= 16; 
1338
        }
1339

    
1340
        if(   pic->data[0] == pic_arg->data[0] 
1341
           && pic->data[1] == pic_arg->data[1]
1342
           && pic->data[2] == pic_arg->data[2]){
1343
       // empty
1344
        }else{
1345
            int h_chroma_shift, v_chroma_shift;
1346
        
1347
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1348
        
1349
            for(i=0; i<3; i++){
1350
                int src_stride= pic_arg->linesize[i];
1351
                int dst_stride= i ? s->uvlinesize : s->linesize;
1352
                int h_shift= i ? h_chroma_shift : 0;
1353
                int v_shift= i ? v_chroma_shift : 0;
1354
                int w= s->width >>h_shift;
1355
                int h= s->height>>v_shift;
1356
                uint8_t *src= pic_arg->data[i];
1357
                uint8_t *dst= pic->data[i];
1358
            
1359
                if(src_stride==dst_stride)
1360
                    memcpy(dst, src, src_stride*h);
1361
                else{
1362
                    while(h--){
1363
                        memcpy(dst, src, w);
1364
                        dst += dst_stride;
1365
                        src += src_stride;
1366
                    }
1367
                }
1368
            }
1369
        }
1370
    }
1371
    pic->quality= pic_arg->quality;
1372
    pic->pict_type= pic_arg->pict_type;
1373
    pic->pts = pic_arg->pts;
1374
    
1375
    if(s->input_picture[encoding_delay])
1376
        pic->display_picture_number= s->input_picture[encoding_delay]->display_picture_number + 1;
1377

    
1378
    /* shift buffer entries */
1379
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1380
        s->input_picture[i-1]= s->input_picture[i];
1381
        
1382
    s->input_picture[encoding_delay]= (Picture*)pic;
1383

    
1384
    return 0;
1385
}
1386

    
1387
static void select_input_picture(MpegEncContext *s){
1388
    int i;
1389
    const int encoding_delay= s->max_b_frames;
1390
    int coded_pic_num=0;    
1391

    
1392
    if(s->reordered_input_picture[0])
1393
        coded_pic_num= s->reordered_input_picture[0]->coded_picture_number + 1;
1394

    
1395
    for(i=1; i<MAX_PICTURE_COUNT; i++)
1396
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1397
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1398

    
1399
    /* set next picture types & ordering */
1400
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1401
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
1402
            s->reordered_input_picture[0]= s->input_picture[0];
1403
            s->reordered_input_picture[0]->pict_type= I_TYPE;
1404
            s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1405
        }else{
1406
            int b_frames;
1407
            
1408
            if(s->flags&CODEC_FLAG_PASS2){
1409
                for(i=0; i<s->max_b_frames+1; i++){
1410
                    int pict_num= s->input_picture[0]->display_picture_number + i;
1411
                    int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1412
                    s->input_picture[i]->pict_type= pict_type;
1413
                    
1414
                    if(i + 1 >= s->rc_context.num_entries) break;
1415
                }
1416
            }
1417

    
1418
            if(s->input_picture[0]->pict_type){
1419
                /* user selected pict_type */
1420
                for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
1421
                    if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
1422
                }
1423
            
1424
                if(b_frames > s->max_b_frames){
1425
                    fprintf(stderr, "warning, too many bframes in a row\n");
1426
                    b_frames = s->max_b_frames;
1427
                }
1428
            }else if(s->b_frame_strategy==0){
1429
                b_frames= s->max_b_frames;
1430
            }else if(s->b_frame_strategy==1){
1431
                for(i=1; i<s->max_b_frames+1; i++){
1432
                    if(s->input_picture[i]->b_frame_score==0){
1433
                        s->input_picture[i]->b_frame_score= 
1434
                            get_intra_count(s, s->input_picture[i  ]->data[0], 
1435
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
1436
                    }
1437
                }
1438
                for(i=0; i<s->max_b_frames; i++){
1439
                    if(s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
1440
                }
1441
                                
1442
                b_frames= FFMAX(0, i-1);
1443
                
1444
                /* reset scores */
1445
                for(i=0; i<b_frames+1; i++){
1446
                    s->input_picture[i]->b_frame_score=0;
1447
                }
1448
            }else{
1449
                fprintf(stderr, "illegal b frame strategy\n");
1450
                b_frames=0;
1451
            }
1452

    
1453
            emms_c();
1454
//static int b_count=0;
1455
//b_count+= b_frames;
1456
//printf("b_frames: %d\n", b_count);
1457
                        
1458
            s->reordered_input_picture[0]= s->input_picture[b_frames];
1459
            if(   s->picture_in_gop_number + b_frames >= s->gop_size 
1460
               || s->reordered_input_picture[0]->pict_type== I_TYPE)
1461
                s->reordered_input_picture[0]->pict_type= I_TYPE;
1462
            else
1463
                s->reordered_input_picture[0]->pict_type= P_TYPE;
1464
            s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1465
            for(i=0; i<b_frames; i++){
1466
                coded_pic_num++;
1467
                s->reordered_input_picture[i+1]= s->input_picture[i];
1468
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
1469
                s->reordered_input_picture[i+1]->coded_picture_number= coded_pic_num;
1470
            }
1471
        }
1472
    }
1473
    
1474
    if(s->reordered_input_picture[0]){
1475
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
1476

    
1477
        s->new_picture= *s->reordered_input_picture[0];
1478

    
1479
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
1480
            // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
1481
        
1482
            int i= find_unused_picture(s, 0);
1483
            Picture *pic= &s->picture[i];
1484

    
1485
            /* mark us unused / free shared pic */
1486
            for(i=0; i<4; i++)
1487
                s->reordered_input_picture[0]->data[i]= NULL;
1488
            s->reordered_input_picture[0]->type= 0;
1489
            
1490
            //FIXME bad, copy * except
1491
            pic->pict_type = s->reordered_input_picture[0]->pict_type;
1492
            pic->quality   = s->reordered_input_picture[0]->quality;
1493
            pic->coded_picture_number = s->reordered_input_picture[0]->coded_picture_number;
1494
            pic->reference = s->reordered_input_picture[0]->reference;
1495
            
1496
            alloc_picture(s, pic, 0);
1497

    
1498
            s->current_picture_ptr= pic;
1499
        }else{
1500
            // input is not a shared pix -> reuse buffer for current_pix
1501

    
1502
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
1503
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
1504
            
1505
            s->current_picture_ptr= s->reordered_input_picture[0];
1506
            for(i=0; i<4; i++){
1507
                //reverse the +16 we did before storing the input
1508
                s->current_picture_ptr->data[i]-=16;
1509
            }
1510
        }
1511
        s->current_picture= *s->current_picture_ptr;
1512
    
1513
        s->picture_number= s->new_picture.display_picture_number;
1514
//printf("dpn:%d\n", s->picture_number);
1515
    }else{
1516
       memset(&s->new_picture, 0, sizeof(Picture));
1517
    }
1518
}
1519

    
1520
int MPV_encode_picture(AVCodecContext *avctx,
1521
                       unsigned char *buf, int buf_size, void *data)
1522
{
1523
    MpegEncContext *s = avctx->priv_data;
1524
    AVFrame *pic_arg = data;
1525
    int i;
1526

    
1527
    init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
1528

    
1529
    s->picture_in_gop_number++;
1530

    
1531
    load_input_picture(s, pic_arg);
1532
    
1533
    select_input_picture(s);
1534
    
1535
    /* output? */
1536
    if(s->new_picture.data[0]){
1537

    
1538
        s->pict_type= s->new_picture.pict_type;
1539
        if (s->fixed_qscale){ /* the ratecontrol needs the last qscale so we dont touch it for CBR */
1540
            s->qscale= (int)(s->new_picture.quality+0.5);
1541
            assert(s->qscale);
1542
        }
1543
//emms_c();
1544
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
1545
        MPV_frame_start(s, avctx);
1546

    
1547
        encode_picture(s, s->picture_number);
1548
        
1549
        avctx->real_pict_num  = s->picture_number;
1550
        avctx->header_bits = s->header_bits;
1551
        avctx->mv_bits     = s->mv_bits;
1552
        avctx->misc_bits   = s->misc_bits;
1553
        avctx->i_tex_bits  = s->i_tex_bits;
1554
        avctx->p_tex_bits  = s->p_tex_bits;
1555
        avctx->i_count     = s->i_count;
1556
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
1557
        avctx->skip_count  = s->skip_count;
1558

    
1559
        MPV_frame_end(s);
1560

    
1561
        if (s->out_format == FMT_MJPEG)
1562
            mjpeg_picture_trailer(s);
1563
        
1564
        if(s->flags&CODEC_FLAG_PASS1)
1565
            ff_write_pass1_stats(s);
1566

    
1567
        for(i=0; i<4; i++){
1568
            avctx->error[i] += s->current_picture_ptr->error[i];
1569
        }
1570
    }
1571

    
1572
    s->input_picture_number++;
1573

    
1574
    flush_put_bits(&s->pb);
1575
    s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1576
    
1577
    s->total_bits += s->frame_bits;
1578
    avctx->frame_bits  = s->frame_bits;
1579
    
1580
    return pbBufPtr(&s->pb) - s->pb.buf;
1581
}
1582

    
1583
#endif //CONFIG_ENCODERS
1584

    
1585
static inline void gmc1_motion(MpegEncContext *s,
1586
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1587
                               int dest_offset,
1588
                               uint8_t **ref_picture, int src_offset)
1589
{
1590
    uint8_t *ptr;
1591
    int offset, src_x, src_y, linesize, uvlinesize;
1592
    int motion_x, motion_y;
1593
    int emu=0;
1594

    
1595
    motion_x= s->sprite_offset[0][0];
1596
    motion_y= s->sprite_offset[0][1];
1597
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1598
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1599
    motion_x<<=(3-s->sprite_warping_accuracy);
1600
    motion_y<<=(3-s->sprite_warping_accuracy);
1601
    src_x = clip(src_x, -16, s->width);
1602
    if (src_x == s->width)
1603
        motion_x =0;
1604
    src_y = clip(src_y, -16, s->height);
1605
    if (src_y == s->height)
1606
        motion_y =0;
1607

    
1608
    linesize = s->linesize;
1609
    uvlinesize = s->uvlinesize;
1610
    
1611
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1612

    
1613
    dest_y+=dest_offset;
1614
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1615
        if(src_x<0 || src_y<0 || src_x + 17 >= s->h_edge_pos
1616
                              || src_y + 17 >= s->v_edge_pos){
1617
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1618
            ptr= s->edge_emu_buffer;
1619
        }
1620
    }
1621
    
1622
    if((motion_x|motion_y)&7){
1623
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1624
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1625
    }else{
1626
        int dxy;
1627
        
1628
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
1629
        if (s->no_rounding){
1630
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
1631
        }else{
1632
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
1633
        }
1634
    }
1635
    
1636
    if(s->flags&CODEC_FLAG_GRAY) return;
1637

    
1638
    motion_x= s->sprite_offset[1][0];
1639
    motion_y= s->sprite_offset[1][1];
1640
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
1641
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
1642
    motion_x<<=(3-s->sprite_warping_accuracy);
1643
    motion_y<<=(3-s->sprite_warping_accuracy);
1644
    src_x = clip(src_x, -8, s->width>>1);
1645
    if (src_x == s->width>>1)
1646
        motion_x =0;
1647
    src_y = clip(src_y, -8, s->height>>1);
1648
    if (src_y == s->height>>1)
1649
        motion_y =0;
1650

    
1651
    offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
1652
    ptr = ref_picture[1] + offset;
1653
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1654
        if(src_x<0 || src_y<0 || src_x + 9 >= s->h_edge_pos>>1
1655
                              || src_y + 9 >= s->v_edge_pos>>1){
1656
            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);
1657
            ptr= s->edge_emu_buffer;
1658
            emu=1;
1659
        }
1660
    }
1661
    s->dsp.gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1662
    
1663
    ptr = ref_picture[2] + offset;
1664
    if(emu){
1665
        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);
1666
        ptr= s->edge_emu_buffer;
1667
    }
1668
    s->dsp.gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1669
    
1670
    return;
1671
}
1672

    
1673
static inline void gmc_motion(MpegEncContext *s,
1674
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1675
                               int dest_offset,
1676
                               uint8_t **ref_picture, int src_offset)
1677
{
1678
    uint8_t *ptr;
1679
    int linesize, uvlinesize;
1680
    const int a= s->sprite_warping_accuracy;
1681
    int ox, oy;
1682

    
1683
    linesize = s->linesize;
1684
    uvlinesize = s->uvlinesize;
1685

    
1686
    ptr = ref_picture[0] + src_offset;
1687

    
1688
    dest_y+=dest_offset;
1689
    
1690
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
1691
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
1692

    
1693
    s->dsp.gmc(dest_y, ptr, linesize, 16,
1694
           ox, 
1695
           oy, 
1696
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1697
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1698
           a+1, (1<<(2*a+1)) - s->no_rounding,
1699
           s->h_edge_pos, s->v_edge_pos);
1700
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
1701
           ox + s->sprite_delta[0][0]*8, 
1702
           oy + s->sprite_delta[1][0]*8, 
1703
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1704
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1705
           a+1, (1<<(2*a+1)) - s->no_rounding,
1706
           s->h_edge_pos, s->v_edge_pos);
1707

    
1708
    if(s->flags&CODEC_FLAG_GRAY) return;
1709

    
1710

    
1711
    dest_cb+=dest_offset>>1;
1712
    dest_cr+=dest_offset>>1;
1713
    
1714
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
1715
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
1716

    
1717
    ptr = ref_picture[1] + (src_offset>>1);
1718
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
1719
           ox, 
1720
           oy, 
1721
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1722
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1723
           a+1, (1<<(2*a+1)) - s->no_rounding,
1724
           s->h_edge_pos>>1, s->v_edge_pos>>1);
1725
    
1726
    ptr = ref_picture[2] + (src_offset>>1);
1727
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
1728
           ox, 
1729
           oy, 
1730
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1731
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1732
           a+1, (1<<(2*a+1)) - s->no_rounding,
1733
           s->h_edge_pos>>1, s->v_edge_pos>>1);
1734
}
1735

    
1736
/**
1737
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
1738
 * @param buf destination buffer
1739
 * @param src source buffer
1740
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
1741
 * @param block_w width of block
1742
 * @param block_h height of block
1743
 * @param src_x x coordinate of the top left sample of the block in the source buffer
1744
 * @param src_y y coordinate of the top left sample of the block in the source buffer
1745
 * @param w width of the source buffer
1746
 * @param h height of the source buffer
1747
 */
1748
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
1749
                                    int src_x, int src_y, int w, int h){
1750
    int x, y;
1751
    int start_y, start_x, end_y, end_x;
1752

    
1753
    if(src_y>= h){
1754
        src+= (h-1-src_y)*linesize;
1755
        src_y=h-1;
1756
    }else if(src_y<=-block_h){
1757
        src+= (1-block_h-src_y)*linesize;
1758
        src_y=1-block_h;
1759
    }
1760
    if(src_x>= w){
1761
        src+= (w-1-src_x);
1762
        src_x=w-1;
1763
    }else if(src_x<=-block_w){
1764
        src+= (1-block_w-src_x);
1765
        src_x=1-block_w;
1766
    }
1767

    
1768
    start_y= FFMAX(0, -src_y);
1769
    start_x= FFMAX(0, -src_x);
1770
    end_y= FFMIN(block_h, h-src_y);
1771
    end_x= FFMIN(block_w, w-src_x);
1772

    
1773
    // copy existing part
1774
    for(y=start_y; y<end_y; y++){
1775
        for(x=start_x; x<end_x; x++){
1776
            buf[x + y*linesize]= src[x + y*linesize];
1777
        }
1778
    }
1779

    
1780
    //top
1781
    for(y=0; y<start_y; y++){
1782
        for(x=start_x; x<end_x; x++){
1783
            buf[x + y*linesize]= buf[x + start_y*linesize];
1784
        }
1785
    }
1786

    
1787
    //bottom
1788
    for(y=end_y; y<block_h; y++){
1789
        for(x=start_x; x<end_x; x++){
1790
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1791
        }
1792
    }
1793
                                    
1794
    for(y=0; y<block_h; y++){
1795
       //left
1796
        for(x=0; x<start_x; x++){
1797
            buf[x + y*linesize]= buf[start_x + y*linesize];
1798
        }
1799
       
1800
       //right
1801
        for(x=end_x; x<block_w; x++){
1802
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1803
        }
1804
    }
1805
}
1806

    
1807

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

    
1844
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1845
        if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 16 > s->h_edge_pos
1846
                              || src_y + (motion_y&1) + h  > v_edge_pos){
1847
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr - src_offset, s->linesize, 17, 17+field_based,  //FIXME linesize? and uv below
1848
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1849
            ptr= s->edge_emu_buffer + src_offset;
1850
            emu=1;
1851
        }
1852
    }
1853
    pix_op[0][dxy](dest_y, ptr, linesize, h);
1854

    
1855
    if(s->flags&CODEC_FLAG_GRAY) return;
1856

    
1857
    if (s->out_format == FMT_H263) {
1858
        dxy = 0;
1859
        if ((motion_x & 3) != 0)
1860
            dxy |= 1;
1861
        if ((motion_y & 3) != 0)
1862
            dxy |= 2;
1863
        mx = motion_x >> 2;
1864
        my = motion_y >> 2;
1865
    } else {
1866
        mx = motion_x / 2;
1867
        my = motion_y / 2;
1868
        dxy = ((my & 1) << 1) | (mx & 1);
1869
        mx >>= 1;
1870
        my >>= 1;
1871
    }
1872
    
1873
    src_x = s->mb_x * 8 + mx;
1874
    src_y = s->mb_y * (8 >> field_based) + my;
1875
    src_x = clip(src_x, -8, s->width >> 1);
1876
    if (src_x == (s->width >> 1))
1877
        dxy &= ~1;
1878
    src_y = clip(src_y, -8, height >> 1);
1879
    if (src_y == (height >> 1))
1880
        dxy &= ~2;
1881
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1882
    ptr = ref_picture[1] + offset;
1883
    if(emu){
1884
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
1885
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1886
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1887
    }
1888
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1889

    
1890
    ptr = ref_picture[2] + offset;
1891
    if(emu){
1892
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
1893
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1894
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1895
    }
1896
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1897
}
1898

    
1899
static inline void qpel_motion(MpegEncContext *s,
1900
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1901
                               int dest_offset,
1902
                               uint8_t **ref_picture, int src_offset,
1903
                               int field_based, op_pixels_func (*pix_op)[4],
1904
                               qpel_mc_func (*qpix_op)[16],
1905
                               int motion_x, int motion_y, int h)
1906
{
1907
    uint8_t *ptr;
1908
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1909
    int emu=0;
1910

    
1911
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1912
    src_x = s->mb_x * 16 + (motion_x >> 2);
1913
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
1914

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

    
1947
    if(s->flags&CODEC_FLAG_GRAY) return;
1948

    
1949
    if(field_based){
1950
        mx= motion_x/2;
1951
        my= motion_y>>1;
1952
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
1953
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
1954
        mx= (motion_x>>1) + rtab[motion_x&7];
1955
        my= (motion_y>>1) + rtab[motion_y&7];
1956
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
1957
        mx= (motion_x>>1)|(motion_x&1);
1958
        my= (motion_y>>1)|(motion_y&1);
1959
    }else{
1960
        mx= motion_x/2;
1961
        my= motion_y/2;
1962
    }
1963
    mx= (mx>>1)|(mx&1);
1964
    my= (my>>1)|(my&1);
1965

    
1966
    dxy= (mx&1) | ((my&1)<<1);
1967
    mx>>=1;
1968
    my>>=1;
1969

    
1970
    src_x = s->mb_x * 8 + mx;
1971
    src_y = s->mb_y * (8 >> field_based) + my;
1972
    src_x = clip(src_x, -8, s->width >> 1);
1973
    if (src_x == (s->width >> 1))
1974
        dxy &= ~1;
1975
    src_y = clip(src_y, -8, height >> 1);
1976
    if (src_y == (height >> 1))
1977
        dxy &= ~2;
1978

    
1979
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1980
    ptr = ref_picture[1] + offset;
1981
    if(emu){
1982
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
1983
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1984
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1985
    }
1986
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1987
    
1988
    ptr = ref_picture[2] + offset;
1989
    if(emu){
1990
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
1991
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1992
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1993
    }
1994
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1995
}
1996

    
1997
inline int ff_h263_round_chroma(int x){
1998
    if (x >= 0)
1999
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2000
    else {
2001
        x = -x;
2002
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2003
    }
2004
}
2005

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

    
2028
    mb_x = s->mb_x;
2029
    mb_y = s->mb_y;
2030

    
2031
    switch(s->mv_type) {
2032
    case MV_TYPE_16X16:
2033
#ifdef CONFIG_RISKY
2034
        if(s->mcsel){
2035
            if(s->real_sprite_warping_points==1){
2036
                gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
2037
                            ref_picture, 0);
2038
            }else{
2039
                gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
2040
                            ref_picture, 0);
2041
            }
2042
        }else if(s->quarter_sample){
2043
            qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2044
                        ref_picture, 0,
2045
                        0, pix_op, qpix_op,
2046
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2047
        }else if(s->mspel){
2048
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
2049
                        ref_picture, pix_op,
2050
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2051
        }else
2052
#endif
2053
        {
2054
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2055
                        ref_picture, 0,
2056
                        0, pix_op,
2057
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2058
        }           
2059
        break;
2060
    case MV_TYPE_8X8:
2061
        mx = 0;
2062
        my = 0;
2063
        if(s->quarter_sample){
2064
            for(i=0;i<4;i++) {
2065
                motion_x = s->mv[dir][i][0];
2066
                motion_y = s->mv[dir][i][1];
2067

    
2068
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2069
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
2070
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
2071
                    
2072
                /* WARNING: do no forget half pels */
2073
                src_x = clip(src_x, -16, s->width);
2074
                if (src_x == s->width)
2075
                    dxy &= ~3;
2076
                src_y = clip(src_y, -16, s->height);
2077
                if (src_y == s->height)
2078
                    dxy &= ~12;
2079
                    
2080
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2081
                if(s->flags&CODEC_FLAG_EMU_EDGE){
2082
                    if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 8 > s->h_edge_pos
2083
                                          || src_y + (motion_y&3) + 8 > s->v_edge_pos){
2084
                        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);
2085
                        ptr= s->edge_emu_buffer;
2086
                    }
2087
                }
2088
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2089
                qpix_op[1][dxy](dest, ptr, s->linesize);
2090

    
2091
                mx += s->mv[dir][i][0]/2;
2092
                my += s->mv[dir][i][1]/2;
2093
            }
2094
        }else{
2095
            for(i=0;i<4;i++) {
2096
                motion_x = s->mv[dir][i][0];
2097
                motion_y = s->mv[dir][i][1];
2098

    
2099
                dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2100
                src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;
2101
                src_y = mb_y * 16 + (motion_y >> 1) + (i >>1) * 8;
2102
                    
2103
                /* WARNING: do no forget half pels */
2104
                src_x = clip(src_x, -16, s->width);
2105
                if (src_x == s->width)
2106
                    dxy &= ~1;
2107
                src_y = clip(src_y, -16, s->height);
2108
                if (src_y == s->height)
2109
                    dxy &= ~2;
2110
                    
2111
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2112
                if(s->flags&CODEC_FLAG_EMU_EDGE){
2113
                    if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 8 > s->h_edge_pos
2114
                                          || src_y + (motion_y&1) + 8 > s->v_edge_pos){
2115
                        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);
2116
                        ptr= s->edge_emu_buffer;
2117
                    }
2118
                }
2119
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2120
                pix_op[1][dxy](dest, ptr, s->linesize, 8);
2121

    
2122
                mx += s->mv[dir][i][0];
2123
                my += s->mv[dir][i][1];
2124
            }
2125
        }
2126

    
2127
        if(s->flags&CODEC_FLAG_GRAY) break;
2128
        /* In case of 8X8, we construct a single chroma motion vector
2129
           with a special rounding */
2130
        mx= ff_h263_round_chroma(mx);
2131
        my= ff_h263_round_chroma(my);
2132
        dxy = ((my & 1) << 1) | (mx & 1);
2133
        mx >>= 1;
2134
        my >>= 1;
2135

    
2136
        src_x = mb_x * 8 + mx;
2137
        src_y = mb_y * 8 + my;
2138
        src_x = clip(src_x, -8, s->width/2);
2139
        if (src_x == s->width/2)
2140
            dxy &= ~1;
2141
        src_y = clip(src_y, -8, s->height/2);
2142
        if (src_y == s->height/2)
2143
            dxy &= ~2;
2144
        
2145
        offset = (src_y * (s->uvlinesize)) + src_x;
2146
        ptr = ref_picture[1] + offset;
2147
        if(s->flags&CODEC_FLAG_EMU_EDGE){
2148
                if(src_x<0 || src_y<0 || src_x + (dxy &1) + 8 > s->h_edge_pos>>1
2149
                                      || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
2150
                    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);
2151
                    ptr= s->edge_emu_buffer;
2152
                    emu=1;
2153
                }
2154
            }
2155
        pix_op[1][dxy](dest_cb, ptr, s->uvlinesize, 8);
2156

    
2157
        ptr = ref_picture[2] + offset;
2158
        if(emu){
2159
            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);
2160
            ptr= s->edge_emu_buffer;
2161
        }
2162
        pix_op[1][dxy](dest_cr, ptr, s->uvlinesize, 8);
2163
        break;
2164
    case MV_TYPE_FIELD:
2165
        if (s->picture_structure == PICT_FRAME) {
2166
            if(s->quarter_sample){
2167
                /* top field */
2168
                qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2169
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2170
                            1, pix_op, qpix_op,
2171
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
2172
                /* bottom field */
2173
                qpel_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, qpix_op,
2176
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
2177
            }else{
2178
                /* top field */       
2179
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2180
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2181
                            1, pix_op,
2182
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
2183
                /* bottom field */
2184
                mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2185
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2186
                            1, pix_op,
2187
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
2188
            }
2189
        } else {
2190
            int offset;
2191
            if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2192
                offset= s->field_select[dir][0] ? s->linesize : 0;
2193
            }else{
2194
                ref_picture= s->current_picture.data;
2195
                offset= s->field_select[dir][0] ? s->linesize : -s->linesize; 
2196
            } 
2197

    
2198
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2199
                        ref_picture, offset,
2200
                        0, pix_op,
2201
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2202
        }
2203
        break;
2204
    case MV_TYPE_16X8:{
2205
        int offset;
2206
         uint8_t ** ref2picture;
2207

    
2208
            if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2209
                ref2picture= ref_picture;
2210
                offset= s->field_select[dir][0] ? s->linesize : 0;
2211
            }else{
2212
                ref2picture= s->current_picture.data;
2213
                offset= s->field_select[dir][0] ? s->linesize : -s->linesize; 
2214
            } 
2215

    
2216
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2217
                        ref2picture, offset,
2218
                        0, pix_op,
2219
                        s->mv[dir][0][0], s->mv[dir][0][1], 8);
2220

    
2221

    
2222
            if(s->picture_structure == s->field_select[dir][1] + 1 || s->pict_type == B_TYPE || s->first_field){
2223
                ref2picture= ref_picture;
2224
                offset= s->field_select[dir][1] ? s->linesize : 0;
2225
            }else{
2226
                ref2picture= s->current_picture.data;
2227
                offset= s->field_select[dir][1] ? s->linesize : -s->linesize; 
2228
            } 
2229
            // I know it is ugly but this is the only way to fool emu_edge without rewrite mpeg_motion
2230
            mpeg_motion(s, dest_y+16*s->linesize, dest_cb+8*s->uvlinesize, dest_cr+8*s->uvlinesize,
2231
                        0,
2232
                        ref2picture, offset,
2233
                        0, pix_op,
2234
                        s->mv[dir][1][0], s->mv[dir][1][1]+16, 8);
2235
        }
2236
        
2237
        break;
2238
    case MV_TYPE_DMV:
2239
    {
2240
    op_pixels_func (*dmv_pix_op)[4];
2241
    int offset;
2242

    
2243
        dmv_pix_op = s->dsp.put_pixels_tab;
2244

    
2245
        if(s->picture_structure == PICT_FRAME){
2246
            //put top field from top field
2247
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2248
                        ref_picture, 0,
2249
                        1, dmv_pix_op,
2250
                        s->mv[dir][0][0], s->mv[dir][0][1], 8);
2251
            //put bottom field from bottom field
2252
            mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2253
                        ref_picture, s->linesize,
2254
                        1, dmv_pix_op,
2255
                        s->mv[dir][0][0], s->mv[dir][0][1], 8);
2256

    
2257
            dmv_pix_op = s->dsp.avg_pixels_tab; 
2258
        
2259
            //avg top field from bottom field
2260
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2261
                        ref_picture, s->linesize,
2262
                        1, dmv_pix_op,
2263
                        s->mv[dir][2][0], s->mv[dir][2][1], 8);
2264
            //avg bottom field from top field
2265
            mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2266
                        ref_picture, 0,
2267
                        1, dmv_pix_op,
2268
                        s->mv[dir][3][0], s->mv[dir][3][1], 8);
2269

    
2270
        }else{
2271
            offset=(s->picture_structure == PICT_BOTTOM_FIELD)? 
2272
                         s->linesize : 0;
2273

    
2274
            //put field from the same parity
2275
            //same parity is never in the same frame
2276
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2277
                        ref_picture,offset,
2278
                        0,dmv_pix_op,
2279
                        s->mv[dir][0][0],s->mv[dir][0][1],16);
2280

    
2281
            // after put we make avg of the same block
2282
            dmv_pix_op=s->dsp.avg_pixels_tab; 
2283

    
2284
            //opposite parity is always in the same frame if this is second field
2285
            if(!s->first_field){
2286
                ref_picture = s->current_picture.data;    
2287
                //top field is one linesize from frame beginig
2288
                offset=(s->picture_structure == PICT_BOTTOM_FIELD)? 
2289
                        -s->linesize : s->linesize;
2290
            }else 
2291
                offset=(s->picture_structure == PICT_BOTTOM_FIELD)? 
2292
                        0 : s->linesize;
2293

    
2294
            //avg field from the opposite parity
2295
            mpeg_motion(s, dest_y, dest_cb, dest_cr,0,
2296
                        ref_picture, offset,
2297
                        0,dmv_pix_op,
2298
                        s->mv[dir][2][0],s->mv[dir][2][1],16);
2299
        }
2300
    }
2301
    break;
2302

    
2303
    }
2304
}
2305

    
2306

    
2307
/* put block[] to dest[] */
2308
static inline void put_dct(MpegEncContext *s, 
2309
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
2310
{
2311
    s->dct_unquantize(s, block, i, s->qscale);
2312
    s->dsp.idct_put (dest, line_size, block);
2313
}
2314

    
2315
/* add block[] to dest[] */
2316
static inline void add_dct(MpegEncContext *s, 
2317
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
2318
{
2319
    if (s->block_last_index[i] >= 0) {
2320
        s->dsp.idct_add (dest, line_size, block);
2321
    }
2322
}
2323

    
2324
static inline void add_dequant_dct(MpegEncContext *s, 
2325
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
2326
{
2327
    if (s->block_last_index[i] >= 0) {
2328
        s->dct_unquantize(s, block, i, s->qscale);
2329

    
2330
        s->dsp.idct_add (dest, line_size, block);
2331
    }
2332
}
2333

    
2334
/**
2335
 * cleans dc, ac, coded_block for the current non intra MB
2336
 */
2337
void ff_clean_intra_table_entries(MpegEncContext *s)
2338
{
2339
    int wrap = s->block_wrap[0];
2340
    int xy = s->block_index[0];
2341
    
2342
    s->dc_val[0][xy           ] = 
2343
    s->dc_val[0][xy + 1       ] = 
2344
    s->dc_val[0][xy     + wrap] =
2345
    s->dc_val[0][xy + 1 + wrap] = 1024;
2346
    /* ac pred */
2347
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2348
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2349
    if (s->msmpeg4_version>=3) {
2350
        s->coded_block[xy           ] =
2351
        s->coded_block[xy + 1       ] =
2352
        s->coded_block[xy     + wrap] =
2353
        s->coded_block[xy + 1 + wrap] = 0;
2354
    }
2355
    /* chroma */
2356
    wrap = s->block_wrap[4];
2357
    xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
2358
    s->dc_val[1][xy] =
2359
    s->dc_val[2][xy] = 1024;
2360
    /* ac pred */
2361
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2362
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2363
    
2364
    s->mbintra_table[s->mb_x + s->mb_y*s->mb_stride]= 0;
2365
}
2366

    
2367
/* generic function called after a macroblock has been parsed by the
2368
   decoder or after it has been encoded by the encoder.
2369

2370
   Important variables used:
2371
   s->mb_intra : true if intra macroblock
2372
   s->mv_dir   : motion vector direction
2373
   s->mv_type  : motion vector type
2374
   s->mv       : motion vector
2375
   s->interlaced_dct : true if interlaced dct used (mpeg2)
2376
 */
2377
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
2378
{
2379
    int mb_x, mb_y;
2380
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2381

    
2382
    mb_x = s->mb_x;
2383
    mb_y = s->mb_y;
2384

    
2385
    s->current_picture.qscale_table[mb_xy]= s->qscale;
2386

    
2387
    /* update DC predictors for P macroblocks */
2388
    if (!s->mb_intra) {
2389
        if (s->h263_pred || s->h263_aic) {
2390
            if(s->mbintra_table[mb_xy])
2391
                ff_clean_intra_table_entries(s);
2392
        } else {
2393
            s->last_dc[0] =
2394
            s->last_dc[1] =
2395
            s->last_dc[2] = 128 << s->intra_dc_precision;
2396
        }
2397
    }
2398
    else if (s->h263_pred || s->h263_aic)
2399
        s->mbintra_table[mb_xy]=1;
2400

    
2401
    /* update motion predictor, not for B-frames as they need the motion_val from the last P/S-Frame */
2402
    if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) { //FIXME move into h263.c if possible, format specific stuff shouldnt be here
2403
        //FIXME a lot of thet is only needed for !low_delay
2404
        const int wrap = s->block_wrap[0];
2405
        const int xy = s->block_index[0];
2406
        if(s->mv_type != MV_TYPE_8X8){
2407
            int motion_x, motion_y;
2408
            if (s->mb_intra) {
2409
                motion_x = 0;
2410
                motion_y = 0;
2411
            } else if (s->mv_type == MV_TYPE_16X16) {
2412
                motion_x = s->mv[0][0][0];
2413
                motion_y = s->mv[0][0][1];
2414
            } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
2415
                int i;
2416
                motion_x = s->mv[0][0][0] + s->mv[0][1][0];
2417
                motion_y = s->mv[0][0][1] + s->mv[0][1][1];
2418
                motion_x = (motion_x>>1) | (motion_x&1);
2419
                for(i=0; i<2; i++){
2420
                    s->field_mv_table[mb_xy][i][0]= s->mv[0][i][0];
2421
                    s->field_mv_table[mb_xy][i][1]= s->mv[0][i][1];
2422
                    s->field_select_table[mb_xy][i]= s->field_select[0][i];
2423
                }
2424
            }
2425
            
2426
            /* no update if 8X8 because it has been done during parsing */
2427
            s->motion_val[xy][0] = motion_x;
2428
            s->motion_val[xy][1] = motion_y;
2429
            s->motion_val[xy + 1][0] = motion_x;
2430
            s->motion_val[xy + 1][1] = motion_y;
2431
            s->motion_val[xy + wrap][0] = motion_x;
2432
            s->motion_val[xy + wrap][1] = motion_y;
2433
            s->motion_val[xy + 1 + wrap][0] = motion_x;
2434
            s->motion_val[xy + 1 + wrap][1] = motion_y;
2435
        }
2436

    
2437
        if(s->encoding){ //FIXME encoding MUST be cleaned up
2438
            if (s->mv_type == MV_TYPE_8X8) 
2439
                s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
2440
            else
2441
                s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
2442
        }
2443
    }
2444
    
2445
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
2446
        uint8_t *dest_y, *dest_cb, *dest_cr;
2447
        int dct_linesize, dct_offset;
2448
        op_pixels_func (*op_pix)[4];
2449
        qpel_mc_func (*op_qpix)[16];
2450
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
2451
        const int uvlinesize= s->current_picture.linesize[1];
2452

    
2453
        /* avoid copy if macroblock skipped in last frame too */
2454
        if (s->pict_type != B_TYPE) {
2455
            s->current_picture.mbskip_table[mb_xy]= s->mb_skiped;
2456
        }
2457

    
2458
        /* skip only during decoding as we might trash the buffers during encoding a bit */
2459
        if(!s->encoding){
2460
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2461
            const int age= s->current_picture.age;
2462

    
2463
            assert(age);
2464

    
2465
            if (s->mb_skiped) {
2466
                s->mb_skiped= 0;
2467
                assert(s->pict_type!=I_TYPE);
2468
 
2469
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
2470
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2471

    
2472
                /* if previous was skipped too, then nothing to do !  */
2473
                if (*mbskip_ptr >= age && s->current_picture.reference){
2474
                    return;
2475
                }
2476
            } else if(!s->current_picture.reference){
2477
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2478
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2479
            } else{
2480
                *mbskip_ptr = 0; /* not skipped */
2481
            }
2482
        }else
2483
            s->mb_skiped= 0;
2484

    
2485
        if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){ //FIXME precalc
2486
            dest_y  = s->current_picture.data[0] + mb_x * 16;
2487
            dest_cb = s->current_picture.data[1] + mb_x * 8;
2488
            dest_cr = s->current_picture.data[2] + mb_x * 8;
2489
        }else{
2490
            dest_y  = s->current_picture.data[0] + (mb_y * 16* linesize  ) + mb_x * 16;
2491
            dest_cb = s->current_picture.data[1] + (mb_y * 8 * uvlinesize) + mb_x * 8;
2492
            dest_cr = s->current_picture.data[2] + (mb_y * 8 * uvlinesize) + mb_x * 8;
2493
        }
2494

    
2495
        if (s->interlaced_dct) {
2496
            dct_linesize = linesize * 2;
2497
            dct_offset = linesize;
2498
        } else {
2499
            dct_linesize = linesize;
2500
            dct_offset = linesize * 8;
2501
        }
2502

    
2503
        if (!s->mb_intra) {
2504
            /* motion handling */
2505
            /* decoding or more than one mb_type (MC was allready done otherwise) */
2506
            if((!s->encoding) || (s->mb_type[mb_xy]&(s->mb_type[mb_xy]-1))){
2507
                if ((!s->no_rounding) || s->pict_type==B_TYPE){                
2508
                    op_pix = s->dsp.put_pixels_tab;
2509
                    op_qpix= s->dsp.put_qpel_pixels_tab;
2510
                }else{
2511
                    op_pix = s->dsp.put_no_rnd_pixels_tab;
2512
                    op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2513
                }
2514

    
2515
                if (s->mv_dir & MV_DIR_FORWARD) {
2516
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2517
                    op_pix = s->dsp.avg_pixels_tab;
2518
                    op_qpix= s->dsp.avg_qpel_pixels_tab;
2519
                }
2520
                if (s->mv_dir & MV_DIR_BACKWARD) {
2521
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2522
                }
2523
            }
2524

    
2525
            /* skip dequant / idct if we are really late ;) */
2526
            if(s->hurry_up>1) return;
2527

    
2528
            /* add dct residue */
2529
            if(s->encoding || !(   s->mpeg2 || s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO 
2530
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2531
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
2532
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2533
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2534
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2535

    
2536
                if(!(s->flags&CODEC_FLAG_GRAY)){
2537
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize);
2538
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize);
2539
                }
2540
            } else if(s->codec_id != CODEC_ID_WMV2){
2541
                add_dct(s, block[0], 0, dest_y, dct_linesize);
2542
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2543
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2544
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2545

    
2546
                if(!(s->flags&CODEC_FLAG_GRAY)){
2547
                    add_dct(s, block[4], 4, dest_cb, uvlinesize);
2548
                    add_dct(s, block[5], 5, dest_cr, uvlinesize);
2549
                }
2550
            } 
2551
#ifdef CONFIG_RISKY
2552
            else{
2553
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2554
            }
2555
#endif
2556
        } else {
2557
            /* dct only in intra block */
2558
            if(s->encoding || !(s->mpeg2 || s->codec_id==CODEC_ID_MPEG1VIDEO)){
2559
                put_dct(s, block[0], 0, dest_y, dct_linesize);
2560
                put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2561
                put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2562
                put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2563

    
2564
                if(!(s->flags&CODEC_FLAG_GRAY)){
2565
                    put_dct(s, block[4], 4, dest_cb, uvlinesize);
2566
                    put_dct(s, block[5], 5, dest_cr, uvlinesize);
2567
                }
2568
            }else{
2569
                s->dsp.idct_put(dest_y                 , dct_linesize, block[0]);
2570
                s->dsp.idct_put(dest_y              + 8, dct_linesize, block[1]);
2571
                s->dsp.idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
2572
                s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
2573

    
2574
                if(!(s->flags&CODEC_FLAG_GRAY)){
2575
                    s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2576
                    s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2577
                }
2578
            }
2579
        }
2580
    }
2581
}
2582

    
2583
#ifdef CONFIG_ENCODERS
2584

    
2585
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
2586
{
2587
    static const char tab[64]=
2588
        {3,2,2,1,1,1,1,1,
2589
         1,1,1,1,1,1,1,1,
2590
         1,1,1,1,1,1,1,1,
2591
         0,0,0,0,0,0,0,0,
2592
         0,0,0,0,0,0,0,0,
2593
         0,0,0,0,0,0,0,0,
2594
         0,0,0,0,0,0,0,0,
2595
         0,0,0,0,0,0,0,0};
2596
    int score=0;
2597
    int run=0;
2598
    int i;
2599
    DCTELEM *block= s->block[n];
2600
    const int last_index= s->block_last_index[n];
2601
    int skip_dc;
2602

    
2603
    if(threshold<0){
2604
        skip_dc=0;
2605
        threshold= -threshold;
2606
    }else
2607
        skip_dc=1;
2608

    
2609
    /* are all which we could set to zero are allready zero? */
2610
    if(last_index<=skip_dc - 1) return;
2611

    
2612
    for(i=0; i<=last_index; i++){
2613
        const int j = s->intra_scantable.permutated[i];
2614
        const int level = ABS(block[j]);
2615
        if(level==1){
2616
            if(skip_dc && i==0) continue;
2617
            score+= tab[run];
2618
            run=0;
2619
        }else if(level>1){
2620
            return;
2621
        }else{
2622
            run++;
2623
        }
2624
    }
2625
    if(score >= threshold) return;
2626
    for(i=skip_dc; i<=last_index; i++){
2627
        const int j = s->intra_scantable.permutated[i];
2628
        block[j]=0;
2629
    }
2630
    if(block[0]) s->block_last_index[n]= 0;
2631
    else         s->block_last_index[n]= -1;
2632
}
2633

    
2634
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
2635
{
2636
    int i;
2637
    const int maxlevel= s->max_qcoeff;
2638
    const int minlevel= s->min_qcoeff;
2639
    
2640
    if(s->mb_intra){
2641
        i=1; //skip clipping of intra dc
2642
    }else
2643
        i=0;
2644
    
2645
    for(;i<=last_index; i++){
2646
        const int j= s->intra_scantable.permutated[i];
2647
        int level = block[j];
2648
       
2649
        if     (level>maxlevel) level=maxlevel;
2650
        else if(level<minlevel) level=minlevel;
2651

    
2652
        block[j]= level;
2653
    }
2654
}
2655

    
2656
#if 0
2657
static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
2658
    int score=0;
2659
    int x,y;
2660
    
2661
    for(y=0; y<7; y++){
2662
        for(x=0; x<16; x+=4){
2663
            score+= ABS(s[x  ] - s[x  +stride]) + ABS(s[x+1] - s[x+1+stride]) 
2664
                   +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
2665
        }
2666
        s+= stride;
2667
    }
2668
    
2669
    return score;
2670
}
2671

2672
static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
2673
    int score=0;
2674
    int x,y;
2675
    
2676
    for(y=0; y<7; y++){
2677
        for(x=0; x<16; x++){
2678
            score+= ABS(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2679
        }
2680
        s1+= stride;
2681
        s2+= stride;
2682
    }
2683
    
2684
    return score;
2685
}
2686
#else
2687
#define SQ(a) ((a)*(a))
2688

    
2689
static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
2690
    int score=0;
2691
    int x,y;
2692
    
2693
    for(y=0; y<7; y++){
2694
        for(x=0; x<16; x+=4){
2695
            score+= SQ(s[x  ] - s[x  +stride]) + SQ(s[x+1] - s[x+1+stride]) 
2696
                   +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
2697
        }
2698
        s+= stride;
2699
    }
2700
    
2701
    return score;
2702
}
2703

    
2704
static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
2705
    int score=0;
2706
    int x,y;
2707
    
2708
    for(y=0; y<7; y++){
2709
        for(x=0; x<16; x++){
2710
            score+= SQ(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2711
        }
2712
        s1+= stride;
2713
        s2+= stride;
2714
    }
2715
    
2716
    return score;
2717
}
2718

    
2719
#endif
2720

    
2721
#endif //CONFIG_ENCODERS
2722

    
2723
/**
2724
 *
2725
 * @param h is the normal height, this will be reduced automatically if needed for the last row
2726
 */
2727
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2728
    if (s->avctx->draw_horiz_band) {
2729
        AVFrame *src;
2730
        uint8_t *src_ptr[3];
2731
        int offset[4];
2732
        
2733
        if(s->picture_structure != PICT_FRAME){
2734
            h <<= 1;
2735
            y <<= 1;
2736
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2737
        }
2738

    
2739
        h= FFMIN(h, s->height - y);
2740

    
2741
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) 
2742
            src= (AVFrame*)s->current_picture_ptr;
2743
        else if(s->last_picture_ptr)
2744
            src= (AVFrame*)s->last_picture_ptr;
2745
        else
2746
            return;
2747
            
2748
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2749
            offset[0]=
2750
            offset[1]=
2751
            offset[2]=
2752
            offset[3]= 0;
2753
        }else{
2754
            offset[0]= y * s->linesize;;
2755
            offset[1]= 
2756
            offset[2]= (y>>1) * s->uvlinesize;;
2757
            offset[3]= 0;
2758
        }
2759

    
2760
        emms_c();
2761

    
2762
        s->avctx->draw_horiz_band(s->avctx, src, offset,
2763
                                  y, s->picture_structure, h);
2764
    }
2765
}
2766

    
2767
#ifdef CONFIG_ENCODERS
2768

    
2769
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2770
{
2771
    const int mb_x= s->mb_x;
2772
    const int mb_y= s->mb_y;
2773
    int i;
2774
    int skip_dct[6];
2775
    int dct_offset   = s->linesize*8; //default for progressive frames
2776
    
2777
    for(i=0; i<6; i++) skip_dct[i]=0;
2778
    
2779
    if(s->adaptive_quant){
2780
        s->dquant= s->current_picture.qscale_table[mb_x + mb_y*s->mb_stride] - s->qscale;
2781

    
2782
        if(s->out_format==FMT_H263){
2783
            if     (s->dquant> 2) s->dquant= 2;
2784
            else if(s->dquant<-2) s->dquant=-2;
2785
        }
2786
            
2787
        if(s->codec_id==CODEC_ID_MPEG4){        
2788
            if(!s->mb_intra){
2789
                if(s->mv_dir&MV_DIRECT)
2790
                    s->dquant=0;
2791

    
2792
                assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
2793
            }
2794
        }
2795
        s->qscale+= s->dquant;
2796
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2797
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2798
    }
2799

    
2800
    if (s->mb_intra) {
2801
        uint8_t *ptr;
2802
        int wrap_y;
2803
        int emu=0;
2804

    
2805
        wrap_y = s->linesize;
2806
        ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2807

    
2808
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2809
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2810
            ptr= s->edge_emu_buffer;
2811
            emu=1;
2812
        }
2813
        
2814
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2815
            int progressive_score, interlaced_score;
2816
            
2817
            progressive_score= pix_vcmp16x8(ptr, wrap_y  ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
2818
            interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y  , wrap_y*2);
2819
            
2820
            if(progressive_score > interlaced_score + 100){
2821
                s->interlaced_dct=1;
2822
            
2823
                dct_offset= wrap_y;
2824
                wrap_y<<=1;
2825
            }else
2826
                s->interlaced_dct=0;
2827
        }
2828
        
2829
        s->dsp.get_pixels(s->block[0], ptr                 , wrap_y);
2830
        s->dsp.get_pixels(s->block[1], ptr              + 8, wrap_y);
2831
        s->dsp.get_pixels(s->block[2], ptr + dct_offset    , wrap_y);
2832
        s->dsp.get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
2833

    
2834
        if(s->flags&CODEC_FLAG_GRAY){
2835
            skip_dct[4]= 1;
2836
            skip_dct[5]= 1;
2837
        }else{
2838
            int wrap_c = s->uvlinesize;
2839
            ptr = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2840
            if(emu){
2841
                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);
2842
                ptr= s->edge_emu_buffer;
2843
            }
2844
            s->dsp.get_pixels(s->block[4], ptr, wrap_c);
2845

    
2846
            ptr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2847
            if(emu){
2848
                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);
2849
                ptr= s->edge_emu_buffer;
2850
            }
2851
            s->dsp.get_pixels(s->block[5], ptr, wrap_c);
2852
        }
2853
    }else{
2854
        op_pixels_func (*op_pix)[4];
2855
        qpel_mc_func (*op_qpix)[16];
2856
        uint8_t *dest_y, *dest_cb, *dest_cr;
2857
        uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2858
        int wrap_y, wrap_c;
2859
        int emu=0;
2860

    
2861
        dest_y  = s->current_picture.data[0] + (mb_y * 16 * s->linesize    ) + mb_x * 16;
2862
        dest_cb = s->current_picture.data[1] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2863
        dest_cr = s->current_picture.data[2] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2864
        wrap_y = s->linesize;
2865
        wrap_c = s->uvlinesize;
2866
        ptr_y  = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2867
        ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2868
        ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2869

    
2870
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
2871
            op_pix = s->dsp.put_pixels_tab;
2872
            op_qpix= s->dsp.put_qpel_pixels_tab;
2873
        }else{
2874
            op_pix = s->dsp.put_no_rnd_pixels_tab;
2875
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2876
        }
2877

    
2878
        if (s->mv_dir & MV_DIR_FORWARD) {
2879
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2880
            op_pix = s->dsp.avg_pixels_tab;
2881
            op_qpix= s->dsp.avg_qpel_pixels_tab;
2882
        }
2883
        if (s->mv_dir & MV_DIR_BACKWARD) {
2884
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2885
        }
2886

    
2887
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2888
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2889
            ptr_y= s->edge_emu_buffer;
2890
            emu=1;
2891
        }
2892
        
2893
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2894
            int progressive_score, interlaced_score;
2895
            
2896
            progressive_score= pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y  ) 
2897
                             + pix_diff_vcmp16x8(ptr_y + wrap_y*8, dest_y + wrap_y*8, wrap_y  );
2898
            interlaced_score = pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y*2)
2899
                             + pix_diff_vcmp16x8(ptr_y + wrap_y  , dest_y + wrap_y  , wrap_y*2);
2900
            
2901
            if(progressive_score > interlaced_score + 600){
2902
                s->interlaced_dct=1;
2903
            
2904
                dct_offset= wrap_y;
2905
                wrap_y<<=1;
2906
            }else
2907
                s->interlaced_dct=0;
2908
        }
2909
        
2910
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
2911
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
2912
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
2913
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
2914
        
2915
        if(s->flags&CODEC_FLAG_GRAY){
2916
            skip_dct[4]= 1;
2917
            skip_dct[5]= 1;
2918
        }else{
2919
            if(emu){
2920
                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);
2921
                ptr_cb= s->edge_emu_buffer;
2922
            }
2923
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2924
            if(emu){
2925
                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);
2926
                ptr_cr= s->edge_emu_buffer;
2927
            }
2928
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2929
        }
2930
        /* pre quantization */         
2931
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
2932
            //FIXME optimize
2933
            if(s->dsp.pix_abs8x8(ptr_y               , dest_y               , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
2934
            if(s->dsp.pix_abs8x8(ptr_y            + 8, dest_y            + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
2935
            if(s->dsp.pix_abs8x8(ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
2936
            if(s->dsp.pix_abs8x8(ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
2937
            if(s->dsp.pix_abs8x8(ptr_cb              , dest_cb              , wrap_c) < 20*s->qscale) skip_dct[4]= 1;
2938
            if(s->dsp.pix_abs8x8(ptr_cr              , dest_cr              , wrap_c) < 20*s->qscale) skip_dct[5]= 1;
2939
#if 0
2940
{
2941
 static int stat[7];
2942
 int num=0;
2943
 for(i=0; i<6; i++)
2944
  if(skip_dct[i]) num++;
2945
 stat[num]++;
2946
 
2947
 if(s->mb_x==0 && s->mb_y==0){
2948
  for(i=0; i<7; i++){
2949
   printf("%6d %1d\n", stat[i], i);
2950
  }
2951
 }
2952
}
2953
#endif
2954
        }
2955

    
2956
    }
2957
            
2958
#if 0
2959
            {
2960
                float adap_parm;
2961
                
2962
                adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_stride*mb_y+mb_x] + 1.0) /
2963
                            ((s->mb_var[s->mb_stride*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);
2964
            
2965
                printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d", 
2966
                        (s->mb_type[s->mb_stride*mb_y+mb_x] > 0) ? 'I' : 'P', 
2967
                        s->qscale, adap_parm, s->qscale*adap_parm,
2968
                        s->mb_var[s->mb_stride*mb_y+mb_x], s->avg_mb_var);
2969
            }
2970
#endif
2971
    /* DCT & quantize */
2972
    if(s->out_format==FMT_MJPEG){
2973
        for(i=0;i<6;i++) {
2974
            int overflow;
2975
            s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
2976
            if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2977
        }
2978
    }else{
2979
        for(i=0;i<6;i++) {
2980
            if(!skip_dct[i]){
2981
                int overflow;
2982
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2983
            // FIXME we could decide to change to quantizer instead of clipping
2984
            // JS: I don't think that would be a good idea it could lower quality instead
2985
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
2986
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2987
            }else
2988
                s->block_last_index[i]= -1;
2989
        }
2990
        if(s->luma_elim_threshold && !s->mb_intra)
2991
            for(i=0; i<4; i++)
2992
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2993
        if(s->chroma_elim_threshold && !s->mb_intra)
2994
            for(i=4; i<6; i++)
2995
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2996
    }
2997

    
2998
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
2999
        s->block_last_index[4]=
3000
        s->block_last_index[5]= 0;
3001
        s->block[4][0]=
3002
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
3003
    }
3004

    
3005
    /* huffman encode */
3006
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
3007
    case CODEC_ID_MPEG1VIDEO:
3008
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
3009
#ifdef CONFIG_RISKY
3010
    case CODEC_ID_MPEG4:
3011
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3012
    case CODEC_ID_MSMPEG4V2:
3013
    case CODEC_ID_MSMPEG4V3:
3014
    case CODEC_ID_WMV1:
3015
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3016
    case CODEC_ID_WMV2:
3017
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
3018
    case CODEC_ID_H263:
3019
    case CODEC_ID_H263P:
3020
    case CODEC_ID_FLV1:
3021
    case CODEC_ID_RV10:
3022
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
3023
#endif
3024
    case CODEC_ID_MJPEG:
3025
        mjpeg_encode_mb(s, s->block); break;
3026
    default:
3027
        assert(0);
3028
    }
3029
}
3030

    
3031
#endif //CONFIG_ENCODERS
3032

    
3033
/**
3034
 * combines the (truncated) bitstream to a complete frame
3035
 * @returns -1 if no complete frame could be created
3036
 */
3037
int ff_combine_frame( MpegEncContext *s, int next, uint8_t **buf, int *buf_size){
3038
    ParseContext *pc= &s->parse_context;
3039

    
3040
#if 0
3041
    if(pc->overread){
3042
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
3043
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
3044
    }
3045
#endif
3046

    
3047
    /* copy overreaded byes from last frame into buffer */
3048
    for(; pc->overread>0; pc->overread--){
3049
        pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
3050
    }
3051
    
3052
    pc->last_index= pc->index;
3053

    
3054
    /* copy into buffer end return */
3055
    if(next == END_NOT_FOUND){
3056
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
3057

    
3058
        memcpy(&pc->buffer[pc->index], *buf, *buf_size);
3059
        pc->index += *buf_size;
3060
        return -1;
3061
    }
3062

    
3063
    *buf_size=
3064
    pc->overread_index= pc->index + next;
3065
    
3066
    /* append to buffer */
3067
    if(pc->index){
3068
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
3069

    
3070
        memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
3071
        pc->index = 0;
3072
        *buf= pc->buffer;
3073
    }
3074

    
3075
    /* store overread bytes */
3076
    for(;next < 0; next++){
3077
        pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
3078
        pc->overread++;
3079
    }
3080

    
3081
#if 0
3082
    if(pc->overread){
3083
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
3084
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
3085
    }
3086
#endif
3087

    
3088
    return 0;
3089
}
3090

    
3091
void ff_mpeg_flush(AVCodecContext *avctx){
3092
    int i;
3093
    MpegEncContext *s = avctx->priv_data;
3094
    
3095
    for(i=0; i<MAX_PICTURE_COUNT; i++){
3096
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
3097
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
3098
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
3099
    }
3100
    s->last_picture_ptr = s->next_picture_ptr = NULL;
3101
}
3102

    
3103
#ifdef CONFIG_ENCODERS
3104
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
3105
{
3106
    int bytes= length>>4;
3107
    int bits= length&15;
3108
    int i;
3109

    
3110
    if(length==0) return;
3111

    
3112
    for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
3113
    put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
3114
}
3115

    
3116
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
3117
    int i;
3118

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

    
3121
    /* mpeg1 */
3122
    d->mb_skip_run= s->mb_skip_run;
3123
    for(i=0; i<3; i++)
3124
        d->last_dc[i]= s->last_dc[i];
3125
    
3126
    /* statistics */
3127
    d->mv_bits= s->mv_bits;
3128
    d->i_tex_bits= s->i_tex_bits;
3129
    d->p_tex_bits= s->p_tex_bits;
3130
    d->i_count= s->i_count;
3131
    d->f_count= s->f_count;
3132
    d->b_count= s->b_count;
3133
    d->skip_count= s->skip_count;
3134
    d->misc_bits= s->misc_bits;
3135
    d->last_bits= 0;
3136

    
3137
    d->mb_skiped= s->mb_skiped;
3138
    d->qscale= s->qscale;
3139
}
3140

    
3141
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
3142
    int i;
3143

    
3144
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
3145
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
3146
    
3147
    /* mpeg1 */
3148
    d->mb_skip_run= s->mb_skip_run;
3149
    for(i=0; i<3; i++)
3150
        d->last_dc[i]= s->last_dc[i];
3151
    
3152
    /* statistics */
3153
    d->mv_bits= s->mv_bits;
3154
    d->i_tex_bits= s->i_tex_bits;
3155
    d->p_tex_bits= s->p_tex_bits;
3156
    d->i_count= s->i_count;
3157
    d->f_count= s->f_count;
3158
    d->b_count= s->b_count;
3159
    d->skip_count= s->skip_count;
3160
    d->misc_bits= s->misc_bits;
3161

    
3162
    d->mb_intra= s->mb_intra;
3163
    d->mb_skiped= s->mb_skiped;
3164
    d->mv_type= s->mv_type;
3165
    d->mv_dir= s->mv_dir;
3166
    d->pb= s->pb;
3167
    if(s->data_partitioning){
3168
        d->pb2= s->pb2;
3169
        d->tex_pb= s->tex_pb;
3170
    }
3171
    d->block= s->block;
3172
    for(i=0; i<6; i++)
3173
        d->block_last_index[i]= s->block_last_index[i];
3174
    d->interlaced_dct= s->interlaced_dct;
3175
    d->qscale= s->qscale;
3176
}
3177

    
3178
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
3179
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
3180
                           int *dmin, int *next_block, int motion_x, int motion_y)
3181
{
3182
    int bits_count;
3183
    
3184
    copy_context_before_encode(s, backup, type);
3185

    
3186
    s->block= s->blocks[*next_block];
3187
    s->pb= pb[*next_block];
3188
    if(s->data_partitioning){
3189
        s->pb2   = pb2   [*next_block];
3190
        s->tex_pb= tex_pb[*next_block];
3191
    }
3192

    
3193
    encode_mb(s, motion_x, motion_y);
3194

    
3195
    bits_count= get_bit_count(&s->pb);
3196
    if(s->data_partitioning){
3197
        bits_count+= get_bit_count(&s->pb2);
3198
        bits_count+= get_bit_count(&s->tex_pb);
3199
    }
3200

    
3201
    if(bits_count<*dmin){
3202
        *dmin= bits_count;
3203
        *next_block^=1;
3204

    
3205
        copy_context_after_encode(best, s, type);
3206
    }
3207
}
3208
                
3209
static inline int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
3210
    uint32_t *sq = squareTbl + 256;
3211
    int acc=0;
3212
    int x,y;
3213
    
3214
    if(w==16 && h==16) 
3215
        return s->dsp.sse[0](NULL, src1, src2, stride);
3216
    else if(w==8 && h==8)
3217
        return s->dsp.sse[1](NULL, src1, src2, stride);
3218
    
3219
    for(y=0; y<h; y++){
3220
        for(x=0; x<w; x++){
3221
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
3222
        } 
3223
    }
3224
    
3225
    assert(acc>=0);
3226
    
3227
    return acc;
3228
}
3229

    
3230
static void encode_picture(MpegEncContext *s, int picture_number)
3231
{
3232
    int mb_x, mb_y, pdif = 0;
3233
    int i;
3234
    int bits;
3235
    MpegEncContext best_s, backup_s;
3236
    uint8_t bit_buf[2][3000];
3237
    uint8_t bit_buf2[2][3000];
3238
    uint8_t bit_buf_tex[2][3000];
3239
    PutBitContext pb[2], pb2[2], tex_pb[2];
3240

    
3241
    for(i=0; i<2; i++){
3242
        init_put_bits(&pb    [i], bit_buf    [i], 3000, NULL, NULL);
3243
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000, NULL, NULL);
3244
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
3245
    }
3246

    
3247
    s->picture_number = picture_number;
3248
    
3249
    /* Reset the average MB variance */
3250
    s->current_picture.mb_var_sum = 0;
3251
    s->current_picture.mc_mb_var_sum = 0;
3252

    
3253
#ifdef CONFIG_RISKY
3254
    /* we need to initialize some time vars before we can encode b-frames */
3255
    // RAL: Condition added for MPEG1VIDEO
3256
    if (s->codec_id == CODEC_ID_MPEG1VIDEO || (s->h263_pred && !s->h263_msmpeg4))
3257
        ff_set_mpeg4_time(s, s->picture_number); 
3258
#endif
3259
        
3260
    s->scene_change_score=0;
3261
    
3262
    s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
3263
    
3264
    if(s->pict_type==I_TYPE){
3265
        if(s->msmpeg4_version >= 3) s->no_rounding=1;
3266
        else                        s->no_rounding=0;
3267
    }else if(s->pict_type!=B_TYPE){
3268
        if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
3269
            s->no_rounding ^= 1;          
3270
    }
3271
    
3272
    /* Estimate motion for every MB */
3273
    s->mb_intra=0; //for the rate distoration & bit compare functions
3274
    if(s->pict_type != I_TYPE){
3275
        if(s->pict_type != B_TYPE){
3276
            if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
3277
                s->me.pre_pass=1;
3278
                s->me.dia_size= s->avctx->pre_dia_size;
3279

    
3280
                for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) {
3281
                    for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) {
3282
                        s->mb_x = mb_x;
3283
                        s->mb_y = mb_y;
3284
                        ff_pre_estimate_p_frame_motion(s, mb_x, mb_y);
3285
                    }
3286
                }
3287
                s->me.pre_pass=0;
3288
            }
3289
        }
3290

    
3291
        s->me.dia_size= s->avctx->dia_size;
3292
        for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3293
            s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3294
            s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3295
            s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3296
            s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3297
            for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3298
                s->mb_x = mb_x;
3299
                s->mb_y = mb_y;
3300
                s->block_index[0]+=2;
3301
                s->block_index[1]+=2;
3302
                s->block_index[2]+=2;
3303
                s->block_index[3]+=2;
3304
                
3305
                /* compute motion vector & mb_type and store in context */
3306
                if(s->pict_type==B_TYPE)
3307
                    ff_estimate_b_frame_motion(s, mb_x, mb_y);
3308
                else
3309
                    ff_estimate_p_frame_motion(s, mb_x, mb_y);
3310
            }
3311
        }
3312
    }else /* if(s->pict_type == I_TYPE) */{
3313
        /* I-Frame */
3314
        //FIXME do we need to zero them?
3315
        memset(s->motion_val[0], 0, sizeof(int16_t)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
3316
        memset(s->p_mv_table   , 0, sizeof(int16_t)*(s->mb_stride)*s->mb_height*2);
3317
        memset(s->mb_type      , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3318
        
3319
        if(!s->fixed_qscale){
3320
            /* finding spatial complexity for I-frame rate control */
3321
            for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3322
                for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3323
                    int xx = mb_x * 16;
3324
                    int yy = mb_y * 16;
3325
                    uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
3326
                    int varc;
3327
                    int sum = s->dsp.pix_sum(pix, s->linesize);
3328
    
3329
                    varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
3330

    
3331
                    s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
3332
                    s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
3333
                    s->current_picture.mb_var_sum    += varc;
3334
                }
3335
            }
3336
        }
3337
    }
3338
    emms_c();
3339

    
3340
    if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
3341
        s->pict_type= I_TYPE;
3342
        memset(s->mb_type   , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3343
//printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3344
    }
3345

    
3346
    if(!s->umvplus){
3347
        if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
3348
            s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
3349
        
3350
            ff_fix_long_p_mvs(s);
3351
        }
3352

    
3353
        if(s->pict_type==B_TYPE){
3354
            int a, b;
3355

    
3356
            a = ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
3357
            b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, MB_TYPE_BIDIR);
3358
            s->f_code = FFMAX(a, b);
3359

    
3360
            a = ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
3361
            b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, MB_TYPE_BIDIR);
3362
            s->b_code = FFMAX(a, b);
3363

    
3364
            ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
3365
            ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
3366
            ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
3367
            ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
3368
        }
3369
    }
3370
    
3371
    if (s->fixed_qscale) 
3372
        s->frame_qscale = s->current_picture.quality;
3373
    else
3374
        s->frame_qscale = ff_rate_estimate_qscale(s);
3375

    
3376
    if(s->adaptive_quant){
3377
#ifdef CONFIG_RISKY
3378
        switch(s->codec_id){
3379
        case CODEC_ID_MPEG4:
3380
            ff_clean_mpeg4_qscales(s);
3381
            break;
3382
        case CODEC_ID_H263:
3383
        case CODEC_ID_H263P:
3384
        case CODEC_ID_FLV1:
3385
            ff_clean_h263_qscales(s);
3386
            break;
3387
        }
3388
#endif
3389

    
3390
        s->qscale= s->current_picture.qscale_table[0];
3391
    }else
3392
        s->qscale= (int)(s->frame_qscale + 0.5);
3393
        
3394
    if (s->out_format == FMT_MJPEG) {
3395
        /* for mjpeg, we do include qscale in the matrix */
3396
        s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
3397
        for(i=1;i<64;i++){
3398
            int j= s->dsp.idct_permutation[i];
3399

    
3400
            s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3401
        }
3402
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, 
3403
                       s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
3404
    }
3405
    
3406
    //FIXME var duplication
3407
    s->current_picture.key_frame= s->pict_type == I_TYPE;
3408
    s->current_picture.pict_type= s->pict_type;
3409

    
3410
    if(s->current_picture.key_frame)
3411
        s->picture_in_gop_number=0;
3412

    
3413
    s->last_bits= get_bit_count(&s->pb);
3414
    switch(s->out_format) {
3415
    case FMT_MJPEG:
3416
        mjpeg_picture_header(s);
3417
        break;
3418
#ifdef CONFIG_RISKY
3419
    case FMT_H263:
3420
        if (s->codec_id == CODEC_ID_WMV2) 
3421
            ff_wmv2_encode_picture_header(s, picture_number);
3422
        else if (s->h263_msmpeg4) 
3423
            msmpeg4_encode_picture_header(s, picture_number);
3424
        else if (s->h263_pred)
3425
            mpeg4_encode_picture_header(s, picture_number);
3426
        else if (s->h263_rv10) 
3427
            rv10_encode_picture_header(s, picture_number);
3428
        else if (s->codec_id == CODEC_ID_FLV1)
3429
            ff_flv_encode_picture_header(s, picture_number);
3430
        else
3431
            h263_encode_picture_header(s, picture_number);
3432
        break;
3433
#endif
3434
    case FMT_MPEG1:
3435
        mpeg1_encode_picture_header(s, picture_number);
3436
        break;
3437
    }
3438
    bits= get_bit_count(&s->pb);
3439
    s->header_bits= bits - s->last_bits;
3440
    s->last_bits= bits;
3441
    s->mv_bits=0;
3442
    s->misc_bits=0;
3443
    s->i_tex_bits=0;
3444
    s->p_tex_bits=0;
3445
    s->i_count=0;
3446
    s->f_count=0;
3447
    s->b_count=0;
3448
    s->skip_count=0;
3449

    
3450
    for(i=0; i<3; i++){
3451
        /* init last dc values */
3452
        /* note: quant matrix value (8) is implied here */
3453
        s->last_dc[i] = 128;
3454
        
3455
        s->current_picture_ptr->error[i] = 0;
3456
    }
3457
    s->mb_skip_run = 0;
3458
    s->last_mv[0][0][0] = 0;
3459
    s->last_mv[0][0][1] = 0;
3460
    s->last_mv[1][0][0] = 0;
3461
    s->last_mv[1][0][1] = 0;
3462
     
3463
    s->last_mv_dir = 0;
3464

    
3465
#ifdef CONFIG_RISKY
3466
    switch(s->codec_id){
3467
    case CODEC_ID_H263:
3468
    case CODEC_ID_H263P:
3469
    case CODEC_ID_FLV1:
3470
        s->gob_index = ff_h263_get_gob_height(s);
3471
        break;
3472
    case CODEC_ID_MPEG4:
3473
        if(s->partitioned_frame)
3474
            ff_mpeg4_init_partitions(s);
3475
        break;
3476
    }
3477
#endif
3478

    
3479
    s->resync_mb_x=0;
3480
    s->resync_mb_y=0;
3481
    s->first_slice_line = 1;
3482
    s->ptr_lastgob = s->pb.buf;
3483
    for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3484
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
3485
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
3486
        
3487
        s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3488
        s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3489
        s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3490
        s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3491
        s->block_index[4]= s->block_wrap[4]*(mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2);
3492
        s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
3493
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3494
            const int xy= mb_y*s->mb_stride + mb_x;
3495
            int mb_type= s->mb_type[xy];
3496
//            int d;
3497
            int dmin=10000000;
3498

    
3499
            s->mb_x = mb_x;
3500
            s->mb_y = mb_y;
3501
            s->block_index[0]+=2;
3502
            s->block_index[1]+=2;
3503
            s->block_index[2]+=2;
3504
            s->block_index[3]+=2;
3505
            s->block_index[4]++;
3506
            s->block_index[5]++;
3507

    
3508
            /* write gob / video packet header  */
3509
#ifdef CONFIG_RISKY
3510
            if(s->rtp_mode){
3511
                int current_packet_size, is_gob_start;
3512
                
3513
                current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
3514
                is_gob_start=0;
3515
                
3516
                if(s->codec_id==CODEC_ID_MPEG4){
3517
                    if(current_packet_size >= s->rtp_payload_size
3518
                       && s->mb_y + s->mb_x>0){
3519

    
3520
                        if(s->partitioned_frame){
3521
                            ff_mpeg4_merge_partitions(s);
3522
                            ff_mpeg4_init_partitions(s);
3523
                        }
3524
                        ff_mpeg4_encode_video_packet_header(s);
3525

    
3526
                        if(s->flags&CODEC_FLAG_PASS1){
3527
                            int bits= get_bit_count(&s->pb);
3528
                            s->misc_bits+= bits - s->last_bits;
3529
                            s->last_bits= bits;
3530
                        }
3531
                        ff_mpeg4_clean_buffers(s);
3532
                        is_gob_start=1;
3533
                    }
3534
                }else if(s->codec_id==CODEC_ID_MPEG1VIDEO){
3535
                    if(   current_packet_size >= s->rtp_payload_size 
3536
                       && s->mb_y + s->mb_x>0 && s->mb_skip_run==0){
3537
                        ff_mpeg1_encode_slice_header(s);
3538
                        ff_mpeg1_clean_buffers(s);
3539
                        is_gob_start=1;
3540
                    }
3541
                }else{
3542
                    if(current_packet_size >= s->rtp_payload_size
3543
                       && s->mb_x==0 && s->mb_y>0 && s->mb_y%s->gob_index==0){
3544
                       
3545
                        h263_encode_gob_header(s, mb_y);                       
3546
                        is_gob_start=1;
3547
                    }
3548
                }
3549

    
3550
                if(is_gob_start){
3551
                    s->ptr_lastgob = pbBufPtr(&s->pb);
3552
                    s->first_slice_line=1;
3553
                    s->resync_mb_x=mb_x;
3554
                    s->resync_mb_y=mb_y;
3555
                }
3556
            }
3557
#endif
3558

    
3559
            if(  (s->resync_mb_x   == s->mb_x)
3560
               && s->resync_mb_y+1 == s->mb_y){
3561
                s->first_slice_line=0; 
3562
            }
3563

    
3564
            if(mb_type & (mb_type-1)){ // more than 1 MB type possible
3565
                int next_block=0;
3566
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3567

    
3568
                copy_context_before_encode(&backup_s, s, -1);
3569
                backup_s.pb= s->pb;
3570
                best_s.data_partitioning= s->data_partitioning;
3571
                best_s.partitioned_frame= s->partitioned_frame;
3572
                if(s->data_partitioning){
3573
                    backup_s.pb2= s->pb2;
3574
                    backup_s.tex_pb= s->tex_pb;
3575
                }
3576

    
3577
                if(mb_type&MB_TYPE_INTER){
3578
                    s->mv_dir = MV_DIR_FORWARD;
3579
                    s->mv_type = MV_TYPE_16X16;
3580
                    s->mb_intra= 0;
3581
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
3582
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
3583
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb, 
3584
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3585
                }
3586
                if(mb_type&MB_TYPE_INTER4V){                 
3587
                    s->mv_dir = MV_DIR_FORWARD;
3588
                    s->mv_type = MV_TYPE_8X8;
3589
                    s->mb_intra= 0;
3590
                    for(i=0; i<4; i++){
3591
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3592
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3593
                    }
3594
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb, 
3595
                                 &dmin, &next_block, 0, 0);
3596
                }
3597
                if(mb_type&MB_TYPE_FORWARD){
3598
                    s->mv_dir = MV_DIR_FORWARD;
3599
                    s->mv_type = MV_TYPE_16X16;
3600
                    s->mb_intra= 0;
3601
                    s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3602
                    s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3603
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb, 
3604
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3605
                }
3606
                if(mb_type&MB_TYPE_BACKWARD){
3607
                    s->mv_dir = MV_DIR_BACKWARD;
3608
                    s->mv_type = MV_TYPE_16X16;
3609
                    s->mb_intra= 0;
3610
                    s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3611
                    s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3612
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb, 
3613
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3614
                }
3615
                if(mb_type&MB_TYPE_BIDIR){
3616
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3617
                    s->mv_type = MV_TYPE_16X16;
3618
                    s->mb_intra= 0;
3619
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3620
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3621
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3622
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3623
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb, 
3624
                                 &dmin, &next_block, 0, 0);
3625
                }
3626
                if(mb_type&MB_TYPE_DIRECT){
3627
                    int mx= s->b_direct_mv_table[xy][0];
3628
                    int my= s->b_direct_mv_table[xy][1];
3629
                    
3630
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3631
                    s->mb_intra= 0;
3632
#ifdef CONFIG_RISKY
3633
                    ff_mpeg4_set_direct_mv(s, mx, my);
3634
#endif
3635
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb, 
3636
                                 &dmin, &next_block, mx, my);
3637
                }
3638
                if(mb_type&MB_TYPE_INTRA){
3639
                    s->mv_dir = 0;
3640
                    s->mv_type = MV_TYPE_16X16;
3641
                    s->mb_intra= 1;
3642
                    s->mv[0][0][0] = 0;
3643
                    s->mv[0][0][1] = 0;
3644
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb, 
3645
                                 &dmin, &next_block, 0, 0);
3646
                    /* force cleaning of ac/dc pred stuff if needed ... */
3647
                    if(s->h263_pred || s->h263_aic)
3648
                        s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
3649
                }
3650
                copy_context_after_encode(s, &best_s, -1);
3651
                
3652
                pb_bits_count= get_bit_count(&s->pb);
3653
                flush_put_bits(&s->pb);
3654
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3655
                s->pb= backup_s.pb;
3656
                
3657
                if(s->data_partitioning){
3658
                    pb2_bits_count= get_bit_count(&s->pb2);
3659
                    flush_put_bits(&s->pb2);
3660
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3661
                    s->pb2= backup_s.pb2;
3662
                    
3663
                    tex_pb_bits_count= get_bit_count(&s->tex_pb);
3664
                    flush_put_bits(&s->tex_pb);
3665
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3666
                    s->tex_pb= backup_s.tex_pb;
3667
                }
3668
                s->last_bits= get_bit_count(&s->pb);
3669
            } else {
3670
                int motion_x, motion_y;
3671
                int intra_score;
3672
                int inter_score= s->current_picture.mb_cmp_score[mb_x + mb_y*s->mb_stride];
3673
                
3674
              if(!(s->flags&CODEC_FLAG_HQ) && s->pict_type==P_TYPE){
3675
                /* get luma score */
3676
                if((s->avctx->mb_cmp&0xFF)==FF_CMP_SSE){
3677
                    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
3678
                }else{
3679
                    uint8_t *dest_y;
3680

    
3681
                    int mean= s->current_picture.mb_mean[mb_x + mb_y*s->mb_stride]; //FIXME
3682
                    mean*= 0x01010101;
3683
                    
3684
                    dest_y  = s->new_picture.data[0] + (mb_y * 16 * s->linesize    ) + mb_x * 16;
3685
                
3686
                    for(i=0; i<16; i++){
3687
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 0]) = mean;
3688
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 4]) = mean;
3689
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 8]) = mean;
3690
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+12]) = mean;
3691
                    }
3692

    
3693
                    s->mb_intra=1;
3694
                    intra_score= s->dsp.mb_cmp[0](s, s->me.scratchpad, dest_y, s->linesize);
3695
                                        
3696
/*                    printf("intra:%7d inter:%7d var:%7d mc_var.%7d\n", intra_score>>8, inter_score>>8, 
3697
                        s->current_picture.mb_var[mb_x + mb_y*s->mb_stride],
3698
                        s->current_picture.mc_mb_var[mb_x + mb_y*s->mb_stride]);*/
3699
                }
3700
                
3701
                /* get chroma score */
3702
                if(s->avctx->mb_cmp&FF_CMP_CHROMA){
3703
                    int i;
3704
                    
3705
                    s->mb_intra=1;
3706
                    for(i=1; i<3; i++){
3707
                        uint8_t *dest_c;
3708
                        int mean;
3709
                        
3710
                        if(s->out_format == FMT_H263){
3711
                            mean= (s->dc_val[i][mb_x + (mb_y+1)*(s->mb_width+2)] + 4)>>3; //FIXME not exact but simple ;)
3712
                        }else{
3713
                            mean= (s->last_dc[i] + 4)>>3;
3714
                        }
3715
                        dest_c = s->new_picture.data[i] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
3716
                        
3717
                        mean*= 0x01010101;
3718
                        for(i=0; i<8; i++){
3719
                            *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 0]) = mean;
3720
                            *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 4]) = mean;
3721
                        }
3722
                        
3723
                        intra_score+= s->dsp.mb_cmp[1](s, s->me.scratchpad, dest_c, s->uvlinesize);
3724
                    }                
3725
                }
3726

    
3727
                /* bias */
3728
                switch(s->avctx->mb_cmp&0xFF){
3729
                default:
3730
                case FF_CMP_SAD:
3731
                    intra_score+= 32*s->qscale;
3732
                    break;
3733
                case FF_CMP_SSE:
3734
                    intra_score+= 24*s->qscale*s->qscale;
3735
                    break;
3736
                case FF_CMP_SATD:
3737
                    intra_score+= 96*s->qscale;
3738
                    break;
3739
                case FF_CMP_DCT:
3740
                    intra_score+= 48*s->qscale;
3741
                    break;
3742
                case FF_CMP_BIT:
3743
                    intra_score+= 16;
3744
                    break;
3745
                case FF_CMP_PSNR:
3746
                case FF_CMP_RD:
3747
                    intra_score+= (s->qscale*s->qscale*109*8 + 64)>>7;
3748
                    break;
3749
                }
3750

    
3751
                if(intra_score < inter_score)
3752
                    mb_type= MB_TYPE_INTRA;
3753
              }  
3754
                
3755
                s->mv_type=MV_TYPE_16X16;
3756
                // only one MB-Type possible
3757
                
3758
                switch(mb_type){
3759
                case MB_TYPE_INTRA:
3760
                    s->mv_dir = 0;
3761
                    s->mb_intra= 1;
3762
                    motion_x= s->mv[0][0][0] = 0;
3763
                    motion_y= s->mv[0][0][1] = 0;
3764
                    break;
3765
                case MB_TYPE_INTER:
3766
                    s->mv_dir = MV_DIR_FORWARD;
3767
                    s->mb_intra= 0;
3768
                    motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3769
                    motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3770
                    break;
3771
                case MB_TYPE_INTER4V:
3772
                    s->mv_dir = MV_DIR_FORWARD;
3773
                    s->mv_type = MV_TYPE_8X8;
3774
                    s->mb_intra= 0;
3775
                    for(i=0; i<4; i++){
3776
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3777
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3778
                    }
3779
                    motion_x= motion_y= 0;
3780
                    break;
3781
                case MB_TYPE_DIRECT:
3782
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3783
                    s->mb_intra= 0;
3784
                    motion_x=s->b_direct_mv_table[xy][0];
3785
                    motion_y=s->b_direct_mv_table[xy][1];
3786
#ifdef CONFIG_RISKY
3787
                    ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3788
#endif
3789
                    break;
3790
                case MB_TYPE_BIDIR:
3791
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3792
                    s->mb_intra= 0;
3793
                    motion_x=0;
3794
                    motion_y=0;
3795
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3796
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3797
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3798
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3799
                    break;
3800
                case MB_TYPE_BACKWARD:
3801
                    s->mv_dir = MV_DIR_BACKWARD;
3802
                    s->mb_intra= 0;
3803
                    motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3804
                    motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3805
                    break;
3806
                case MB_TYPE_FORWARD:
3807
                    s->mv_dir = MV_DIR_FORWARD;
3808
                    s->mb_intra= 0;
3809
                    motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3810
                    motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3811
//                    printf(" %d %d ", motion_x, motion_y);
3812
                    break;
3813
                default:
3814
                    motion_x=motion_y=0; //gcc warning fix
3815
                    printf("illegal MB type\n");
3816
                }
3817

    
3818
                encode_mb(s, motion_x, motion_y);
3819

    
3820
                // RAL: Update last macrobloc type
3821
                s->last_mv_dir = s->mv_dir;
3822
            }
3823

    
3824
            /* clean the MV table in IPS frames for direct mode in B frames */
3825
            if(s->mb_intra /* && I,P,S_TYPE */){
3826
                s->p_mv_table[xy][0]=0;
3827
                s->p_mv_table[xy][1]=0;
3828
            }
3829

    
3830
            MPV_decode_mb(s, s->block);
3831
            
3832
            if(s->flags&CODEC_FLAG_PSNR){
3833
                int w= 16;
3834
                int h= 16;
3835

    
3836
                if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3837
                if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3838

    
3839
                s->current_picture_ptr->error[0] += sse(
3840
                    s,
3841
                    s->new_picture    .data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3842
                    s->current_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3843
                    w, h, s->linesize);
3844
                s->current_picture_ptr->error[1] += sse(
3845
                    s,
3846
                    s->new_picture    .data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3847
                    s->current_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3848
                    w>>1, h>>1, s->uvlinesize);
3849
                s->current_picture_ptr->error[2] += sse(
3850
                    s,
3851
                    s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3852
                    s->current_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3853
                    w>>1, h>>1, s->uvlinesize);
3854
            }
3855
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, get_bit_count(&s->pb));
3856
        }
3857
    }
3858
    emms_c();
3859

    
3860
#ifdef CONFIG_RISKY
3861
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3862
        ff_mpeg4_merge_partitions(s);
3863

    
3864
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
3865
        msmpeg4_encode_ext_header(s);
3866

    
3867
    if(s->codec_id==CODEC_ID_MPEG4) 
3868
        ff_mpeg4_stuffing(&s->pb);
3869
#endif
3870

    
3871
    //if (s->gob_number)
3872
    //    fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
3873
    
3874
    /* Send the last GOB if RTP */    
3875
    if (s->rtp_mode) {
3876
        flush_put_bits(&s->pb);
3877
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
3878
        /* Call the RTP callback to send the last GOB */
3879
        if (s->rtp_callback)
3880
            s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
3881
        s->ptr_lastgob = pbBufPtr(&s->pb);
3882
        //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
3883
    }
3884
}
3885

    
3886
static int dct_quantize_trellis_c(MpegEncContext *s, 
3887
                        DCTELEM *block, int n,
3888
                        int qscale, int *overflow){
3889
    const int *qmat;
3890
    const uint8_t *scantable= s->intra_scantable.scantable;
3891
    int max=0;
3892
    unsigned int threshold1, threshold2;
3893
    int bias=0;
3894
    int run_tab[65];
3895
    int level_tab[65];
3896
    int score_tab[65];
3897
    int last_run=0;
3898
    int last_level=0;
3899
    int last_score= 0;
3900
    int last_i= 0;
3901
    int coeff[3][64];
3902
    int coeff_count[64];
3903
    int lambda, qmul, qadd, start_i, last_non_zero, i;
3904
    const int esc_length= s->ac_esc_length;
3905
    uint8_t * length;
3906
    uint8_t * last_length;
3907
    int score_limit=0;
3908
    int left_limit= 0;
3909
        
3910
    s->dsp.fdct (block);
3911

    
3912
    qmul= qscale*16;
3913
    qadd= ((qscale-1)|1)*8;
3914

    
3915
    if (s->mb_intra) {
3916
        int q;
3917
        if (!s->h263_aic) {
3918
            if (n < 4)
3919
                q = s->y_dc_scale;
3920
            else
3921
                q = s->c_dc_scale;
3922
            q = q << 3;
3923
        } else{
3924
            /* For AIC we skip quant/dequant of INTRADC */
3925
            q = 1 << 3;
3926
            qadd=0;
3927
        }
3928
            
3929
        /* note: block[0] is assumed to be positive */
3930
        block[0] = (block[0] + (q >> 1)) / q;
3931
        start_i = 1;
3932
        last_non_zero = 0;
3933
        qmat = s->q_intra_matrix[qscale];
3934
        if(s->mpeg_quant || s->codec_id== CODEC_ID_MPEG1VIDEO)
3935
            bias= 1<<(QMAT_SHIFT-1);
3936
        length     = s->intra_ac_vlc_length;
3937
        last_length= s->intra_ac_vlc_last_length;
3938
    } else {
3939
        start_i = 0;
3940
        last_non_zero = -1;
3941
        qmat = s->q_inter_matrix[qscale];
3942
        length     = s->inter_ac_vlc_length;
3943
        last_length= s->inter_ac_vlc_last_length;
3944
    }
3945

    
3946
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
3947
    threshold2= (threshold1<<1);
3948

    
3949
    for(i=start_i; i<64; i++) {
3950
        const int j = scantable[i];
3951
        const int k= i-start_i;
3952
        int level = block[j];
3953
        level = level * qmat[j];
3954

    
3955
//        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
3956
//           || bias-level >= (1<<(QMAT_SHIFT - 3))){
3957
        if(((unsigned)(level+threshold1))>threshold2){
3958
            if(level>0){
3959
                level= (bias + level)>>QMAT_SHIFT;
3960
                coeff[0][k]= level;
3961
                coeff[1][k]= level-1;
3962
//                coeff[2][k]= level-2;
3963
            }else{
3964
                level= (bias - level)>>QMAT_SHIFT;
3965
                coeff[0][k]= -level;
3966
                coeff[1][k]= -level+1;
3967
//                coeff[2][k]= -level+2;
3968
            }
3969
            coeff_count[k]= FFMIN(level, 2);
3970
            max |=level;
3971
            last_non_zero = i;
3972
        }else{
3973
            coeff[0][k]= (level>>31)|1;
3974
            coeff_count[k]= 1;
3975
        }
3976
    }
3977
    
3978
    *overflow= s->max_qcoeff < max; //overflow might have happend
3979
    
3980
    if(last_non_zero < start_i){
3981
        memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3982
        return last_non_zero;
3983
    }
3984

    
3985
    lambda= (qscale*qscale*64*105 + 64)>>7; //FIXME finetune
3986
        
3987
    score_tab[0]= 0;
3988
    for(i=0; i<=last_non_zero - start_i; i++){
3989
        int level_index, run, j;
3990
        const int dct_coeff= block[ scantable[i + start_i] ];
3991
        const int zero_distoration= dct_coeff*dct_coeff;
3992
        int best_score=256*256*256*120;
3993

    
3994
        last_score += zero_distoration;
3995
        for(level_index=0; level_index < coeff_count[i]; level_index++){
3996
            int distoration;
3997
            int level= coeff[level_index][i];
3998
            int unquant_coeff;
3999
            
4000
            assert(level);
4001

    
4002
            if(s->out_format == FMT_H263){
4003
                if(level>0){
4004
                    unquant_coeff= level*qmul + qadd;
4005
                }else{
4006
                    unquant_coeff= level*qmul - qadd;
4007
                }
4008
            }else{ //MPEG1
4009
                j= s->dsp.idct_permutation[ scantable[i + start_i] ]; //FIXME optimize
4010
                if(s->mb_intra){
4011
                    if (level < 0) {
4012
                        unquant_coeff = (int)((-level) * qscale * s->intra_matrix[j]) >> 3;
4013
                        unquant_coeff = -((unquant_coeff - 1) | 1);
4014
                    } else {
4015
                        unquant_coeff = (int)(  level  * qscale * s->intra_matrix[j]) >> 3;
4016
                        unquant_coeff =   (unquant_coeff - 1) | 1;
4017
                    }
4018
                }else{
4019
                    if (level < 0) {
4020
                        unquant_coeff = ((((-level) << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
4021
                        unquant_coeff = -((unquant_coeff - 1) | 1);
4022
                    } else {
4023
                        unquant_coeff = (((  level  << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
4024
                        unquant_coeff =   (unquant_coeff - 1) | 1;
4025
                    }
4026
                }
4027
                unquant_coeff<<= 3;
4028
            }
4029

    
4030
            distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff);
4031
            level+=64;
4032
            if((level&(~127)) == 0){
4033
                for(run=0; run<=i - left_limit; run++){
4034
                    int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4035
                    score += score_tab[i-run];
4036
                    
4037
                    if(score < best_score){
4038
                        best_score= 
4039
                        score_tab[i+1]= score;
4040
                        run_tab[i+1]= run;
4041
                        level_tab[i+1]= level-64;
4042
                    }
4043
                }
4044

    
4045
                if(s->out_format == FMT_H263){
4046
                    for(run=0; run<=i - left_limit; run++){
4047
                        int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4048
                        score += score_tab[i-run];
4049
                        if(score < last_score){
4050
                            last_score= score;
4051
                            last_run= run;
4052
                            last_level= level-64;
4053
                            last_i= i+1;
4054
                        }
4055
                    }
4056
                }
4057
            }else{
4058
                distoration += esc_length*lambda;
4059
                for(run=0; run<=i - left_limit; run++){
4060
                    int score= distoration + score_tab[i-run];
4061
                    
4062
                    if(score < best_score){
4063
                        best_score= 
4064
                        score_tab[i+1]= score;
4065
                        run_tab[i+1]= run;
4066
                        level_tab[i+1]= level-64;
4067
                    }
4068
                }
4069

    
4070
                if(s->out_format == FMT_H263){
4071
                    for(run=0; run<=i - left_limit; run++){
4072
                        int score= distoration + score_tab[i-run];
4073
                        if(score < last_score){
4074
                            last_score= score;
4075
                            last_run= run;
4076
                            last_level= level-64;
4077
                            last_i= i+1;
4078
                        }
4079
                    }
4080
                }
4081
            }
4082
        }
4083

    
4084
        for(j=left_limit; j<=i; j++){
4085
            score_tab[j] += zero_distoration;
4086
        }
4087
        score_limit+= zero_distoration;
4088
        if(score_tab[i+1] < score_limit)
4089
            score_limit= score_tab[i+1];
4090
        
4091
        //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
4092
        while(score_tab[ left_limit ] > score_limit + lambda) left_limit++;
4093
    }
4094

    
4095
        //FIXME add some cbp penalty
4096

    
4097
    if(s->out_format != FMT_H263){
4098
        last_score= 256*256*256*120;
4099
        for(i= left_limit; i<=last_non_zero - start_i + 1; i++){
4100
            int score= score_tab[i];
4101
            if(i) score += lambda*2; //FIXME exacter?
4102

    
4103
            if(score < last_score){
4104
                last_score= score;
4105
                last_i= i;
4106
                last_level= level_tab[i];
4107
                last_run= run_tab[i];
4108
            }
4109
        }
4110
    }
4111
    
4112
    last_non_zero= last_i - 1 + start_i;
4113
    memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
4114
    
4115
    if(last_non_zero < start_i)
4116
        return last_non_zero;
4117
    
4118
    i= last_i;
4119
    assert(last_level);
4120
//FIXME use permutated scantable
4121
    block[ s->dsp.idct_permutation[ scantable[last_non_zero] ] ]= last_level;
4122
    i -= last_run + 1;
4123
    
4124
    for(;i>0 ; i -= run_tab[i] + 1){
4125
        const int j= s->dsp.idct_permutation[ scantable[i - 1 + start_i] ];
4126
    
4127
        block[j]= level_tab[i];
4128
        assert(block[j]);
4129
    }
4130

    
4131
    return last_non_zero;
4132
}
4133

    
4134
static int dct_quantize_c(MpegEncContext *s, 
4135
                        DCTELEM *block, int n,
4136
                        int qscale, int *overflow)
4137
{
4138
    int i, j, level, last_non_zero, q;
4139
    const int *qmat;
4140
    const uint8_t *scantable= s->intra_scantable.scantable;
4141
    int bias;
4142
    int max=0;
4143
    unsigned int threshold1, threshold2;
4144

    
4145
    s->dsp.fdct (block);
4146

    
4147
    if (s->mb_intra) {
4148
        if (!s->h263_aic) {
4149
            if (n < 4)
4150
                q = s->y_dc_scale;
4151
            else
4152
                q = s->c_dc_scale;
4153
            q = q << 3;
4154
        } else
4155
            /* For AIC we skip quant/dequant of INTRADC */
4156
            q = 1 << 3;
4157
            
4158
        /* note: block[0] is assumed to be positive */
4159
        block[0] = (block[0] + (q >> 1)) / q;
4160
        i = 1;
4161
        last_non_zero = 0;
4162
        qmat = s->q_intra_matrix[qscale];
4163
        bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4164
    } else {
4165
        i = 0;
4166
        last_non_zero = -1;
4167
        qmat = s->q_inter_matrix[qscale];
4168
        bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4169
    }
4170
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
4171
    threshold2= (threshold1<<1);
4172

    
4173
    for(;i<64;i++) {
4174
        j = scantable[i];
4175
        level = block[j];
4176
        level = level * qmat[j];
4177

    
4178
//        if(   bias+level >= (1<<QMAT_SHIFT)
4179
//           || bias-level >= (1<<QMAT_SHIFT)){
4180
        if(((unsigned)(level+threshold1))>threshold2){
4181
            if(level>0){
4182
                level= (bias + level)>>QMAT_SHIFT;
4183
                block[j]= level;
4184
            }else{
4185
                level= (bias - level)>>QMAT_SHIFT;
4186
                block[j]= -level;
4187
            }
4188
            max |=level;
4189
            last_non_zero = i;
4190
        }else{
4191
            block[j]=0;
4192
        }
4193
    }
4194
    *overflow= s->max_qcoeff < max; //overflow might have happend
4195
    
4196
    /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4197
    if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
4198
        ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4199

    
4200
    return last_non_zero;
4201
}
4202

    
4203
#endif //CONFIG_ENCODERS
4204

    
4205
static void dct_unquantize_mpeg1_c(MpegEncContext *s, 
4206
                                   DCTELEM *block, int n, int qscale)
4207
{
4208
    int i, level, nCoeffs;
4209
    const uint16_t *quant_matrix;
4210

    
4211
    nCoeffs= s->block_last_index[n];
4212
    
4213
    if (s->mb_intra) {
4214
        if (n < 4) 
4215
            block[0] = block[0] * s->y_dc_scale;
4216
        else
4217
            block[0] = block[0] * s->c_dc_scale;
4218
        /* XXX: only mpeg1 */
4219
        quant_matrix = s->intra_matrix;
4220
        for(i=1;i<=nCoeffs;i++) {
4221
            int j= s->intra_scantable.permutated[i];
4222
            level = block[j];
4223
            if (level) {
4224
                if (level < 0) {
4225
                    level = -level;
4226
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
4227
                    level = (level - 1) | 1;
4228
                    level = -level;
4229
                } else {
4230
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
4231
                    level = (level - 1) | 1;
4232
                }
4233
#ifdef PARANOID
4234
                if (level < -2048 || level > 2047)
4235
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4236
#endif
4237
                block[j] = level;
4238
            }
4239
        }
4240
    } else {
4241
        i = 0;
4242
        quant_matrix = s->inter_matrix;
4243
        for(;i<=nCoeffs;i++) {
4244
            int j= s->intra_scantable.permutated[i];
4245
            level = block[j];
4246
            if (level) {
4247
                if (level < 0) {
4248
                    level = -level;
4249
                    level = (((level << 1) + 1) * qscale *
4250
                             ((int) (quant_matrix[j]))) >> 4;
4251
                    level = (level - 1) | 1;
4252
                    level = -level;
4253
                } else {
4254
                    level = (((level << 1) + 1) * qscale *
4255
                             ((int) (quant_matrix[j]))) >> 4;
4256
                    level = (level - 1) | 1;
4257
                }
4258
#ifdef PARANOID
4259
                if (level < -2048 || level > 2047)
4260
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4261
#endif
4262
                block[j] = level;
4263
            }
4264
        }
4265
    }
4266
}
4267

    
4268
static void dct_unquantize_mpeg2_c(MpegEncContext *s, 
4269
                                   DCTELEM *block, int n, int qscale)
4270
{
4271
    int i, level, nCoeffs;
4272
    const uint16_t *quant_matrix;
4273

    
4274
    if(s->alternate_scan) nCoeffs= 63;
4275
    else nCoeffs= s->block_last_index[n];
4276
    
4277
    if (s->mb_intra) {
4278
        if (n < 4) 
4279
            block[0] = block[0] * s->y_dc_scale;
4280
        else
4281
            block[0] = block[0] * s->c_dc_scale;
4282
        quant_matrix = s->intra_matrix;
4283
        for(i=1;i<=nCoeffs;i++) {
4284
            int j= s->intra_scantable.permutated[i];
4285
            level = block[j];
4286
            if (level) {
4287
                if (level < 0) {
4288
                    level = -level;
4289
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
4290
                    level = -level;
4291
                } else {
4292
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
4293
                }
4294
#ifdef PARANOID
4295
                if (level < -2048 || level > 2047)
4296
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4297
#endif
4298
                block[j] = level;
4299
            }
4300
        }
4301
    } else {
4302
        int sum=-1;
4303
        i = 0;
4304
        quant_matrix = s->inter_matrix;
4305
        for(;i<=nCoeffs;i++) {
4306
            int j= s->intra_scantable.permutated[i];
4307
            level = block[j];
4308
            if (level) {
4309
                if (level < 0) {
4310
                    level = -level;
4311
                    level = (((level << 1) + 1) * qscale *
4312
                             ((int) (quant_matrix[j]))) >> 4;
4313
                    level = -level;
4314
                } else {
4315
                    level = (((level << 1) + 1) * qscale *
4316
                             ((int) (quant_matrix[j]))) >> 4;
4317
                }
4318
#ifdef PARANOID
4319
                if (level < -2048 || level > 2047)
4320
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4321
#endif
4322
                block[j] = level;
4323
                sum+=level;
4324
            }
4325
        }
4326
        block[63]^=sum&1;
4327
    }
4328
}
4329

    
4330

    
4331
static void dct_unquantize_h263_c(MpegEncContext *s, 
4332
                                  DCTELEM *block, int n, int qscale)
4333
{
4334
    int i, level, qmul, qadd;
4335
    int nCoeffs;
4336
    
4337
    assert(s->block_last_index[n]>=0);
4338
    
4339
    qadd = (qscale - 1) | 1;
4340
    qmul = qscale << 1;
4341
    
4342
    if (s->mb_intra) {
4343
        if (!s->h263_aic) {
4344
            if (n < 4) 
4345
                block[0] = block[0] * s->y_dc_scale;
4346
            else
4347
                block[0] = block[0] * s->c_dc_scale;
4348
        }else
4349
            qadd = 0;
4350
        i = 1;
4351
        nCoeffs= 63; //does not allways use zigzag table 
4352
    } else {
4353
        i = 0;
4354
        nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
4355
    }
4356

    
4357
    for(;i<=nCoeffs;i++) {
4358
        level = block[i];
4359
        if (level) {
4360
            if (level < 0) {
4361
                level = level * qmul - qadd;
4362
            } else {
4363
                level = level * qmul + qadd;
4364
            }
4365
#ifdef PARANOID
4366
                if (level < -2048 || level > 2047)
4367
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4368
#endif
4369
            block[i] = level;
4370
        }
4371
    }
4372
}
4373

    
4374

    
4375
static const AVOption mpeg4_options[] =
4376
{
4377
    AVOPTION_CODEC_INT("bitrate", "desired video bitrate", bit_rate, 4, 240000000, 800000),
4378
    AVOPTION_CODEC_FLAG("vhq", "very high quality", flags, CODEC_FLAG_HQ, 0),
4379
    AVOPTION_CODEC_INT("ratetol", "number of bits the bitstream is allowed to diverge from the reference"
4380
                       "the reference can be CBR (for CBR pass1) or VBR (for pass2)",
4381
                       bit_rate_tolerance, 4, 240000000, 8000),
4382
    AVOPTION_CODEC_INT("qmin", "minimum quantizer", qmin, 1, 31, 2),
4383
    AVOPTION_CODEC_INT("qmax", "maximum quantizer", qmax, 1, 31, 31),
4384
    AVOPTION_CODEC_STRING("rc_eq", "rate control equation",
4385
                          rc_eq, "tex^qComp,option1,options2", 0),
4386
    AVOPTION_CODEC_INT("rc_minrate", "rate control minimum bitrate",
4387
                       rc_min_rate, 4, 24000000, 0),
4388
    AVOPTION_CODEC_INT("rc_maxrate", "rate control maximum bitrate",
4389
                       rc_max_rate, 4, 24000000, 0),
4390
    AVOPTION_CODEC_DOUBLE("rc_buf_aggresivity", "rate control buffer aggresivity",
4391
                          rc_buffer_aggressivity, 4, 24000000, 0),
4392
    AVOPTION_CODEC_DOUBLE("rc_initial_cplx", "initial complexity for pass1 ratecontrol",
4393
                          rc_initial_cplx, 0., 9999999., 0),
4394
    AVOPTION_CODEC_DOUBLE("i_quant_factor", "qscale factor between p and i frames",
4395
                          i_quant_factor, 0., 0., 0),
4396
    AVOPTION_CODEC_DOUBLE("i_quant_offset", "qscale offset between p and i frames",
4397
                          i_quant_factor, -999999., 999999., 0),
4398
    AVOPTION_CODEC_INT("dct_algo", "dct alghorithm",
4399
                       dct_algo, 0, 5, 0), // fixme - "Auto,FastInt,Int,MMX,MLib,Altivec"
4400
    AVOPTION_CODEC_DOUBLE("lumi_masking", "luminance masking",
4401
                          lumi_masking, 0., 999999., 0),
4402
    AVOPTION_CODEC_DOUBLE("temporal_cplx_masking", "temporary complexity masking",
4403
                          temporal_cplx_masking, 0., 999999., 0),
4404
    AVOPTION_CODEC_DOUBLE("spatial_cplx_masking", "spatial complexity masking",
4405
                          spatial_cplx_masking, 0., 999999., 0),
4406
    AVOPTION_CODEC_DOUBLE("p_masking", "p block masking",
4407
                          p_masking, 0., 999999., 0),
4408
    AVOPTION_CODEC_DOUBLE("dark_masking", "darkness masking",
4409
                          dark_masking, 0., 999999., 0),
4410
    AVOPTION_CODEC_INT("idct_algo", "idct alghorithm",
4411
                       idct_algo, 0, 8, 0), // fixme - "Auto,Int,Simple,SimpleMMX,LibMPEG2MMX,PS2,MLib,ARM,Altivec"
4412

    
4413
    AVOPTION_CODEC_INT("mb_qmin", "minimum MB quantizer",
4414
                       mb_qmin, 0, 8, 0),
4415
    AVOPTION_CODEC_INT("mb_qmax", "maximum MB quantizer",
4416
                       mb_qmin, 0, 8, 0),
4417

    
4418
    AVOPTION_CODEC_INT("me_cmp", "ME compare function",
4419
                       me_cmp, 0, 24000000, 0),
4420
    AVOPTION_CODEC_INT("me_sub_cmp", "subpixel ME compare function",
4421
                       me_sub_cmp, 0, 24000000, 0),
4422

    
4423

    
4424
    AVOPTION_CODEC_INT("dia_size", "ME diamond size & shape",
4425
                       dia_size, 0, 24000000, 0),
4426
    AVOPTION_CODEC_INT("last_predictor_count", "amount of previous MV predictors",
4427
                       last_predictor_count, 0, 24000000, 0),
4428

    
4429
    AVOPTION_CODEC_INT("pre_me", "pre pass for ME",
4430
                       pre_me, 0, 24000000, 0),
4431
    AVOPTION_CODEC_INT("me_pre_cmp", "ME pre pass compare function",
4432
                       me_pre_cmp, 0, 24000000, 0),
4433

    
4434
    AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4435
                       me_range, 0, 24000000, 0),
4436
    AVOPTION_CODEC_INT("pre_dia_size", "ME pre pass diamod size & shape",
4437
                       pre_dia_size, 0, 24000000, 0),
4438
    AVOPTION_CODEC_INT("me_subpel_quality", "subpel ME quality",
4439
                       me_subpel_quality, 0, 24000000, 0),
4440
    AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4441
                       me_range, 0, 24000000, 0),
4442
    AVOPTION_CODEC_FLAG("psnr", "calculate PSNR of compressed frames",
4443
                        flags, CODEC_FLAG_PSNR, 0),
4444
    AVOPTION_CODEC_RCOVERRIDE("rc_override", "ratecontrol override (=startframe,endframe,qscale,quality_factor)",
4445
                              rc_override),
4446
    AVOPTION_SUB(avoptions_common),
4447
    AVOPTION_END()
4448
};
4449

    
4450
#ifdef CONFIG_ENCODERS
4451

    
4452
AVCodec mpeg1video_encoder = {
4453
    "mpeg1video",
4454
    CODEC_TYPE_VIDEO,
4455
    CODEC_ID_MPEG1VIDEO,
4456
    sizeof(MpegEncContext),
4457
    MPV_encode_init,
4458
    MPV_encode_picture,
4459
    MPV_encode_end,
4460
};
4461

    
4462
#ifdef CONFIG_RISKY
4463

    
4464
AVCodec h263_encoder = {
4465
    "h263",
4466
    CODEC_TYPE_VIDEO,
4467
    CODEC_ID_H263,
4468
    sizeof(MpegEncContext),
4469
    MPV_encode_init,
4470
    MPV_encode_picture,
4471
    MPV_encode_end,
4472
};
4473

    
4474
AVCodec h263p_encoder = {
4475
    "h263p",
4476
    CODEC_TYPE_VIDEO,
4477
    CODEC_ID_H263P,
4478
    sizeof(MpegEncContext),
4479
    MPV_encode_init,
4480
    MPV_encode_picture,
4481
    MPV_encode_end,
4482
};
4483

    
4484
AVCodec flv_encoder = {
4485
    "flv",
4486
    CODEC_TYPE_VIDEO,
4487
    CODEC_ID_FLV1,
4488
    sizeof(MpegEncContext),
4489
    MPV_encode_init,
4490
    MPV_encode_picture,
4491
    MPV_encode_end,
4492
};
4493

    
4494
AVCodec rv10_encoder = {
4495
    "rv10",
4496
    CODEC_TYPE_VIDEO,
4497
    CODEC_ID_RV10,
4498
    sizeof(MpegEncContext),
4499
    MPV_encode_init,
4500
    MPV_encode_picture,
4501
    MPV_encode_end,
4502
};
4503

    
4504
AVCodec mpeg4_encoder = {
4505
    "mpeg4",
4506
    CODEC_TYPE_VIDEO,
4507
    CODEC_ID_MPEG4,
4508
    sizeof(MpegEncContext),
4509
    MPV_encode_init,
4510
    MPV_encode_picture,
4511
    MPV_encode_end,
4512
    .options = mpeg4_options,
4513
};
4514

    
4515
AVCodec msmpeg4v1_encoder = {
4516
    "msmpeg4v1",
4517
    CODEC_TYPE_VIDEO,
4518
    CODEC_ID_MSMPEG4V1,
4519
    sizeof(MpegEncContext),
4520
    MPV_encode_init,
4521
    MPV_encode_picture,
4522
    MPV_encode_end,
4523
    .options = mpeg4_options,
4524
};
4525

    
4526
AVCodec msmpeg4v2_encoder = {
4527
    "msmpeg4v2",
4528
    CODEC_TYPE_VIDEO,
4529
    CODEC_ID_MSMPEG4V2,
4530
    sizeof(MpegEncContext),
4531
    MPV_encode_init,
4532
    MPV_encode_picture,
4533
    MPV_encode_end,
4534
    .options = mpeg4_options,
4535
};
4536

    
4537
AVCodec msmpeg4v3_encoder = {
4538
    "msmpeg4",
4539
    CODEC_TYPE_VIDEO,
4540
    CODEC_ID_MSMPEG4V3,
4541
    sizeof(MpegEncContext),
4542
    MPV_encode_init,
4543
    MPV_encode_picture,
4544
    MPV_encode_end,
4545
    .options = mpeg4_options,
4546
};
4547

    
4548
AVCodec wmv1_encoder = {
4549
    "wmv1",
4550
    CODEC_TYPE_VIDEO,
4551
    CODEC_ID_WMV1,
4552
    sizeof(MpegEncContext),
4553
    MPV_encode_init,
4554
    MPV_encode_picture,
4555
    MPV_encode_end,
4556
    .options = mpeg4_options,
4557
};
4558

    
4559
#endif
4560

    
4561
AVCodec mjpeg_encoder = {
4562
    "mjpeg",
4563
    CODEC_TYPE_VIDEO,
4564
    CODEC_ID_MJPEG,
4565
    sizeof(MpegEncContext),
4566
    MPV_encode_init,
4567
    MPV_encode_picture,
4568
    MPV_encode_end,
4569
};
4570

    
4571
#endif //CONFIG_ENCODERS
4572