Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 59c673d5

History | View | Annotate | Download (160 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
static int sse_mb(MpegEncContext *s);
54
#endif //CONFIG_ENCODERS
55

    
56
#ifdef HAVE_XVMC
57
extern int  XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
58
extern void XVMC_field_end(MpegEncContext *s);
59
extern void XVMC_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
60
#endif
61

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

    
64

    
65
/* enable all paranoid tests for rounding, overflows, etc... */
66
//#define PARANOID
67

    
68
//#define DEBUG
69

    
70

    
71
/* for jpeg fast DCT */
72
#define CONST_BITS 14
73

    
74
static const uint16_t aanscales[64] = {
75
    /* precomputed values scaled up by 14 bits */
76
    16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
77
    22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
78
    21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
79
    19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
80
    16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
81
    12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
82
    8867 , 12299, 11585, 10426,  8867,  6967,  4799,  2446,
83
    4520 ,  6270,  5906,  5315,  4520,  3552,  2446,  1247
84
};
85

    
86
static const uint8_t h263_chroma_roundtab[16] = {
87
//  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
88
    0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
89
};
90

    
91
#ifdef CONFIG_ENCODERS
92
static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
93
static uint8_t default_fcode_tab[MAX_MV*2+1];
94

    
95
enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
96

    
97
static void convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[64], uint16_t (*qmat16_bias)[64],
98
                           const uint16_t *quant_matrix, int bias, int qmin, int qmax)
99
{
100
    int qscale;
101

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

    
138
                if(qmat16[qscale][i]==0 || qmat16[qscale][i]==128*256) qmat16[qscale][i]=128*256-1;
139
                qmat16_bias[qscale][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][i]);
140
            }
141
        }
142
    }
143
}
144
#endif //CONFIG_ENCODERS
145

    
146
void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
147
    int i;
148
    int end;
149
    
150
    st->scantable= src_scantable;
151

    
152
    for(i=0; i<64; i++){
153
        int j;
154
        j = src_scantable[i];
155
        st->permutated[i] = permutation[j];
156
#ifdef ARCH_POWERPC
157
        st->inverse[j] = i;
158
#endif
159
    }
160
    
161
    end=-1;
162
    for(i=0; i<64; i++){
163
        int j;
164
        j = st->permutated[i];
165
        if(j>end) end=j;
166
        st->raster_end[i]= end;
167
    }
168
}
169

    
170
/* init common dct for both encoder and decoder */
171
int DCT_common_init(MpegEncContext *s)
172
{
173
    s->dct_unquantize_h263 = dct_unquantize_h263_c;
174
    s->dct_unquantize_mpeg1 = dct_unquantize_mpeg1_c;
175
    s->dct_unquantize_mpeg2 = dct_unquantize_mpeg2_c;
176

    
177
#ifdef CONFIG_ENCODERS
178
    s->dct_quantize= dct_quantize_c;
179
#endif
180
        
181
#ifdef HAVE_MMX
182
    MPV_common_init_mmx(s);
183
#endif
184
#ifdef ARCH_ALPHA
185
    MPV_common_init_axp(s);
186
#endif
187
#ifdef HAVE_MLIB
188
    MPV_common_init_mlib(s);
189
#endif
190
#ifdef HAVE_MMI
191
    MPV_common_init_mmi(s);
192
#endif
193
#ifdef ARCH_ARMV4L
194
    MPV_common_init_armv4l(s);
195
#endif
196
#ifdef ARCH_POWERPC
197
    MPV_common_init_ppc(s);
198
#endif
199

    
200
#ifdef CONFIG_ENCODERS
201
    s->fast_dct_quantize= s->dct_quantize;
202

    
203
    if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
204
        s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
205
    }
206

    
207
#endif //CONFIG_ENCODERS
208

    
209
    /* load & permutate scantables
210
       note: only wmv uses differnt ones 
211
    */
212
    ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
213
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
214
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
215
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
216

    
217
    s->picture_structure= PICT_FRAME;
218
    
219
    return 0;
220
}
221

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

    
247
        if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
248
            fprintf(stderr, "get_buffer() failed (stride changed)\n");
249
            return -1;
250
        }
251

    
252
        if(pic->linesize[1] != pic->linesize[2]){
253
            fprintf(stderr, "get_buffer() failed (uv stride missmatch)\n");
254
            return -1;
255
        }
256

    
257
        s->linesize  = pic->linesize[0];
258
        s->uvlinesize= pic->linesize[1];
259
    }
260
    
261
    if(pic->qscale_table==NULL){
262
        if (s->encoding) {        
263
            CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
264
            CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
265
            CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
266
            CHECKED_ALLOCZ(pic->mb_cmp_score, mb_array_size * sizeof(int32_t))
267
        }
268

    
269
        CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
270
        CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
271
        CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num    * sizeof(int))
272
        pic->mb_type= pic->mb_type_base + s->mb_stride+1;
273
        if(s->out_format == FMT_H264){
274
            for(i=0; i<2; i++){
275
                CHECKED_ALLOCZ(pic->motion_val[i], 2 * 16 * s->mb_num * sizeof(uint16_t))
276
                CHECKED_ALLOCZ(pic->ref_index[i] , 4 * s->mb_num * sizeof(uint8_t))
277
            }
278
        }
279
        pic->qstride= s->mb_stride;
280
    }
281

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

    
293
/**
294
 * deallocates a picture
295
 */
296
static void free_picture(MpegEncContext *s, Picture *pic){
297
    int i;
298

    
299
    if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
300
        s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
301
    }
302

    
303
    av_freep(&pic->mb_var);
304
    av_freep(&pic->mc_mb_var);
305
    av_freep(&pic->mb_mean);
306
    av_freep(&pic->mb_cmp_score);
307
    av_freep(&pic->mbskip_table);
308
    av_freep(&pic->qscale_table);
309
    av_freep(&pic->mb_type_base);
310
    pic->mb_type= NULL;
311
    for(i=0; i<2; i++){
312
        av_freep(&pic->motion_val[i]);
313
        av_freep(&pic->ref_index[i]);
314
    }
315
    
316
    if(pic->type == FF_BUFFER_TYPE_SHARED){
317
        for(i=0; i<4; i++){
318
            pic->base[i]=
319
            pic->data[i]= NULL;
320
        }
321
        pic->type= 0;        
322
    }
323
}
324

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
478

    
479
//extern int sads;
480

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

    
486
    av_freep(&s->parse_context.buffer);
487
    s->parse_context.buffer_size=0;
488

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

    
527
    for(i=0; i<MAX_PICTURE_COUNT; i++){
528
        free_picture(s, &s->picture[i]);
529
    }
530
    avcodec_default_free_buffers(s->avctx);
531
    s->context_initialized = 0;
532
}
533

    
534
#ifdef CONFIG_ENCODERS
535

    
536
/* init video encoder */
537
int MPV_encode_init(AVCodecContext *avctx)
538
{
539
    MpegEncContext *s = avctx->priv_data;
540
    int i;
541
    int chroma_h_shift, chroma_v_shift;
542

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

    
571
    if (s->gop_size <= 1) {
572
        s->intra_only = 1;
573
        s->gop_size = 12;
574
    } else {
575
        s->intra_only = 0;
576
    }
577

    
578
    s->me_method = avctx->me_method;
579

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

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

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

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

    
760
            default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
761
            memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
762
            memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
763

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

    
778
    s->encoding = 1;
779

    
780
    /* init */
781
    if (MPV_common_init(s) < 0)
782
        return -1;
783
    
784
    ff_init_me(s);
785

    
786
#ifdef CONFIG_ENCODERS
787
#ifdef CONFIG_RISKY
788
    if (s->out_format == FMT_H263)
789
        h263_encode_init(s);
790
    if(s->msmpeg4_version)
791
        ff_msmpeg4_encode_init(s);
792
#endif
793
    if (s->out_format == FMT_MPEG1)
794
        ff_mpeg1_encode_init(s);
795
#endif
796

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

    
815
    /* precompute matrix */
816
    /* for mjpeg, we do include qscale in the matrix */
817
    if (s->out_format != FMT_MJPEG) {
818
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, s->q_intra_matrix16_bias, 
819
                       s->intra_matrix, s->intra_quant_bias, 1, 31);
820
        convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16, s->q_inter_matrix16_bias, 
821
                       s->inter_matrix, s->inter_quant_bias, 1, 31);
822
    }
823

    
824
    if(ff_rate_control_init(s) < 0)
825
        return -1;
826

    
827
    s->picture_number = 0;
828
    s->picture_in_gop_number = 0;
829
    s->fake_picture_number = 0;
830
    /* motion detector init */
831
    s->f_code = 1;
832
    s->b_code = 1;
833

    
834
    return 0;
835
}
836

    
837
int MPV_encode_end(AVCodecContext *avctx)
838
{
839
    MpegEncContext *s = avctx->priv_data;
840

    
841
#ifdef STATS
842
    print_stats();
843
#endif
844

    
845
    ff_rate_control_uninit(s);
846

    
847
    MPV_common_end(s);
848
    if (s->out_format == FMT_MJPEG)
849
        mjpeg_close(s);
850
      
851
    return 0;
852
}
853

    
854
#endif //CONFIG_ENCODERS
855

    
856
void init_rl(RLTable *rl)
857
{
858
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
859
    uint8_t index_run[MAX_RUN+1];
860
    int last, run, level, start, end, i;
861

    
862
    /* compute max_level[], max_run[] and index_run[] */
863
    for(last=0;last<2;last++) {
864
        if (last == 0) {
865
            start = 0;
866
            end = rl->last;
867
        } else {
868
            start = rl->last;
869
            end = rl->n;
870
        }
871

    
872
        memset(max_level, 0, MAX_RUN + 1);
873
        memset(max_run, 0, MAX_LEVEL + 1);
874
        memset(index_run, rl->n, MAX_RUN + 1);
875
        for(i=start;i<end;i++) {
876
            run = rl->table_run[i];
877
            level = rl->table_level[i];
878
            if (index_run[run] == rl->n)
879
                index_run[run] = i;
880
            if (level > max_level[run])
881
                max_level[run] = level;
882
            if (run > max_run[level])
883
                max_run[level] = run;
884
        }
885
        rl->max_level[last] = av_malloc(MAX_RUN + 1);
886
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
887
        rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
888
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
889
        rl->index_run[last] = av_malloc(MAX_RUN + 1);
890
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
891
    }
892
}
893

    
894
/* draw the edges of width 'w' of an image of size width, height */
895
//FIXME check that this is ok for mpeg4 interlaced
896
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
897
{
898
    uint8_t *ptr, *last_line;
899
    int i;
900

    
901
    last_line = buf + (height - 1) * wrap;
902
    for(i=0;i<w;i++) {
903
        /* top and bottom */
904
        memcpy(buf - (i + 1) * wrap, buf, width);
905
        memcpy(last_line + (i + 1) * wrap, last_line, width);
906
    }
907
    /* left and right */
908
    ptr = buf;
909
    for(i=0;i<height;i++) {
910
        memset(ptr - w, ptr[0], w);
911
        memset(ptr + width, ptr[width-1], w);
912
        ptr += wrap;
913
    }
914
    /* corners */
915
    for(i=0;i<w;i++) {
916
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
917
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
918
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
919
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
920
    }
921
}
922

    
923
static int find_unused_picture(MpegEncContext *s, int shared){
924
    int i;
925
    
926
    if(shared){
927
        for(i=0; i<MAX_PICTURE_COUNT; i++){
928
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) break;
929
        }
930
    }else{
931
        for(i=0; i<MAX_PICTURE_COUNT; i++){
932
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) break; //FIXME
933
        }
934
        for(i=0; i<MAX_PICTURE_COUNT; i++){
935
            if(s->picture[i].data[0]==NULL) break;
936
        }
937
    }
938

    
939
    assert(i<MAX_PICTURE_COUNT);
940
    return i;
941
}
942

    
943
/* generic function for encode/decode called before a frame is coded/decoded */
944
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
945
{
946
    int i;
947
    AVFrame *pic;
948

    
949
    s->mb_skiped = 0;
950

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

    
953
    /* mark&release old frames */
954
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr->data[0]) {
955
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
956

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

    
977
        i= find_unused_picture(s, 0);
978
    
979
        pic= (AVFrame*)&s->picture[i];
980
        pic->reference= s->pict_type != B_TYPE ? 3 : 0;
981

    
982
        if(s->current_picture_ptr)
983
            pic->coded_picture_number= s->current_picture_ptr->coded_picture_number+1;
984
        
985
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
986
            return -1;
987

    
988
        s->current_picture_ptr= &s->picture[i];
989
    }
990

    
991
    s->current_picture_ptr->pict_type= s->pict_type;
992
    s->current_picture_ptr->quality= s->qscale;
993
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
994

    
995
    s->current_picture= *s->current_picture_ptr;
996
  
997
  if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
998
    if (s->pict_type != B_TYPE) {
999
        s->last_picture_ptr= s->next_picture_ptr;
1000
        s->next_picture_ptr= s->current_picture_ptr;
1001
    }
1002
    
1003
    if(s->last_picture_ptr) s->last_picture= *s->last_picture_ptr;
1004
    if(s->next_picture_ptr) s->next_picture= *s->next_picture_ptr;
1005
    if(s->new_picture_ptr ) s->new_picture = *s->new_picture_ptr;
1006
    
1007
    if(s->pict_type != I_TYPE && s->last_picture_ptr==NULL){
1008
        fprintf(stderr, "warning: first frame is no keyframe\n");
1009
        assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1010
        goto alloc;
1011
    }
1012

    
1013
    assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1014

    
1015
    if(s->picture_structure!=PICT_FRAME){
1016
        int i;
1017
        for(i=0; i<4; i++){
1018
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1019
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1020
            } 
1021
            s->current_picture.linesize[i] *= 2;
1022
            s->last_picture.linesize[i] *=2;
1023
            s->next_picture.linesize[i] *=2;
1024
        }
1025
    }
1026
  }
1027
   
1028
    s->hurry_up= s->avctx->hurry_up;
1029
    s->error_resilience= avctx->error_resilience;
1030

    
1031
    /* set dequantizer, we cant do it during init as it might change for mpeg4
1032
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1033
    if(s->out_format == FMT_H263){
1034
        if(s->mpeg_quant)
1035
            s->dct_unquantize = s->dct_unquantize_mpeg2;
1036
        else
1037
            s->dct_unquantize = s->dct_unquantize_h263;
1038
    }else 
1039
        s->dct_unquantize = s->dct_unquantize_mpeg1;
1040

    
1041
#ifdef HAVE_XVMC
1042
    if(s->avctx->xvmc_acceleration)
1043
        return XVMC_field_start(s, avctx);
1044
#endif
1045
    return 0;
1046
}
1047

    
1048
/* generic function for encode/decode called after a frame has been coded/decoded */
1049
void MPV_frame_end(MpegEncContext *s)
1050
{
1051
    int i;
1052
    /* draw edge for correct motion prediction if outside */
1053
#ifdef HAVE_XVMC
1054
//just to make sure that all data is rendered.
1055
    if(s->avctx->xvmc_acceleration){
1056
        XVMC_field_end(s);
1057
    }else
1058
#endif
1059
    if(s->codec_id!=CODEC_ID_SVQ1 && s->codec_id != CODEC_ID_MPEG1VIDEO){
1060
        if (s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1061
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1062
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1063
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1064
        }
1065
    }
1066
    emms_c();
1067
    
1068
    s->last_pict_type    = s->pict_type;
1069
    if(s->pict_type!=B_TYPE){
1070
        s->last_non_b_pict_type= s->pict_type;
1071
    }
1072
#if 0
1073
        /* copy back current_picture variables */
1074
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1075
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1076
            s->picture[i]= s->current_picture;
1077
            break;
1078
        }    
1079
    }
1080
    assert(i<MAX_PICTURE_COUNT);
1081
#endif    
1082

    
1083
    if(s->encoding){
1084
        /* release non refernce frames */
1085
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1086
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1087
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1088
            }
1089
        }
1090
    }
1091
    // clear copies, to avoid confusion
1092
#if 0
1093
    memset(&s->last_picture, 0, sizeof(Picture));
1094
    memset(&s->next_picture, 0, sizeof(Picture));
1095
    memset(&s->current_picture, 0, sizeof(Picture));
1096
#endif
1097
}
1098

    
1099
/**
1100
 * draws an line from (ex, ey) -> (sx, sy).
1101
 * @param w width of the image
1102
 * @param h height of the image
1103
 * @param stride stride/linesize of the image
1104
 * @param color color of the arrow
1105
 */
1106
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1107
    int t, x, y, f;
1108
    
1109
    sx= clip(sx, 0, w-1);
1110
    sy= clip(sy, 0, h-1);
1111
    ex= clip(ex, 0, w-1);
1112
    ey= clip(ey, 0, h-1);
1113
    
1114
    buf[sy*stride + sx]+= color;
1115
    
1116
    if(ABS(ex - sx) > ABS(ey - sy)){
1117
        if(sx > ex){
1118
            t=sx; sx=ex; ex=t;
1119
            t=sy; sy=ey; ey=t;
1120
        }
1121
        buf+= sx + sy*stride;
1122
        ex-= sx;
1123
        f= ((ey-sy)<<16)/ex;
1124
        for(x= 0; x <= ex; x++){
1125
            y= ((x*f) + (1<<15))>>16;
1126
            buf[y*stride + x]+= color;
1127
        }
1128
    }else{
1129
        if(sy > ey){
1130
            t=sx; sx=ex; ex=t;
1131
            t=sy; sy=ey; ey=t;
1132
        }
1133
        buf+= sx + sy*stride;
1134
        ey-= sy;
1135
        if(ey) f= ((ex-sx)<<16)/ey;
1136
        else   f= 0;
1137
        for(y= 0; y <= ey; y++){
1138
            x= ((y*f) + (1<<15))>>16;
1139
            buf[y*stride + x]+= color;
1140
        }
1141
    }
1142
}
1143

    
1144
/**
1145
 * draws an arrow from (ex, ey) -> (sx, sy).
1146
 * @param w width of the image
1147
 * @param h height of the image
1148
 * @param stride stride/linesize of the image
1149
 * @param color color of the arrow
1150
 */
1151
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1152
    int dx,dy;
1153

    
1154
    sx= clip(sx, -100, w+100);
1155
    sy= clip(sy, -100, h+100);
1156
    ex= clip(ex, -100, w+100);
1157
    ey= clip(ey, -100, h+100);
1158
    
1159
    dx= ex - sx;
1160
    dy= ey - sy;
1161
    
1162
    if(dx*dx + dy*dy > 3*3){
1163
        int rx=  dx + dy;
1164
        int ry= -dx + dy;
1165
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1166
        
1167
        //FIXME subpixel accuracy
1168
        rx= ROUNDED_DIV(rx*3<<4, length);
1169
        ry= ROUNDED_DIV(ry*3<<4, length);
1170
        
1171
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1172
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1173
    }
1174
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1175
}
1176

    
1177
/**
1178
 * prints debuging info for the given picture.
1179
 */
1180
void ff_print_debug_info(MpegEncContext *s, Picture *pict){
1181

    
1182
    if(!pict || !pict->mb_type) return;
1183

    
1184
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1185
        int x,y;
1186

    
1187
        for(y=0; y<s->mb_height; y++){
1188
            for(x=0; x<s->mb_width; x++){
1189
                if(s->avctx->debug&FF_DEBUG_SKIP){
1190
                    int count= s->mbskip_table[x + y*s->mb_stride];
1191
                    if(count>9) count=9;
1192
                    printf("%1d", count);
1193
                }
1194
                if(s->avctx->debug&FF_DEBUG_QP){
1195
                    printf("%2d", pict->qscale_table[x + y*s->mb_stride]);
1196
                }
1197
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1198
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
1199
                    
1200
                    //Type & MV direction
1201
                    if(IS_PCM(mb_type))
1202
                        printf("P");
1203
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1204
                        printf("A");
1205
                    else if(IS_INTRA4x4(mb_type))
1206
                        printf("i");
1207
                    else if(IS_INTRA16x16(mb_type))
1208
                        printf("I");
1209
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1210
                        printf("d");
1211
                    else if(IS_DIRECT(mb_type))
1212
                        printf("D");
1213
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1214
                        printf("g");
1215
                    else if(IS_GMC(mb_type))
1216
                        printf("G");
1217
                    else if(IS_SKIP(mb_type))
1218
                        printf("S");
1219
                    else if(!USES_LIST(mb_type, 1))
1220
                        printf(">");
1221
                    else if(!USES_LIST(mb_type, 0))
1222
                        printf("<");
1223
                    else{
1224
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1225
                        printf("X");
1226
                    }
1227
                    
1228
                    //segmentation
1229
                    if(IS_8X8(mb_type))
1230
                        printf("+");
1231
                    else if(IS_16X8(mb_type))
1232
                        printf("-");
1233
                    else if(IS_8X16(mb_type))
1234
                        printf("?");
1235
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1236
                        printf(" ");
1237
                    else
1238
                        printf("?");
1239
                    
1240
                        
1241
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1242
                        printf("=");
1243
                    else
1244
                        printf(" ");
1245
                }
1246
//                printf(" ");
1247
            }
1248
            printf("\n");
1249
        }
1250
    }
1251
    
1252
    if((s->avctx->debug&FF_DEBUG_VIS_MV) && s->motion_val){
1253
        const int shift= 1 + s->quarter_sample;
1254
        int mb_y;
1255
        uint8_t *ptr= pict->data[0];
1256
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1257

    
1258
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1259
            int mb_x;
1260
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1261
                const int mb_index= mb_x + mb_y*s->mb_stride;
1262
                if(IS_8X8(s->current_picture.mb_type[mb_index])){
1263
                    int i;
1264
                    for(i=0; i<4; i++){
1265
                        int sx= mb_x*16 + 4 + 8*(i&1);
1266
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1267
                        int xy= 1 + mb_x*2 + (i&1) + (mb_y*2 + 1 + (i>>1))*(s->mb_width*2 + 2);
1268
                        int mx= (s->motion_val[xy][0]>>shift) + sx;
1269
                        int my= (s->motion_val[xy][1]>>shift) + sy;
1270
                        draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1271
                    }
1272
                }else{
1273
                    int sx= mb_x*16 + 8;
1274
                    int sy= mb_y*16 + 8;
1275
                    int xy= 1 + mb_x*2 + (mb_y*2 + 1)*(s->mb_width*2 + 2);
1276
                    int mx= (s->motion_val[xy][0]>>shift) + sx;
1277
                    int my= (s->motion_val[xy][1]>>shift) + sy;
1278
                    draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1279
                }
1280
                s->mbskip_table[mb_index]=0;
1281
            }
1282
        }
1283
    }
1284
}
1285

    
1286
#ifdef CONFIG_ENCODERS
1287

    
1288
static int get_sae(uint8_t *src, int ref, int stride){
1289
    int x,y;
1290
    int acc=0;
1291
    
1292
    for(y=0; y<16; y++){
1293
        for(x=0; x<16; x++){
1294
            acc+= ABS(src[x+y*stride] - ref);
1295
        }
1296
    }
1297
    
1298
    return acc;
1299
}
1300

    
1301
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1302
    int x, y, w, h;
1303
    int acc=0;
1304
    
1305
    w= s->width &~15;
1306
    h= s->height&~15;
1307
    
1308
    for(y=0; y<h; y+=16){
1309
        for(x=0; x<w; x+=16){
1310
            int offset= x + y*stride;
1311
            int sad = s->dsp.pix_abs16x16(src + offset, ref + offset, stride);
1312
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1313
            int sae = get_sae(src + offset, mean, stride);
1314
            
1315
            acc+= sae + 500 < sad;
1316
        }
1317
    }
1318
    return acc;
1319
}
1320

    
1321

    
1322
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1323
    AVFrame *pic=NULL;
1324
    int i;
1325
    const int encoding_delay= s->max_b_frames;
1326
    int direct=1;
1327
    
1328
  if(pic_arg){
1329
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1330
    if(pic_arg->linesize[0] != s->linesize) direct=0;
1331
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1332
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1333
  
1334
//    printf("%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1335
    
1336
    if(direct){
1337
        i= find_unused_picture(s, 1);
1338

    
1339
        pic= (AVFrame*)&s->picture[i];
1340
        pic->reference= 3;
1341
    
1342
        for(i=0; i<4; i++){
1343
            pic->data[i]= pic_arg->data[i];
1344
            pic->linesize[i]= pic_arg->linesize[i];
1345
        }
1346
        alloc_picture(s, (Picture*)pic, 1);
1347
    }else{
1348
        i= find_unused_picture(s, 0);
1349

    
1350
        pic= (AVFrame*)&s->picture[i];
1351
        pic->reference= 3;
1352

    
1353
        alloc_picture(s, (Picture*)pic, 0);
1354
        for(i=0; i<4; i++){
1355
            /* the input will be 16 pixels to the right relative to the actual buffer start
1356
             * and the current_pic, so the buffer can be reused, yes its not beatifull 
1357
             */
1358
            pic->data[i]+= 16; 
1359
        }
1360

    
1361
        if(   pic->data[0] == pic_arg->data[0] 
1362
           && pic->data[1] == pic_arg->data[1]
1363
           && pic->data[2] == pic_arg->data[2]){
1364
       // empty
1365
        }else{
1366
            int h_chroma_shift, v_chroma_shift;
1367
        
1368
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1369
        
1370
            for(i=0; i<3; i++){
1371
                int src_stride= pic_arg->linesize[i];
1372
                int dst_stride= i ? s->uvlinesize : s->linesize;
1373
                int h_shift= i ? h_chroma_shift : 0;
1374
                int v_shift= i ? v_chroma_shift : 0;
1375
                int w= s->width >>h_shift;
1376
                int h= s->height>>v_shift;
1377
                uint8_t *src= pic_arg->data[i];
1378
                uint8_t *dst= pic->data[i];
1379
            
1380
                if(src_stride==dst_stride)
1381
                    memcpy(dst, src, src_stride*h);
1382
                else{
1383
                    while(h--){
1384
                        memcpy(dst, src, w);
1385
                        dst += dst_stride;
1386
                        src += src_stride;
1387
                    }
1388
                }
1389
            }
1390
        }
1391
    }
1392
    pic->quality= pic_arg->quality;
1393
    pic->pict_type= pic_arg->pict_type;
1394
    pic->pts = pic_arg->pts;
1395
    
1396
    if(s->input_picture[encoding_delay])
1397
        pic->display_picture_number= s->input_picture[encoding_delay]->display_picture_number + 1;
1398
    
1399
  }
1400

    
1401
    /* shift buffer entries */
1402
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1403
        s->input_picture[i-1]= s->input_picture[i];
1404
        
1405
    s->input_picture[encoding_delay]= (Picture*)pic;
1406

    
1407
    return 0;
1408
}
1409

    
1410
static void select_input_picture(MpegEncContext *s){
1411
    int i;
1412
    const int encoding_delay= s->max_b_frames;
1413
    int coded_pic_num=0;    
1414

    
1415
    if(s->reordered_input_picture[0])
1416
        coded_pic_num= s->reordered_input_picture[0]->coded_picture_number + 1;
1417

    
1418
    for(i=1; i<MAX_PICTURE_COUNT; i++)
1419
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1420
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1421

    
1422
    /* set next picture types & ordering */
1423
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1424
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
1425
            s->reordered_input_picture[0]= s->input_picture[0];
1426
            s->reordered_input_picture[0]->pict_type= I_TYPE;
1427
            s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1428
        }else{
1429
            int b_frames;
1430
            
1431
            if(s->flags&CODEC_FLAG_PASS2){
1432
                for(i=0; i<s->max_b_frames+1; i++){
1433
                    int pict_num= s->input_picture[0]->display_picture_number + i;
1434
                    int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1435
                    s->input_picture[i]->pict_type= pict_type;
1436
                    
1437
                    if(i + 1 >= s->rc_context.num_entries) break;
1438
                }
1439
            }
1440

    
1441
            if(s->input_picture[0]->pict_type){
1442
                /* user selected pict_type */
1443
                for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
1444
                    if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
1445
                }
1446
            
1447
                if(b_frames > s->max_b_frames){
1448
                    fprintf(stderr, "warning, too many bframes in a row\n");
1449
                    b_frames = s->max_b_frames;
1450
                }
1451
            }else if(s->b_frame_strategy==0){
1452
                b_frames= s->max_b_frames;
1453
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
1454
            }else if(s->b_frame_strategy==1){
1455
                for(i=1; i<s->max_b_frames+1; i++){
1456
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
1457
                        s->input_picture[i]->b_frame_score= 
1458
                            get_intra_count(s, s->input_picture[i  ]->data[0], 
1459
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
1460
                    }
1461
                }
1462
                for(i=0; i<s->max_b_frames; i++){
1463
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
1464
                }
1465
                                
1466
                b_frames= FFMAX(0, i-1);
1467
                
1468
                /* reset scores */
1469
                for(i=0; i<b_frames+1; i++){
1470
                    s->input_picture[i]->b_frame_score=0;
1471
                }
1472
            }else{
1473
                fprintf(stderr, "illegal b frame strategy\n");
1474
                b_frames=0;
1475
            }
1476

    
1477
            emms_c();
1478
//static int b_count=0;
1479
//b_count+= b_frames;
1480
//printf("b_frames: %d\n", b_count);
1481
                        
1482
            s->reordered_input_picture[0]= s->input_picture[b_frames];
1483
            if(   s->picture_in_gop_number + b_frames >= s->gop_size 
1484
               || s->reordered_input_picture[0]->pict_type== I_TYPE)
1485
                s->reordered_input_picture[0]->pict_type= I_TYPE;
1486
            else
1487
                s->reordered_input_picture[0]->pict_type= P_TYPE;
1488
            s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1489
            for(i=0; i<b_frames; i++){
1490
                coded_pic_num++;
1491
                s->reordered_input_picture[i+1]= s->input_picture[i];
1492
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
1493
                s->reordered_input_picture[i+1]->coded_picture_number= coded_pic_num;
1494
            }
1495
        }
1496
    }
1497
    
1498
    if(s->reordered_input_picture[0]){
1499
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
1500

    
1501
        s->new_picture= *s->reordered_input_picture[0];
1502

    
1503
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
1504
            // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
1505
        
1506
            int i= find_unused_picture(s, 0);
1507
            Picture *pic= &s->picture[i];
1508

    
1509
            /* mark us unused / free shared pic */
1510
            for(i=0; i<4; i++)
1511
                s->reordered_input_picture[0]->data[i]= NULL;
1512
            s->reordered_input_picture[0]->type= 0;
1513
            
1514
            //FIXME bad, copy * except
1515
            pic->pict_type = s->reordered_input_picture[0]->pict_type;
1516
            pic->quality   = s->reordered_input_picture[0]->quality;
1517
            pic->coded_picture_number = s->reordered_input_picture[0]->coded_picture_number;
1518
            pic->reference = s->reordered_input_picture[0]->reference;
1519
            
1520
            alloc_picture(s, pic, 0);
1521

    
1522
            s->current_picture_ptr= pic;
1523
        }else{
1524
            // input is not a shared pix -> reuse buffer for current_pix
1525

    
1526
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
1527
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
1528
            
1529
            s->current_picture_ptr= s->reordered_input_picture[0];
1530
            for(i=0; i<4; i++){
1531
                //reverse the +16 we did before storing the input
1532
                s->current_picture_ptr->data[i]-=16;
1533
            }
1534
        }
1535
        s->current_picture= *s->current_picture_ptr;
1536
    
1537
        s->picture_number= s->new_picture.display_picture_number;
1538
//printf("dpn:%d\n", s->picture_number);
1539
    }else{
1540
       memset(&s->new_picture, 0, sizeof(Picture));
1541
    }
1542
}
1543

    
1544
int MPV_encode_picture(AVCodecContext *avctx,
1545
                       unsigned char *buf, int buf_size, void *data)
1546
{
1547
    MpegEncContext *s = avctx->priv_data;
1548
    AVFrame *pic_arg = data;
1549
    int i;
1550

    
1551
    init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
1552

    
1553
    s->picture_in_gop_number++;
1554

    
1555
    load_input_picture(s, pic_arg);
1556
    
1557
    select_input_picture(s);
1558
    
1559
    /* output? */
1560
    if(s->new_picture.data[0]){
1561

    
1562
        s->pict_type= s->new_picture.pict_type;
1563
        if (s->fixed_qscale){ /* the ratecontrol needs the last qscale so we dont touch it for CBR */
1564
            s->qscale= (int)(s->new_picture.quality+0.5);
1565
            assert(s->qscale);
1566
        }
1567
//emms_c();
1568
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
1569
        MPV_frame_start(s, avctx);
1570

    
1571
        encode_picture(s, s->picture_number);
1572
        
1573
        avctx->real_pict_num  = s->picture_number;
1574
        avctx->header_bits = s->header_bits;
1575
        avctx->mv_bits     = s->mv_bits;
1576
        avctx->misc_bits   = s->misc_bits;
1577
        avctx->i_tex_bits  = s->i_tex_bits;
1578
        avctx->p_tex_bits  = s->p_tex_bits;
1579
        avctx->i_count     = s->i_count;
1580
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
1581
        avctx->skip_count  = s->skip_count;
1582

    
1583
        MPV_frame_end(s);
1584

    
1585
        if (s->out_format == FMT_MJPEG)
1586
            mjpeg_picture_trailer(s);
1587
        
1588
        if(s->flags&CODEC_FLAG_PASS1)
1589
            ff_write_pass1_stats(s);
1590

    
1591
        for(i=0; i<4; i++){
1592
            avctx->error[i] += s->current_picture_ptr->error[i];
1593
        }
1594
    }
1595

    
1596
    s->input_picture_number++;
1597

    
1598
    flush_put_bits(&s->pb);
1599
    s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1600
    
1601
    s->total_bits += s->frame_bits;
1602
    avctx->frame_bits  = s->frame_bits;
1603
    
1604
    return pbBufPtr(&s->pb) - s->pb.buf;
1605
}
1606

    
1607
#endif //CONFIG_ENCODERS
1608

    
1609
static inline void gmc1_motion(MpegEncContext *s,
1610
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1611
                               int dest_offset,
1612
                               uint8_t **ref_picture, int src_offset)
1613
{
1614
    uint8_t *ptr;
1615
    int offset, src_x, src_y, linesize, uvlinesize;
1616
    int motion_x, motion_y;
1617
    int emu=0;
1618

    
1619
    motion_x= s->sprite_offset[0][0];
1620
    motion_y= s->sprite_offset[0][1];
1621
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1622
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1623
    motion_x<<=(3-s->sprite_warping_accuracy);
1624
    motion_y<<=(3-s->sprite_warping_accuracy);
1625
    src_x = clip(src_x, -16, s->width);
1626
    if (src_x == s->width)
1627
        motion_x =0;
1628
    src_y = clip(src_y, -16, s->height);
1629
    if (src_y == s->height)
1630
        motion_y =0;
1631

    
1632
    linesize = s->linesize;
1633
    uvlinesize = s->uvlinesize;
1634
    
1635
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1636

    
1637
    dest_y+=dest_offset;
1638
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1639
        if(src_x<0 || src_y<0 || src_x + 17 >= s->h_edge_pos
1640
                              || src_y + 17 >= s->v_edge_pos){
1641
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1642
            ptr= s->edge_emu_buffer;
1643
        }
1644
    }
1645
    
1646
    if((motion_x|motion_y)&7){
1647
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1648
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1649
    }else{
1650
        int dxy;
1651
        
1652
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
1653
        if (s->no_rounding){
1654
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
1655
        }else{
1656
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
1657
        }
1658
    }
1659
    
1660
    if(s->flags&CODEC_FLAG_GRAY) return;
1661

    
1662
    motion_x= s->sprite_offset[1][0];
1663
    motion_y= s->sprite_offset[1][1];
1664
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
1665
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
1666
    motion_x<<=(3-s->sprite_warping_accuracy);
1667
    motion_y<<=(3-s->sprite_warping_accuracy);
1668
    src_x = clip(src_x, -8, s->width>>1);
1669
    if (src_x == s->width>>1)
1670
        motion_x =0;
1671
    src_y = clip(src_y, -8, s->height>>1);
1672
    if (src_y == s->height>>1)
1673
        motion_y =0;
1674

    
1675
    offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
1676
    ptr = ref_picture[1] + offset;
1677
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1678
        if(src_x<0 || src_y<0 || src_x + 9 >= s->h_edge_pos>>1
1679
                              || src_y + 9 >= s->v_edge_pos>>1){
1680
            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);
1681
            ptr= s->edge_emu_buffer;
1682
            emu=1;
1683
        }
1684
    }
1685
    s->dsp.gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1686
    
1687
    ptr = ref_picture[2] + offset;
1688
    if(emu){
1689
        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);
1690
        ptr= s->edge_emu_buffer;
1691
    }
1692
    s->dsp.gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1693
    
1694
    return;
1695
}
1696

    
1697
static inline void gmc_motion(MpegEncContext *s,
1698
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1699
                               int dest_offset,
1700
                               uint8_t **ref_picture, int src_offset)
1701
{
1702
    uint8_t *ptr;
1703
    int linesize, uvlinesize;
1704
    const int a= s->sprite_warping_accuracy;
1705
    int ox, oy;
1706

    
1707
    linesize = s->linesize;
1708
    uvlinesize = s->uvlinesize;
1709

    
1710
    ptr = ref_picture[0] + src_offset;
1711

    
1712
    dest_y+=dest_offset;
1713
    
1714
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
1715
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
1716

    
1717
    s->dsp.gmc(dest_y, ptr, linesize, 16,
1718
           ox, 
1719
           oy, 
1720
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1721
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1722
           a+1, (1<<(2*a+1)) - s->no_rounding,
1723
           s->h_edge_pos, s->v_edge_pos);
1724
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
1725
           ox + s->sprite_delta[0][0]*8, 
1726
           oy + s->sprite_delta[1][0]*8, 
1727
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1728
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1729
           a+1, (1<<(2*a+1)) - s->no_rounding,
1730
           s->h_edge_pos, s->v_edge_pos);
1731

    
1732
    if(s->flags&CODEC_FLAG_GRAY) return;
1733

    
1734

    
1735
    dest_cb+=dest_offset>>1;
1736
    dest_cr+=dest_offset>>1;
1737
    
1738
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
1739
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
1740

    
1741
    ptr = ref_picture[1] + (src_offset>>1);
1742
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
1743
           ox, 
1744
           oy, 
1745
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1746
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1747
           a+1, (1<<(2*a+1)) - s->no_rounding,
1748
           s->h_edge_pos>>1, s->v_edge_pos>>1);
1749
    
1750
    ptr = ref_picture[2] + (src_offset>>1);
1751
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
1752
           ox, 
1753
           oy, 
1754
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1755
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1756
           a+1, (1<<(2*a+1)) - s->no_rounding,
1757
           s->h_edge_pos>>1, s->v_edge_pos>>1);
1758
}
1759

    
1760
/**
1761
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
1762
 * @param buf destination buffer
1763
 * @param src source buffer
1764
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
1765
 * @param block_w width of block
1766
 * @param block_h height of block
1767
 * @param src_x x coordinate of the top left sample of the block in the source buffer
1768
 * @param src_y y coordinate of the top left sample of the block in the source buffer
1769
 * @param w width of the source buffer
1770
 * @param h height of the source buffer
1771
 */
1772
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
1773
                                    int src_x, int src_y, int w, int h){
1774
    int x, y;
1775
    int start_y, start_x, end_y, end_x;
1776

    
1777
    if(src_y>= h){
1778
        src+= (h-1-src_y)*linesize;
1779
        src_y=h-1;
1780
    }else if(src_y<=-block_h){
1781
        src+= (1-block_h-src_y)*linesize;
1782
        src_y=1-block_h;
1783
    }
1784
    if(src_x>= w){
1785
        src+= (w-1-src_x);
1786
        src_x=w-1;
1787
    }else if(src_x<=-block_w){
1788
        src+= (1-block_w-src_x);
1789
        src_x=1-block_w;
1790
    }
1791

    
1792
    start_y= FFMAX(0, -src_y);
1793
    start_x= FFMAX(0, -src_x);
1794
    end_y= FFMIN(block_h, h-src_y);
1795
    end_x= FFMIN(block_w, w-src_x);
1796

    
1797
    // copy existing part
1798
    for(y=start_y; y<end_y; y++){
1799
        for(x=start_x; x<end_x; x++){
1800
            buf[x + y*linesize]= src[x + y*linesize];
1801
        }
1802
    }
1803

    
1804
    //top
1805
    for(y=0; y<start_y; y++){
1806
        for(x=start_x; x<end_x; x++){
1807
            buf[x + y*linesize]= buf[x + start_y*linesize];
1808
        }
1809
    }
1810

    
1811
    //bottom
1812
    for(y=end_y; y<block_h; y++){
1813
        for(x=start_x; x<end_x; x++){
1814
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1815
        }
1816
    }
1817
                                    
1818
    for(y=0; y<block_h; y++){
1819
       //left
1820
        for(x=0; x<start_x; x++){
1821
            buf[x + y*linesize]= buf[start_x + y*linesize];
1822
        }
1823
       
1824
       //right
1825
        for(x=end_x; x<block_w; x++){
1826
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1827
        }
1828
    }
1829
}
1830

    
1831

    
1832
/* apply one mpeg motion vector to the three components */
1833
static inline void mpeg_motion(MpegEncContext *s,
1834
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1835
                               int dest_offset,
1836
                               uint8_t **ref_picture, int src_offset,
1837
                               int field_based, op_pixels_func (*pix_op)[4],
1838
                               int motion_x, int motion_y, int h)
1839
{
1840
    uint8_t *ptr;
1841
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1842
    int emu=0;
1843
#if 0    
1844
if(s->quarter_sample)
1845
{
1846
    motion_x>>=1;
1847
    motion_y>>=1;
1848
}
1849
#endif
1850
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1851
    src_x = s->mb_x * 16 + (motion_x >> 1);
1852
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 1);
1853
                
1854
    /* WARNING: do no forget half pels */
1855
    height = s->height >> field_based;
1856
    v_edge_pos = s->v_edge_pos >> field_based;
1857
    src_x = clip(src_x, -16, s->width);
1858
    if (src_x == s->width)
1859
        dxy &= ~1;
1860
    src_y = clip(src_y, -16, height);
1861
    if (src_y == height)
1862
        dxy &= ~2;
1863
    linesize   = s->current_picture.linesize[0] << field_based;
1864
    uvlinesize = s->current_picture.linesize[1] << field_based;
1865
    ptr = ref_picture[0] + (src_y * linesize) + (src_x) + src_offset;
1866
    dest_y += dest_offset;
1867

    
1868
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1869
        if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 16 > s->h_edge_pos
1870
                              || src_y + (motion_y&1) + h  > v_edge_pos){
1871
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr - src_offset, s->linesize, 17, 17+field_based,  //FIXME linesize? and uv below
1872
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1873
            ptr= s->edge_emu_buffer + src_offset;
1874
            emu=1;
1875
        }
1876
    }
1877
    pix_op[0][dxy](dest_y, ptr, linesize, h);
1878

    
1879
    if(s->flags&CODEC_FLAG_GRAY) return;
1880

    
1881
    if (s->out_format == FMT_H263) {
1882
        dxy = 0;
1883
        if ((motion_x & 3) != 0)
1884
            dxy |= 1;
1885
        if ((motion_y & 3) != 0)
1886
            dxy |= 2;
1887
        mx = motion_x >> 2;
1888
        my = motion_y >> 2;
1889
    } else {
1890
        mx = motion_x / 2;
1891
        my = motion_y / 2;
1892
        dxy = ((my & 1) << 1) | (mx & 1);
1893
        mx >>= 1;
1894
        my >>= 1;
1895
    }
1896
    
1897
    src_x = s->mb_x * 8 + mx;
1898
    src_y = s->mb_y * (8 >> field_based) + my;
1899
    src_x = clip(src_x, -8, s->width >> 1);
1900
    if (src_x == (s->width >> 1))
1901
        dxy &= ~1;
1902
    src_y = clip(src_y, -8, height >> 1);
1903
    if (src_y == (height >> 1))
1904
        dxy &= ~2;
1905
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1906
    ptr = ref_picture[1] + offset;
1907
    if(emu){
1908
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
1909
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1910
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1911
    }
1912
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1913

    
1914
    ptr = ref_picture[2] + offset;
1915
    if(emu){
1916
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
1917
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1918
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1919
    }
1920
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1921
}
1922

    
1923
static inline void qpel_motion(MpegEncContext *s,
1924
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1925
                               int dest_offset,
1926
                               uint8_t **ref_picture, int src_offset,
1927
                               int field_based, op_pixels_func (*pix_op)[4],
1928
                               qpel_mc_func (*qpix_op)[16],
1929
                               int motion_x, int motion_y, int h)
1930
{
1931
    uint8_t *ptr;
1932
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1933
    int emu=0;
1934

    
1935
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1936
    src_x = s->mb_x * 16 + (motion_x >> 2);
1937
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
1938

    
1939
    height = s->height >> field_based;
1940
    v_edge_pos = s->v_edge_pos >> field_based;
1941
    src_x = clip(src_x, -16, s->width);
1942
    if (src_x == s->width)
1943
        dxy &= ~3;
1944
    src_y = clip(src_y, -16, height);
1945
    if (src_y == height)
1946
        dxy &= ~12;
1947
    linesize = s->linesize << field_based;
1948
    uvlinesize = s->uvlinesize << field_based;
1949
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1950
    dest_y += dest_offset;
1951
//printf("%d %d %d\n", src_x, src_y, dxy);
1952
    
1953
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1954
        if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 16 > s->h_edge_pos
1955
                              || src_y + (motion_y&3) + h  > v_edge_pos){
1956
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr - src_offset, s->linesize, 17, 17+field_based, 
1957
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1958
            ptr= s->edge_emu_buffer + src_offset;
1959
            emu=1;
1960
        }
1961
    }
1962
    if(!field_based)
1963
        qpix_op[0][dxy](dest_y, ptr, linesize);
1964
    else{
1965
        //damn interlaced mode
1966
        //FIXME boundary mirroring is not exactly correct here
1967
        qpix_op[1][dxy](dest_y  , ptr  , linesize);
1968
        qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
1969
    }
1970

    
1971
    if(s->flags&CODEC_FLAG_GRAY) return;
1972

    
1973
    if(field_based){
1974
        mx= motion_x/2;
1975
        my= motion_y>>1;
1976
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
1977
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
1978
        mx= (motion_x>>1) + rtab[motion_x&7];
1979
        my= (motion_y>>1) + rtab[motion_y&7];
1980
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
1981
        mx= (motion_x>>1)|(motion_x&1);
1982
        my= (motion_y>>1)|(motion_y&1);
1983
    }else{
1984
        mx= motion_x/2;
1985
        my= motion_y/2;
1986
    }
1987
    mx= (mx>>1)|(mx&1);
1988
    my= (my>>1)|(my&1);
1989

    
1990
    dxy= (mx&1) | ((my&1)<<1);
1991
    mx>>=1;
1992
    my>>=1;
1993

    
1994
    src_x = s->mb_x * 8 + mx;
1995
    src_y = s->mb_y * (8 >> field_based) + my;
1996
    src_x = clip(src_x, -8, s->width >> 1);
1997
    if (src_x == (s->width >> 1))
1998
        dxy &= ~1;
1999
    src_y = clip(src_y, -8, height >> 1);
2000
    if (src_y == (height >> 1))
2001
        dxy &= ~2;
2002

    
2003
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
2004
    ptr = ref_picture[1] + offset;
2005
    if(emu){
2006
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
2007
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2008
        ptr= s->edge_emu_buffer + (src_offset >> 1);
2009
    }
2010
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
2011
    
2012
    ptr = ref_picture[2] + offset;
2013
    if(emu){
2014
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
2015
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2016
        ptr= s->edge_emu_buffer + (src_offset >> 1);
2017
    }
2018
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
2019
}
2020

    
2021
inline int ff_h263_round_chroma(int x){
2022
    if (x >= 0)
2023
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2024
    else {
2025
        x = -x;
2026
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2027
    }
2028
}
2029

    
2030
/**
2031
 * motion compesation of a single macroblock
2032
 * @param s context
2033
 * @param dest_y luma destination pointer
2034
 * @param dest_cb chroma cb/u destination pointer
2035
 * @param dest_cr chroma cr/v destination pointer
2036
 * @param dir direction (0->forward, 1->backward)
2037
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2038
 * @param pic_op halfpel motion compensation function (average or put normally)
2039
 * @param pic_op qpel motion compensation function (average or put normally)
2040
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2041
 */
2042
static inline void MPV_motion(MpegEncContext *s, 
2043
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2044
                              int dir, uint8_t **ref_picture, 
2045
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
2046
{
2047
    int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
2048
    int mb_x, mb_y, i;
2049
    uint8_t *ptr, *dest;
2050
    int emu=0;
2051

    
2052
    mb_x = s->mb_x;
2053
    mb_y = s->mb_y;
2054

    
2055
    switch(s->mv_type) {
2056
    case MV_TYPE_16X16:
2057
#ifdef CONFIG_RISKY
2058
        if(s->mcsel){
2059
            if(s->real_sprite_warping_points==1){
2060
                gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
2061
                            ref_picture, 0);
2062
            }else{
2063
                gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
2064
                            ref_picture, 0);
2065
            }
2066
        }else if(s->quarter_sample){
2067
            qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2068
                        ref_picture, 0,
2069
                        0, pix_op, qpix_op,
2070
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2071
        }else if(s->mspel){
2072
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
2073
                        ref_picture, pix_op,
2074
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2075
        }else
2076
#endif
2077
        {
2078
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2079
                        ref_picture, 0,
2080
                        0, pix_op,
2081
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2082
        }           
2083
        break;
2084
    case MV_TYPE_8X8:
2085
        mx = 0;
2086
        my = 0;
2087
        if(s->quarter_sample){
2088
            for(i=0;i<4;i++) {
2089
                motion_x = s->mv[dir][i][0];
2090
                motion_y = s->mv[dir][i][1];
2091

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

    
2115
                mx += s->mv[dir][i][0]/2;
2116
                my += s->mv[dir][i][1]/2;
2117
            }
2118
        }else{
2119
            for(i=0;i<4;i++) {
2120
                motion_x = s->mv[dir][i][0];
2121
                motion_y = s->mv[dir][i][1];
2122

    
2123
                dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2124
                src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;
2125
                src_y = mb_y * 16 + (motion_y >> 1) + (i >>1) * 8;
2126
                    
2127
                /* WARNING: do no forget half pels */
2128
                src_x = clip(src_x, -16, s->width);
2129
                if (src_x == s->width)
2130
                    dxy &= ~1;
2131
                src_y = clip(src_y, -16, s->height);
2132
                if (src_y == s->height)
2133
                    dxy &= ~2;
2134
                    
2135
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2136
                if(s->flags&CODEC_FLAG_EMU_EDGE){
2137
                    if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 8 > s->h_edge_pos
2138
                                          || src_y + (motion_y&1) + 8 > s->v_edge_pos){
2139
                        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);
2140
                        ptr= s->edge_emu_buffer;
2141
                    }
2142
                }
2143
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2144
                pix_op[1][dxy](dest, ptr, s->linesize, 8);
2145

    
2146
                mx += s->mv[dir][i][0];
2147
                my += s->mv[dir][i][1];
2148
            }
2149
        }
2150

    
2151
        if(s->flags&CODEC_FLAG_GRAY) break;
2152
        /* In case of 8X8, we construct a single chroma motion vector
2153
           with a special rounding */
2154
        mx= ff_h263_round_chroma(mx);
2155
        my= ff_h263_round_chroma(my);
2156
        dxy = ((my & 1) << 1) | (mx & 1);
2157
        mx >>= 1;
2158
        my >>= 1;
2159

    
2160
        src_x = mb_x * 8 + mx;
2161
        src_y = mb_y * 8 + my;
2162
        src_x = clip(src_x, -8, s->width/2);
2163
        if (src_x == s->width/2)
2164
            dxy &= ~1;
2165
        src_y = clip(src_y, -8, s->height/2);
2166
        if (src_y == s->height/2)
2167
            dxy &= ~2;
2168
        
2169
        offset = (src_y * (s->uvlinesize)) + src_x;
2170
        ptr = ref_picture[1] + offset;
2171
        if(s->flags&CODEC_FLAG_EMU_EDGE){
2172
                if(src_x<0 || src_y<0 || src_x + (dxy &1) + 8 > s->h_edge_pos>>1
2173
                                      || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
2174
                    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);
2175
                    ptr= s->edge_emu_buffer;
2176
                    emu=1;
2177
                }
2178
            }
2179
        pix_op[1][dxy](dest_cb, ptr, s->uvlinesize, 8);
2180

    
2181
        ptr = ref_picture[2] + offset;
2182
        if(emu){
2183
            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);
2184
            ptr= s->edge_emu_buffer;
2185
        }
2186
        pix_op[1][dxy](dest_cr, ptr, s->uvlinesize, 8);
2187
        break;
2188
    case MV_TYPE_FIELD:
2189
        if (s->picture_structure == PICT_FRAME) {
2190
            if(s->quarter_sample){
2191
                /* top field */
2192
                qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2193
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2194
                            1, pix_op, qpix_op,
2195
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
2196
                /* bottom field */
2197
                qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2198
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2199
                            1, pix_op, qpix_op,
2200
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
2201
            }else{
2202
                /* top field */       
2203
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2204
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2205
                            1, pix_op,
2206
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
2207
                /* bottom field */
2208
                mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2209
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2210
                            1, pix_op,
2211
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
2212
            }
2213
        } else {
2214
            int offset;
2215
            if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2216
                offset= s->field_select[dir][0] ? s->linesize : 0;
2217
            }else{
2218
                ref_picture= s->current_picture.data;
2219
                offset= s->field_select[dir][0] ? s->linesize : -s->linesize; 
2220
            } 
2221

    
2222
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2223
                        ref_picture, offset,
2224
                        0, pix_op,
2225
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2226
        }
2227
        break;
2228
    case MV_TYPE_16X8:{
2229
        int offset;
2230
         uint8_t ** ref2picture;
2231

    
2232
            if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2233
                ref2picture= ref_picture;
2234
                offset= s->field_select[dir][0] ? s->linesize : 0;
2235
            }else{
2236
                ref2picture= s->current_picture.data;
2237
                offset= s->field_select[dir][0] ? s->linesize : -s->linesize; 
2238
            } 
2239

    
2240
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2241
                        ref2picture, offset,
2242
                        0, pix_op,
2243
                        s->mv[dir][0][0], s->mv[dir][0][1], 8);
2244

    
2245

    
2246
            if(s->picture_structure == s->field_select[dir][1] + 1 || s->pict_type == B_TYPE || s->first_field){
2247
                ref2picture= ref_picture;
2248
                offset= s->field_select[dir][1] ? s->linesize : 0;
2249
            }else{
2250
                ref2picture= s->current_picture.data;
2251
                offset= s->field_select[dir][1] ? s->linesize : -s->linesize; 
2252
            } 
2253
            // I know it is ugly but this is the only way to fool emu_edge without rewrite mpeg_motion
2254
            mpeg_motion(s, dest_y+16*s->linesize, dest_cb+8*s->uvlinesize, dest_cr+8*s->uvlinesize,
2255
                        0,
2256
                        ref2picture, offset,
2257
                        0, pix_op,
2258
                        s->mv[dir][1][0], s->mv[dir][1][1]+16, 8);
2259
        }
2260
        
2261
        break;
2262
    case MV_TYPE_DMV:
2263
    {
2264
    op_pixels_func (*dmv_pix_op)[4];
2265
    int offset;
2266

    
2267
        dmv_pix_op = s->dsp.put_pixels_tab;
2268

    
2269
        if(s->picture_structure == PICT_FRAME){
2270
            //put top field from top field
2271
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2272
                        ref_picture, 0,
2273
                        1, dmv_pix_op,
2274
                        s->mv[dir][0][0], s->mv[dir][0][1], 8);
2275
            //put bottom field from bottom field
2276
            mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2277
                        ref_picture, s->linesize,
2278
                        1, dmv_pix_op,
2279
                        s->mv[dir][0][0], s->mv[dir][0][1], 8);
2280

    
2281
            dmv_pix_op = s->dsp.avg_pixels_tab; 
2282
        
2283
            //avg top field from bottom field
2284
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2285
                        ref_picture, s->linesize,
2286
                        1, dmv_pix_op,
2287
                        s->mv[dir][2][0], s->mv[dir][2][1], 8);
2288
            //avg bottom field from top field
2289
            mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2290
                        ref_picture, 0,
2291
                        1, dmv_pix_op,
2292
                        s->mv[dir][3][0], s->mv[dir][3][1], 8);
2293

    
2294
        }else{
2295
            offset=(s->picture_structure == PICT_BOTTOM_FIELD)? 
2296
                         s->linesize : 0;
2297

    
2298
            //put field from the same parity
2299
            //same parity is never in the same frame
2300
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2301
                        ref_picture,offset,
2302
                        0,dmv_pix_op,
2303
                        s->mv[dir][0][0],s->mv[dir][0][1],16);
2304

    
2305
            // after put we make avg of the same block
2306
            dmv_pix_op=s->dsp.avg_pixels_tab; 
2307

    
2308
            //opposite parity is always in the same frame if this is second field
2309
            if(!s->first_field){
2310
                ref_picture = s->current_picture.data;    
2311
                //top field is one linesize from frame beginig
2312
                offset=(s->picture_structure == PICT_BOTTOM_FIELD)? 
2313
                        -s->linesize : s->linesize;
2314
            }else 
2315
                offset=(s->picture_structure == PICT_BOTTOM_FIELD)? 
2316
                        0 : s->linesize;
2317

    
2318
            //avg field from the opposite parity
2319
            mpeg_motion(s, dest_y, dest_cb, dest_cr,0,
2320
                        ref_picture, offset,
2321
                        0,dmv_pix_op,
2322
                        s->mv[dir][2][0],s->mv[dir][2][1],16);
2323
        }
2324
    }
2325
    break;
2326

    
2327
    }
2328
}
2329

    
2330

    
2331
/* put block[] to dest[] */
2332
static inline void put_dct(MpegEncContext *s, 
2333
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
2334
{
2335
    s->dct_unquantize(s, block, i, s->qscale);
2336
    s->dsp.idct_put (dest, line_size, block);
2337
}
2338

    
2339
/* add block[] to dest[] */
2340
static inline void add_dct(MpegEncContext *s, 
2341
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
2342
{
2343
    if (s->block_last_index[i] >= 0) {
2344
        s->dsp.idct_add (dest, line_size, block);
2345
    }
2346
}
2347

    
2348
static inline void add_dequant_dct(MpegEncContext *s, 
2349
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
2350
{
2351
    if (s->block_last_index[i] >= 0) {
2352
        s->dct_unquantize(s, block, i, s->qscale);
2353

    
2354
        s->dsp.idct_add (dest, line_size, block);
2355
    }
2356
}
2357

    
2358
/**
2359
 * cleans dc, ac, coded_block for the current non intra MB
2360
 */
2361
void ff_clean_intra_table_entries(MpegEncContext *s)
2362
{
2363
    int wrap = s->block_wrap[0];
2364
    int xy = s->block_index[0];
2365
    
2366
    s->dc_val[0][xy           ] = 
2367
    s->dc_val[0][xy + 1       ] = 
2368
    s->dc_val[0][xy     + wrap] =
2369
    s->dc_val[0][xy + 1 + wrap] = 1024;
2370
    /* ac pred */
2371
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2372
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2373
    if (s->msmpeg4_version>=3) {
2374
        s->coded_block[xy           ] =
2375
        s->coded_block[xy + 1       ] =
2376
        s->coded_block[xy     + wrap] =
2377
        s->coded_block[xy + 1 + wrap] = 0;
2378
    }
2379
    /* chroma */
2380
    wrap = s->block_wrap[4];
2381
    xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
2382
    s->dc_val[1][xy] =
2383
    s->dc_val[2][xy] = 1024;
2384
    /* ac pred */
2385
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2386
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2387
    
2388
    s->mbintra_table[s->mb_x + s->mb_y*s->mb_stride]= 0;
2389
}
2390

    
2391
/* generic function called after a macroblock has been parsed by the
2392
   decoder or after it has been encoded by the encoder.
2393

2394
   Important variables used:
2395
   s->mb_intra : true if intra macroblock
2396
   s->mv_dir   : motion vector direction
2397
   s->mv_type  : motion vector type
2398
   s->mv       : motion vector
2399
   s->interlaced_dct : true if interlaced dct used (mpeg2)
2400
 */
2401
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
2402
{
2403
    int mb_x, mb_y;
2404
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2405
#ifdef HAVE_XVMC
2406
    if(s->avctx->xvmc_acceleration){
2407
        XVMC_decode_mb(s,block);
2408
        return;
2409
    }
2410
#endif
2411

    
2412
    mb_x = s->mb_x;
2413
    mb_y = s->mb_y;
2414

    
2415
    s->current_picture.qscale_table[mb_xy]= s->qscale;
2416

    
2417
    /* update DC predictors for P macroblocks */
2418
    if (!s->mb_intra) {
2419
        if (s->h263_pred || s->h263_aic) {
2420
            if(s->mbintra_table[mb_xy])
2421
                ff_clean_intra_table_entries(s);
2422
        } else {
2423
            s->last_dc[0] =
2424
            s->last_dc[1] =
2425
            s->last_dc[2] = 128 << s->intra_dc_precision;
2426
        }
2427
    }
2428
    else if (s->h263_pred || s->h263_aic)
2429
        s->mbintra_table[mb_xy]=1;
2430

    
2431
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
2432
        uint8_t *dest_y, *dest_cb, *dest_cr;
2433
        int dct_linesize, dct_offset;
2434
        op_pixels_func (*op_pix)[4];
2435
        qpel_mc_func (*op_qpix)[16];
2436
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
2437
        const int uvlinesize= s->current_picture.linesize[1];
2438

    
2439
        /* avoid copy if macroblock skipped in last frame too */
2440
        /* skip only during decoding as we might trash the buffers during encoding a bit */
2441
        if(!s->encoding){
2442
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2443
            const int age= s->current_picture.age;
2444

    
2445
            assert(age);
2446

    
2447
            if (s->mb_skiped) {
2448
                s->mb_skiped= 0;
2449
                assert(s->pict_type!=I_TYPE);
2450
 
2451
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
2452
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2453

    
2454
                /* if previous was skipped too, then nothing to do !  */
2455
                if (*mbskip_ptr >= age && s->current_picture.reference){
2456
                    return;
2457
                }
2458
            } else if(!s->current_picture.reference){
2459
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2460
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2461
            } else{
2462
                *mbskip_ptr = 0; /* not skipped */
2463
            }
2464
        }
2465

    
2466
        if (s->interlaced_dct) {
2467
            dct_linesize = linesize * 2;
2468
            dct_offset = linesize;
2469
        } else {
2470
            dct_linesize = linesize;
2471
            dct_offset = linesize * 8;
2472
        }
2473
        
2474
        dest_y=  s->dest[0];
2475
        dest_cb= s->dest[1];
2476
        dest_cr= s->dest[2];
2477

    
2478
        if (!s->mb_intra) {
2479
            /* motion handling */
2480
            /* decoding or more than one mb_type (MC was allready done otherwise) */
2481
            if(!s->encoding){
2482
                if ((!s->no_rounding) || s->pict_type==B_TYPE){                
2483
                    op_pix = s->dsp.put_pixels_tab;
2484
                    op_qpix= s->dsp.put_qpel_pixels_tab;
2485
                }else{
2486
                    op_pix = s->dsp.put_no_rnd_pixels_tab;
2487
                    op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2488
                }
2489

    
2490
                if (s->mv_dir & MV_DIR_FORWARD) {
2491
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2492
                    op_pix = s->dsp.avg_pixels_tab;
2493
                    op_qpix= s->dsp.avg_qpel_pixels_tab;
2494
                }
2495
                if (s->mv_dir & MV_DIR_BACKWARD) {
2496
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2497
                }
2498
            }
2499

    
2500
            /* skip dequant / idct if we are really late ;) */
2501
            if(s->hurry_up>1) return;
2502

    
2503
            /* add dct residue */
2504
            if(s->encoding || !(   s->mpeg2 || s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO 
2505
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2506
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
2507
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2508
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2509
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2510

    
2511
                if(!(s->flags&CODEC_FLAG_GRAY)){
2512
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize);
2513
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize);
2514
                }
2515
            } else if(s->codec_id != CODEC_ID_WMV2){
2516
                add_dct(s, block[0], 0, dest_y, dct_linesize);
2517
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2518
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2519
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2520

    
2521
                if(!(s->flags&CODEC_FLAG_GRAY)){
2522
                    add_dct(s, block[4], 4, dest_cb, uvlinesize);
2523
                    add_dct(s, block[5], 5, dest_cr, uvlinesize);
2524
                }
2525
            } 
2526
#ifdef CONFIG_RISKY
2527
            else{
2528
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2529
            }
2530
#endif
2531
        } else {
2532
            /* dct only in intra block */
2533
            if(s->encoding || !(s->mpeg2 || s->codec_id==CODEC_ID_MPEG1VIDEO)){
2534
                put_dct(s, block[0], 0, dest_y, dct_linesize);
2535
                put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2536
                put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2537
                put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2538

    
2539
                if(!(s->flags&CODEC_FLAG_GRAY)){
2540
                    put_dct(s, block[4], 4, dest_cb, uvlinesize);
2541
                    put_dct(s, block[5], 5, dest_cr, uvlinesize);
2542
                }
2543
            }else{
2544
                s->dsp.idct_put(dest_y                 , dct_linesize, block[0]);
2545
                s->dsp.idct_put(dest_y              + 8, dct_linesize, block[1]);
2546
                s->dsp.idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
2547
                s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
2548

    
2549
                if(!(s->flags&CODEC_FLAG_GRAY)){
2550
                    s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2551
                    s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2552
                }
2553
            }
2554
        }
2555
    }
2556
}
2557

    
2558
#ifdef CONFIG_ENCODERS
2559

    
2560
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
2561
{
2562
    static const char tab[64]=
2563
        {3,2,2,1,1,1,1,1,
2564
         1,1,1,1,1,1,1,1,
2565
         1,1,1,1,1,1,1,1,
2566
         0,0,0,0,0,0,0,0,
2567
         0,0,0,0,0,0,0,0,
2568
         0,0,0,0,0,0,0,0,
2569
         0,0,0,0,0,0,0,0,
2570
         0,0,0,0,0,0,0,0};
2571
    int score=0;
2572
    int run=0;
2573
    int i;
2574
    DCTELEM *block= s->block[n];
2575
    const int last_index= s->block_last_index[n];
2576
    int skip_dc;
2577

    
2578
    if(threshold<0){
2579
        skip_dc=0;
2580
        threshold= -threshold;
2581
    }else
2582
        skip_dc=1;
2583

    
2584
    /* are all which we could set to zero are allready zero? */
2585
    if(last_index<=skip_dc - 1) return;
2586

    
2587
    for(i=0; i<=last_index; i++){
2588
        const int j = s->intra_scantable.permutated[i];
2589
        const int level = ABS(block[j]);
2590
        if(level==1){
2591
            if(skip_dc && i==0) continue;
2592
            score+= tab[run];
2593
            run=0;
2594
        }else if(level>1){
2595
            return;
2596
        }else{
2597
            run++;
2598
        }
2599
    }
2600
    if(score >= threshold) return;
2601
    for(i=skip_dc; i<=last_index; i++){
2602
        const int j = s->intra_scantable.permutated[i];
2603
        block[j]=0;
2604
    }
2605
    if(block[0]) s->block_last_index[n]= 0;
2606
    else         s->block_last_index[n]= -1;
2607
}
2608

    
2609
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
2610
{
2611
    int i;
2612
    const int maxlevel= s->max_qcoeff;
2613
    const int minlevel= s->min_qcoeff;
2614
    
2615
    if(s->mb_intra){
2616
        i=1; //skip clipping of intra dc
2617
    }else
2618
        i=0;
2619
    
2620
    for(;i<=last_index; i++){
2621
        const int j= s->intra_scantable.permutated[i];
2622
        int level = block[j];
2623
       
2624
        if     (level>maxlevel) level=maxlevel;
2625
        else if(level<minlevel) level=minlevel;
2626

    
2627
        block[j]= level;
2628
    }
2629
}
2630

    
2631
#if 0
2632
static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
2633
    int score=0;
2634
    int x,y;
2635
    
2636
    for(y=0; y<7; y++){
2637
        for(x=0; x<16; x+=4){
2638
            score+= ABS(s[x  ] - s[x  +stride]) + ABS(s[x+1] - s[x+1+stride]) 
2639
                   +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
2640
        }
2641
        s+= stride;
2642
    }
2643
    
2644
    return score;
2645
}
2646

2647
static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
2648
    int score=0;
2649
    int x,y;
2650
    
2651
    for(y=0; y<7; y++){
2652
        for(x=0; x<16; x++){
2653
            score+= ABS(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2654
        }
2655
        s1+= stride;
2656
        s2+= stride;
2657
    }
2658
    
2659
    return score;
2660
}
2661
#else
2662
#define SQ(a) ((a)*(a))
2663

    
2664
static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
2665
    int score=0;
2666
    int x,y;
2667
    
2668
    for(y=0; y<7; y++){
2669
        for(x=0; x<16; x+=4){
2670
            score+= SQ(s[x  ] - s[x  +stride]) + SQ(s[x+1] - s[x+1+stride]) 
2671
                   +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
2672
        }
2673
        s+= stride;
2674
    }
2675
    
2676
    return score;
2677
}
2678

    
2679
static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
2680
    int score=0;
2681
    int x,y;
2682
    
2683
    for(y=0; y<7; y++){
2684
        for(x=0; x<16; x++){
2685
            score+= SQ(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2686
        }
2687
        s1+= stride;
2688
        s2+= stride;
2689
    }
2690
    
2691
    return score;
2692
}
2693

    
2694
#endif
2695

    
2696
#endif //CONFIG_ENCODERS
2697

    
2698
/**
2699
 *
2700
 * @param h is the normal height, this will be reduced automatically if needed for the last row
2701
 */
2702
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2703
    if (s->avctx->draw_horiz_band) {
2704
        AVFrame *src;
2705
        uint8_t *src_ptr[3];
2706
        int offset[4];
2707
        
2708
        if(s->picture_structure != PICT_FRAME){
2709
            h <<= 1;
2710
            y <<= 1;
2711
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2712
        }
2713

    
2714
        h= FFMIN(h, s->height - y);
2715

    
2716
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) 
2717
            src= (AVFrame*)s->current_picture_ptr;
2718
        else if(s->last_picture_ptr)
2719
            src= (AVFrame*)s->last_picture_ptr;
2720
        else
2721
            return;
2722
            
2723
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2724
            offset[0]=
2725
            offset[1]=
2726
            offset[2]=
2727
            offset[3]= 0;
2728
        }else{
2729
            offset[0]= y * s->linesize;;
2730
            offset[1]= 
2731
            offset[2]= (y>>1) * s->uvlinesize;;
2732
            offset[3]= 0;
2733
        }
2734

    
2735
        emms_c();
2736

    
2737
        s->avctx->draw_horiz_band(s->avctx, src, offset,
2738
                                  y, s->picture_structure, h);
2739
    }
2740
}
2741

    
2742
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2743
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
2744
    const int uvlinesize= s->current_picture.linesize[1];
2745
        
2746
    s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2747
    s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1)     + s->mb_x*2;
2748
    s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1 + s->mb_x*2;
2749
    s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2)     + s->mb_x*2;
2750
    s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
2751
    s->block_index[5]= s->block_wrap[4]*(s->mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
2752
    
2753
    if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){
2754
        s->dest[0] = s->current_picture.data[0] + s->mb_x * 16 - 16;
2755
        s->dest[1] = s->current_picture.data[1] + s->mb_x * 8 - 8;
2756
        s->dest[2] = s->current_picture.data[2] + s->mb_x * 8 - 8;
2757
    }else{
2758
        s->dest[0] = s->current_picture.data[0] + (s->mb_y * 16* linesize  ) + s->mb_x * 16 - 16;
2759
        s->dest[1] = s->current_picture.data[1] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
2760
        s->dest[2] = s->current_picture.data[2] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
2761
    }    
2762
}
2763

    
2764
#ifdef CONFIG_ENCODERS
2765

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

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

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

    
2797
    if (s->mb_intra) {
2798
        uint8_t *ptr;
2799
        int wrap_y;
2800
        int emu=0;
2801

    
2802
        wrap_y = s->linesize;
2803
        ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2804

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

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

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

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

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

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

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

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

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

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

    
3028
#endif //CONFIG_ENCODERS
3029

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

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

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

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

    
3055
        memcpy(&pc->buffer[pc->index], *buf, *buf_size);
3056
        pc->index += *buf_size;
3057
        return -1;
3058
    }
3059

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

    
3067
        memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
3068
        pc->index = 0;
3069
        *buf= pc->buffer;
3070
    }
3071

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

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

    
3085
    return 0;
3086
}
3087

    
3088
void ff_mpeg_flush(AVCodecContext *avctx){
3089
    int i;
3090
    MpegEncContext *s = avctx->priv_data;
3091
    
3092
    for(i=0; i<MAX_PICTURE_COUNT; i++){
3093
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
3094
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
3095
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
3096
    }
3097
    s->last_picture_ptr = s->next_picture_ptr = NULL;
3098
    
3099
    s->parse_context.state= -1;
3100
    s->parse_context.frame_start_found= 0;
3101
    s->parse_context.overread= 0;
3102
    s->parse_context.overread_index= 0;
3103
    s->parse_context.index= 0;
3104
    s->parse_context.last_index= 0;
3105
}
3106

    
3107
#ifdef CONFIG_ENCODERS
3108
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
3109
{
3110
    int bytes= length>>4;
3111
    int bits= length&15;
3112
    int i;
3113

    
3114
    if(length==0) return;
3115

    
3116
    for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
3117
    put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
3118
}
3119

    
3120
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
3121
    int i;
3122

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

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

    
3141
    d->mb_skiped= 0;
3142
    d->qscale= s->qscale;
3143
}
3144

    
3145
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
3146
    int i;
3147

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

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

    
3182
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
3183
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
3184
                           int *dmin, int *next_block, int motion_x, int motion_y)
3185
{
3186
    int score;
3187
    uint8_t *dest_backup[3];
3188
    
3189
    copy_context_before_encode(s, backup, type);
3190

    
3191
    s->block= s->blocks[*next_block];
3192
    s->pb= pb[*next_block];
3193
    if(s->data_partitioning){
3194
        s->pb2   = pb2   [*next_block];
3195
        s->tex_pb= tex_pb[*next_block];
3196
    }
3197
    
3198
    if(*next_block){
3199
        memcpy(dest_backup, s->dest, sizeof(s->dest));
3200
        s->dest[0] = s->me.scratchpad;
3201
        s->dest[1] = s->me.scratchpad + 16;
3202
        s->dest[2] = s->me.scratchpad + 16 + 8;
3203
        assert(2*s->uvlinesize == s->linesize); //should be no prob for encoding
3204
        assert(s->linesize >= 64); //FIXME
3205
    }
3206

    
3207
    encode_mb(s, motion_x, motion_y);
3208
    
3209
    score= get_bit_count(&s->pb);
3210
    if(s->data_partitioning){
3211
        score+= get_bit_count(&s->pb2);
3212
        score+= get_bit_count(&s->tex_pb);
3213
    }
3214
   
3215
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
3216
        MPV_decode_mb(s, s->block);
3217

    
3218
        score *= s->qscale * s->qscale * 109;
3219
        score += sse_mb(s) << 7;
3220
    }
3221
    
3222
    if(*next_block){
3223
        memcpy(s->dest, dest_backup, sizeof(s->dest));
3224
    }
3225

    
3226
    if(score<*dmin){
3227
        *dmin= score;
3228
        *next_block^=1;
3229

    
3230
        copy_context_after_encode(best, s, type);
3231
    }
3232
}
3233
                
3234
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
3235
    uint32_t *sq = squareTbl + 256;
3236
    int acc=0;
3237
    int x,y;
3238
    
3239
    if(w==16 && h==16) 
3240
        return s->dsp.sse[0](NULL, src1, src2, stride);
3241
    else if(w==8 && h==8)
3242
        return s->dsp.sse[1](NULL, src1, src2, stride);
3243
    
3244
    for(y=0; y<h; y++){
3245
        for(x=0; x<w; x++){
3246
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
3247
        } 
3248
    }
3249
    
3250
    assert(acc>=0);
3251
    
3252
    return acc;
3253
}
3254

    
3255
static int sse_mb(MpegEncContext *s){
3256
    int w= 16;
3257
    int h= 16;
3258

    
3259
    if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3260
    if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3261

    
3262
    if(w==16 && h==16)
3263
        return  s->dsp.sse[0](NULL, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize)
3264
               +s->dsp.sse[1](NULL, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize)
3265
               +s->dsp.sse[1](NULL, s->new_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize);
3266
    else
3267
        return  sse(s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], w, h, s->linesize)
3268
               +sse(s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[1], w>>1, h>>1, s->uvlinesize)
3269
               +sse(s, s->new_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[2], w>>1, h>>1, s->uvlinesize);
3270
}
3271

    
3272
static void encode_picture(MpegEncContext *s, int picture_number)
3273
{
3274
    int mb_x, mb_y, pdif = 0;
3275
    int i;
3276
    int bits;
3277
    MpegEncContext best_s, backup_s;
3278
    uint8_t bit_buf[2][3000];
3279
    uint8_t bit_buf2[2][3000];
3280
    uint8_t bit_buf_tex[2][3000];
3281
    PutBitContext pb[2], pb2[2], tex_pb[2];
3282

    
3283
    for(i=0; i<2; i++){
3284
        init_put_bits(&pb    [i], bit_buf    [i], 3000, NULL, NULL);
3285
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000, NULL, NULL);
3286
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
3287
    }
3288

    
3289
    s->picture_number = picture_number;
3290
    
3291
    /* Reset the average MB variance */
3292
    s->current_picture.mb_var_sum = 0;
3293
    s->current_picture.mc_mb_var_sum = 0;
3294

    
3295
#ifdef CONFIG_RISKY
3296
    /* we need to initialize some time vars before we can encode b-frames */
3297
    // RAL: Condition added for MPEG1VIDEO
3298
    if (s->codec_id == CODEC_ID_MPEG1VIDEO || (s->h263_pred && !s->h263_msmpeg4))
3299
        ff_set_mpeg4_time(s, s->picture_number); 
3300
#endif
3301
        
3302
    s->scene_change_score=0;
3303
    
3304
    s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
3305
    
3306
    if(s->pict_type==I_TYPE){
3307
        if(s->msmpeg4_version >= 3) s->no_rounding=1;
3308
        else                        s->no_rounding=0;
3309
    }else if(s->pict_type!=B_TYPE){
3310
        if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
3311
            s->no_rounding ^= 1;          
3312
    }
3313
    
3314
    /* Estimate motion for every MB */
3315
    s->mb_intra=0; //for the rate distoration & bit compare functions
3316
    if(s->pict_type != I_TYPE){
3317
        if(s->pict_type != B_TYPE){
3318
            if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
3319
                s->me.pre_pass=1;
3320
                s->me.dia_size= s->avctx->pre_dia_size;
3321

    
3322
                for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) {
3323
                    for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) {
3324
                        s->mb_x = mb_x;
3325
                        s->mb_y = mb_y;
3326
                        ff_pre_estimate_p_frame_motion(s, mb_x, mb_y);
3327
                    }
3328
                }
3329
                s->me.pre_pass=0;
3330
            }
3331
        }
3332

    
3333
        s->me.dia_size= s->avctx->dia_size;
3334
        for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3335
            s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3336
            s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3337
            s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3338
            s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3339
            for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3340
                s->mb_x = mb_x;
3341
                s->mb_y = mb_y;
3342
                s->block_index[0]+=2;
3343
                s->block_index[1]+=2;
3344
                s->block_index[2]+=2;
3345
                s->block_index[3]+=2;
3346
                
3347
                /* compute motion vector & mb_type and store in context */
3348
                if(s->pict_type==B_TYPE)
3349
                    ff_estimate_b_frame_motion(s, mb_x, mb_y);
3350
                else
3351
                    ff_estimate_p_frame_motion(s, mb_x, mb_y);
3352
            }
3353
        }
3354
    }else /* if(s->pict_type == I_TYPE) */{
3355
        /* I-Frame */
3356
        //FIXME do we need to zero them?
3357
        memset(s->motion_val[0], 0, sizeof(int16_t)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
3358
        memset(s->p_mv_table   , 0, sizeof(int16_t)*(s->mb_stride)*s->mb_height*2);
3359
        memset(s->mb_type      , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3360
        
3361
        if(!s->fixed_qscale){
3362
            /* finding spatial complexity for I-frame rate control */
3363
            for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3364
                for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3365
                    int xx = mb_x * 16;
3366
                    int yy = mb_y * 16;
3367
                    uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
3368
                    int varc;
3369
                    int sum = s->dsp.pix_sum(pix, s->linesize);
3370
    
3371
                    varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
3372

    
3373
                    s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
3374
                    s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
3375
                    s->current_picture.mb_var_sum    += varc;
3376
                }
3377
            }
3378
        }
3379
    }
3380
    emms_c();
3381

    
3382
    if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
3383
        s->pict_type= I_TYPE;
3384
        memset(s->mb_type   , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3385
//printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3386
    }
3387

    
3388
    if(!s->umvplus){
3389
        if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
3390
            s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
3391
        
3392
            ff_fix_long_p_mvs(s);
3393
        }
3394

    
3395
        if(s->pict_type==B_TYPE){
3396
            int a, b;
3397

    
3398
            a = ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
3399
            b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, MB_TYPE_BIDIR);
3400
            s->f_code = FFMAX(a, b);
3401

    
3402
            a = ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
3403
            b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, MB_TYPE_BIDIR);
3404
            s->b_code = FFMAX(a, b);
3405

    
3406
            ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
3407
            ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
3408
            ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
3409
            ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
3410
        }
3411
    }
3412
    
3413
    if (s->fixed_qscale) 
3414
        s->frame_qscale = s->current_picture.quality;
3415
    else
3416
        s->frame_qscale = ff_rate_estimate_qscale(s);
3417

    
3418
    if(s->adaptive_quant){
3419
#ifdef CONFIG_RISKY
3420
        switch(s->codec_id){
3421
        case CODEC_ID_MPEG4:
3422
            ff_clean_mpeg4_qscales(s);
3423
            break;
3424
        case CODEC_ID_H263:
3425
        case CODEC_ID_H263P:
3426
        case CODEC_ID_FLV1:
3427
            ff_clean_h263_qscales(s);
3428
            break;
3429
        }
3430
#endif
3431

    
3432
        s->qscale= s->current_picture.qscale_table[0];
3433
    }else
3434
        s->qscale= (int)(s->frame_qscale + 0.5);
3435
        
3436
    if (s->out_format == FMT_MJPEG) {
3437
        /* for mjpeg, we do include qscale in the matrix */
3438
        s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
3439
        for(i=1;i<64;i++){
3440
            int j= s->dsp.idct_permutation[i];
3441

    
3442
            s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3443
        }
3444
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, 
3445
                       s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
3446
    }
3447
    
3448
    //FIXME var duplication
3449
    s->current_picture.key_frame= s->pict_type == I_TYPE;
3450
    s->current_picture.pict_type= s->pict_type;
3451

    
3452
    if(s->current_picture.key_frame)
3453
        s->picture_in_gop_number=0;
3454

    
3455
    s->last_bits= get_bit_count(&s->pb);
3456
    switch(s->out_format) {
3457
    case FMT_MJPEG:
3458
        mjpeg_picture_header(s);
3459
        break;
3460
#ifdef CONFIG_RISKY
3461
    case FMT_H263:
3462
        if (s->codec_id == CODEC_ID_WMV2) 
3463
            ff_wmv2_encode_picture_header(s, picture_number);
3464
        else if (s->h263_msmpeg4) 
3465
            msmpeg4_encode_picture_header(s, picture_number);
3466
        else if (s->h263_pred)
3467
            mpeg4_encode_picture_header(s, picture_number);
3468
        else if (s->h263_rv10) 
3469
            rv10_encode_picture_header(s, picture_number);
3470
        else if (s->codec_id == CODEC_ID_FLV1)
3471
            ff_flv_encode_picture_header(s, picture_number);
3472
        else
3473
            h263_encode_picture_header(s, picture_number);
3474
        break;
3475
#endif
3476
    case FMT_MPEG1:
3477
        mpeg1_encode_picture_header(s, picture_number);
3478
        break;
3479
    }
3480
    bits= get_bit_count(&s->pb);
3481
    s->header_bits= bits - s->last_bits;
3482
    s->last_bits= bits;
3483
    s->mv_bits=0;
3484
    s->misc_bits=0;
3485
    s->i_tex_bits=0;
3486
    s->p_tex_bits=0;
3487
    s->i_count=0;
3488
    s->f_count=0;
3489
    s->b_count=0;
3490
    s->skip_count=0;
3491

    
3492
    for(i=0; i<3; i++){
3493
        /* init last dc values */
3494
        /* note: quant matrix value (8) is implied here */
3495
        s->last_dc[i] = 128;
3496
        
3497
        s->current_picture_ptr->error[i] = 0;
3498
    }
3499
    s->mb_skip_run = 0;
3500
    s->last_mv[0][0][0] = 0;
3501
    s->last_mv[0][0][1] = 0;
3502
    s->last_mv[1][0][0] = 0;
3503
    s->last_mv[1][0][1] = 0;
3504
     
3505
    s->last_mv_dir = 0;
3506

    
3507
#ifdef CONFIG_RISKY
3508
    switch(s->codec_id){
3509
    case CODEC_ID_H263:
3510
    case CODEC_ID_H263P:
3511
    case CODEC_ID_FLV1:
3512
        s->gob_index = ff_h263_get_gob_height(s);
3513
        break;
3514
    case CODEC_ID_MPEG4:
3515
        if(s->partitioned_frame)
3516
            ff_mpeg4_init_partitions(s);
3517
        break;
3518
    }
3519
#endif
3520

    
3521
    s->resync_mb_x=0;
3522
    s->resync_mb_y=0;
3523
    s->first_slice_line = 1;
3524
    s->ptr_lastgob = s->pb.buf;
3525
    for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3526
        s->mb_x=0;
3527
        s->mb_y= mb_y;
3528

    
3529
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
3530
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
3531
        ff_init_block_index(s);
3532
        
3533
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3534
            const int xy= mb_y*s->mb_stride + mb_x;
3535
            int mb_type= s->mb_type[xy];
3536
//            int d;
3537
            int dmin= INT_MAX;
3538

    
3539
            s->mb_x = mb_x;
3540
            ff_update_block_index(s);
3541

    
3542
            /* write gob / video packet header  */
3543
#ifdef CONFIG_RISKY
3544
            if(s->rtp_mode){
3545
                int current_packet_size, is_gob_start;
3546
                
3547
                current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
3548
                is_gob_start=0;
3549
                
3550
                if(s->codec_id==CODEC_ID_MPEG4){
3551
                    if(current_packet_size >= s->rtp_payload_size
3552
                       && s->mb_y + s->mb_x>0){
3553

    
3554
                        if(s->partitioned_frame){
3555
                            ff_mpeg4_merge_partitions(s);
3556
                            ff_mpeg4_init_partitions(s);
3557
                        }
3558
                        ff_mpeg4_encode_video_packet_header(s);
3559

    
3560
                        if(s->flags&CODEC_FLAG_PASS1){
3561
                            int bits= get_bit_count(&s->pb);
3562
                            s->misc_bits+= bits - s->last_bits;
3563
                            s->last_bits= bits;
3564
                        }
3565
                        ff_mpeg4_clean_buffers(s);
3566
                        is_gob_start=1;
3567
                    }
3568
                }else if(s->codec_id==CODEC_ID_MPEG1VIDEO){
3569
                    if(   current_packet_size >= s->rtp_payload_size 
3570
                       && s->mb_y + s->mb_x>0 && s->mb_skip_run==0){
3571
                        ff_mpeg1_encode_slice_header(s);
3572
                        ff_mpeg1_clean_buffers(s);
3573
                        is_gob_start=1;
3574
                    }
3575
                }else{
3576
                    if(current_packet_size >= s->rtp_payload_size
3577
                       && s->mb_x==0 && s->mb_y>0 && s->mb_y%s->gob_index==0){
3578
                       
3579
                        h263_encode_gob_header(s, mb_y);                       
3580
                        is_gob_start=1;
3581
                    }
3582
                }
3583

    
3584
                if(is_gob_start){
3585
                    s->ptr_lastgob = pbBufPtr(&s->pb);
3586
                    s->first_slice_line=1;
3587
                    s->resync_mb_x=mb_x;
3588
                    s->resync_mb_y=mb_y;
3589
                }
3590
            }
3591
#endif
3592

    
3593
            if(  (s->resync_mb_x   == s->mb_x)
3594
               && s->resync_mb_y+1 == s->mb_y){
3595
                s->first_slice_line=0; 
3596
            }
3597

    
3598
            s->mb_skiped=0;
3599

    
3600
            if(mb_type & (mb_type-1)){ // more than 1 MB type possible
3601
                int next_block=0;
3602
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3603

    
3604
                copy_context_before_encode(&backup_s, s, -1);
3605
                backup_s.pb= s->pb;
3606
                best_s.data_partitioning= s->data_partitioning;
3607
                best_s.partitioned_frame= s->partitioned_frame;
3608
                if(s->data_partitioning){
3609
                    backup_s.pb2= s->pb2;
3610
                    backup_s.tex_pb= s->tex_pb;
3611
                }
3612

    
3613
                if(mb_type&MB_TYPE_INTER){
3614
                    s->mv_dir = MV_DIR_FORWARD;
3615
                    s->mv_type = MV_TYPE_16X16;
3616
                    s->mb_intra= 0;
3617
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
3618
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
3619
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb, 
3620
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3621
                }
3622
                if(mb_type&MB_TYPE_INTER4V){                 
3623
                    s->mv_dir = MV_DIR_FORWARD;
3624
                    s->mv_type = MV_TYPE_8X8;
3625
                    s->mb_intra= 0;
3626
                    for(i=0; i<4; i++){
3627
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3628
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3629
                    }
3630
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb, 
3631
                                 &dmin, &next_block, 0, 0);
3632
                }
3633
                if(mb_type&MB_TYPE_FORWARD){
3634
                    s->mv_dir = MV_DIR_FORWARD;
3635
                    s->mv_type = MV_TYPE_16X16;
3636
                    s->mb_intra= 0;
3637
                    s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3638
                    s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3639
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb, 
3640
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3641
                }
3642
                if(mb_type&MB_TYPE_BACKWARD){
3643
                    s->mv_dir = MV_DIR_BACKWARD;
3644
                    s->mv_type = MV_TYPE_16X16;
3645
                    s->mb_intra= 0;
3646
                    s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3647
                    s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3648
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb, 
3649
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3650
                }
3651
                if(mb_type&MB_TYPE_BIDIR){
3652
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3653
                    s->mv_type = MV_TYPE_16X16;
3654
                    s->mb_intra= 0;
3655
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3656
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3657
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3658
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3659
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb, 
3660
                                 &dmin, &next_block, 0, 0);
3661
                }
3662
                if(mb_type&MB_TYPE_DIRECT){
3663
                    int mx= s->b_direct_mv_table[xy][0];
3664
                    int my= s->b_direct_mv_table[xy][1];
3665
                    
3666
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3667
                    s->mb_intra= 0;
3668
#ifdef CONFIG_RISKY
3669
                    ff_mpeg4_set_direct_mv(s, mx, my);
3670
#endif
3671
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb, 
3672
                                 &dmin, &next_block, mx, my);
3673
                }
3674
                if(mb_type&MB_TYPE_INTRA){
3675
                    s->mv_dir = 0;
3676
                    s->mv_type = MV_TYPE_16X16;
3677
                    s->mb_intra= 1;
3678
                    s->mv[0][0][0] = 0;
3679
                    s->mv[0][0][1] = 0;
3680
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb, 
3681
                                 &dmin, &next_block, 0, 0);
3682
                    if(s->h263_pred || s->h263_aic){
3683
                        if(best_s.mb_intra)
3684
                            s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
3685
                        else
3686
                            ff_clean_intra_table_entries(s); //old mode?
3687
                    }
3688
                }
3689
                copy_context_after_encode(s, &best_s, -1);
3690
                
3691
                pb_bits_count= get_bit_count(&s->pb);
3692
                flush_put_bits(&s->pb);
3693
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3694
                s->pb= backup_s.pb;
3695
                
3696
                if(s->data_partitioning){
3697
                    pb2_bits_count= get_bit_count(&s->pb2);
3698
                    flush_put_bits(&s->pb2);
3699
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3700
                    s->pb2= backup_s.pb2;
3701
                    
3702
                    tex_pb_bits_count= get_bit_count(&s->tex_pb);
3703
                    flush_put_bits(&s->tex_pb);
3704
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3705
                    s->tex_pb= backup_s.tex_pb;
3706
                }
3707
                s->last_bits= get_bit_count(&s->pb);
3708
                
3709
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
3710
                    ff_h263_update_motion_val(s);
3711
        
3712
                if(next_block==0){
3713
                    s->dsp.put_pixels_tab[0][0](s->dest[0], s->me.scratchpad     , s->linesize  ,16);
3714
                    s->dsp.put_pixels_tab[1][0](s->dest[1], s->me.scratchpad + 16, s->uvlinesize, 8);
3715
                    s->dsp.put_pixels_tab[1][0](s->dest[2], s->me.scratchpad + 24, s->uvlinesize, 8);
3716
                }
3717

    
3718
                if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
3719
                    MPV_decode_mb(s, s->block);
3720
            } else {
3721
                int motion_x, motion_y;
3722
                int intra_score;
3723
                int inter_score= s->current_picture.mb_cmp_score[mb_x + mb_y*s->mb_stride];
3724
                
3725
              if(s->avctx->mb_decision==FF_MB_DECISION_SIMPLE && s->pict_type==P_TYPE){ //FIXME check if the mess is usefull at all
3726
                /* get luma score */
3727
                if((s->avctx->mb_cmp&0xFF)==FF_CMP_SSE){
3728
                    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
3729
                }else{
3730
                    uint8_t *dest_y;
3731

    
3732
                    int mean= s->current_picture.mb_mean[mb_x + mb_y*s->mb_stride]; //FIXME
3733
                    mean*= 0x01010101;
3734
                    
3735
                    dest_y  = s->new_picture.data[0] + (mb_y * 16 * s->linesize    ) + mb_x * 16;
3736
                
3737
                    for(i=0; i<16; i++){
3738
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 0]) = mean;
3739
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 4]) = mean;
3740
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 8]) = mean;
3741
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+12]) = mean;
3742
                    }
3743

    
3744
                    s->mb_intra=1;
3745
                    intra_score= s->dsp.mb_cmp[0](s, s->me.scratchpad, dest_y, s->linesize);
3746
                                        
3747
/*                    printf("intra:%7d inter:%7d var:%7d mc_var.%7d\n", intra_score>>8, inter_score>>8, 
3748
                        s->current_picture.mb_var[mb_x + mb_y*s->mb_stride],
3749
                        s->current_picture.mc_mb_var[mb_x + mb_y*s->mb_stride]);*/
3750
                }
3751
                
3752
                /* get chroma score */
3753
                if(s->avctx->mb_cmp&FF_CMP_CHROMA){
3754
                    int i;
3755
                    
3756
                    s->mb_intra=1;
3757
                    for(i=1; i<3; i++){
3758
                        uint8_t *dest_c;
3759
                        int mean;
3760
                        
3761
                        if(s->out_format == FMT_H263){
3762
                            mean= (s->dc_val[i][mb_x + (mb_y+1)*(s->mb_width+2)] + 4)>>3; //FIXME not exact but simple ;)
3763
                        }else{
3764
                            mean= (s->last_dc[i] + 4)>>3;
3765
                        }
3766
                        dest_c = s->new_picture.data[i] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
3767
                        
3768
                        mean*= 0x01010101;
3769
                        for(i=0; i<8; i++){
3770
                            *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 0]) = mean;
3771
                            *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 4]) = mean;
3772
                        }
3773
                        
3774
                        intra_score+= s->dsp.mb_cmp[1](s, s->me.scratchpad, dest_c, s->uvlinesize);
3775
                    }                
3776
                }
3777

    
3778
                /* bias */
3779
                switch(s->avctx->mb_cmp&0xFF){
3780
                default:
3781
                case FF_CMP_SAD:
3782
                    intra_score+= 32*s->qscale;
3783
                    break;
3784
                case FF_CMP_SSE:
3785
                    intra_score+= 24*s->qscale*s->qscale;
3786
                    break;
3787
                case FF_CMP_SATD:
3788
                    intra_score+= 96*s->qscale;
3789
                    break;
3790
                case FF_CMP_DCT:
3791
                    intra_score+= 48*s->qscale;
3792
                    break;
3793
                case FF_CMP_BIT:
3794
                    intra_score+= 16;
3795
                    break;
3796
                case FF_CMP_PSNR:
3797
                case FF_CMP_RD:
3798
                    intra_score+= (s->qscale*s->qscale*109*8 + 64)>>7;
3799
                    break;
3800
                }
3801

    
3802
                if(intra_score < inter_score)
3803
                    mb_type= MB_TYPE_INTRA;
3804
              }  
3805
                
3806
                s->mv_type=MV_TYPE_16X16;
3807
                // only one MB-Type possible
3808
                
3809
                switch(mb_type){
3810
                case MB_TYPE_INTRA:
3811
                    s->mv_dir = 0;
3812
                    s->mb_intra= 1;
3813
                    motion_x= s->mv[0][0][0] = 0;
3814
                    motion_y= s->mv[0][0][1] = 0;
3815
                    break;
3816
                case MB_TYPE_INTER:
3817
                    s->mv_dir = MV_DIR_FORWARD;
3818
                    s->mb_intra= 0;
3819
                    motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3820
                    motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3821
                    break;
3822
                case MB_TYPE_INTER4V:
3823
                    s->mv_dir = MV_DIR_FORWARD;
3824
                    s->mv_type = MV_TYPE_8X8;
3825
                    s->mb_intra= 0;
3826
                    for(i=0; i<4; i++){
3827
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3828
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3829
                    }
3830
                    motion_x= motion_y= 0;
3831
                    break;
3832
                case MB_TYPE_DIRECT:
3833
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3834
                    s->mb_intra= 0;
3835
                    motion_x=s->b_direct_mv_table[xy][0];
3836
                    motion_y=s->b_direct_mv_table[xy][1];
3837
#ifdef CONFIG_RISKY
3838
                    ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3839
#endif
3840
                    break;
3841
                case MB_TYPE_BIDIR:
3842
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3843
                    s->mb_intra= 0;
3844
                    motion_x=0;
3845
                    motion_y=0;
3846
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3847
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3848
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3849
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3850
                    break;
3851
                case MB_TYPE_BACKWARD:
3852
                    s->mv_dir = MV_DIR_BACKWARD;
3853
                    s->mb_intra= 0;
3854
                    motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3855
                    motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3856
                    break;
3857
                case MB_TYPE_FORWARD:
3858
                    s->mv_dir = MV_DIR_FORWARD;
3859
                    s->mb_intra= 0;
3860
                    motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3861
                    motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3862
//                    printf(" %d %d ", motion_x, motion_y);
3863
                    break;
3864
                default:
3865
                    motion_x=motion_y=0; //gcc warning fix
3866
                    printf("illegal MB type\n");
3867
                }
3868

    
3869
                encode_mb(s, motion_x, motion_y);
3870

    
3871
                // RAL: Update last macrobloc type
3872
                s->last_mv_dir = s->mv_dir;
3873
            
3874
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
3875
                    ff_h263_update_motion_val(s);
3876

    
3877
                MPV_decode_mb(s, s->block);
3878
            }
3879

    
3880
            /* clean the MV table in IPS frames for direct mode in B frames */
3881
            if(s->mb_intra /* && I,P,S_TYPE */){
3882
                s->p_mv_table[xy][0]=0;
3883
                s->p_mv_table[xy][1]=0;
3884
            }
3885
            
3886
            if(s->flags&CODEC_FLAG_PSNR){
3887
                int w= 16;
3888
                int h= 16;
3889

    
3890
                if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3891
                if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3892

    
3893
                s->current_picture_ptr->error[0] += sse(
3894
                    s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3895
                    s->dest[0], w, h, s->linesize);
3896
                s->current_picture_ptr->error[1] += sse(
3897
                    s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3898
                    s->dest[1], w>>1, h>>1, s->uvlinesize);
3899
                s->current_picture_ptr->error[2] += sse(
3900
                    s, s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3901
                    s->dest[2], w>>1, h>>1, s->uvlinesize);
3902
            }
3903
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, get_bit_count(&s->pb));
3904
        }
3905
    }
3906
    emms_c();
3907

    
3908
#ifdef CONFIG_RISKY
3909
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3910
        ff_mpeg4_merge_partitions(s);
3911

    
3912
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
3913
        msmpeg4_encode_ext_header(s);
3914

    
3915
    if(s->codec_id==CODEC_ID_MPEG4) 
3916
        ff_mpeg4_stuffing(&s->pb);
3917
#endif
3918

    
3919
    //if (s->gob_number)
3920
    //    fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
3921
    
3922
    /* Send the last GOB if RTP */    
3923
    if (s->rtp_mode) {
3924
        flush_put_bits(&s->pb);
3925
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
3926
        /* Call the RTP callback to send the last GOB */
3927
        if (s->rtp_callback)
3928
            s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
3929
        s->ptr_lastgob = pbBufPtr(&s->pb);
3930
        //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
3931
    }
3932
}
3933

    
3934
static int dct_quantize_trellis_c(MpegEncContext *s, 
3935
                        DCTELEM *block, int n,
3936
                        int qscale, int *overflow){
3937
    const int *qmat;
3938
    const uint8_t *scantable= s->intra_scantable.scantable;
3939
    int max=0;
3940
    unsigned int threshold1, threshold2;
3941
    int bias=0;
3942
    int run_tab[65];
3943
    int level_tab[65];
3944
    int score_tab[65];
3945
    int last_run=0;
3946
    int last_level=0;
3947
    int last_score= 0;
3948
    int last_i= 0;
3949
    int coeff[3][64];
3950
    int coeff_count[64];
3951
    int lambda, qmul, qadd, start_i, last_non_zero, i;
3952
    const int esc_length= s->ac_esc_length;
3953
    uint8_t * length;
3954
    uint8_t * last_length;
3955
    int score_limit=0;
3956
    int left_limit= 0;
3957
        
3958
    s->dsp.fdct (block);
3959

    
3960
    qmul= qscale*16;
3961
    qadd= ((qscale-1)|1)*8;
3962

    
3963
    if (s->mb_intra) {
3964
        int q;
3965
        if (!s->h263_aic) {
3966
            if (n < 4)
3967
                q = s->y_dc_scale;
3968
            else
3969
                q = s->c_dc_scale;
3970
            q = q << 3;
3971
        } else{
3972
            /* For AIC we skip quant/dequant of INTRADC */
3973
            q = 1 << 3;
3974
            qadd=0;
3975
        }
3976
            
3977
        /* note: block[0] is assumed to be positive */
3978
        block[0] = (block[0] + (q >> 1)) / q;
3979
        start_i = 1;
3980
        last_non_zero = 0;
3981
        qmat = s->q_intra_matrix[qscale];
3982
        if(s->mpeg_quant || s->codec_id== CODEC_ID_MPEG1VIDEO)
3983
            bias= 1<<(QMAT_SHIFT-1);
3984
        length     = s->intra_ac_vlc_length;
3985
        last_length= s->intra_ac_vlc_last_length;
3986
    } else {
3987
        start_i = 0;
3988
        last_non_zero = -1;
3989
        qmat = s->q_inter_matrix[qscale];
3990
        length     = s->inter_ac_vlc_length;
3991
        last_length= s->inter_ac_vlc_last_length;
3992
    }
3993

    
3994
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
3995
    threshold2= (threshold1<<1);
3996

    
3997
    for(i=start_i; i<64; i++) {
3998
        const int j = scantable[i];
3999
        const int k= i-start_i;
4000
        int level = block[j];
4001
        level = level * qmat[j];
4002

    
4003
//        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
4004
//           || bias-level >= (1<<(QMAT_SHIFT - 3))){
4005
        if(((unsigned)(level+threshold1))>threshold2){
4006
            if(level>0){
4007
                level= (bias + level)>>QMAT_SHIFT;
4008
                coeff[0][k]= level;
4009
                coeff[1][k]= level-1;
4010
//                coeff[2][k]= level-2;
4011
            }else{
4012
                level= (bias - level)>>QMAT_SHIFT;
4013
                coeff[0][k]= -level;
4014
                coeff[1][k]= -level+1;
4015
//                coeff[2][k]= -level+2;
4016
            }
4017
            coeff_count[k]= FFMIN(level, 2);
4018
            max |=level;
4019
            last_non_zero = i;
4020
        }else{
4021
            coeff[0][k]= (level>>31)|1;
4022
            coeff_count[k]= 1;
4023
        }
4024
    }
4025
    
4026
    *overflow= s->max_qcoeff < max; //overflow might have happend
4027
    
4028
    if(last_non_zero < start_i){
4029
        memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
4030
        return last_non_zero;
4031
    }
4032

    
4033
    lambda= (qscale*qscale*64*105 + 64)>>7; //FIXME finetune
4034
        
4035
    score_tab[0]= 0;
4036
    for(i=0; i<=last_non_zero - start_i; i++){
4037
        int level_index, run, j;
4038
        const int dct_coeff= block[ scantable[i + start_i] ];
4039
        const int zero_distoration= dct_coeff*dct_coeff;
4040
        int best_score=256*256*256*120;
4041

    
4042
        last_score += zero_distoration;
4043
        for(level_index=0; level_index < coeff_count[i]; level_index++){
4044
            int distoration;
4045
            int level= coeff[level_index][i];
4046
            int unquant_coeff;
4047
            
4048
            assert(level);
4049

    
4050
            if(s->out_format == FMT_H263){
4051
                if(level>0){
4052
                    unquant_coeff= level*qmul + qadd;
4053
                }else{
4054
                    unquant_coeff= level*qmul - qadd;
4055
                }
4056
            }else{ //MPEG1
4057
                j= s->dsp.idct_permutation[ scantable[i + start_i] ]; //FIXME optimize
4058
                if(s->mb_intra){
4059
                    if (level < 0) {
4060
                        unquant_coeff = (int)((-level) * qscale * s->intra_matrix[j]) >> 3;
4061
                        unquant_coeff = -((unquant_coeff - 1) | 1);
4062
                    } else {
4063
                        unquant_coeff = (int)(  level  * qscale * s->intra_matrix[j]) >> 3;
4064
                        unquant_coeff =   (unquant_coeff - 1) | 1;
4065
                    }
4066
                }else{
4067
                    if (level < 0) {
4068
                        unquant_coeff = ((((-level) << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
4069
                        unquant_coeff = -((unquant_coeff - 1) | 1);
4070
                    } else {
4071
                        unquant_coeff = (((  level  << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
4072
                        unquant_coeff =   (unquant_coeff - 1) | 1;
4073
                    }
4074
                }
4075
                unquant_coeff<<= 3;
4076
            }
4077

    
4078
            distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff);
4079
            level+=64;
4080
            if((level&(~127)) == 0){
4081
                for(run=0; run<=i - left_limit; run++){
4082
                    int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4083
                    score += score_tab[i-run];
4084
                    
4085
                    if(score < best_score){
4086
                        best_score= 
4087
                        score_tab[i+1]= score;
4088
                        run_tab[i+1]= run;
4089
                        level_tab[i+1]= level-64;
4090
                    }
4091
                }
4092

    
4093
                if(s->out_format == FMT_H263){
4094
                    for(run=0; run<=i - left_limit; run++){
4095
                        int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4096
                        score += score_tab[i-run];
4097
                        if(score < last_score){
4098
                            last_score= score;
4099
                            last_run= run;
4100
                            last_level= level-64;
4101
                            last_i= i+1;
4102
                        }
4103
                    }
4104
                }
4105
            }else{
4106
                distoration += esc_length*lambda;
4107
                for(run=0; run<=i - left_limit; run++){
4108
                    int score= distoration + score_tab[i-run];
4109
                    
4110
                    if(score < best_score){
4111
                        best_score= 
4112
                        score_tab[i+1]= score;
4113
                        run_tab[i+1]= run;
4114
                        level_tab[i+1]= level-64;
4115
                    }
4116
                }
4117

    
4118
                if(s->out_format == FMT_H263){
4119
                    for(run=0; run<=i - left_limit; run++){
4120
                        int score= distoration + score_tab[i-run];
4121
                        if(score < last_score){
4122
                            last_score= score;
4123
                            last_run= run;
4124
                            last_level= level-64;
4125
                            last_i= i+1;
4126
                        }
4127
                    }
4128
                }
4129
            }
4130
        }
4131

    
4132
        for(j=left_limit; j<=i; j++){
4133
            score_tab[j] += zero_distoration;
4134
        }
4135
        score_limit+= zero_distoration;
4136
        if(score_tab[i+1] < score_limit)
4137
            score_limit= score_tab[i+1];
4138
        
4139
        //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
4140
        while(score_tab[ left_limit ] > score_limit + lambda) left_limit++;
4141
    }
4142

    
4143
        //FIXME add some cbp penalty
4144

    
4145
    if(s->out_format != FMT_H263){
4146
        last_score= 256*256*256*120;
4147
        for(i= left_limit; i<=last_non_zero - start_i + 1; i++){
4148
            int score= score_tab[i];
4149
            if(i) score += lambda*2; //FIXME exacter?
4150

    
4151
            if(score < last_score){
4152
                last_score= score;
4153
                last_i= i;
4154
                last_level= level_tab[i];
4155
                last_run= run_tab[i];
4156
            }
4157
        }
4158
    }
4159
    
4160
    last_non_zero= last_i - 1 + start_i;
4161
    memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
4162
    
4163
    if(last_non_zero < start_i)
4164
        return last_non_zero;
4165
    
4166
    i= last_i;
4167
    assert(last_level);
4168
//FIXME use permutated scantable
4169
    block[ s->dsp.idct_permutation[ scantable[last_non_zero] ] ]= last_level;
4170
    i -= last_run + 1;
4171
    
4172
    for(;i>0 ; i -= run_tab[i] + 1){
4173
        const int j= s->dsp.idct_permutation[ scantable[i - 1 + start_i] ];
4174
    
4175
        block[j]= level_tab[i];
4176
        assert(block[j]);
4177
    }
4178

    
4179
    return last_non_zero;
4180
}
4181

    
4182
static int dct_quantize_c(MpegEncContext *s, 
4183
                        DCTELEM *block, int n,
4184
                        int qscale, int *overflow)
4185
{
4186
    int i, j, level, last_non_zero, q;
4187
    const int *qmat;
4188
    const uint8_t *scantable= s->intra_scantable.scantable;
4189
    int bias;
4190
    int max=0;
4191
    unsigned int threshold1, threshold2;
4192

    
4193
    s->dsp.fdct (block);
4194

    
4195
    if (s->mb_intra) {
4196
        if (!s->h263_aic) {
4197
            if (n < 4)
4198
                q = s->y_dc_scale;
4199
            else
4200
                q = s->c_dc_scale;
4201
            q = q << 3;
4202
        } else
4203
            /* For AIC we skip quant/dequant of INTRADC */
4204
            q = 1 << 3;
4205
            
4206
        /* note: block[0] is assumed to be positive */
4207
        block[0] = (block[0] + (q >> 1)) / q;
4208
        i = 1;
4209
        last_non_zero = 0;
4210
        qmat = s->q_intra_matrix[qscale];
4211
        bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4212
    } else {
4213
        i = 0;
4214
        last_non_zero = -1;
4215
        qmat = s->q_inter_matrix[qscale];
4216
        bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4217
    }
4218
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
4219
    threshold2= (threshold1<<1);
4220

    
4221
    for(;i<64;i++) {
4222
        j = scantable[i];
4223
        level = block[j];
4224
        level = level * qmat[j];
4225

    
4226
//        if(   bias+level >= (1<<QMAT_SHIFT)
4227
//           || bias-level >= (1<<QMAT_SHIFT)){
4228
        if(((unsigned)(level+threshold1))>threshold2){
4229
            if(level>0){
4230
                level= (bias + level)>>QMAT_SHIFT;
4231
                block[j]= level;
4232
            }else{
4233
                level= (bias - level)>>QMAT_SHIFT;
4234
                block[j]= -level;
4235
            }
4236
            max |=level;
4237
            last_non_zero = i;
4238
        }else{
4239
            block[j]=0;
4240
        }
4241
    }
4242
    *overflow= s->max_qcoeff < max; //overflow might have happend
4243
    
4244
    /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4245
    if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
4246
        ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4247

    
4248
    return last_non_zero;
4249
}
4250

    
4251
#endif //CONFIG_ENCODERS
4252

    
4253
static void dct_unquantize_mpeg1_c(MpegEncContext *s, 
4254
                                   DCTELEM *block, int n, int qscale)
4255
{
4256
    int i, level, nCoeffs;
4257
    const uint16_t *quant_matrix;
4258

    
4259
    nCoeffs= s->block_last_index[n];
4260
    
4261
    if (s->mb_intra) {
4262
        if (n < 4) 
4263
            block[0] = block[0] * s->y_dc_scale;
4264
        else
4265
            block[0] = block[0] * s->c_dc_scale;
4266
        /* XXX: only mpeg1 */
4267
        quant_matrix = s->intra_matrix;
4268
        for(i=1;i<=nCoeffs;i++) {
4269
            int j= s->intra_scantable.permutated[i];
4270
            level = block[j];
4271
            if (level) {
4272
                if (level < 0) {
4273
                    level = -level;
4274
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
4275
                    level = (level - 1) | 1;
4276
                    level = -level;
4277
                } else {
4278
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
4279
                    level = (level - 1) | 1;
4280
                }
4281
#ifdef PARANOID
4282
                if (level < -2048 || level > 2047)
4283
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4284
#endif
4285
                block[j] = level;
4286
            }
4287
        }
4288
    } else {
4289
        i = 0;
4290
        quant_matrix = s->inter_matrix;
4291
        for(;i<=nCoeffs;i++) {
4292
            int j= s->intra_scantable.permutated[i];
4293
            level = block[j];
4294
            if (level) {
4295
                if (level < 0) {
4296
                    level = -level;
4297
                    level = (((level << 1) + 1) * qscale *
4298
                             ((int) (quant_matrix[j]))) >> 4;
4299
                    level = (level - 1) | 1;
4300
                    level = -level;
4301
                } else {
4302
                    level = (((level << 1) + 1) * qscale *
4303
                             ((int) (quant_matrix[j]))) >> 4;
4304
                    level = (level - 1) | 1;
4305
                }
4306
#ifdef PARANOID
4307
                if (level < -2048 || level > 2047)
4308
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4309
#endif
4310
                block[j] = level;
4311
            }
4312
        }
4313
    }
4314
}
4315

    
4316
static void dct_unquantize_mpeg2_c(MpegEncContext *s, 
4317
                                   DCTELEM *block, int n, int qscale)
4318
{
4319
    int i, level, nCoeffs;
4320
    const uint16_t *quant_matrix;
4321

    
4322
    if(s->alternate_scan) nCoeffs= 63;
4323
    else nCoeffs= s->block_last_index[n];
4324
    
4325
    if (s->mb_intra) {
4326
        if (n < 4) 
4327
            block[0] = block[0] * s->y_dc_scale;
4328
        else
4329
            block[0] = block[0] * s->c_dc_scale;
4330
        quant_matrix = s->intra_matrix;
4331
        for(i=1;i<=nCoeffs;i++) {
4332
            int j= s->intra_scantable.permutated[i];
4333
            level = block[j];
4334
            if (level) {
4335
                if (level < 0) {
4336
                    level = -level;
4337
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
4338
                    level = -level;
4339
                } else {
4340
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
4341
                }
4342
#ifdef PARANOID
4343
                if (level < -2048 || level > 2047)
4344
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4345
#endif
4346
                block[j] = level;
4347
            }
4348
        }
4349
    } else {
4350
        int sum=-1;
4351
        i = 0;
4352
        quant_matrix = s->inter_matrix;
4353
        for(;i<=nCoeffs;i++) {
4354
            int j= s->intra_scantable.permutated[i];
4355
            level = block[j];
4356
            if (level) {
4357
                if (level < 0) {
4358
                    level = -level;
4359
                    level = (((level << 1) + 1) * qscale *
4360
                             ((int) (quant_matrix[j]))) >> 4;
4361
                    level = -level;
4362
                } else {
4363
                    level = (((level << 1) + 1) * qscale *
4364
                             ((int) (quant_matrix[j]))) >> 4;
4365
                }
4366
#ifdef PARANOID
4367
                if (level < -2048 || level > 2047)
4368
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4369
#endif
4370
                block[j] = level;
4371
                sum+=level;
4372
            }
4373
        }
4374
        block[63]^=sum&1;
4375
    }
4376
}
4377

    
4378

    
4379
static void dct_unquantize_h263_c(MpegEncContext *s, 
4380
                                  DCTELEM *block, int n, int qscale)
4381
{
4382
    int i, level, qmul, qadd;
4383
    int nCoeffs;
4384
    
4385
    assert(s->block_last_index[n]>=0);
4386
    
4387
    qadd = (qscale - 1) | 1;
4388
    qmul = qscale << 1;
4389
    
4390
    if (s->mb_intra) {
4391
        if (!s->h263_aic) {
4392
            if (n < 4) 
4393
                block[0] = block[0] * s->y_dc_scale;
4394
            else
4395
                block[0] = block[0] * s->c_dc_scale;
4396
        }else
4397
            qadd = 0;
4398
        i = 1;
4399
        nCoeffs= 63; //does not allways use zigzag table 
4400
    } else {
4401
        i = 0;
4402
        nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
4403
    }
4404

    
4405
    for(;i<=nCoeffs;i++) {
4406
        level = block[i];
4407
        if (level) {
4408
            if (level < 0) {
4409
                level = level * qmul - qadd;
4410
            } else {
4411
                level = level * qmul + qadd;
4412
            }
4413
#ifdef PARANOID
4414
                if (level < -2048 || level > 2047)
4415
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4416
#endif
4417
            block[i] = level;
4418
        }
4419
    }
4420
}
4421

    
4422

    
4423
static const AVOption mpeg4_options[] =
4424
{
4425
    AVOPTION_CODEC_INT("bitrate", "desired video bitrate", bit_rate, 4, 240000000, 800000),
4426
    AVOPTION_CODEC_INT("ratetol", "number of bits the bitstream is allowed to diverge from the reference"
4427
                       "the reference can be CBR (for CBR pass1) or VBR (for pass2)",
4428
                       bit_rate_tolerance, 4, 240000000, 8000),
4429
    AVOPTION_CODEC_INT("qmin", "minimum quantizer", qmin, 1, 31, 2),
4430
    AVOPTION_CODEC_INT("qmax", "maximum quantizer", qmax, 1, 31, 31),
4431
    AVOPTION_CODEC_STRING("rc_eq", "rate control equation",
4432
                          rc_eq, "tex^qComp,option1,options2", 0),
4433
    AVOPTION_CODEC_INT("rc_minrate", "rate control minimum bitrate",
4434
                       rc_min_rate, 4, 24000000, 0),
4435
    AVOPTION_CODEC_INT("rc_maxrate", "rate control maximum bitrate",
4436
                       rc_max_rate, 4, 24000000, 0),
4437
    AVOPTION_CODEC_DOUBLE("rc_buf_aggresivity", "rate control buffer aggresivity",
4438
                          rc_buffer_aggressivity, 4, 24000000, 0),
4439
    AVOPTION_CODEC_DOUBLE("rc_initial_cplx", "initial complexity for pass1 ratecontrol",
4440
                          rc_initial_cplx, 0., 9999999., 0),
4441
    AVOPTION_CODEC_DOUBLE("i_quant_factor", "qscale factor between p and i frames",
4442
                          i_quant_factor, 0., 0., 0),
4443
    AVOPTION_CODEC_DOUBLE("i_quant_offset", "qscale offset between p and i frames",
4444
                          i_quant_factor, -999999., 999999., 0),
4445
    AVOPTION_CODEC_INT("dct_algo", "dct alghorithm",
4446
                       dct_algo, 0, 5, 0), // fixme - "Auto,FastInt,Int,MMX,MLib,Altivec"
4447
    AVOPTION_CODEC_DOUBLE("lumi_masking", "luminance masking",
4448
                          lumi_masking, 0., 999999., 0),
4449
    AVOPTION_CODEC_DOUBLE("temporal_cplx_masking", "temporary complexity masking",
4450
                          temporal_cplx_masking, 0., 999999., 0),
4451
    AVOPTION_CODEC_DOUBLE("spatial_cplx_masking", "spatial complexity masking",
4452
                          spatial_cplx_masking, 0., 999999., 0),
4453
    AVOPTION_CODEC_DOUBLE("p_masking", "p block masking",
4454
                          p_masking, 0., 999999., 0),
4455
    AVOPTION_CODEC_DOUBLE("dark_masking", "darkness masking",
4456
                          dark_masking, 0., 999999., 0),
4457
    AVOPTION_CODEC_INT("idct_algo", "idct alghorithm",
4458
                       idct_algo, 0, 8, 0), // fixme - "Auto,Int,Simple,SimpleMMX,LibMPEG2MMX,PS2,MLib,ARM,Altivec"
4459

    
4460
    AVOPTION_CODEC_INT("mb_qmin", "minimum MB quantizer",
4461
                       mb_qmin, 0, 8, 0),
4462
    AVOPTION_CODEC_INT("mb_qmax", "maximum MB quantizer",
4463
                       mb_qmin, 0, 8, 0),
4464

    
4465
    AVOPTION_CODEC_INT("me_cmp", "ME compare function",
4466
                       me_cmp, 0, 24000000, 0),
4467
    AVOPTION_CODEC_INT("me_sub_cmp", "subpixel ME compare function",
4468
                       me_sub_cmp, 0, 24000000, 0),
4469

    
4470

    
4471
    AVOPTION_CODEC_INT("dia_size", "ME diamond size & shape",
4472
                       dia_size, 0, 24000000, 0),
4473
    AVOPTION_CODEC_INT("last_predictor_count", "amount of previous MV predictors",
4474
                       last_predictor_count, 0, 24000000, 0),
4475

    
4476
    AVOPTION_CODEC_INT("pre_me", "pre pass for ME",
4477
                       pre_me, 0, 24000000, 0),
4478
    AVOPTION_CODEC_INT("me_pre_cmp", "ME pre pass compare function",
4479
                       me_pre_cmp, 0, 24000000, 0),
4480

    
4481
    AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4482
                       me_range, 0, 24000000, 0),
4483
    AVOPTION_CODEC_INT("pre_dia_size", "ME pre pass diamod size & shape",
4484
                       pre_dia_size, 0, 24000000, 0),
4485
    AVOPTION_CODEC_INT("me_subpel_quality", "subpel ME quality",
4486
                       me_subpel_quality, 0, 24000000, 0),
4487
    AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4488
                       me_range, 0, 24000000, 0),
4489
    AVOPTION_CODEC_FLAG("psnr", "calculate PSNR of compressed frames",
4490
                        flags, CODEC_FLAG_PSNR, 0),
4491
    AVOPTION_CODEC_RCOVERRIDE("rc_override", "ratecontrol override (=startframe,endframe,qscale,quality_factor)",
4492
                              rc_override),
4493
    AVOPTION_SUB(avoptions_common),
4494
    AVOPTION_END()
4495
};
4496

    
4497
#ifdef CONFIG_ENCODERS
4498

    
4499
AVCodec mpeg1video_encoder = {
4500
    "mpeg1video",
4501
    CODEC_TYPE_VIDEO,
4502
    CODEC_ID_MPEG1VIDEO,
4503
    sizeof(MpegEncContext),
4504
    MPV_encode_init,
4505
    MPV_encode_picture,
4506
    MPV_encode_end,
4507
};
4508

    
4509
#ifdef CONFIG_RISKY
4510

    
4511
AVCodec h263_encoder = {
4512
    "h263",
4513
    CODEC_TYPE_VIDEO,
4514
    CODEC_ID_H263,
4515
    sizeof(MpegEncContext),
4516
    MPV_encode_init,
4517
    MPV_encode_picture,
4518
    MPV_encode_end,
4519
};
4520

    
4521
AVCodec h263p_encoder = {
4522
    "h263p",
4523
    CODEC_TYPE_VIDEO,
4524
    CODEC_ID_H263P,
4525
    sizeof(MpegEncContext),
4526
    MPV_encode_init,
4527
    MPV_encode_picture,
4528
    MPV_encode_end,
4529
};
4530

    
4531
AVCodec flv_encoder = {
4532
    "flv",
4533
    CODEC_TYPE_VIDEO,
4534
    CODEC_ID_FLV1,
4535
    sizeof(MpegEncContext),
4536
    MPV_encode_init,
4537
    MPV_encode_picture,
4538
    MPV_encode_end,
4539
};
4540

    
4541
AVCodec rv10_encoder = {
4542
    "rv10",
4543
    CODEC_TYPE_VIDEO,
4544
    CODEC_ID_RV10,
4545
    sizeof(MpegEncContext),
4546
    MPV_encode_init,
4547
    MPV_encode_picture,
4548
    MPV_encode_end,
4549
};
4550

    
4551
AVCodec mpeg4_encoder = {
4552
    "mpeg4",
4553
    CODEC_TYPE_VIDEO,
4554
    CODEC_ID_MPEG4,
4555
    sizeof(MpegEncContext),
4556
    MPV_encode_init,
4557
    MPV_encode_picture,
4558
    MPV_encode_end,
4559
    .options = mpeg4_options,
4560
};
4561

    
4562
AVCodec msmpeg4v1_encoder = {
4563
    "msmpeg4v1",
4564
    CODEC_TYPE_VIDEO,
4565
    CODEC_ID_MSMPEG4V1,
4566
    sizeof(MpegEncContext),
4567
    MPV_encode_init,
4568
    MPV_encode_picture,
4569
    MPV_encode_end,
4570
    .options = mpeg4_options,
4571
};
4572

    
4573
AVCodec msmpeg4v2_encoder = {
4574
    "msmpeg4v2",
4575
    CODEC_TYPE_VIDEO,
4576
    CODEC_ID_MSMPEG4V2,
4577
    sizeof(MpegEncContext),
4578
    MPV_encode_init,
4579
    MPV_encode_picture,
4580
    MPV_encode_end,
4581
    .options = mpeg4_options,
4582
};
4583

    
4584
AVCodec msmpeg4v3_encoder = {
4585
    "msmpeg4",
4586
    CODEC_TYPE_VIDEO,
4587
    CODEC_ID_MSMPEG4V3,
4588
    sizeof(MpegEncContext),
4589
    MPV_encode_init,
4590
    MPV_encode_picture,
4591
    MPV_encode_end,
4592
    .options = mpeg4_options,
4593
};
4594

    
4595
AVCodec wmv1_encoder = {
4596
    "wmv1",
4597
    CODEC_TYPE_VIDEO,
4598
    CODEC_ID_WMV1,
4599
    sizeof(MpegEncContext),
4600
    MPV_encode_init,
4601
    MPV_encode_picture,
4602
    MPV_encode_end,
4603
    .options = mpeg4_options,
4604
};
4605

    
4606
#endif
4607

    
4608
AVCodec mjpeg_encoder = {
4609
    "mjpeg",
4610
    CODEC_TYPE_VIDEO,
4611
    CODEC_ID_MJPEG,
4612
    sizeof(MpegEncContext),
4613
    MPV_encode_init,
4614
    MPV_encode_picture,
4615
    MPV_encode_end,
4616
};
4617

    
4618
#endif //CONFIG_ENCODERS
4619