Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 029911d1

History | View | Annotate | Download (162 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
void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
171
    int i;
172

    
173
    if(matrix){
174
        put_bits(pb, 1, 1);
175
        for(i=0;i<64;i++) {
176
            put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
177
        }
178
    }else
179
        put_bits(pb, 1, 0);
180
}
181

    
182
/* init common dct for both encoder and decoder */
183
int DCT_common_init(MpegEncContext *s)
184
{
185
    s->dct_unquantize_h263 = dct_unquantize_h263_c;
186
    s->dct_unquantize_mpeg1 = dct_unquantize_mpeg1_c;
187
    s->dct_unquantize_mpeg2 = dct_unquantize_mpeg2_c;
188

    
189
#ifdef CONFIG_ENCODERS
190
    s->dct_quantize= dct_quantize_c;
191
#endif
192
        
193
#ifdef HAVE_MMX
194
    MPV_common_init_mmx(s); //FIXME dont pass mpegenccontext to these, rather use dspcontext
195
#endif
196
#ifdef ARCH_ALPHA
197
    MPV_common_init_axp(s);
198
#endif
199
#ifdef HAVE_MLIB
200
    MPV_common_init_mlib(s);
201
#endif
202
#ifdef HAVE_MMI
203
    MPV_common_init_mmi(s);
204
#endif
205
#ifdef ARCH_ARMV4L
206
    MPV_common_init_armv4l(s);
207
#endif
208
#ifdef ARCH_POWERPC
209
    MPV_common_init_ppc(s);
210
#endif
211

    
212
#ifdef CONFIG_ENCODERS
213
    s->fast_dct_quantize= s->dct_quantize;
214

    
215
    if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
216
        s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
217
    }
218

    
219
#endif //CONFIG_ENCODERS
220

    
221
    /* load & permutate scantables
222
       note: only wmv uses differnt ones 
223
    */
224
    ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
225
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
226
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
227
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
228

    
229
    s->picture_structure= PICT_FRAME;
230
    
231
    return 0;
232
}
233

    
234
/**
235
 * allocates a Picture
236
 * The pixels are allocated/set by calling get_buffer() if shared=0
237
 */
238
static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
239
    const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
240
    const int mb_array_size= s->mb_stride*s->mb_height;
241
    int i;
242
    
243
    if(shared){
244
        assert(pic->data[0]);
245
        assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
246
        pic->type= FF_BUFFER_TYPE_SHARED;
247
    }else{
248
        int r;
249
        
250
        assert(!pic->data[0]);
251
        
252
        r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
253
        
254
        if(r<0 || !pic->age || !pic->type || !pic->data[0]){
255
            fprintf(stderr, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
256
            return -1;
257
        }
258

    
259
        if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
260
            fprintf(stderr, "get_buffer() failed (stride changed)\n");
261
            return -1;
262
        }
263

    
264
        if(pic->linesize[1] != pic->linesize[2]){
265
            fprintf(stderr, "get_buffer() failed (uv stride missmatch)\n");
266
            return -1;
267
        }
268

    
269
        s->linesize  = pic->linesize[0];
270
        s->uvlinesize= pic->linesize[1];
271
    }
272
    
273
    if(pic->qscale_table==NULL){
274
        if (s->encoding) {        
275
            CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
276
            CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
277
            CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
278
            CHECKED_ALLOCZ(pic->mb_cmp_score, mb_array_size * sizeof(int32_t))
279
        }
280

    
281
        CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
282
        CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t)+3) //+3 for mpeg2 SIMD >>1
283
        CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num    * sizeof(int))
284
        pic->mb_type= pic->mb_type_base + s->mb_stride+1;
285
        if(s->out_format == FMT_H264){
286
            for(i=0; i<2; i++){
287
                CHECKED_ALLOCZ(pic->motion_val[i], 2 * 16 * s->mb_num * sizeof(uint16_t))
288
                CHECKED_ALLOCZ(pic->ref_index[i] , 4 * s->mb_num * sizeof(uint8_t))
289
            }
290
        }
291
        pic->qstride= s->mb_stride;
292
    }
293

    
294
    //it might be nicer if the application would keep track of these but it would require a API change
295
    memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
296
    s->prev_pict_types[0]= s->pict_type;
297
    if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
298
        pic->age= INT_MAX; // skiped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
299
    
300
    return 0;
301
fail: //for the CHECKED_ALLOCZ macro
302
    return -1;
303
}
304

    
305
/**
306
 * deallocates a picture
307
 */
308
static void free_picture(MpegEncContext *s, Picture *pic){
309
    int i;
310

    
311
    if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
312
        s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
313
    }
314

    
315
    av_freep(&pic->mb_var);
316
    av_freep(&pic->mc_mb_var);
317
    av_freep(&pic->mb_mean);
318
    av_freep(&pic->mb_cmp_score);
319
    av_freep(&pic->mbskip_table);
320
    av_freep(&pic->qscale_table);
321
    av_freep(&pic->mb_type_base);
322
    pic->mb_type= NULL;
323
    for(i=0; i<2; i++){
324
        av_freep(&pic->motion_val[i]);
325
        av_freep(&pic->ref_index[i]);
326
    }
327
    
328
    if(pic->type == FF_BUFFER_TYPE_SHARED){
329
        for(i=0; i<4; i++){
330
            pic->base[i]=
331
            pic->data[i]= NULL;
332
        }
333
        pic->type= 0;        
334
    }
335
}
336

    
337
/* init common structure for both encoder and decoder */
338
int MPV_common_init(MpegEncContext *s)
339
{
340
    int y_size, c_size, yc_size, i, mb_array_size, x, y;
341

    
342
    dsputil_init(&s->dsp, s->avctx);
343
    DCT_common_init(s);
344

    
345
    s->flags= s->avctx->flags;
346

    
347
    s->mb_width  = (s->width  + 15) / 16;
348
    s->mb_height = (s->height + 15) / 16;
349
    s->mb_stride = s->mb_width + 1;
350
    mb_array_size= s->mb_height * s->mb_stride;
351

    
352
    /* set default edge pos, will be overriden in decode_header if needed */
353
    s->h_edge_pos= s->mb_width*16;
354
    s->v_edge_pos= s->mb_height*16;
355

    
356
    s->mb_num = s->mb_width * s->mb_height;
357
    
358
    s->block_wrap[0]=
359
    s->block_wrap[1]=
360
    s->block_wrap[2]=
361
    s->block_wrap[3]= s->mb_width*2 + 2;
362
    s->block_wrap[4]=
363
    s->block_wrap[5]= s->mb_width + 2;
364

    
365
    y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
366
    c_size = (s->mb_width + 2) * (s->mb_height + 2);
367
    yc_size = y_size + 2 * c_size;
368

    
369
    /* convert fourcc to upper case */
370
    s->avctx->codec_tag=   toupper( s->avctx->codec_tag     &0xFF)          
371
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
372
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16) 
373
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
374

    
375
    CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
376
    s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
377

    
378
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
379

    
380
    CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
381
    for(y=0; y<s->mb_height; y++){
382
        for(x=0; x<s->mb_width; x++){
383
            s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
384
        }
385
    }
386
    s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
387
    
388
    if (s->encoding) {
389
        int mv_table_size= s->mb_stride * (s->mb_height+2) + 1;
390

    
391
        /* Allocate MV tables */
392
        CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
393
        CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
394
        CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
395
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
396
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
397
        CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
398
        s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
399
        s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
400
        s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
401
        s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
402
        s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
403
        s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
404

    
405
        //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
406
        CHECKED_ALLOCZ(s->me.scratchpad,  s->width*2*16*3*sizeof(uint8_t)) 
407
        
408
        CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
409
        CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
410

    
411
        if(s->codec_id==CODEC_ID_MPEG4){
412
            CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
413
            CHECKED_ALLOCZ(   s->pb2_buffer, PB_BUFFER_SIZE);
414
        }
415
        
416
        if(s->msmpeg4_version){
417
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
418
        }
419
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
420

    
421
        /* Allocate MB type table */
422
        CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint8_t)) //needed for encoding
423
    }
424
        
425
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
426
    
427
    if (s->out_format == FMT_H263 || s->encoding || 1) {
428
        int size;
429

    
430
        /* MV prediction */
431
        size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
432
        CHECKED_ALLOCZ(s->motion_val, size * 2 * sizeof(int16_t));
433
    }
434

    
435
    if(s->codec_id==CODEC_ID_MPEG4){
436
        /* interlaced direct mode decoding tables */
437
        CHECKED_ALLOCZ(s->field_mv_table, mb_array_size*2*2 * sizeof(int16_t))
438
        CHECKED_ALLOCZ(s->field_select_table, mb_array_size*2* sizeof(int8_t))
439
    }
440
    if (s->out_format == FMT_H263) {
441
        /* ac values */
442
        CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(int16_t) * 16);
443
        s->ac_val[1] = s->ac_val[0] + y_size;
444
        s->ac_val[2] = s->ac_val[1] + c_size;
445
        
446
        /* cbp values */
447
        CHECKED_ALLOCZ(s->coded_block, y_size);
448
        
449
        /* divx501 bitstream reorder buffer */
450
        CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
451

    
452
        /* cbp, ac_pred, pred_dir */
453
        CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
454
        CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
455
    }
456
    
457
    if (s->h263_pred || s->h263_plus || !s->encoding) {
458
        /* dc values */
459
        //MN: we need these for error resilience of intra-frames
460
        CHECKED_ALLOCZ(s->dc_val[0], yc_size * sizeof(int16_t));
461
        s->dc_val[1] = s->dc_val[0] + y_size;
462
        s->dc_val[2] = s->dc_val[1] + c_size;
463
        for(i=0;i<yc_size;i++)
464
            s->dc_val[0][i] = 1024;
465
    }
466

    
467
    /* which mb is a intra block */
468
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
469
    memset(s->mbintra_table, 1, mb_array_size);
470
    
471
    /* default structure is frame */
472
    s->picture_structure = PICT_FRAME;
473
    
474
    /* init macroblock skip table */
475
    CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
476
    //Note the +1 is for a quicker mpeg4 slice_end detection
477
    CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
478
    
479
    s->block= s->blocks[0];
480

    
481
    s->parse_context.state= -1;
482

    
483
    s->context_initialized = 1;
484
    return 0;
485
 fail:
486
    MPV_common_end(s);
487
    return -1;
488
}
489

    
490

    
491
//extern int sads;
492

    
493
/* init common structure for both encoder and decoder */
494
void MPV_common_end(MpegEncContext *s)
495
{
496
    int i;
497

    
498
    av_freep(&s->parse_context.buffer);
499
    s->parse_context.buffer_size=0;
500

    
501
    av_freep(&s->mb_type);
502
    av_freep(&s->p_mv_table_base);
503
    av_freep(&s->b_forw_mv_table_base);
504
    av_freep(&s->b_back_mv_table_base);
505
    av_freep(&s->b_bidir_forw_mv_table_base);
506
    av_freep(&s->b_bidir_back_mv_table_base);
507
    av_freep(&s->b_direct_mv_table_base);
508
    s->p_mv_table= NULL;
509
    s->b_forw_mv_table= NULL;
510
    s->b_back_mv_table= NULL;
511
    s->b_bidir_forw_mv_table= NULL;
512
    s->b_bidir_back_mv_table= NULL;
513
    s->b_direct_mv_table= NULL;
514
    
515
    av_freep(&s->motion_val);
516
    av_freep(&s->dc_val[0]);
517
    av_freep(&s->ac_val[0]);
518
    av_freep(&s->coded_block);
519
    av_freep(&s->mbintra_table);
520
    av_freep(&s->cbp_table);
521
    av_freep(&s->pred_dir_table);
522
    av_freep(&s->me.scratchpad);
523
    av_freep(&s->me.map);
524
    av_freep(&s->me.score_map);
525
    
526
    av_freep(&s->mbskip_table);
527
    av_freep(&s->prev_pict_types);
528
    av_freep(&s->bitstream_buffer);
529
    av_freep(&s->tex_pb_buffer);
530
    av_freep(&s->pb2_buffer);
531
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
532
    av_freep(&s->field_mv_table);
533
    av_freep(&s->field_select_table);
534
    av_freep(&s->avctx->stats_out);
535
    av_freep(&s->ac_stats);
536
    av_freep(&s->error_status_table);
537
    av_freep(&s->mb_index2xy);
538

    
539
    for(i=0; i<MAX_PICTURE_COUNT; i++){
540
        free_picture(s, &s->picture[i]);
541
    }
542
    avcodec_default_free_buffers(s->avctx);
543
    s->context_initialized = 0;
544
}
545

    
546
#ifdef CONFIG_ENCODERS
547

    
548
/* init video encoder */
549
int MPV_encode_init(AVCodecContext *avctx)
550
{
551
    MpegEncContext *s = avctx->priv_data;
552
    int i;
553
    int chroma_h_shift, chroma_v_shift;
554

    
555
    avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME
556

    
557
    s->bit_rate = avctx->bit_rate;
558
    s->bit_rate_tolerance = avctx->bit_rate_tolerance;
559
    s->width = avctx->width;
560
    s->height = avctx->height;
561
    if(avctx->gop_size > 600){
562
        fprintf(stderr, "Warning keyframe interval too large! reducing it ...\n");
563
        avctx->gop_size=600;
564
    }
565
    s->gop_size = avctx->gop_size;
566
    s->rtp_mode = avctx->rtp_mode;
567
    s->rtp_payload_size = avctx->rtp_payload_size;
568
    if (avctx->rtp_callback)
569
        s->rtp_callback = avctx->rtp_callback;
570
    s->max_qdiff= avctx->max_qdiff;
571
    s->qcompress= avctx->qcompress;
572
    s->qblur= avctx->qblur;
573
    s->avctx = avctx;
574
    s->flags= avctx->flags;
575
    s->max_b_frames= avctx->max_b_frames;
576
    s->b_frame_strategy= avctx->b_frame_strategy;
577
    s->codec_id= avctx->codec->id;
578
    s->luma_elim_threshold  = avctx->luma_elim_threshold;
579
    s->chroma_elim_threshold= avctx->chroma_elim_threshold;
580
    s->strict_std_compliance= avctx->strict_std_compliance;
581
    s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
582
    s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
583
    s->mpeg_quant= avctx->mpeg_quant;
584
    
585
    if (s->gop_size <= 1) {
586
        s->intra_only = 1;
587
        s->gop_size = 12;
588
    } else {
589
        s->intra_only = 0;
590
    }
591

    
592
    s->me_method = avctx->me_method;
593

    
594
    /* Fixed QSCALE */
595
    s->fixed_qscale = (avctx->flags & CODEC_FLAG_QSCALE);
596
    
597
    s->adaptive_quant= (   s->avctx->lumi_masking
598
                        || s->avctx->dark_masking
599
                        || s->avctx->temporal_cplx_masking 
600
                        || s->avctx->spatial_cplx_masking
601
                        || s->avctx->p_masking)
602
                       && !s->fixed_qscale;
603
    
604
    s->progressive_sequence= !(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
605

    
606
    if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4){
607
        fprintf(stderr, "4MV not supporetd by codec\n");
608
        return -1;
609
    }
610
    
611
    if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
612
        fprintf(stderr, "qpel not supporetd by codec\n");
613
        return -1;
614
    }
615

    
616
    if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
617
        fprintf(stderr, "data partitioning not supporetd by codec\n");
618
        return -1;
619
    }
620
    
621
    if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
622
        fprintf(stderr, "b frames not supporetd by codec\n");
623
        return -1;
624
    }
625
/*    
626
    if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
627
        fprintf(stderr, "mpeg2 style quantization not supporetd by codec\n");
628
        return -1;
629
    }
630
  */      
631
    if(s->codec_id==CODEC_ID_MJPEG){
632
        s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
633
        s->inter_quant_bias= 0;
634
    }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
635
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
636
        s->inter_quant_bias= 0;
637
    }else{
638
        s->intra_quant_bias=0;
639
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
640
    }
641
    
642
    if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
643
        s->intra_quant_bias= avctx->intra_quant_bias;
644
    if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
645
        s->inter_quant_bias= avctx->inter_quant_bias;
646
        
647
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
648

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

    
781
            default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
782
            memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
783
            memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
784

    
785
            for(i=-16; i<16; i++){
786
                default_fcode_tab[i + MAX_MV]= 1;
787
            }
788
        }
789
    }
790
    s->me.mv_penalty= default_mv_penalty;
791
    s->fcode_tab= default_fcode_tab;
792
    s->y_dc_scale_table=
793
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
794
 
795
    /* dont use mv_penalty table for crap MV as it would be confused */
796
    //FIXME remove after fixing / removing old ME
797
    if (s->me_method < ME_EPZS) s->me.mv_penalty = default_mv_penalty;
798

    
799
    s->encoding = 1;
800

    
801
    /* init */
802
    if (MPV_common_init(s) < 0)
803
        return -1;
804
    
805
    ff_init_me(s);
806

    
807
#ifdef CONFIG_ENCODERS
808
#ifdef CONFIG_RISKY
809
    if (s->out_format == FMT_H263)
810
        h263_encode_init(s);
811
    if(s->msmpeg4_version)
812
        ff_msmpeg4_encode_init(s);
813
#endif
814
    if (s->out_format == FMT_MPEG1)
815
        ff_mpeg1_encode_init(s);
816
#endif
817

    
818
    /* init default q matrix */
819
    for(i=0;i<64;i++) {
820
        int j= s->dsp.idct_permutation[i];
821
#ifdef CONFIG_RISKY
822
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
823
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
824
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
825
        }else if(s->out_format == FMT_H263){
826
            s->intra_matrix[j] =
827
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
828
        }else
829
#endif
830
        { /* mpeg1/2 */
831
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
832
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
833
        }
834
        if(s->avctx->intra_matrix)
835
            s->intra_matrix[j] = s->avctx->intra_matrix[i];
836
        if(s->avctx->inter_matrix)
837
            s->inter_matrix[j] = s->avctx->inter_matrix[i];
838
    }
839

    
840
    /* precompute matrix */
841
    /* for mjpeg, we do include qscale in the matrix */
842
    if (s->out_format != FMT_MJPEG) {
843
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, s->q_intra_matrix16_bias, 
844
                       s->intra_matrix, s->intra_quant_bias, 1, 31);
845
        convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16, s->q_inter_matrix16_bias, 
846
                       s->inter_matrix, s->inter_quant_bias, 1, 31);
847
    }
848

    
849
    if(ff_rate_control_init(s) < 0)
850
        return -1;
851

    
852
    s->picture_number = 0;
853
    s->picture_in_gop_number = 0;
854
    s->fake_picture_number = 0;
855
    /* motion detector init */
856
    s->f_code = 1;
857
    s->b_code = 1;
858

    
859
    return 0;
860
}
861

    
862
int MPV_encode_end(AVCodecContext *avctx)
863
{
864
    MpegEncContext *s = avctx->priv_data;
865

    
866
#ifdef STATS
867
    print_stats();
868
#endif
869

    
870
    ff_rate_control_uninit(s);
871

    
872
    MPV_common_end(s);
873
    if (s->out_format == FMT_MJPEG)
874
        mjpeg_close(s);
875
      
876
    return 0;
877
}
878

    
879
#endif //CONFIG_ENCODERS
880

    
881
void init_rl(RLTable *rl)
882
{
883
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
884
    uint8_t index_run[MAX_RUN+1];
885
    int last, run, level, start, end, i;
886

    
887
    /* compute max_level[], max_run[] and index_run[] */
888
    for(last=0;last<2;last++) {
889
        if (last == 0) {
890
            start = 0;
891
            end = rl->last;
892
        } else {
893
            start = rl->last;
894
            end = rl->n;
895
        }
896

    
897
        memset(max_level, 0, MAX_RUN + 1);
898
        memset(max_run, 0, MAX_LEVEL + 1);
899
        memset(index_run, rl->n, MAX_RUN + 1);
900
        for(i=start;i<end;i++) {
901
            run = rl->table_run[i];
902
            level = rl->table_level[i];
903
            if (index_run[run] == rl->n)
904
                index_run[run] = i;
905
            if (level > max_level[run])
906
                max_level[run] = level;
907
            if (run > max_run[level])
908
                max_run[level] = run;
909
        }
910
        rl->max_level[last] = av_malloc(MAX_RUN + 1);
911
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
912
        rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
913
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
914
        rl->index_run[last] = av_malloc(MAX_RUN + 1);
915
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
916
    }
917
}
918

    
919
/* draw the edges of width 'w' of an image of size width, height */
920
//FIXME check that this is ok for mpeg4 interlaced
921
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
922
{
923
    uint8_t *ptr, *last_line;
924
    int i;
925

    
926
    last_line = buf + (height - 1) * wrap;
927
    for(i=0;i<w;i++) {
928
        /* top and bottom */
929
        memcpy(buf - (i + 1) * wrap, buf, width);
930
        memcpy(last_line + (i + 1) * wrap, last_line, width);
931
    }
932
    /* left and right */
933
    ptr = buf;
934
    for(i=0;i<height;i++) {
935
        memset(ptr - w, ptr[0], w);
936
        memset(ptr + width, ptr[width-1], w);
937
        ptr += wrap;
938
    }
939
    /* corners */
940
    for(i=0;i<w;i++) {
941
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
942
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
943
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
944
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
945
    }
946
}
947

    
948
static int find_unused_picture(MpegEncContext *s, int shared){
949
    int i;
950
    
951
    if(shared){
952
        for(i=0; i<MAX_PICTURE_COUNT; i++){
953
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) break;
954
        }
955
    }else{
956
        for(i=0; i<MAX_PICTURE_COUNT; i++){
957
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) break; //FIXME
958
        }
959
        for(i=0; i<MAX_PICTURE_COUNT; i++){
960
            if(s->picture[i].data[0]==NULL) break;
961
        }
962
    }
963

    
964
    assert(i<MAX_PICTURE_COUNT);
965
    return i;
966
}
967

    
968
/* generic function for encode/decode called before a frame is coded/decoded */
969
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
970
{
971
    int i;
972
    AVFrame *pic;
973

    
974
    s->mb_skiped = 0;
975

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

    
978
    /* mark&release old frames */
979
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr->data[0]) {
980
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
981

    
982
        /* release forgotten pictures */
983
        /* if(mpeg124/h263) */
984
        if(!s->encoding){
985
            for(i=0; i<MAX_PICTURE_COUNT; i++){
986
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
987
                    fprintf(stderr, "releasing zombie picture\n");
988
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
989
                }
990
            }
991
        }
992
    }
993
alloc:
994
    if(!s->encoding){
995
        /* release non refernce frames */
996
        for(i=0; i<MAX_PICTURE_COUNT; i++){
997
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
998
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
999
            }
1000
        }
1001

    
1002
        i= find_unused_picture(s, 0);
1003
    
1004
        pic= (AVFrame*)&s->picture[i];
1005
        pic->reference= s->pict_type != B_TYPE ? 3 : 0;
1006

    
1007
        if(s->current_picture_ptr)
1008
            pic->coded_picture_number= s->current_picture_ptr->coded_picture_number+1;
1009
        
1010
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1011
            return -1;
1012
        assert(pic->data[0]);
1013

    
1014
        s->current_picture_ptr= &s->picture[i];
1015
    }
1016

    
1017
    s->current_picture_ptr->pict_type= s->pict_type;
1018
    s->current_picture_ptr->quality= s->qscale;
1019
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1020

    
1021
    s->current_picture= *s->current_picture_ptr;
1022
  
1023
  if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1024
    if (s->pict_type != B_TYPE) {
1025
        s->last_picture_ptr= s->next_picture_ptr;
1026
        s->next_picture_ptr= s->current_picture_ptr;
1027
    }
1028
    
1029
    if(s->last_picture_ptr) s->last_picture= *s->last_picture_ptr;
1030
    if(s->next_picture_ptr) s->next_picture= *s->next_picture_ptr;
1031
    if(s->new_picture_ptr ) s->new_picture = *s->new_picture_ptr;
1032
    
1033
    if(s->pict_type != I_TYPE && s->last_picture_ptr==NULL){
1034
        fprintf(stderr, "warning: first frame is no keyframe\n");
1035
        assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1036
        goto alloc;
1037
    }
1038

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

    
1041
    if(s->picture_structure!=PICT_FRAME){
1042
        int i;
1043
        for(i=0; i<4; i++){
1044
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1045
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1046
            } 
1047
            s->current_picture.linesize[i] *= 2;
1048
            s->last_picture.linesize[i] *=2;
1049
            s->next_picture.linesize[i] *=2;
1050
        }
1051
    }
1052
  }
1053
   
1054
    s->hurry_up= s->avctx->hurry_up;
1055
    s->error_resilience= avctx->error_resilience;
1056

    
1057
    /* set dequantizer, we cant do it during init as it might change for mpeg4
1058
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1059
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO) 
1060
        s->dct_unquantize = s->dct_unquantize_mpeg2;
1061
    else if(s->out_format == FMT_H263)
1062
        s->dct_unquantize = s->dct_unquantize_h263;
1063
    else 
1064
        s->dct_unquantize = s->dct_unquantize_mpeg1;
1065

    
1066
#ifdef HAVE_XVMC
1067
    if(s->avctx->xvmc_acceleration)
1068
        return XVMC_field_start(s, avctx);
1069
#endif
1070
    return 0;
1071
}
1072

    
1073
/* generic function for encode/decode called after a frame has been coded/decoded */
1074
void MPV_frame_end(MpegEncContext *s)
1075
{
1076
    int i;
1077
    /* draw edge for correct motion prediction if outside */
1078
#ifdef HAVE_XVMC
1079
//just to make sure that all data is rendered.
1080
    if(s->avctx->xvmc_acceleration){
1081
        XVMC_field_end(s);
1082
    }else
1083
#endif
1084
    if(s->codec_id!=CODEC_ID_SVQ1 && s->out_format != FMT_MPEG1){
1085
        if (s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1086
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1087
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1088
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1089
        }
1090
    }
1091
    emms_c();
1092
    
1093
    s->last_pict_type    = s->pict_type;
1094
    if(s->pict_type!=B_TYPE){
1095
        s->last_non_b_pict_type= s->pict_type;
1096
    }
1097
#if 0
1098
        /* copy back current_picture variables */
1099
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1100
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1101
            s->picture[i]= s->current_picture;
1102
            break;
1103
        }    
1104
    }
1105
    assert(i<MAX_PICTURE_COUNT);
1106
#endif    
1107

    
1108
    if(s->encoding){
1109
        /* release non refernce frames */
1110
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1111
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1112
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1113
            }
1114
        }
1115
    }
1116
    // clear copies, to avoid confusion
1117
#if 0
1118
    memset(&s->last_picture, 0, sizeof(Picture));
1119
    memset(&s->next_picture, 0, sizeof(Picture));
1120
    memset(&s->current_picture, 0, sizeof(Picture));
1121
#endif
1122
}
1123

    
1124
/**
1125
 * draws an line from (ex, ey) -> (sx, sy).
1126
 * @param w width of the image
1127
 * @param h height of the image
1128
 * @param stride stride/linesize of the image
1129
 * @param color color of the arrow
1130
 */
1131
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1132
    int t, x, y, f;
1133
    
1134
    sx= clip(sx, 0, w-1);
1135
    sy= clip(sy, 0, h-1);
1136
    ex= clip(ex, 0, w-1);
1137
    ey= clip(ey, 0, h-1);
1138
    
1139
    buf[sy*stride + sx]+= color;
1140
    
1141
    if(ABS(ex - sx) > ABS(ey - sy)){
1142
        if(sx > ex){
1143
            t=sx; sx=ex; ex=t;
1144
            t=sy; sy=ey; ey=t;
1145
        }
1146
        buf+= sx + sy*stride;
1147
        ex-= sx;
1148
        f= ((ey-sy)<<16)/ex;
1149
        for(x= 0; x <= ex; x++){
1150
            y= ((x*f) + (1<<15))>>16;
1151
            buf[y*stride + x]+= color;
1152
        }
1153
    }else{
1154
        if(sy > ey){
1155
            t=sx; sx=ex; ex=t;
1156
            t=sy; sy=ey; ey=t;
1157
        }
1158
        buf+= sx + sy*stride;
1159
        ey-= sy;
1160
        if(ey) f= ((ex-sx)<<16)/ey;
1161
        else   f= 0;
1162
        for(y= 0; y <= ey; y++){
1163
            x= ((y*f) + (1<<15))>>16;
1164
            buf[y*stride + x]+= color;
1165
        }
1166
    }
1167
}
1168

    
1169
/**
1170
 * draws an arrow from (ex, ey) -> (sx, sy).
1171
 * @param w width of the image
1172
 * @param h height of the image
1173
 * @param stride stride/linesize of the image
1174
 * @param color color of the arrow
1175
 */
1176
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1177
    int dx,dy;
1178

    
1179
    sx= clip(sx, -100, w+100);
1180
    sy= clip(sy, -100, h+100);
1181
    ex= clip(ex, -100, w+100);
1182
    ey= clip(ey, -100, h+100);
1183
    
1184
    dx= ex - sx;
1185
    dy= ey - sy;
1186
    
1187
    if(dx*dx + dy*dy > 3*3){
1188
        int rx=  dx + dy;
1189
        int ry= -dx + dy;
1190
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1191
        
1192
        //FIXME subpixel accuracy
1193
        rx= ROUNDED_DIV(rx*3<<4, length);
1194
        ry= ROUNDED_DIV(ry*3<<4, length);
1195
        
1196
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1197
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1198
    }
1199
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1200
}
1201

    
1202
/**
1203
 * prints debuging info for the given picture.
1204
 */
1205
void ff_print_debug_info(MpegEncContext *s, Picture *pict){
1206

    
1207
    if(!pict || !pict->mb_type) return;
1208

    
1209
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1210
        int x,y;
1211

    
1212
        for(y=0; y<s->mb_height; y++){
1213
            for(x=0; x<s->mb_width; x++){
1214
                if(s->avctx->debug&FF_DEBUG_SKIP){
1215
                    int count= s->mbskip_table[x + y*s->mb_stride];
1216
                    if(count>9) count=9;
1217
                    printf("%1d", count);
1218
                }
1219
                if(s->avctx->debug&FF_DEBUG_QP){
1220
                    printf("%2d", pict->qscale_table[x + y*s->mb_stride]);
1221
                }
1222
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1223
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
1224
                    
1225
                    //Type & MV direction
1226
                    if(IS_PCM(mb_type))
1227
                        printf("P");
1228
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1229
                        printf("A");
1230
                    else if(IS_INTRA4x4(mb_type))
1231
                        printf("i");
1232
                    else if(IS_INTRA16x16(mb_type))
1233
                        printf("I");
1234
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1235
                        printf("d");
1236
                    else if(IS_DIRECT(mb_type))
1237
                        printf("D");
1238
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1239
                        printf("g");
1240
                    else if(IS_GMC(mb_type))
1241
                        printf("G");
1242
                    else if(IS_SKIP(mb_type))
1243
                        printf("S");
1244
                    else if(!USES_LIST(mb_type, 1))
1245
                        printf(">");
1246
                    else if(!USES_LIST(mb_type, 0))
1247
                        printf("<");
1248
                    else{
1249
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1250
                        printf("X");
1251
                    }
1252
                    
1253
                    //segmentation
1254
                    if(IS_8X8(mb_type))
1255
                        printf("+");
1256
                    else if(IS_16X8(mb_type))
1257
                        printf("-");
1258
                    else if(IS_8X16(mb_type))
1259
                        printf("?");
1260
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1261
                        printf(" ");
1262
                    else
1263
                        printf("?");
1264
                    
1265
                        
1266
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1267
                        printf("=");
1268
                    else
1269
                        printf(" ");
1270
                }
1271
//                printf(" ");
1272
            }
1273
            printf("\n");
1274
        }
1275
    }
1276
    
1277
    if((s->avctx->debug&FF_DEBUG_VIS_MV) && s->motion_val){
1278
        const int shift= 1 + s->quarter_sample;
1279
        int mb_y;
1280
        uint8_t *ptr= pict->data[0];
1281
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1282

    
1283
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1284
            int mb_x;
1285
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1286
                const int mb_index= mb_x + mb_y*s->mb_stride;
1287
                if(IS_8X8(s->current_picture.mb_type[mb_index])){
1288
                    int i;
1289
                    for(i=0; i<4; i++){
1290
                        int sx= mb_x*16 + 4 + 8*(i&1);
1291
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1292
                        int xy= 1 + mb_x*2 + (i&1) + (mb_y*2 + 1 + (i>>1))*(s->mb_width*2 + 2);
1293
                        int mx= (s->motion_val[xy][0]>>shift) + sx;
1294
                        int my= (s->motion_val[xy][1]>>shift) + sy;
1295
                        draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1296
                    }
1297
                }else{
1298
                    int sx= mb_x*16 + 8;
1299
                    int sy= mb_y*16 + 8;
1300
                    int xy= 1 + mb_x*2 + (mb_y*2 + 1)*(s->mb_width*2 + 2);
1301
                    int mx= (s->motion_val[xy][0]>>shift) + sx;
1302
                    int my= (s->motion_val[xy][1]>>shift) + sy;
1303
                    draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1304
                }
1305
                s->mbskip_table[mb_index]=0;
1306
            }
1307
        }
1308
    }
1309
}
1310

    
1311
#ifdef CONFIG_ENCODERS
1312

    
1313
static int get_sae(uint8_t *src, int ref, int stride){
1314
    int x,y;
1315
    int acc=0;
1316
    
1317
    for(y=0; y<16; y++){
1318
        for(x=0; x<16; x++){
1319
            acc+= ABS(src[x+y*stride] - ref);
1320
        }
1321
    }
1322
    
1323
    return acc;
1324
}
1325

    
1326
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1327
    int x, y, w, h;
1328
    int acc=0;
1329
    
1330
    w= s->width &~15;
1331
    h= s->height&~15;
1332
    
1333
    for(y=0; y<h; y+=16){
1334
        for(x=0; x<w; x+=16){
1335
            int offset= x + y*stride;
1336
            int sad = s->dsp.pix_abs16x16(src + offset, ref + offset, stride);
1337
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1338
            int sae = get_sae(src + offset, mean, stride);
1339
            
1340
            acc+= sae + 500 < sad;
1341
        }
1342
    }
1343
    return acc;
1344
}
1345

    
1346

    
1347
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1348
    AVFrame *pic=NULL;
1349
    int i;
1350
    const int encoding_delay= s->max_b_frames;
1351
    int direct=1;
1352
    
1353
  if(pic_arg){
1354
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1355
    if(pic_arg->linesize[0] != s->linesize) direct=0;
1356
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1357
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1358
  
1359
//    printf("%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1360
    
1361
    if(direct){
1362
        i= find_unused_picture(s, 1);
1363

    
1364
        pic= (AVFrame*)&s->picture[i];
1365
        pic->reference= 3;
1366
    
1367
        for(i=0; i<4; i++){
1368
            pic->data[i]= pic_arg->data[i];
1369
            pic->linesize[i]= pic_arg->linesize[i];
1370
        }
1371
        alloc_picture(s, (Picture*)pic, 1);
1372
    }else{
1373
        i= find_unused_picture(s, 0);
1374

    
1375
        pic= (AVFrame*)&s->picture[i];
1376
        pic->reference= 3;
1377

    
1378
        alloc_picture(s, (Picture*)pic, 0);
1379
        for(i=0; i<4; i++){
1380
            /* the input will be 16 pixels to the right relative to the actual buffer start
1381
             * and the current_pic, so the buffer can be reused, yes its not beatifull 
1382
             */
1383
            pic->data[i]+= 16; 
1384
        }
1385

    
1386
        if(   pic->data[0] == pic_arg->data[0] 
1387
           && pic->data[1] == pic_arg->data[1]
1388
           && pic->data[2] == pic_arg->data[2]){
1389
       // empty
1390
        }else{
1391
            int h_chroma_shift, v_chroma_shift;
1392
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1393
        
1394
            for(i=0; i<3; i++){
1395
                int src_stride= pic_arg->linesize[i];
1396
                int dst_stride= i ? s->uvlinesize : s->linesize;
1397
                int h_shift= i ? h_chroma_shift : 0;
1398
                int v_shift= i ? v_chroma_shift : 0;
1399
                int w= s->width >>h_shift;
1400
                int h= s->height>>v_shift;
1401
                uint8_t *src= pic_arg->data[i];
1402
                uint8_t *dst= pic->data[i];
1403
            
1404
                if(src_stride==dst_stride)
1405
                    memcpy(dst, src, src_stride*h);
1406
                else{
1407
                    while(h--){
1408
                        memcpy(dst, src, w);
1409
                        dst += dst_stride;
1410
                        src += src_stride;
1411
                    }
1412
                }
1413
            }
1414
        }
1415
    }
1416
    pic->quality= pic_arg->quality;
1417
    pic->pict_type= pic_arg->pict_type;
1418
    pic->pts = pic_arg->pts;
1419
    
1420
    if(s->input_picture[encoding_delay])
1421
        pic->display_picture_number= s->input_picture[encoding_delay]->display_picture_number + 1;
1422
    
1423
  }
1424

    
1425
    /* shift buffer entries */
1426
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1427
        s->input_picture[i-1]= s->input_picture[i];
1428
        
1429
    s->input_picture[encoding_delay]= (Picture*)pic;
1430

    
1431
    return 0;
1432
}
1433

    
1434
static void select_input_picture(MpegEncContext *s){
1435
    int i;
1436
    int coded_pic_num=0;    
1437

    
1438
    if(s->reordered_input_picture[0])
1439
        coded_pic_num= s->reordered_input_picture[0]->coded_picture_number + 1;
1440

    
1441
    for(i=1; i<MAX_PICTURE_COUNT; i++)
1442
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1443
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1444

    
1445
    /* set next picture types & ordering */
1446
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1447
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
1448
            s->reordered_input_picture[0]= s->input_picture[0];
1449
            s->reordered_input_picture[0]->pict_type= I_TYPE;
1450
            s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1451
        }else{
1452
            int b_frames;
1453
            
1454
            if(s->flags&CODEC_FLAG_PASS2){
1455
                for(i=0; i<s->max_b_frames+1; i++){
1456
                    int pict_num= s->input_picture[0]->display_picture_number + i;
1457
                    int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1458
                    s->input_picture[i]->pict_type= pict_type;
1459
                    
1460
                    if(i + 1 >= s->rc_context.num_entries) break;
1461
                }
1462
            }
1463

    
1464
            if(s->input_picture[0]->pict_type){
1465
                /* user selected pict_type */
1466
                for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
1467
                    if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
1468
                }
1469
            
1470
                if(b_frames > s->max_b_frames){
1471
                    fprintf(stderr, "warning, too many bframes in a row\n");
1472
                    b_frames = s->max_b_frames;
1473
                }
1474
            }else if(s->b_frame_strategy==0){
1475
                b_frames= s->max_b_frames;
1476
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
1477
            }else if(s->b_frame_strategy==1){
1478
                for(i=1; i<s->max_b_frames+1; i++){
1479
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
1480
                        s->input_picture[i]->b_frame_score= 
1481
                            get_intra_count(s, s->input_picture[i  ]->data[0], 
1482
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
1483
                    }
1484
                }
1485
                for(i=0; i<s->max_b_frames; i++){
1486
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
1487
                }
1488
                                
1489
                b_frames= FFMAX(0, i-1);
1490
                
1491
                /* reset scores */
1492
                for(i=0; i<b_frames+1; i++){
1493
                    s->input_picture[i]->b_frame_score=0;
1494
                }
1495
            }else{
1496
                fprintf(stderr, "illegal b frame strategy\n");
1497
                b_frames=0;
1498
            }
1499

    
1500
            emms_c();
1501
//static int b_count=0;
1502
//b_count+= b_frames;
1503
//printf("b_frames: %d\n", b_count);
1504
                        
1505
            s->reordered_input_picture[0]= s->input_picture[b_frames];
1506
            if(   s->picture_in_gop_number + b_frames >= s->gop_size 
1507
               || s->reordered_input_picture[0]->pict_type== I_TYPE)
1508
                s->reordered_input_picture[0]->pict_type= I_TYPE;
1509
            else
1510
                s->reordered_input_picture[0]->pict_type= P_TYPE;
1511
            s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1512
            for(i=0; i<b_frames; i++){
1513
                coded_pic_num++;
1514
                s->reordered_input_picture[i+1]= s->input_picture[i];
1515
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
1516
                s->reordered_input_picture[i+1]->coded_picture_number= coded_pic_num;
1517
            }
1518
        }
1519
    }
1520
    
1521
    if(s->reordered_input_picture[0]){
1522
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
1523

    
1524
        s->new_picture= *s->reordered_input_picture[0];
1525

    
1526
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
1527
            // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
1528
        
1529
            int i= find_unused_picture(s, 0);
1530
            Picture *pic= &s->picture[i];
1531

    
1532
            /* mark us unused / free shared pic */
1533
            for(i=0; i<4; i++)
1534
                s->reordered_input_picture[0]->data[i]= NULL;
1535
            s->reordered_input_picture[0]->type= 0;
1536
            
1537
            //FIXME bad, copy * except
1538
            pic->pict_type = s->reordered_input_picture[0]->pict_type;
1539
            pic->quality   = s->reordered_input_picture[0]->quality;
1540
            pic->coded_picture_number = s->reordered_input_picture[0]->coded_picture_number;
1541
            pic->reference = s->reordered_input_picture[0]->reference;
1542
            pic->pts = s->reordered_input_picture[0]->pts;
1543
            
1544
            alloc_picture(s, pic, 0);
1545

    
1546
            s->current_picture_ptr= pic;
1547
        }else{
1548
            // input is not a shared pix -> reuse buffer for current_pix
1549

    
1550
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
1551
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
1552
            
1553
            s->current_picture_ptr= s->reordered_input_picture[0];
1554
            for(i=0; i<4; i++){
1555
                //reverse the +16 we did before storing the input
1556
                s->current_picture_ptr->data[i]-=16;
1557
            }
1558
        }
1559
        s->current_picture= *s->current_picture_ptr;
1560
    
1561
        s->picture_number= s->new_picture.display_picture_number;
1562
//printf("dpn:%d\n", s->picture_number);
1563
    }else{
1564
       memset(&s->new_picture, 0, sizeof(Picture));
1565
    }
1566
}
1567

    
1568
int MPV_encode_picture(AVCodecContext *avctx,
1569
                       unsigned char *buf, int buf_size, void *data)
1570
{
1571
    MpegEncContext *s = avctx->priv_data;
1572
    AVFrame *pic_arg = data;
1573
    int i;
1574

    
1575
    if(avctx->pix_fmt != PIX_FMT_YUV420P){
1576
        fprintf(stderr, "this codec supports only YUV420P\n");
1577
        return -1;
1578
    }
1579
    
1580
    init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
1581

    
1582
    s->picture_in_gop_number++;
1583

    
1584
    load_input_picture(s, pic_arg);
1585
    
1586
    select_input_picture(s);
1587
    
1588
    /* output? */
1589
    if(s->new_picture.data[0]){
1590

    
1591
        s->pict_type= s->new_picture.pict_type;
1592
        if (s->fixed_qscale){ /* the ratecontrol needs the last qscale so we dont touch it for CBR */
1593
            s->qscale= (int)(s->new_picture.quality+0.5);
1594
            assert(s->qscale);
1595
        }
1596
//emms_c();
1597
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
1598
        MPV_frame_start(s, avctx);
1599

    
1600
        encode_picture(s, s->picture_number);
1601
        
1602
        avctx->real_pict_num  = s->picture_number;
1603
        avctx->header_bits = s->header_bits;
1604
        avctx->mv_bits     = s->mv_bits;
1605
        avctx->misc_bits   = s->misc_bits;
1606
        avctx->i_tex_bits  = s->i_tex_bits;
1607
        avctx->p_tex_bits  = s->p_tex_bits;
1608
        avctx->i_count     = s->i_count;
1609
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
1610
        avctx->skip_count  = s->skip_count;
1611

    
1612
        MPV_frame_end(s);
1613

    
1614
        if (s->out_format == FMT_MJPEG)
1615
            mjpeg_picture_trailer(s);
1616
        
1617
        if(s->flags&CODEC_FLAG_PASS1)
1618
            ff_write_pass1_stats(s);
1619

    
1620
        for(i=0; i<4; i++){
1621
            avctx->error[i] += s->current_picture_ptr->error[i];
1622
        }
1623
    }
1624

    
1625
    s->input_picture_number++;
1626

    
1627
    flush_put_bits(&s->pb);
1628
    s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1629
    
1630
    s->total_bits += s->frame_bits;
1631
    avctx->frame_bits  = s->frame_bits;
1632
    
1633
    return pbBufPtr(&s->pb) - s->pb.buf;
1634
}
1635

    
1636
#endif //CONFIG_ENCODERS
1637

    
1638
static inline void gmc1_motion(MpegEncContext *s,
1639
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1640
                               int dest_offset,
1641
                               uint8_t **ref_picture, int src_offset)
1642
{
1643
    uint8_t *ptr;
1644
    int offset, src_x, src_y, linesize, uvlinesize;
1645
    int motion_x, motion_y;
1646
    int emu=0;
1647

    
1648
    motion_x= s->sprite_offset[0][0];
1649
    motion_y= s->sprite_offset[0][1];
1650
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1651
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1652
    motion_x<<=(3-s->sprite_warping_accuracy);
1653
    motion_y<<=(3-s->sprite_warping_accuracy);
1654
    src_x = clip(src_x, -16, s->width);
1655
    if (src_x == s->width)
1656
        motion_x =0;
1657
    src_y = clip(src_y, -16, s->height);
1658
    if (src_y == s->height)
1659
        motion_y =0;
1660

    
1661
    linesize = s->linesize;
1662
    uvlinesize = s->uvlinesize;
1663
    
1664
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1665

    
1666
    dest_y+=dest_offset;
1667
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1668
        if(src_x<0 || src_y<0 || src_x + 17 >= s->h_edge_pos
1669
                              || src_y + 17 >= s->v_edge_pos){
1670
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1671
            ptr= s->edge_emu_buffer;
1672
        }
1673
    }
1674
    
1675
    if((motion_x|motion_y)&7){
1676
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1677
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1678
    }else{
1679
        int dxy;
1680
        
1681
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
1682
        if (s->no_rounding){
1683
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
1684
        }else{
1685
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
1686
        }
1687
    }
1688
    
1689
    if(s->flags&CODEC_FLAG_GRAY) return;
1690

    
1691
    motion_x= s->sprite_offset[1][0];
1692
    motion_y= s->sprite_offset[1][1];
1693
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
1694
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
1695
    motion_x<<=(3-s->sprite_warping_accuracy);
1696
    motion_y<<=(3-s->sprite_warping_accuracy);
1697
    src_x = clip(src_x, -8, s->width>>1);
1698
    if (src_x == s->width>>1)
1699
        motion_x =0;
1700
    src_y = clip(src_y, -8, s->height>>1);
1701
    if (src_y == s->height>>1)
1702
        motion_y =0;
1703

    
1704
    offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
1705
    ptr = ref_picture[1] + offset;
1706
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1707
        if(src_x<0 || src_y<0 || src_x + 9 >= s->h_edge_pos>>1
1708
                              || src_y + 9 >= s->v_edge_pos>>1){
1709
            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);
1710
            ptr= s->edge_emu_buffer;
1711
            emu=1;
1712
        }
1713
    }
1714
    s->dsp.gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1715
    
1716
    ptr = ref_picture[2] + offset;
1717
    if(emu){
1718
        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);
1719
        ptr= s->edge_emu_buffer;
1720
    }
1721
    s->dsp.gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1722
    
1723
    return;
1724
}
1725

    
1726
static inline void gmc_motion(MpegEncContext *s,
1727
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1728
                               int dest_offset,
1729
                               uint8_t **ref_picture, int src_offset)
1730
{
1731
    uint8_t *ptr;
1732
    int linesize, uvlinesize;
1733
    const int a= s->sprite_warping_accuracy;
1734
    int ox, oy;
1735

    
1736
    linesize = s->linesize;
1737
    uvlinesize = s->uvlinesize;
1738

    
1739
    ptr = ref_picture[0] + src_offset;
1740

    
1741
    dest_y+=dest_offset;
1742
    
1743
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
1744
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
1745

    
1746
    s->dsp.gmc(dest_y, ptr, linesize, 16,
1747
           ox, 
1748
           oy, 
1749
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1750
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1751
           a+1, (1<<(2*a+1)) - s->no_rounding,
1752
           s->h_edge_pos, s->v_edge_pos);
1753
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
1754
           ox + s->sprite_delta[0][0]*8, 
1755
           oy + s->sprite_delta[1][0]*8, 
1756
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1757
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1758
           a+1, (1<<(2*a+1)) - s->no_rounding,
1759
           s->h_edge_pos, s->v_edge_pos);
1760

    
1761
    if(s->flags&CODEC_FLAG_GRAY) return;
1762

    
1763

    
1764
    dest_cb+=dest_offset>>1;
1765
    dest_cr+=dest_offset>>1;
1766
    
1767
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
1768
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
1769

    
1770
    ptr = ref_picture[1] + (src_offset>>1);
1771
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
1772
           ox, 
1773
           oy, 
1774
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1775
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1776
           a+1, (1<<(2*a+1)) - s->no_rounding,
1777
           s->h_edge_pos>>1, s->v_edge_pos>>1);
1778
    
1779
    ptr = ref_picture[2] + (src_offset>>1);
1780
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
1781
           ox, 
1782
           oy, 
1783
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1784
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1785
           a+1, (1<<(2*a+1)) - s->no_rounding,
1786
           s->h_edge_pos>>1, s->v_edge_pos>>1);
1787
}
1788

    
1789
/**
1790
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
1791
 * @param buf destination buffer
1792
 * @param src source buffer
1793
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
1794
 * @param block_w width of block
1795
 * @param block_h height of block
1796
 * @param src_x x coordinate of the top left sample of the block in the source buffer
1797
 * @param src_y y coordinate of the top left sample of the block in the source buffer
1798
 * @param w width of the source buffer
1799
 * @param h height of the source buffer
1800
 */
1801
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
1802
                                    int src_x, int src_y, int w, int h){
1803
    int x, y;
1804
    int start_y, start_x, end_y, end_x;
1805

    
1806
    if(src_y>= h){
1807
        src+= (h-1-src_y)*linesize;
1808
        src_y=h-1;
1809
    }else if(src_y<=-block_h){
1810
        src+= (1-block_h-src_y)*linesize;
1811
        src_y=1-block_h;
1812
    }
1813
    if(src_x>= w){
1814
        src+= (w-1-src_x);
1815
        src_x=w-1;
1816
    }else if(src_x<=-block_w){
1817
        src+= (1-block_w-src_x);
1818
        src_x=1-block_w;
1819
    }
1820

    
1821
    start_y= FFMAX(0, -src_y);
1822
    start_x= FFMAX(0, -src_x);
1823
    end_y= FFMIN(block_h, h-src_y);
1824
    end_x= FFMIN(block_w, w-src_x);
1825

    
1826
    // copy existing part
1827
    for(y=start_y; y<end_y; y++){
1828
        for(x=start_x; x<end_x; x++){
1829
            buf[x + y*linesize]= src[x + y*linesize];
1830
        }
1831
    }
1832

    
1833
    //top
1834
    for(y=0; y<start_y; y++){
1835
        for(x=start_x; x<end_x; x++){
1836
            buf[x + y*linesize]= buf[x + start_y*linesize];
1837
        }
1838
    }
1839

    
1840
    //bottom
1841
    for(y=end_y; y<block_h; y++){
1842
        for(x=start_x; x<end_x; x++){
1843
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1844
        }
1845
    }
1846
                                    
1847
    for(y=0; y<block_h; y++){
1848
       //left
1849
        for(x=0; x<start_x; x++){
1850
            buf[x + y*linesize]= buf[start_x + y*linesize];
1851
        }
1852
       
1853
       //right
1854
        for(x=end_x; x<block_w; x++){
1855
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1856
        }
1857
    }
1858
}
1859

    
1860

    
1861
/* apply one mpeg motion vector to the three components */
1862
static inline void mpeg_motion(MpegEncContext *s,
1863
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1864
                               int dest_offset,
1865
                               uint8_t **ref_picture, int src_offset,
1866
                               int field_based, op_pixels_func (*pix_op)[4],
1867
                               int motion_x, int motion_y, int h)
1868
{
1869
    uint8_t *ptr;
1870
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1871
    int emu=0;
1872
#if 0    
1873
if(s->quarter_sample)
1874
{
1875
    motion_x>>=1;
1876
    motion_y>>=1;
1877
}
1878
#endif
1879
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1880
    src_x = s->mb_x * 16 + (motion_x >> 1);
1881
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 1);
1882
                
1883
    /* WARNING: do no forget half pels */
1884
    height = s->height >> field_based;
1885
    v_edge_pos = s->v_edge_pos >> field_based;
1886
    src_x = clip(src_x, -16, s->width);
1887
    if (src_x == s->width)
1888
        dxy &= ~1;
1889
    src_y = clip(src_y, -16, height);
1890
    if (src_y == height)
1891
        dxy &= ~2;
1892
    linesize   = s->current_picture.linesize[0] << field_based;
1893
    uvlinesize = s->current_picture.linesize[1] << field_based;
1894
    ptr = ref_picture[0] + (src_y * linesize) + (src_x) + src_offset;
1895
    dest_y += dest_offset;
1896

    
1897
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1898
        if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 16 > s->h_edge_pos
1899
                              || src_y + (motion_y&1) + h  > v_edge_pos){
1900
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr - src_offset, s->linesize, 17, 17+field_based,  //FIXME linesize? and uv below
1901
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1902
            ptr= s->edge_emu_buffer + src_offset;
1903
            emu=1;
1904
        }
1905
    }
1906
    pix_op[0][dxy](dest_y, ptr, linesize, h);
1907

    
1908
    if(s->flags&CODEC_FLAG_GRAY) return;
1909

    
1910
    if (s->out_format == FMT_H263) {
1911
        dxy = 0;
1912
        if ((motion_x & 3) != 0)
1913
            dxy |= 1;
1914
        if ((motion_y & 3) != 0)
1915
            dxy |= 2;
1916
        mx = motion_x >> 2;
1917
        my = motion_y >> 2;
1918
    } else {
1919
        mx = motion_x / 2;
1920
        my = motion_y / 2;
1921
        dxy = ((my & 1) << 1) | (mx & 1);
1922
        mx >>= 1;
1923
        my >>= 1;
1924
    }
1925
    
1926
    src_x = s->mb_x * 8 + mx;
1927
    src_y = s->mb_y * (8 >> field_based) + my;
1928
    src_x = clip(src_x, -8, s->width >> 1);
1929
    if (src_x == (s->width >> 1))
1930
        dxy &= ~1;
1931
    src_y = clip(src_y, -8, height >> 1);
1932
    if (src_y == (height >> 1))
1933
        dxy &= ~2;
1934
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1935
    ptr = ref_picture[1] + offset;
1936
    if(emu){
1937
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
1938
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1939
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1940
    }
1941
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1942

    
1943
    ptr = ref_picture[2] + offset;
1944
    if(emu){
1945
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
1946
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1947
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1948
    }
1949
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1950
}
1951

    
1952
static inline void qpel_motion(MpegEncContext *s,
1953
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1954
                               int dest_offset,
1955
                               uint8_t **ref_picture, int src_offset,
1956
                               int field_based, op_pixels_func (*pix_op)[4],
1957
                               qpel_mc_func (*qpix_op)[16],
1958
                               int motion_x, int motion_y, int h)
1959
{
1960
    uint8_t *ptr;
1961
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1962
    int emu=0;
1963

    
1964
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1965
    src_x = s->mb_x * 16 + (motion_x >> 2);
1966
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
1967

    
1968
    height = s->height >> field_based;
1969
    v_edge_pos = s->v_edge_pos >> field_based;
1970
    src_x = clip(src_x, -16, s->width);
1971
    if (src_x == s->width)
1972
        dxy &= ~3;
1973
    src_y = clip(src_y, -16, height);
1974
    if (src_y == height)
1975
        dxy &= ~12;
1976
    linesize = s->linesize << field_based;
1977
    uvlinesize = s->uvlinesize << field_based;
1978
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1979
    dest_y += dest_offset;
1980
//printf("%d %d %d\n", src_x, src_y, dxy);
1981
    
1982
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1983
        if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 16 > s->h_edge_pos
1984
                              || src_y + (motion_y&3) + h  > v_edge_pos){
1985
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr - src_offset, s->linesize, 17, 17+field_based, 
1986
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1987
            ptr= s->edge_emu_buffer + src_offset;
1988
            emu=1;
1989
        }
1990
    }
1991
    if(!field_based)
1992
        qpix_op[0][dxy](dest_y, ptr, linesize);
1993
    else{
1994
        //damn interlaced mode
1995
        //FIXME boundary mirroring is not exactly correct here
1996
        qpix_op[1][dxy](dest_y  , ptr  , linesize);
1997
        qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
1998
    }
1999

    
2000
    if(s->flags&CODEC_FLAG_GRAY) return;
2001

    
2002
    if(field_based){
2003
        mx= motion_x/2;
2004
        my= motion_y>>1;
2005
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2006
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
2007
        mx= (motion_x>>1) + rtab[motion_x&7];
2008
        my= (motion_y>>1) + rtab[motion_y&7];
2009
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2010
        mx= (motion_x>>1)|(motion_x&1);
2011
        my= (motion_y>>1)|(motion_y&1);
2012
    }else{
2013
        mx= motion_x/2;
2014
        my= motion_y/2;
2015
    }
2016
    mx= (mx>>1)|(mx&1);
2017
    my= (my>>1)|(my&1);
2018

    
2019
    dxy= (mx&1) | ((my&1)<<1);
2020
    mx>>=1;
2021
    my>>=1;
2022

    
2023
    src_x = s->mb_x * 8 + mx;
2024
    src_y = s->mb_y * (8 >> field_based) + my;
2025
    src_x = clip(src_x, -8, s->width >> 1);
2026
    if (src_x == (s->width >> 1))
2027
        dxy &= ~1;
2028
    src_y = clip(src_y, -8, height >> 1);
2029
    if (src_y == (height >> 1))
2030
        dxy &= ~2;
2031

    
2032
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
2033
    ptr = ref_picture[1] + offset;
2034
    if(emu){
2035
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
2036
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2037
        ptr= s->edge_emu_buffer + (src_offset >> 1);
2038
    }
2039
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
2040
    
2041
    ptr = ref_picture[2] + offset;
2042
    if(emu){
2043
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
2044
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2045
        ptr= s->edge_emu_buffer + (src_offset >> 1);
2046
    }
2047
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
2048
}
2049

    
2050
inline int ff_h263_round_chroma(int x){
2051
    if (x >= 0)
2052
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2053
    else {
2054
        x = -x;
2055
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2056
    }
2057
}
2058

    
2059
/**
2060
 * motion compesation of a single macroblock
2061
 * @param s context
2062
 * @param dest_y luma destination pointer
2063
 * @param dest_cb chroma cb/u destination pointer
2064
 * @param dest_cr chroma cr/v destination pointer
2065
 * @param dir direction (0->forward, 1->backward)
2066
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2067
 * @param pic_op halfpel motion compensation function (average or put normally)
2068
 * @param pic_op qpel motion compensation function (average or put normally)
2069
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2070
 */
2071
static inline void MPV_motion(MpegEncContext *s, 
2072
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2073
                              int dir, uint8_t **ref_picture, 
2074
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
2075
{
2076
    int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
2077
    int mb_x, mb_y, i;
2078
    uint8_t *ptr, *dest;
2079
    int emu=0;
2080

    
2081
    mb_x = s->mb_x;
2082
    mb_y = s->mb_y;
2083

    
2084
    switch(s->mv_type) {
2085
    case MV_TYPE_16X16:
2086
#ifdef CONFIG_RISKY
2087
        if(s->mcsel){
2088
            if(s->real_sprite_warping_points==1){
2089
                gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
2090
                            ref_picture, 0);
2091
            }else{
2092
                gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
2093
                            ref_picture, 0);
2094
            }
2095
        }else if(s->quarter_sample){
2096
            qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2097
                        ref_picture, 0,
2098
                        0, pix_op, qpix_op,
2099
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2100
        }else if(s->mspel){
2101
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
2102
                        ref_picture, pix_op,
2103
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2104
        }else
2105
#endif
2106
        {
2107
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2108
                        ref_picture, 0,
2109
                        0, pix_op,
2110
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2111
        }           
2112
        break;
2113
    case MV_TYPE_8X8:
2114
        mx = 0;
2115
        my = 0;
2116
        if(s->quarter_sample){
2117
            for(i=0;i<4;i++) {
2118
                motion_x = s->mv[dir][i][0];
2119
                motion_y = s->mv[dir][i][1];
2120

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

    
2144
                mx += s->mv[dir][i][0]/2;
2145
                my += s->mv[dir][i][1]/2;
2146
            }
2147
        }else{
2148
            for(i=0;i<4;i++) {
2149
                motion_x = s->mv[dir][i][0];
2150
                motion_y = s->mv[dir][i][1];
2151

    
2152
                dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2153
                src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;
2154
                src_y = mb_y * 16 + (motion_y >> 1) + (i >>1) * 8;
2155
                    
2156
                /* WARNING: do no forget half pels */
2157
                src_x = clip(src_x, -16, s->width);
2158
                if (src_x == s->width)
2159
                    dxy &= ~1;
2160
                src_y = clip(src_y, -16, s->height);
2161
                if (src_y == s->height)
2162
                    dxy &= ~2;
2163
                    
2164
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2165
                if(s->flags&CODEC_FLAG_EMU_EDGE){
2166
                    if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 8 > s->h_edge_pos
2167
                                          || src_y + (motion_y&1) + 8 > s->v_edge_pos){
2168
                        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);
2169
                        ptr= s->edge_emu_buffer;
2170
                    }
2171
                }
2172
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2173
                pix_op[1][dxy](dest, ptr, s->linesize, 8);
2174

    
2175
                mx += s->mv[dir][i][0];
2176
                my += s->mv[dir][i][1];
2177
            }
2178
        }
2179

    
2180
        if(s->flags&CODEC_FLAG_GRAY) break;
2181
        /* In case of 8X8, we construct a single chroma motion vector
2182
           with a special rounding */
2183
        mx= ff_h263_round_chroma(mx);
2184
        my= ff_h263_round_chroma(my);
2185
        dxy = ((my & 1) << 1) | (mx & 1);
2186
        mx >>= 1;
2187
        my >>= 1;
2188

    
2189
        src_x = mb_x * 8 + mx;
2190
        src_y = mb_y * 8 + my;
2191
        src_x = clip(src_x, -8, s->width/2);
2192
        if (src_x == s->width/2)
2193
            dxy &= ~1;
2194
        src_y = clip(src_y, -8, s->height/2);
2195
        if (src_y == s->height/2)
2196
            dxy &= ~2;
2197
        
2198
        offset = (src_y * (s->uvlinesize)) + src_x;
2199
        ptr = ref_picture[1] + offset;
2200
        if(s->flags&CODEC_FLAG_EMU_EDGE){
2201
                if(src_x<0 || src_y<0 || src_x + (dxy &1) + 8 > s->h_edge_pos>>1
2202
                                      || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
2203
                    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);
2204
                    ptr= s->edge_emu_buffer;
2205
                    emu=1;
2206
                }
2207
            }
2208
        pix_op[1][dxy](dest_cb, ptr, s->uvlinesize, 8);
2209

    
2210
        ptr = ref_picture[2] + offset;
2211
        if(emu){
2212
            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);
2213
            ptr= s->edge_emu_buffer;
2214
        }
2215
        pix_op[1][dxy](dest_cr, ptr, s->uvlinesize, 8);
2216
        break;
2217
    case MV_TYPE_FIELD:
2218
        if (s->picture_structure == PICT_FRAME) {
2219
            if(s->quarter_sample){
2220
                /* top field */
2221
                qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2222
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2223
                            1, pix_op, qpix_op,
2224
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
2225
                /* bottom field */
2226
                qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2227
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2228
                            1, pix_op, qpix_op,
2229
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
2230
            }else{
2231
                /* top field */       
2232
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2233
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2234
                            1, pix_op,
2235
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
2236
                /* bottom field */
2237
                mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2238
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2239
                            1, pix_op,
2240
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
2241
            }
2242
        } else {
2243
            int offset;
2244
            if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2245
                offset= s->field_select[dir][0] ? s->linesize : 0;
2246
            }else{
2247
                ref_picture= s->current_picture.data;
2248
                offset= s->field_select[dir][0] ? s->linesize : -s->linesize; 
2249
            } 
2250

    
2251
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2252
                        ref_picture, offset,
2253
                        0, pix_op,
2254
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2255
        }
2256
        break;
2257
    case MV_TYPE_16X8:{
2258
        int offset;
2259
         uint8_t ** ref2picture;
2260

    
2261
            if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2262
                ref2picture= ref_picture;
2263
                offset= s->field_select[dir][0] ? s->linesize : 0;
2264
            }else{
2265
                ref2picture= s->current_picture.data;
2266
                offset= s->field_select[dir][0] ? s->linesize : -s->linesize; 
2267
            } 
2268

    
2269
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2270
                        ref2picture, offset,
2271
                        0, pix_op,
2272
                        s->mv[dir][0][0], s->mv[dir][0][1], 8);
2273

    
2274

    
2275
            if(s->picture_structure == s->field_select[dir][1] + 1 || s->pict_type == B_TYPE || s->first_field){
2276
                ref2picture= ref_picture;
2277
                offset= s->field_select[dir][1] ? s->linesize : 0;
2278
            }else{
2279
                ref2picture= s->current_picture.data;
2280
                offset= s->field_select[dir][1] ? s->linesize : -s->linesize; 
2281
            } 
2282
            // I know it is ugly but this is the only way to fool emu_edge without rewrite mpeg_motion
2283
            mpeg_motion(s, dest_y+16*s->linesize, dest_cb+8*s->uvlinesize, dest_cr+8*s->uvlinesize,
2284
                        0,
2285
                        ref2picture, offset,
2286
                        0, pix_op,
2287
                        s->mv[dir][1][0], s->mv[dir][1][1]+16, 8);
2288
        }
2289
        
2290
        break;
2291
    case MV_TYPE_DMV:
2292
    {
2293
    op_pixels_func (*dmv_pix_op)[4];
2294
    int offset;
2295

    
2296
        dmv_pix_op = s->dsp.put_pixels_tab;
2297

    
2298
        if(s->picture_structure == PICT_FRAME){
2299
            //put top field from top field
2300
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2301
                        ref_picture, 0,
2302
                        1, dmv_pix_op,
2303
                        s->mv[dir][0][0], s->mv[dir][0][1], 8);
2304
            //put bottom field from bottom field
2305
            mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2306
                        ref_picture, s->linesize,
2307
                        1, dmv_pix_op,
2308
                        s->mv[dir][0][0], s->mv[dir][0][1], 8);
2309

    
2310
            dmv_pix_op = s->dsp.avg_pixels_tab; 
2311
        
2312
            //avg top field from bottom field
2313
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2314
                        ref_picture, s->linesize,
2315
                        1, dmv_pix_op,
2316
                        s->mv[dir][2][0], s->mv[dir][2][1], 8);
2317
            //avg bottom field from top field
2318
            mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2319
                        ref_picture, 0,
2320
                        1, dmv_pix_op,
2321
                        s->mv[dir][3][0], s->mv[dir][3][1], 8);
2322

    
2323
        }else{
2324
            offset=(s->picture_structure == PICT_BOTTOM_FIELD)? 
2325
                         s->linesize : 0;
2326

    
2327
            //put field from the same parity
2328
            //same parity is never in the same frame
2329
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2330
                        ref_picture,offset,
2331
                        0,dmv_pix_op,
2332
                        s->mv[dir][0][0],s->mv[dir][0][1],16);
2333

    
2334
            // after put we make avg of the same block
2335
            dmv_pix_op=s->dsp.avg_pixels_tab; 
2336

    
2337
            //opposite parity is always in the same frame if this is second field
2338
            if(!s->first_field){
2339
                ref_picture = s->current_picture.data;    
2340
                //top field is one linesize from frame beginig
2341
                offset=(s->picture_structure == PICT_BOTTOM_FIELD)? 
2342
                        -s->linesize : s->linesize;
2343
            }else 
2344
                offset=(s->picture_structure == PICT_BOTTOM_FIELD)? 
2345
                        0 : s->linesize;
2346

    
2347
            //avg field from the opposite parity
2348
            mpeg_motion(s, dest_y, dest_cb, dest_cr,0,
2349
                        ref_picture, offset,
2350
                        0,dmv_pix_op,
2351
                        s->mv[dir][2][0],s->mv[dir][2][1],16);
2352
        }
2353
    }
2354
    break;
2355
    default:
2356
        printf("X");
2357
    }
2358
}
2359

    
2360

    
2361
/* put block[] to dest[] */
2362
static inline void put_dct(MpegEncContext *s, 
2363
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
2364
{
2365
    s->dct_unquantize(s, block, i, s->qscale);
2366
    s->dsp.idct_put (dest, line_size, block);
2367
}
2368

    
2369
/* add block[] to dest[] */
2370
static inline void add_dct(MpegEncContext *s, 
2371
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
2372
{
2373
    if (s->block_last_index[i] >= 0) {
2374
        s->dsp.idct_add (dest, line_size, block);
2375
    }
2376
}
2377

    
2378
static inline void add_dequant_dct(MpegEncContext *s, 
2379
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
2380
{
2381
    if (s->block_last_index[i] >= 0) {
2382
        s->dct_unquantize(s, block, i, s->qscale);
2383

    
2384
        s->dsp.idct_add (dest, line_size, block);
2385
    }
2386
}
2387

    
2388
/**
2389
 * cleans dc, ac, coded_block for the current non intra MB
2390
 */
2391
void ff_clean_intra_table_entries(MpegEncContext *s)
2392
{
2393
    int wrap = s->block_wrap[0];
2394
    int xy = s->block_index[0];
2395
    
2396
    s->dc_val[0][xy           ] = 
2397
    s->dc_val[0][xy + 1       ] = 
2398
    s->dc_val[0][xy     + wrap] =
2399
    s->dc_val[0][xy + 1 + wrap] = 1024;
2400
    /* ac pred */
2401
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2402
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2403
    if (s->msmpeg4_version>=3) {
2404
        s->coded_block[xy           ] =
2405
        s->coded_block[xy + 1       ] =
2406
        s->coded_block[xy     + wrap] =
2407
        s->coded_block[xy + 1 + wrap] = 0;
2408
    }
2409
    /* chroma */
2410
    wrap = s->block_wrap[4];
2411
    xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
2412
    s->dc_val[1][xy] =
2413
    s->dc_val[2][xy] = 1024;
2414
    /* ac pred */
2415
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2416
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2417
    
2418
    s->mbintra_table[s->mb_x + s->mb_y*s->mb_stride]= 0;
2419
}
2420

    
2421
/* generic function called after a macroblock has been parsed by the
2422
   decoder or after it has been encoded by the encoder.
2423

2424
   Important variables used:
2425
   s->mb_intra : true if intra macroblock
2426
   s->mv_dir   : motion vector direction
2427
   s->mv_type  : motion vector type
2428
   s->mv       : motion vector
2429
   s->interlaced_dct : true if interlaced dct used (mpeg2)
2430
 */
2431
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
2432
{
2433
    int mb_x, mb_y;
2434
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2435
#ifdef HAVE_XVMC
2436
    if(s->avctx->xvmc_acceleration){
2437
        XVMC_decode_mb(s,block);
2438
        return;
2439
    }
2440
#endif
2441

    
2442
    mb_x = s->mb_x;
2443
    mb_y = s->mb_y;
2444

    
2445
    s->current_picture.qscale_table[mb_xy]= s->qscale;
2446

    
2447
    /* update DC predictors for P macroblocks */
2448
    if (!s->mb_intra) {
2449
        if (s->h263_pred || s->h263_aic) {
2450
            if(s->mbintra_table[mb_xy])
2451
                ff_clean_intra_table_entries(s);
2452
        } else {
2453
            s->last_dc[0] =
2454
            s->last_dc[1] =
2455
            s->last_dc[2] = 128 << s->intra_dc_precision;
2456
        }
2457
    }
2458
    else if (s->h263_pred || s->h263_aic)
2459
        s->mbintra_table[mb_xy]=1;
2460

    
2461
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
2462
        uint8_t *dest_y, *dest_cb, *dest_cr;
2463
        int dct_linesize, dct_offset;
2464
        op_pixels_func (*op_pix)[4];
2465
        qpel_mc_func (*op_qpix)[16];
2466
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
2467
        const int uvlinesize= s->current_picture.linesize[1];
2468

    
2469
        /* avoid copy if macroblock skipped in last frame too */
2470
        /* skip only during decoding as we might trash the buffers during encoding a bit */
2471
        if(!s->encoding){
2472
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2473
            const int age= s->current_picture.age;
2474

    
2475
            assert(age);
2476

    
2477
            if (s->mb_skiped) {
2478
                s->mb_skiped= 0;
2479
                assert(s->pict_type!=I_TYPE);
2480
 
2481
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
2482
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2483

    
2484
                /* if previous was skipped too, then nothing to do !  */
2485
                if (*mbskip_ptr >= age && s->current_picture.reference){
2486
                    return;
2487
                }
2488
            } else if(!s->current_picture.reference){
2489
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2490
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2491
            } else{
2492
                *mbskip_ptr = 0; /* not skipped */
2493
            }
2494
        }
2495

    
2496
        if (s->interlaced_dct) {
2497
            dct_linesize = linesize * 2;
2498
            dct_offset = linesize;
2499
        } else {
2500
            dct_linesize = linesize;
2501
            dct_offset = linesize * 8;
2502
        }
2503
        
2504
        dest_y=  s->dest[0];
2505
        dest_cb= s->dest[1];
2506
        dest_cr= s->dest[2];
2507

    
2508
        if (!s->mb_intra) {
2509
            /* motion handling */
2510
            /* decoding or more than one mb_type (MC was allready done otherwise) */
2511
            if(!s->encoding){
2512
                if ((!s->no_rounding) || s->pict_type==B_TYPE){                
2513
                    op_pix = s->dsp.put_pixels_tab;
2514
                    op_qpix= s->dsp.put_qpel_pixels_tab;
2515
                }else{
2516
                    op_pix = s->dsp.put_no_rnd_pixels_tab;
2517
                    op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2518
                }
2519

    
2520
                if (s->mv_dir & MV_DIR_FORWARD) {
2521
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2522
                    op_pix = s->dsp.avg_pixels_tab;
2523
                    op_qpix= s->dsp.avg_qpel_pixels_tab;
2524
                }
2525
                if (s->mv_dir & MV_DIR_BACKWARD) {
2526
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2527
                }
2528
            }
2529

    
2530
            /* skip dequant / idct if we are really late ;) */
2531
            if(s->hurry_up>1) return;
2532

    
2533
            /* add dct residue */
2534
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
2535
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2536
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
2537
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2538
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2539
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2540

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

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

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

    
2579
                if(!(s->flags&CODEC_FLAG_GRAY)){
2580
                    s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2581
                    s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2582
                }
2583
            }
2584
        }
2585
    }
2586
}
2587

    
2588
#ifdef CONFIG_ENCODERS
2589

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

    
2608
    if(threshold<0){
2609
        skip_dc=0;
2610
        threshold= -threshold;
2611
    }else
2612
        skip_dc=1;
2613

    
2614
    /* are all which we could set to zero are allready zero? */
2615
    if(last_index<=skip_dc - 1) return;
2616

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

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

    
2657
        block[j]= level;
2658
    }
2659
}
2660

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

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

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

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

    
2724
#endif
2725

    
2726
#endif //CONFIG_ENCODERS
2727

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

    
2743
        h= FFMIN(h, s->height - y);
2744

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

    
2764
        emms_c();
2765

    
2766
        s->avctx->draw_horiz_band(s->avctx, src, offset,
2767
                                  y, s->picture_structure, h);
2768
    }
2769
}
2770

    
2771
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2772
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
2773
    const int uvlinesize= s->current_picture.linesize[1];
2774
        
2775
    s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2776
    s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1)     + s->mb_x*2;
2777
    s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1 + s->mb_x*2;
2778
    s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2)     + s->mb_x*2;
2779
    s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
2780
    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;
2781
    
2782
    if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){
2783
        s->dest[0] = s->current_picture.data[0] + s->mb_x * 16 - 16;
2784
        s->dest[1] = s->current_picture.data[1] + s->mb_x * 8 - 8;
2785
        s->dest[2] = s->current_picture.data[2] + s->mb_x * 8 - 8;
2786
    }else{
2787
        s->dest[0] = s->current_picture.data[0] + (s->mb_y * 16* linesize  ) + s->mb_x * 16 - 16;
2788
        s->dest[1] = s->current_picture.data[1] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
2789
        s->dest[2] = s->current_picture.data[2] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
2790
    }    
2791
}
2792

    
2793
#ifdef CONFIG_ENCODERS
2794

    
2795
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2796
{
2797
    const int mb_x= s->mb_x;
2798
    const int mb_y= s->mb_y;
2799
    int i;
2800
    int skip_dct[6];
2801
    int dct_offset   = s->linesize*8; //default for progressive frames
2802
    
2803
    for(i=0; i<6; i++) skip_dct[i]=0;
2804
    
2805
    if(s->adaptive_quant){
2806
        s->dquant= s->current_picture.qscale_table[mb_x + mb_y*s->mb_stride] - s->qscale;
2807

    
2808
        if(s->out_format==FMT_H263){
2809
            if     (s->dquant> 2) s->dquant= 2;
2810
            else if(s->dquant<-2) s->dquant=-2;
2811
        }
2812
            
2813
        if(s->codec_id==CODEC_ID_MPEG4){        
2814
            if(!s->mb_intra){
2815
                if(s->mv_dir&MV_DIRECT)
2816
                    s->dquant=0;
2817

    
2818
                assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
2819
            }
2820
        }
2821
        s->qscale+= s->dquant;
2822
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2823
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2824
    }
2825

    
2826
    if (s->mb_intra) {
2827
        uint8_t *ptr;
2828
        int wrap_y;
2829
        int emu=0;
2830

    
2831
        wrap_y = s->linesize;
2832
        ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2833

    
2834
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2835
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2836
            ptr= s->edge_emu_buffer;
2837
            emu=1;
2838
        }
2839
        
2840
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2841
            int progressive_score, interlaced_score;
2842
            
2843
            progressive_score= pix_vcmp16x8(ptr, wrap_y  ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
2844
            interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y  , wrap_y*2);
2845
            
2846
            if(progressive_score > interlaced_score + 100){
2847
                s->interlaced_dct=1;
2848
            
2849
                dct_offset= wrap_y;
2850
                wrap_y<<=1;
2851
            }else
2852
                s->interlaced_dct=0;
2853
        }
2854
        
2855
        s->dsp.get_pixels(s->block[0], ptr                 , wrap_y);
2856
        s->dsp.get_pixels(s->block[1], ptr              + 8, wrap_y);
2857
        s->dsp.get_pixels(s->block[2], ptr + dct_offset    , wrap_y);
2858
        s->dsp.get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
2859

    
2860
        if(s->flags&CODEC_FLAG_GRAY){
2861
            skip_dct[4]= 1;
2862
            skip_dct[5]= 1;
2863
        }else{
2864
            int wrap_c = s->uvlinesize;
2865
            ptr = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2866
            if(emu){
2867
                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);
2868
                ptr= s->edge_emu_buffer;
2869
            }
2870
            s->dsp.get_pixels(s->block[4], ptr, wrap_c);
2871

    
2872
            ptr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2873
            if(emu){
2874
                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);
2875
                ptr= s->edge_emu_buffer;
2876
            }
2877
            s->dsp.get_pixels(s->block[5], ptr, wrap_c);
2878
        }
2879
    }else{
2880
        op_pixels_func (*op_pix)[4];
2881
        qpel_mc_func (*op_qpix)[16];
2882
        uint8_t *dest_y, *dest_cb, *dest_cr;
2883
        uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2884
        int wrap_y, wrap_c;
2885
        int emu=0;
2886

    
2887
        dest_y  = s->dest[0];
2888
        dest_cb = s->dest[1];
2889
        dest_cr = s->dest[2];
2890
        wrap_y = s->linesize;
2891
        wrap_c = s->uvlinesize;
2892
        ptr_y  = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2893
        ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2894
        ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2895

    
2896
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
2897
            op_pix = s->dsp.put_pixels_tab;
2898
            op_qpix= s->dsp.put_qpel_pixels_tab;
2899
        }else{
2900
            op_pix = s->dsp.put_no_rnd_pixels_tab;
2901
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2902
        }
2903

    
2904
        if (s->mv_dir & MV_DIR_FORWARD) {
2905
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2906
            op_pix = s->dsp.avg_pixels_tab;
2907
            op_qpix= s->dsp.avg_qpel_pixels_tab;
2908
        }
2909
        if (s->mv_dir & MV_DIR_BACKWARD) {
2910
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2911
        }
2912

    
2913
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2914
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2915
            ptr_y= s->edge_emu_buffer;
2916
            emu=1;
2917
        }
2918
        
2919
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2920
            int progressive_score, interlaced_score;
2921
            
2922
            progressive_score= pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y  ) 
2923
                             + pix_diff_vcmp16x8(ptr_y + wrap_y*8, dest_y + wrap_y*8, wrap_y  );
2924
            interlaced_score = pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y*2)
2925
                             + pix_diff_vcmp16x8(ptr_y + wrap_y  , dest_y + wrap_y  , wrap_y*2);
2926
            
2927
            if(progressive_score > interlaced_score + 600){
2928
                s->interlaced_dct=1;
2929
            
2930
                dct_offset= wrap_y;
2931
                wrap_y<<=1;
2932
            }else
2933
                s->interlaced_dct=0;
2934
        }
2935
        
2936
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
2937
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
2938
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
2939
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
2940
        
2941
        if(s->flags&CODEC_FLAG_GRAY){
2942
            skip_dct[4]= 1;
2943
            skip_dct[5]= 1;
2944
        }else{
2945
            if(emu){
2946
                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);
2947
                ptr_cb= s->edge_emu_buffer;
2948
            }
2949
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2950
            if(emu){
2951
                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);
2952
                ptr_cr= s->edge_emu_buffer;
2953
            }
2954
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2955
        }
2956
        /* pre quantization */         
2957
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
2958
            //FIXME optimize
2959
            if(s->dsp.pix_abs8x8(ptr_y               , dest_y               , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
2960
            if(s->dsp.pix_abs8x8(ptr_y            + 8, dest_y            + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
2961
            if(s->dsp.pix_abs8x8(ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
2962
            if(s->dsp.pix_abs8x8(ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
2963
            if(s->dsp.pix_abs8x8(ptr_cb              , dest_cb              , wrap_c) < 20*s->qscale) skip_dct[4]= 1;
2964
            if(s->dsp.pix_abs8x8(ptr_cr              , dest_cr              , wrap_c) < 20*s->qscale) skip_dct[5]= 1;
2965
#if 0
2966
{
2967
 static int stat[7];
2968
 int num=0;
2969
 for(i=0; i<6; i++)
2970
  if(skip_dct[i]) num++;
2971
 stat[num]++;
2972
 
2973
 if(s->mb_x==0 && s->mb_y==0){
2974
  for(i=0; i<7; i++){
2975
   printf("%6d %1d\n", stat[i], i);
2976
  }
2977
 }
2978
}
2979
#endif
2980
        }
2981

    
2982
    }
2983
            
2984
#if 0
2985
            {
2986
                float adap_parm;
2987
                
2988
                adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_stride*mb_y+mb_x] + 1.0) /
2989
                            ((s->mb_var[s->mb_stride*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);
2990
            
2991
                printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d", 
2992
                        (s->mb_type[s->mb_stride*mb_y+mb_x] > 0) ? 'I' : 'P', 
2993
                        s->qscale, adap_parm, s->qscale*adap_parm,
2994
                        s->mb_var[s->mb_stride*mb_y+mb_x], s->avg_mb_var);
2995
            }
2996
#endif
2997
    /* DCT & quantize */
2998
    if(s->out_format==FMT_MJPEG){
2999
        for(i=0;i<6;i++) {
3000
            int overflow;
3001
            s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
3002
            if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
3003
        }
3004
    }else{
3005
        for(i=0;i<6;i++) {
3006
            if(!skip_dct[i]){
3007
                int overflow;
3008
START_TIMER;
3009
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
3010
STOP_TIMER("dct_quant");
3011
            // FIXME we could decide to change to quantizer instead of clipping
3012
            // JS: I don't think that would be a good idea it could lower quality instead
3013
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
3014
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
3015
            }else
3016
                s->block_last_index[i]= -1;
3017
        }
3018
        if(s->luma_elim_threshold && !s->mb_intra)
3019
            for(i=0; i<4; i++)
3020
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
3021
        if(s->chroma_elim_threshold && !s->mb_intra)
3022
            for(i=4; i<6; i++)
3023
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
3024
    }
3025

    
3026
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
3027
        s->block_last_index[4]=
3028
        s->block_last_index[5]= 0;
3029
        s->block[4][0]=
3030
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
3031
    }
3032

    
3033
    /* huffman encode */
3034
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
3035
    case CODEC_ID_MPEG1VIDEO:
3036
    case CODEC_ID_MPEG2VIDEO:
3037
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
3038
#ifdef CONFIG_RISKY
3039
    case CODEC_ID_MPEG4:
3040
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3041
    case CODEC_ID_MSMPEG4V2:
3042
    case CODEC_ID_MSMPEG4V3:
3043
    case CODEC_ID_WMV1:
3044
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3045
    case CODEC_ID_WMV2:
3046
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
3047
    case CODEC_ID_H263:
3048
    case CODEC_ID_H263P:
3049
    case CODEC_ID_FLV1:
3050
    case CODEC_ID_RV10:
3051
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
3052
#endif
3053
    case CODEC_ID_MJPEG:
3054
        mjpeg_encode_mb(s, s->block); break;
3055
    default:
3056
        assert(0);
3057
    }
3058
}
3059

    
3060
#endif //CONFIG_ENCODERS
3061

    
3062
/**
3063
 * combines the (truncated) bitstream to a complete frame
3064
 * @returns -1 if no complete frame could be created
3065
 */
3066
int ff_combine_frame( MpegEncContext *s, int next, uint8_t **buf, int *buf_size){
3067
    ParseContext *pc= &s->parse_context;
3068

    
3069
#if 0
3070
    if(pc->overread){
3071
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
3072
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
3073
    }
3074
#endif
3075

    
3076
    /* copy overreaded byes from last frame into buffer */
3077
    for(; pc->overread>0; pc->overread--){
3078
        pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
3079
    }
3080
    
3081
    pc->last_index= pc->index;
3082

    
3083
    /* copy into buffer end return */
3084
    if(next == END_NOT_FOUND){
3085
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
3086

    
3087
        memcpy(&pc->buffer[pc->index], *buf, *buf_size);
3088
        pc->index += *buf_size;
3089
        return -1;
3090
    }
3091

    
3092
    *buf_size=
3093
    pc->overread_index= pc->index + next;
3094
    
3095
    /* append to buffer */
3096
    if(pc->index){
3097
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
3098

    
3099
        memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
3100
        pc->index = 0;
3101
        *buf= pc->buffer;
3102
    }
3103

    
3104
    /* store overread bytes */
3105
    for(;next < 0; next++){
3106
        pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
3107
        pc->overread++;
3108
    }
3109

    
3110
#if 0
3111
    if(pc->overread){
3112
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
3113
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
3114
    }
3115
#endif
3116

    
3117
    return 0;
3118
}
3119

    
3120
void ff_mpeg_flush(AVCodecContext *avctx){
3121
    int i;
3122
    MpegEncContext *s = avctx->priv_data;
3123
    
3124
    for(i=0; i<MAX_PICTURE_COUNT; i++){
3125
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
3126
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
3127
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
3128
    }
3129
    s->last_picture_ptr = s->next_picture_ptr = NULL;
3130
    
3131
    s->parse_context.state= -1;
3132
    s->parse_context.frame_start_found= 0;
3133
    s->parse_context.overread= 0;
3134
    s->parse_context.overread_index= 0;
3135
    s->parse_context.index= 0;
3136
    s->parse_context.last_index= 0;
3137
}
3138

    
3139
#ifdef CONFIG_ENCODERS
3140
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
3141
{
3142
    int bytes= length>>4;
3143
    int bits= length&15;
3144
    int i;
3145

    
3146
    if(length==0) return;
3147

    
3148
    for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
3149
    put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
3150
}
3151

    
3152
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
3153
    int i;
3154

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

    
3157
    /* mpeg1 */
3158
    d->mb_skip_run= s->mb_skip_run;
3159
    for(i=0; i<3; i++)
3160
        d->last_dc[i]= s->last_dc[i];
3161
    
3162
    /* statistics */
3163
    d->mv_bits= s->mv_bits;
3164
    d->i_tex_bits= s->i_tex_bits;
3165
    d->p_tex_bits= s->p_tex_bits;
3166
    d->i_count= s->i_count;
3167
    d->f_count= s->f_count;
3168
    d->b_count= s->b_count;
3169
    d->skip_count= s->skip_count;
3170
    d->misc_bits= s->misc_bits;
3171
    d->last_bits= 0;
3172

    
3173
    d->mb_skiped= 0;
3174
    d->qscale= s->qscale;
3175
}
3176

    
3177
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
3178
    int i;
3179

    
3180
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
3181
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
3182
    
3183
    /* mpeg1 */
3184
    d->mb_skip_run= s->mb_skip_run;
3185
    for(i=0; i<3; i++)
3186
        d->last_dc[i]= s->last_dc[i];
3187
    
3188
    /* statistics */
3189
    d->mv_bits= s->mv_bits;
3190
    d->i_tex_bits= s->i_tex_bits;
3191
    d->p_tex_bits= s->p_tex_bits;
3192
    d->i_count= s->i_count;
3193
    d->f_count= s->f_count;
3194
    d->b_count= s->b_count;
3195
    d->skip_count= s->skip_count;
3196
    d->misc_bits= s->misc_bits;
3197

    
3198
    d->mb_intra= s->mb_intra;
3199
    d->mb_skiped= s->mb_skiped;
3200
    d->mv_type= s->mv_type;
3201
    d->mv_dir= s->mv_dir;
3202
    d->pb= s->pb;
3203
    if(s->data_partitioning){
3204
        d->pb2= s->pb2;
3205
        d->tex_pb= s->tex_pb;
3206
    }
3207
    d->block= s->block;
3208
    for(i=0; i<6; i++)
3209
        d->block_last_index[i]= s->block_last_index[i];
3210
    d->interlaced_dct= s->interlaced_dct;
3211
    d->qscale= s->qscale;
3212
}
3213

    
3214
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
3215
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
3216
                           int *dmin, int *next_block, int motion_x, int motion_y)
3217
{
3218
    int score;
3219
    uint8_t *dest_backup[3];
3220
    
3221
    copy_context_before_encode(s, backup, type);
3222

    
3223
    s->block= s->blocks[*next_block];
3224
    s->pb= pb[*next_block];
3225
    if(s->data_partitioning){
3226
        s->pb2   = pb2   [*next_block];
3227
        s->tex_pb= tex_pb[*next_block];
3228
    }
3229
    
3230
    if(*next_block){
3231
        memcpy(dest_backup, s->dest, sizeof(s->dest));
3232
        s->dest[0] = s->me.scratchpad;
3233
        s->dest[1] = s->me.scratchpad + 16;
3234
        s->dest[2] = s->me.scratchpad + 16 + 8;
3235
        assert(2*s->uvlinesize == s->linesize); //should be no prob for encoding
3236
        assert(s->linesize >= 64); //FIXME
3237
    }
3238

    
3239
    encode_mb(s, motion_x, motion_y);
3240
    
3241
    score= get_bit_count(&s->pb);
3242
    if(s->data_partitioning){
3243
        score+= get_bit_count(&s->pb2);
3244
        score+= get_bit_count(&s->tex_pb);
3245
    }
3246
   
3247
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
3248
        MPV_decode_mb(s, s->block);
3249

    
3250
        score *= s->qscale * s->qscale * 109;
3251
        score += sse_mb(s) << 7;
3252
    }
3253
    
3254
    if(*next_block){
3255
        memcpy(s->dest, dest_backup, sizeof(s->dest));
3256
    }
3257

    
3258
    if(score<*dmin){
3259
        *dmin= score;
3260
        *next_block^=1;
3261

    
3262
        copy_context_after_encode(best, s, type);
3263
    }
3264
}
3265
                
3266
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
3267
    uint32_t *sq = squareTbl + 256;
3268
    int acc=0;
3269
    int x,y;
3270
    
3271
    if(w==16 && h==16) 
3272
        return s->dsp.sse[0](NULL, src1, src2, stride);
3273
    else if(w==8 && h==8)
3274
        return s->dsp.sse[1](NULL, src1, src2, stride);
3275
    
3276
    for(y=0; y<h; y++){
3277
        for(x=0; x<w; x++){
3278
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
3279
        } 
3280
    }
3281
    
3282
    assert(acc>=0);
3283
    
3284
    return acc;
3285
}
3286

    
3287
static int sse_mb(MpegEncContext *s){
3288
    int w= 16;
3289
    int h= 16;
3290

    
3291
    if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3292
    if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3293

    
3294
    if(w==16 && h==16)
3295
        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)
3296
               +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)
3297
               +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);
3298
    else
3299
        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)
3300
               +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)
3301
               +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);
3302
}
3303

    
3304
static void encode_picture(MpegEncContext *s, int picture_number)
3305
{
3306
    int mb_x, mb_y, pdif = 0;
3307
    int i;
3308
    int bits;
3309
    MpegEncContext best_s, backup_s;
3310
    uint8_t bit_buf[2][3000];
3311
    uint8_t bit_buf2[2][3000];
3312
    uint8_t bit_buf_tex[2][3000];
3313
    PutBitContext pb[2], pb2[2], tex_pb[2];
3314

    
3315
    for(i=0; i<2; i++){
3316
        init_put_bits(&pb    [i], bit_buf    [i], 3000, NULL, NULL);
3317
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000, NULL, NULL);
3318
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
3319
    }
3320

    
3321
    s->picture_number = picture_number;
3322
    
3323
    /* Reset the average MB variance */
3324
    s->current_picture.mb_var_sum = 0;
3325
    s->current_picture.mc_mb_var_sum = 0;
3326

    
3327
#ifdef CONFIG_RISKY
3328
    /* we need to initialize some time vars before we can encode b-frames */
3329
    // RAL: Condition added for MPEG1VIDEO
3330
    //FIXME figure out why mpeg1/2 need this !!!
3331
    if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
3332
        ff_set_mpeg4_time(s, s->picture_number); 
3333
#endif
3334
        
3335
    s->scene_change_score=0;
3336
    
3337
    s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
3338
    
3339
    if(s->pict_type==I_TYPE){
3340
        if(s->msmpeg4_version >= 3) s->no_rounding=1;
3341
        else                        s->no_rounding=0;
3342
    }else if(s->pict_type!=B_TYPE){
3343
        if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
3344
            s->no_rounding ^= 1;          
3345
    }
3346
    
3347
    /* Estimate motion for every MB */
3348
    s->mb_intra=0; //for the rate distoration & bit compare functions
3349
    if(s->pict_type != I_TYPE){
3350
        if(s->pict_type != B_TYPE){
3351
            if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
3352
                s->me.pre_pass=1;
3353
                s->me.dia_size= s->avctx->pre_dia_size;
3354

    
3355
                for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) {
3356
                    for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) {
3357
                        s->mb_x = mb_x;
3358
                        s->mb_y = mb_y;
3359
                        ff_pre_estimate_p_frame_motion(s, mb_x, mb_y);
3360
                    }
3361
                }
3362
                s->me.pre_pass=0;
3363
            }
3364
        }
3365

    
3366
        s->me.dia_size= s->avctx->dia_size;
3367
        for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3368
            s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3369
            s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3370
            s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3371
            s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3372
            for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3373
                s->mb_x = mb_x;
3374
                s->mb_y = mb_y;
3375
                s->block_index[0]+=2;
3376
                s->block_index[1]+=2;
3377
                s->block_index[2]+=2;
3378
                s->block_index[3]+=2;
3379
                
3380
                /* compute motion vector & mb_type and store in context */
3381
                if(s->pict_type==B_TYPE)
3382
                    ff_estimate_b_frame_motion(s, mb_x, mb_y);
3383
                else
3384
                    ff_estimate_p_frame_motion(s, mb_x, mb_y);
3385
            }
3386
        }
3387
    }else /* if(s->pict_type == I_TYPE) */{
3388
        /* I-Frame */
3389
        //FIXME do we need to zero them?
3390
        memset(s->motion_val[0], 0, sizeof(int16_t)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
3391
        memset(s->p_mv_table   , 0, sizeof(int16_t)*(s->mb_stride)*s->mb_height*2);
3392
        memset(s->mb_type      , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3393
        
3394
        if(!s->fixed_qscale){
3395
            /* finding spatial complexity for I-frame rate control */
3396
            for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3397
                for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3398
                    int xx = mb_x * 16;
3399
                    int yy = mb_y * 16;
3400
                    uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
3401
                    int varc;
3402
                    int sum = s->dsp.pix_sum(pix, s->linesize);
3403
    
3404
                    varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
3405

    
3406
                    s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
3407
                    s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
3408
                    s->current_picture.mb_var_sum    += varc;
3409
                }
3410
            }
3411
        }
3412
    }
3413
    emms_c();
3414

    
3415
    if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
3416
        s->pict_type= I_TYPE;
3417
        memset(s->mb_type   , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3418
//printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3419
    }
3420

    
3421
    if(!s->umvplus){
3422
        if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
3423
            s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
3424
        
3425
            ff_fix_long_p_mvs(s);
3426
        }
3427

    
3428
        if(s->pict_type==B_TYPE){
3429
            int a, b;
3430

    
3431
            a = ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
3432
            b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, MB_TYPE_BIDIR);
3433
            s->f_code = FFMAX(a, b);
3434

    
3435
            a = ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
3436
            b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, MB_TYPE_BIDIR);
3437
            s->b_code = FFMAX(a, b);
3438

    
3439
            ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
3440
            ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
3441
            ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
3442
            ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
3443
        }
3444
    }
3445
    
3446
    if (s->fixed_qscale) 
3447
        s->frame_qscale = s->current_picture.quality;
3448
    else
3449
        s->frame_qscale = ff_rate_estimate_qscale(s);
3450

    
3451
    if(s->adaptive_quant){
3452
#ifdef CONFIG_RISKY
3453
        switch(s->codec_id){
3454
        case CODEC_ID_MPEG4:
3455
            ff_clean_mpeg4_qscales(s);
3456
            break;
3457
        case CODEC_ID_H263:
3458
        case CODEC_ID_H263P:
3459
        case CODEC_ID_FLV1:
3460
            ff_clean_h263_qscales(s);
3461
            break;
3462
        }
3463
#endif
3464

    
3465
        s->qscale= s->current_picture.qscale_table[0];
3466
    }else
3467
        s->qscale= (int)(s->frame_qscale + 0.5);
3468
        
3469
    if (s->out_format == FMT_MJPEG) {
3470
        /* for mjpeg, we do include qscale in the matrix */
3471
        s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
3472
        for(i=1;i<64;i++){
3473
            int j= s->dsp.idct_permutation[i];
3474

    
3475
            s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3476
        }
3477
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, 
3478
                       s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
3479
    }
3480
    
3481
    //FIXME var duplication
3482
    s->current_picture.key_frame= s->pict_type == I_TYPE;
3483
    s->current_picture.pict_type= s->pict_type;
3484

    
3485
    if(s->current_picture.key_frame)
3486
        s->picture_in_gop_number=0;
3487

    
3488
    s->last_bits= get_bit_count(&s->pb);
3489
    switch(s->out_format) {
3490
    case FMT_MJPEG:
3491
        mjpeg_picture_header(s);
3492
        break;
3493
#ifdef CONFIG_RISKY
3494
    case FMT_H263:
3495
        if (s->codec_id == CODEC_ID_WMV2) 
3496
            ff_wmv2_encode_picture_header(s, picture_number);
3497
        else if (s->h263_msmpeg4) 
3498
            msmpeg4_encode_picture_header(s, picture_number);
3499
        else if (s->h263_pred)
3500
            mpeg4_encode_picture_header(s, picture_number);
3501
        else if (s->h263_rv10) 
3502
            rv10_encode_picture_header(s, picture_number);
3503
        else if (s->codec_id == CODEC_ID_FLV1)
3504
            ff_flv_encode_picture_header(s, picture_number);
3505
        else
3506
            h263_encode_picture_header(s, picture_number);
3507
        break;
3508
#endif
3509
    case FMT_MPEG1:
3510
        mpeg1_encode_picture_header(s, picture_number);
3511
        break;
3512
    }
3513
    bits= get_bit_count(&s->pb);
3514
    s->header_bits= bits - s->last_bits;
3515
    s->last_bits= bits;
3516
    s->mv_bits=0;
3517
    s->misc_bits=0;
3518
    s->i_tex_bits=0;
3519
    s->p_tex_bits=0;
3520
    s->i_count=0;
3521
    s->f_count=0;
3522
    s->b_count=0;
3523
    s->skip_count=0;
3524

    
3525
    for(i=0; i<3; i++){
3526
        /* init last dc values */
3527
        /* note: quant matrix value (8) is implied here */
3528
        s->last_dc[i] = 128;
3529
        
3530
        s->current_picture_ptr->error[i] = 0;
3531
    }
3532
    s->mb_skip_run = 0;
3533
    s->last_mv[0][0][0] = 0;
3534
    s->last_mv[0][0][1] = 0;
3535
    s->last_mv[1][0][0] = 0;
3536
    s->last_mv[1][0][1] = 0;
3537
     
3538
    s->last_mv_dir = 0;
3539

    
3540
#ifdef CONFIG_RISKY
3541
    switch(s->codec_id){
3542
    case CODEC_ID_H263:
3543
    case CODEC_ID_H263P:
3544
    case CODEC_ID_FLV1:
3545
        s->gob_index = ff_h263_get_gob_height(s);
3546
        break;
3547
    case CODEC_ID_MPEG4:
3548
        if(s->partitioned_frame)
3549
            ff_mpeg4_init_partitions(s);
3550
        break;
3551
    }
3552
#endif
3553

    
3554
    s->resync_mb_x=0;
3555
    s->resync_mb_y=0;
3556
    s->first_slice_line = 1;
3557
    s->ptr_lastgob = s->pb.buf;
3558
    for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3559
        s->mb_x=0;
3560
        s->mb_y= mb_y;
3561

    
3562
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
3563
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
3564
        ff_init_block_index(s);
3565
        
3566
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3567
            const int xy= mb_y*s->mb_stride + mb_x;
3568
            int mb_type= s->mb_type[xy];
3569
//            int d;
3570
            int dmin= INT_MAX;
3571

    
3572
            s->mb_x = mb_x;
3573
            ff_update_block_index(s);
3574

    
3575
            /* write gob / video packet header  */
3576
#ifdef CONFIG_RISKY
3577
            if(s->rtp_mode && mb_y + mb_x>0){
3578
                int current_packet_size, is_gob_start;
3579
                
3580
                current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
3581
                is_gob_start=0;
3582
                
3583
                if(s->codec_id==CODEC_ID_MPEG4){
3584
                    if(current_packet_size >= s->rtp_payload_size){
3585

    
3586
                        if(s->partitioned_frame){
3587
                            ff_mpeg4_merge_partitions(s);
3588
                            ff_mpeg4_init_partitions(s);
3589
                        }
3590
                        ff_mpeg4_encode_video_packet_header(s);
3591

    
3592
                        if(s->flags&CODEC_FLAG_PASS1){
3593
                            int bits= get_bit_count(&s->pb);
3594
                            s->misc_bits+= bits - s->last_bits;
3595
                            s->last_bits= bits;
3596
                        }
3597
                        ff_mpeg4_clean_buffers(s);
3598
                        is_gob_start=1;
3599
                    }
3600
                }else if(s->codec_id==CODEC_ID_MPEG1VIDEO){
3601
                    if(   current_packet_size >= s->rtp_payload_size 
3602
                       && s->mb_skip_run==0){
3603
                        ff_mpeg1_encode_slice_header(s);
3604
                        ff_mpeg1_clean_buffers(s);
3605
                        is_gob_start=1;
3606
                    }
3607
                }else if(s->codec_id==CODEC_ID_MPEG2VIDEO){
3608
                    if(   (   current_packet_size >= s->rtp_payload_size || mb_x==0)
3609
                       && s->mb_skip_run==0){
3610
                        ff_mpeg1_encode_slice_header(s);
3611
                        ff_mpeg1_clean_buffers(s);
3612
                        is_gob_start=1;
3613
                    }
3614
                }else{
3615
                    if(current_packet_size >= s->rtp_payload_size
3616
                       && s->mb_x==0 && s->mb_y%s->gob_index==0){
3617
                       
3618
                        h263_encode_gob_header(s, mb_y);                       
3619
                        is_gob_start=1;
3620
                    }
3621
                }
3622

    
3623
                if(is_gob_start){
3624
                    s->ptr_lastgob = pbBufPtr(&s->pb);
3625
                    s->first_slice_line=1;
3626
                    s->resync_mb_x=mb_x;
3627
                    s->resync_mb_y=mb_y;
3628
                }
3629
            }
3630
#endif
3631

    
3632
            if(  (s->resync_mb_x   == s->mb_x)
3633
               && s->resync_mb_y+1 == s->mb_y){
3634
                s->first_slice_line=0; 
3635
            }
3636

    
3637
            s->mb_skiped=0;
3638

    
3639
            if(mb_type & (mb_type-1)){ // more than 1 MB type possible
3640
                int next_block=0;
3641
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3642

    
3643
                copy_context_before_encode(&backup_s, s, -1);
3644
                backup_s.pb= s->pb;
3645
                best_s.data_partitioning= s->data_partitioning;
3646
                best_s.partitioned_frame= s->partitioned_frame;
3647
                if(s->data_partitioning){
3648
                    backup_s.pb2= s->pb2;
3649
                    backup_s.tex_pb= s->tex_pb;
3650
                }
3651

    
3652
                if(mb_type&MB_TYPE_INTER){
3653
                    s->mv_dir = MV_DIR_FORWARD;
3654
                    s->mv_type = MV_TYPE_16X16;
3655
                    s->mb_intra= 0;
3656
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
3657
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
3658
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb, 
3659
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3660
                }
3661
                if(mb_type&MB_TYPE_INTER4V){                 
3662
                    s->mv_dir = MV_DIR_FORWARD;
3663
                    s->mv_type = MV_TYPE_8X8;
3664
                    s->mb_intra= 0;
3665
                    for(i=0; i<4; i++){
3666
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3667
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3668
                    }
3669
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb, 
3670
                                 &dmin, &next_block, 0, 0);
3671
                }
3672
                if(mb_type&MB_TYPE_FORWARD){
3673
                    s->mv_dir = MV_DIR_FORWARD;
3674
                    s->mv_type = MV_TYPE_16X16;
3675
                    s->mb_intra= 0;
3676
                    s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3677
                    s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3678
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb, 
3679
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3680
                }
3681
                if(mb_type&MB_TYPE_BACKWARD){
3682
                    s->mv_dir = MV_DIR_BACKWARD;
3683
                    s->mv_type = MV_TYPE_16X16;
3684
                    s->mb_intra= 0;
3685
                    s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3686
                    s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3687
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb, 
3688
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3689
                }
3690
                if(mb_type&MB_TYPE_BIDIR){
3691
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3692
                    s->mv_type = MV_TYPE_16X16;
3693
                    s->mb_intra= 0;
3694
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3695
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3696
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3697
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3698
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb, 
3699
                                 &dmin, &next_block, 0, 0);
3700
                }
3701
                if(mb_type&MB_TYPE_DIRECT){
3702
                    int mx= s->b_direct_mv_table[xy][0];
3703
                    int my= s->b_direct_mv_table[xy][1];
3704
                    
3705
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3706
                    s->mb_intra= 0;
3707
#ifdef CONFIG_RISKY
3708
                    ff_mpeg4_set_direct_mv(s, mx, my);
3709
#endif
3710
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb, 
3711
                                 &dmin, &next_block, mx, my);
3712
                }
3713
                if(mb_type&MB_TYPE_INTRA){
3714
                    s->mv_dir = 0;
3715
                    s->mv_type = MV_TYPE_16X16;
3716
                    s->mb_intra= 1;
3717
                    s->mv[0][0][0] = 0;
3718
                    s->mv[0][0][1] = 0;
3719
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb, 
3720
                                 &dmin, &next_block, 0, 0);
3721
                    if(s->h263_pred || s->h263_aic){
3722
                        if(best_s.mb_intra)
3723
                            s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
3724
                        else
3725
                            ff_clean_intra_table_entries(s); //old mode?
3726
                    }
3727
                }
3728
                copy_context_after_encode(s, &best_s, -1);
3729
                
3730
                pb_bits_count= get_bit_count(&s->pb);
3731
                flush_put_bits(&s->pb);
3732
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3733
                s->pb= backup_s.pb;
3734
                
3735
                if(s->data_partitioning){
3736
                    pb2_bits_count= get_bit_count(&s->pb2);
3737
                    flush_put_bits(&s->pb2);
3738
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3739
                    s->pb2= backup_s.pb2;
3740
                    
3741
                    tex_pb_bits_count= get_bit_count(&s->tex_pb);
3742
                    flush_put_bits(&s->tex_pb);
3743
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3744
                    s->tex_pb= backup_s.tex_pb;
3745
                }
3746
                s->last_bits= get_bit_count(&s->pb);
3747
                
3748
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
3749
                    ff_h263_update_motion_val(s);
3750
        
3751
                if(next_block==0){
3752
                    s->dsp.put_pixels_tab[0][0](s->dest[0], s->me.scratchpad     , s->linesize  ,16);
3753
                    s->dsp.put_pixels_tab[1][0](s->dest[1], s->me.scratchpad + 16, s->uvlinesize, 8);
3754
                    s->dsp.put_pixels_tab[1][0](s->dest[2], s->me.scratchpad + 24, s->uvlinesize, 8);
3755
                }
3756

    
3757
                if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
3758
                    MPV_decode_mb(s, s->block);
3759
            } else {
3760
                int motion_x, motion_y;
3761
                int intra_score;
3762
                int inter_score= s->current_picture.mb_cmp_score[mb_x + mb_y*s->mb_stride];
3763
                
3764
              if(s->avctx->mb_decision==FF_MB_DECISION_SIMPLE && s->pict_type==P_TYPE){ //FIXME check if the mess is usefull at all
3765
                /* get luma score */
3766
                if((s->avctx->mb_cmp&0xFF)==FF_CMP_SSE){
3767
                    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
3768
                }else{
3769
                    uint8_t *dest_y;
3770

    
3771
                    int mean= s->current_picture.mb_mean[mb_x + mb_y*s->mb_stride]; //FIXME
3772
                    mean*= 0x01010101;
3773
                    
3774
                    dest_y  = s->new_picture.data[0] + (mb_y * 16 * s->linesize    ) + mb_x * 16;
3775
                
3776
                    for(i=0; i<16; i++){
3777
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 0]) = mean;
3778
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 4]) = mean;
3779
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 8]) = mean;
3780
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+12]) = mean;
3781
                    }
3782

    
3783
                    s->mb_intra=1;
3784
                    intra_score= s->dsp.mb_cmp[0](s, s->me.scratchpad, dest_y, s->linesize);
3785
                                        
3786
/*                    printf("intra:%7d inter:%7d var:%7d mc_var.%7d\n", intra_score>>8, inter_score>>8, 
3787
                        s->current_picture.mb_var[mb_x + mb_y*s->mb_stride],
3788
                        s->current_picture.mc_mb_var[mb_x + mb_y*s->mb_stride]);*/
3789
                }
3790
                
3791
                /* get chroma score */
3792
                if(s->avctx->mb_cmp&FF_CMP_CHROMA){
3793
                    int i;
3794
                    
3795
                    s->mb_intra=1;
3796
                    for(i=1; i<3; i++){
3797
                        uint8_t *dest_c;
3798
                        int mean;
3799
                        
3800
                        if(s->out_format == FMT_H263){
3801
                            mean= (s->dc_val[i][mb_x + (mb_y+1)*(s->mb_width+2)] + 4)>>3; //FIXME not exact but simple ;)
3802
                        }else{
3803
                            mean= (s->last_dc[i] + 4)>>3;
3804
                        }
3805
                        dest_c = s->new_picture.data[i] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
3806
                        
3807
                        mean*= 0x01010101;
3808
                        for(i=0; i<8; i++){
3809
                            *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 0]) = mean;
3810
                            *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 4]) = mean;
3811
                        }
3812
                        
3813
                        intra_score+= s->dsp.mb_cmp[1](s, s->me.scratchpad, dest_c, s->uvlinesize);
3814
                    }                
3815
                }
3816

    
3817
                /* bias */
3818
                switch(s->avctx->mb_cmp&0xFF){
3819
                default:
3820
                case FF_CMP_SAD:
3821
                    intra_score+= 32*s->qscale;
3822
                    break;
3823
                case FF_CMP_SSE:
3824
                    intra_score+= 24*s->qscale*s->qscale;
3825
                    break;
3826
                case FF_CMP_SATD:
3827
                    intra_score+= 96*s->qscale;
3828
                    break;
3829
                case FF_CMP_DCT:
3830
                    intra_score+= 48*s->qscale;
3831
                    break;
3832
                case FF_CMP_BIT:
3833
                    intra_score+= 16;
3834
                    break;
3835
                case FF_CMP_PSNR:
3836
                case FF_CMP_RD:
3837
                    intra_score+= (s->qscale*s->qscale*109*8 + 64)>>7;
3838
                    break;
3839
                }
3840

    
3841
                if(intra_score < inter_score)
3842
                    mb_type= MB_TYPE_INTRA;
3843
              }  
3844
                
3845
                s->mv_type=MV_TYPE_16X16;
3846
                // only one MB-Type possible
3847
                
3848
                switch(mb_type){
3849
                case MB_TYPE_INTRA:
3850
                    s->mv_dir = 0;
3851
                    s->mb_intra= 1;
3852
                    motion_x= s->mv[0][0][0] = 0;
3853
                    motion_y= s->mv[0][0][1] = 0;
3854
                    break;
3855
                case MB_TYPE_INTER:
3856
                    s->mv_dir = MV_DIR_FORWARD;
3857
                    s->mb_intra= 0;
3858
                    motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3859
                    motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3860
                    break;
3861
                case MB_TYPE_INTER4V:
3862
                    s->mv_dir = MV_DIR_FORWARD;
3863
                    s->mv_type = MV_TYPE_8X8;
3864
                    s->mb_intra= 0;
3865
                    for(i=0; i<4; i++){
3866
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3867
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3868
                    }
3869
                    motion_x= motion_y= 0;
3870
                    break;
3871
                case MB_TYPE_DIRECT:
3872
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3873
                    s->mb_intra= 0;
3874
                    motion_x=s->b_direct_mv_table[xy][0];
3875
                    motion_y=s->b_direct_mv_table[xy][1];
3876
#ifdef CONFIG_RISKY
3877
                    ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3878
#endif
3879
                    break;
3880
                case MB_TYPE_BIDIR:
3881
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3882
                    s->mb_intra= 0;
3883
                    motion_x=0;
3884
                    motion_y=0;
3885
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3886
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3887
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3888
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3889
                    break;
3890
                case MB_TYPE_BACKWARD:
3891
                    s->mv_dir = MV_DIR_BACKWARD;
3892
                    s->mb_intra= 0;
3893
                    motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3894
                    motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3895
                    break;
3896
                case MB_TYPE_FORWARD:
3897
                    s->mv_dir = MV_DIR_FORWARD;
3898
                    s->mb_intra= 0;
3899
                    motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3900
                    motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3901
//                    printf(" %d %d ", motion_x, motion_y);
3902
                    break;
3903
                default:
3904
                    motion_x=motion_y=0; //gcc warning fix
3905
                    printf("illegal MB type\n");
3906
                }
3907

    
3908
                encode_mb(s, motion_x, motion_y);
3909

    
3910
                // RAL: Update last macrobloc type
3911
                s->last_mv_dir = s->mv_dir;
3912
            
3913
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
3914
                    ff_h263_update_motion_val(s);
3915

    
3916
                MPV_decode_mb(s, s->block);
3917
            }
3918

    
3919
            /* clean the MV table in IPS frames for direct mode in B frames */
3920
            if(s->mb_intra /* && I,P,S_TYPE */){
3921
                s->p_mv_table[xy][0]=0;
3922
                s->p_mv_table[xy][1]=0;
3923
            }
3924
            
3925
            if(s->flags&CODEC_FLAG_PSNR){
3926
                int w= 16;
3927
                int h= 16;
3928

    
3929
                if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3930
                if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3931

    
3932
                s->current_picture_ptr->error[0] += sse(
3933
                    s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3934
                    s->dest[0], w, h, s->linesize);
3935
                s->current_picture_ptr->error[1] += sse(
3936
                    s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3937
                    s->dest[1], w>>1, h>>1, s->uvlinesize);
3938
                s->current_picture_ptr->error[2] += sse(
3939
                    s, s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3940
                    s->dest[2], w>>1, h>>1, s->uvlinesize);
3941
            }
3942
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, get_bit_count(&s->pb));
3943
        }
3944
    }
3945
    emms_c();
3946

    
3947
#ifdef CONFIG_RISKY
3948
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3949
        ff_mpeg4_merge_partitions(s);
3950

    
3951
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
3952
        msmpeg4_encode_ext_header(s);
3953

    
3954
    if(s->codec_id==CODEC_ID_MPEG4) 
3955
        ff_mpeg4_stuffing(&s->pb);
3956
#endif
3957

    
3958
    //if (s->gob_number)
3959
    //    fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
3960
    
3961
    /* Send the last GOB if RTP */    
3962
    if (s->rtp_mode) {
3963
        flush_put_bits(&s->pb);
3964
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
3965
        /* Call the RTP callback to send the last GOB */
3966
        if (s->rtp_callback)
3967
            s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
3968
        s->ptr_lastgob = pbBufPtr(&s->pb);
3969
        //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
3970
    }
3971
}
3972

    
3973
static int dct_quantize_trellis_c(MpegEncContext *s, 
3974
                        DCTELEM *block, int n,
3975
                        int qscale, int *overflow){
3976
    const int *qmat;
3977
    const uint8_t *scantable= s->intra_scantable.scantable;
3978
    int max=0;
3979
    unsigned int threshold1, threshold2;
3980
    int bias=0;
3981
    int run_tab[65];
3982
    int level_tab[65];
3983
    int score_tab[65];
3984
    int last_run=0;
3985
    int last_level=0;
3986
    int last_score= 0;
3987
    int last_i= 0;
3988
    int coeff[3][64];
3989
    int coeff_count[64];
3990
    int lambda, qmul, qadd, start_i, last_non_zero, i;
3991
    const int esc_length= s->ac_esc_length;
3992
    uint8_t * length;
3993
    uint8_t * last_length;
3994
    int score_limit=0;
3995
    int left_limit= 0;
3996
        
3997
    s->dsp.fdct (block);
3998

    
3999
    qmul= qscale*16;
4000
    qadd= ((qscale-1)|1)*8;
4001

    
4002
    if (s->mb_intra) {
4003
        int q;
4004
        if (!s->h263_aic) {
4005
            if (n < 4)
4006
                q = s->y_dc_scale;
4007
            else
4008
                q = s->c_dc_scale;
4009
            q = q << 3;
4010
        } else{
4011
            /* For AIC we skip quant/dequant of INTRADC */
4012
            q = 1 << 3;
4013
            qadd=0;
4014
        }
4015
            
4016
        /* note: block[0] is assumed to be positive */
4017
        block[0] = (block[0] + (q >> 1)) / q;
4018
        start_i = 1;
4019
        last_non_zero = 0;
4020
        qmat = s->q_intra_matrix[qscale];
4021
        if(s->mpeg_quant)
4022
            bias= 1<<(QMAT_SHIFT-1);
4023
        length     = s->intra_ac_vlc_length;
4024
        last_length= s->intra_ac_vlc_last_length;
4025
    } else {
4026
        start_i = 0;
4027
        last_non_zero = -1;
4028
        qmat = s->q_inter_matrix[qscale];
4029
        length     = s->inter_ac_vlc_length;
4030
        last_length= s->inter_ac_vlc_last_length;
4031
    }
4032

    
4033
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
4034
    threshold2= (threshold1<<1);
4035

    
4036
    for(i=start_i; i<64; i++) {
4037
        const int j = scantable[i];
4038
        const int k= i-start_i;
4039
        int level = block[j];
4040
        level = level * qmat[j];
4041

    
4042
//        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
4043
//           || bias-level >= (1<<(QMAT_SHIFT - 3))){
4044
        if(((unsigned)(level+threshold1))>threshold2){
4045
            if(level>0){
4046
                level= (bias + level)>>QMAT_SHIFT;
4047
                coeff[0][k]= level;
4048
                coeff[1][k]= level-1;
4049
//                coeff[2][k]= level-2;
4050
            }else{
4051
                level= (bias - level)>>QMAT_SHIFT;
4052
                coeff[0][k]= -level;
4053
                coeff[1][k]= -level+1;
4054
//                coeff[2][k]= -level+2;
4055
            }
4056
            coeff_count[k]= FFMIN(level, 2);
4057
            max |=level;
4058
            last_non_zero = i;
4059
        }else{
4060
            coeff[0][k]= (level>>31)|1;
4061
            coeff_count[k]= 1;
4062
        }
4063
    }
4064
    
4065
    *overflow= s->max_qcoeff < max; //overflow might have happend
4066
    
4067
    if(last_non_zero < start_i){
4068
        memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
4069
        return last_non_zero;
4070
    }
4071

    
4072
    lambda= (qscale*qscale*64*105 + 64)>>7; //FIXME finetune
4073
        
4074
    score_tab[0]= 0;
4075
    for(i=0; i<=last_non_zero - start_i; i++){
4076
        int level_index, run, j;
4077
        const int dct_coeff= block[ scantable[i + start_i] ];
4078
        const int zero_distoration= dct_coeff*dct_coeff;
4079
        int best_score=256*256*256*120;
4080

    
4081
        last_score += zero_distoration;
4082
        for(level_index=0; level_index < coeff_count[i]; level_index++){
4083
            int distoration;
4084
            int level= coeff[level_index][i];
4085
            int unquant_coeff;
4086
            
4087
            assert(level);
4088

    
4089
            if(s->out_format == FMT_H263){
4090
                if(level>0){
4091
                    unquant_coeff= level*qmul + qadd;
4092
                }else{
4093
                    unquant_coeff= level*qmul - qadd;
4094
                }
4095
            }else{ //MPEG1
4096
                j= s->dsp.idct_permutation[ scantable[i + start_i] ]; //FIXME optimize
4097
                if(s->mb_intra){
4098
                    if (level < 0) {
4099
                        unquant_coeff = (int)((-level) * qscale * s->intra_matrix[j]) >> 3;
4100
                        unquant_coeff = -((unquant_coeff - 1) | 1);
4101
                    } else {
4102
                        unquant_coeff = (int)(  level  * qscale * s->intra_matrix[j]) >> 3;
4103
                        unquant_coeff =   (unquant_coeff - 1) | 1;
4104
                    }
4105
                }else{
4106
                    if (level < 0) {
4107
                        unquant_coeff = ((((-level) << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
4108
                        unquant_coeff = -((unquant_coeff - 1) | 1);
4109
                    } else {
4110
                        unquant_coeff = (((  level  << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
4111
                        unquant_coeff =   (unquant_coeff - 1) | 1;
4112
                    }
4113
                }
4114
                unquant_coeff<<= 3;
4115
            }
4116

    
4117
            distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff);
4118
            level+=64;
4119
            if((level&(~127)) == 0){
4120
                for(run=0; run<=i - left_limit; run++){
4121
                    int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4122
                    score += score_tab[i-run];
4123
                    
4124
                    if(score < best_score){
4125
                        best_score= 
4126
                        score_tab[i+1]= score;
4127
                        run_tab[i+1]= run;
4128
                        level_tab[i+1]= level-64;
4129
                    }
4130
                }
4131

    
4132
                if(s->out_format == FMT_H263){
4133
                    for(run=0; run<=i - left_limit; run++){
4134
                        int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4135
                        score += score_tab[i-run];
4136
                        if(score < last_score){
4137
                            last_score= score;
4138
                            last_run= run;
4139
                            last_level= level-64;
4140
                            last_i= i+1;
4141
                        }
4142
                    }
4143
                }
4144
            }else{
4145
                distoration += esc_length*lambda;
4146
                for(run=0; run<=i - left_limit; run++){
4147
                    int score= distoration + score_tab[i-run];
4148
                    
4149
                    if(score < best_score){
4150
                        best_score= 
4151
                        score_tab[i+1]= score;
4152
                        run_tab[i+1]= run;
4153
                        level_tab[i+1]= level-64;
4154
                    }
4155
                }
4156

    
4157
                if(s->out_format == FMT_H263){
4158
                    for(run=0; run<=i - left_limit; run++){
4159
                        int score= distoration + score_tab[i-run];
4160
                        if(score < last_score){
4161
                            last_score= score;
4162
                            last_run= run;
4163
                            last_level= level-64;
4164
                            last_i= i+1;
4165
                        }
4166
                    }
4167
                }
4168
            }
4169
        }
4170

    
4171
        for(j=left_limit; j<=i; j++){
4172
            score_tab[j] += zero_distoration;
4173
        }
4174
        score_limit+= zero_distoration;
4175
        if(score_tab[i+1] < score_limit)
4176
            score_limit= score_tab[i+1];
4177
        
4178
        //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
4179
        while(score_tab[ left_limit ] > score_limit + lambda) left_limit++;
4180
    }
4181

    
4182
        //FIXME add some cbp penalty
4183

    
4184
    if(s->out_format != FMT_H263){
4185
        last_score= 256*256*256*120;
4186
        for(i= left_limit; i<=last_non_zero - start_i + 1; i++){
4187
            int score= score_tab[i];
4188
            if(i) score += lambda*2; //FIXME exacter?
4189

    
4190
            if(score < last_score){
4191
                last_score= score;
4192
                last_i= i;
4193
                last_level= level_tab[i];
4194
                last_run= run_tab[i];
4195
            }
4196
        }
4197
    }
4198
    
4199
    last_non_zero= last_i - 1 + start_i;
4200
    memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
4201
    
4202
    if(last_non_zero < start_i)
4203
        return last_non_zero;
4204
    
4205
    i= last_i;
4206
    assert(last_level);
4207
//FIXME use permutated scantable
4208
    block[ s->dsp.idct_permutation[ scantable[last_non_zero] ] ]= last_level;
4209
    i -= last_run + 1;
4210
    
4211
    for(;i>0 ; i -= run_tab[i] + 1){
4212
        const int j= s->dsp.idct_permutation[ scantable[i - 1 + start_i] ];
4213
    
4214
        block[j]= level_tab[i];
4215
        assert(block[j]);
4216
    }
4217

    
4218
    return last_non_zero;
4219
}
4220

    
4221
static int dct_quantize_c(MpegEncContext *s, 
4222
                        DCTELEM *block, int n,
4223
                        int qscale, int *overflow)
4224
{
4225
    int i, j, level, last_non_zero, q;
4226
    const int *qmat;
4227
    const uint8_t *scantable= s->intra_scantable.scantable;
4228
    int bias;
4229
    int max=0;
4230
    unsigned int threshold1, threshold2;
4231

    
4232
    s->dsp.fdct (block);
4233

    
4234
    if (s->mb_intra) {
4235
        if (!s->h263_aic) {
4236
            if (n < 4)
4237
                q = s->y_dc_scale;
4238
            else
4239
                q = s->c_dc_scale;
4240
            q = q << 3;
4241
        } else
4242
            /* For AIC we skip quant/dequant of INTRADC */
4243
            q = 1 << 3;
4244
            
4245
        /* note: block[0] is assumed to be positive */
4246
        block[0] = (block[0] + (q >> 1)) / q;
4247
        i = 1;
4248
        last_non_zero = 0;
4249
        qmat = s->q_intra_matrix[qscale];
4250
        bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4251
    } else {
4252
        i = 0;
4253
        last_non_zero = -1;
4254
        qmat = s->q_inter_matrix[qscale];
4255
        bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4256
    }
4257
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
4258
    threshold2= (threshold1<<1);
4259

    
4260
    for(;i<64;i++) {
4261
        j = scantable[i];
4262
        level = block[j];
4263
        level = level * qmat[j];
4264

    
4265
//        if(   bias+level >= (1<<QMAT_SHIFT)
4266
//           || bias-level >= (1<<QMAT_SHIFT)){
4267
        if(((unsigned)(level+threshold1))>threshold2){
4268
            if(level>0){
4269
                level= (bias + level)>>QMAT_SHIFT;
4270
                block[j]= level;
4271
            }else{
4272
                level= (bias - level)>>QMAT_SHIFT;
4273
                block[j]= -level;
4274
            }
4275
            max |=level;
4276
            last_non_zero = i;
4277
        }else{
4278
            block[j]=0;
4279
        }
4280
    }
4281
    *overflow= s->max_qcoeff < max; //overflow might have happend
4282
    
4283
    /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4284
    if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
4285
        ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4286

    
4287
    return last_non_zero;
4288
}
4289

    
4290
#endif //CONFIG_ENCODERS
4291

    
4292
static void dct_unquantize_mpeg1_c(MpegEncContext *s, 
4293
                                   DCTELEM *block, int n, int qscale)
4294
{
4295
    int i, level, nCoeffs;
4296
    const uint16_t *quant_matrix;
4297

    
4298
    nCoeffs= s->block_last_index[n];
4299
    
4300
    if (s->mb_intra) {
4301
        if (n < 4) 
4302
            block[0] = block[0] * s->y_dc_scale;
4303
        else
4304
            block[0] = block[0] * s->c_dc_scale;
4305
        /* XXX: only mpeg1 */
4306
        quant_matrix = s->intra_matrix;
4307
        for(i=1;i<=nCoeffs;i++) {
4308
            int j= s->intra_scantable.permutated[i];
4309
            level = block[j];
4310
            if (level) {
4311
                if (level < 0) {
4312
                    level = -level;
4313
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
4314
                    level = (level - 1) | 1;
4315
                    level = -level;
4316
                } else {
4317
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
4318
                    level = (level - 1) | 1;
4319
                }
4320
#ifdef PARANOID
4321
                if (level < -2048 || level > 2047)
4322
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4323
#endif
4324
                block[j] = level;
4325
            }
4326
        }
4327
    } else {
4328
        i = 0;
4329
        quant_matrix = s->inter_matrix;
4330
        for(;i<=nCoeffs;i++) {
4331
            int j= s->intra_scantable.permutated[i];
4332
            level = block[j];
4333
            if (level) {
4334
                if (level < 0) {
4335
                    level = -level;
4336
                    level = (((level << 1) + 1) * qscale *
4337
                             ((int) (quant_matrix[j]))) >> 4;
4338
                    level = (level - 1) | 1;
4339
                    level = -level;
4340
                } else {
4341
                    level = (((level << 1) + 1) * qscale *
4342
                             ((int) (quant_matrix[j]))) >> 4;
4343
                    level = (level - 1) | 1;
4344
                }
4345
#ifdef PARANOID
4346
                if (level < -2048 || level > 2047)
4347
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4348
#endif
4349
                block[j] = level;
4350
            }
4351
        }
4352
    }
4353
}
4354

    
4355
static void dct_unquantize_mpeg2_c(MpegEncContext *s, 
4356
                                   DCTELEM *block, int n, int qscale)
4357
{
4358
    int i, level, nCoeffs;
4359
    const uint16_t *quant_matrix;
4360

    
4361
    if(s->alternate_scan) nCoeffs= 63;
4362
    else nCoeffs= s->block_last_index[n];
4363
    
4364
    if (s->mb_intra) {
4365
        if (n < 4) 
4366
            block[0] = block[0] * s->y_dc_scale;
4367
        else
4368
            block[0] = block[0] * s->c_dc_scale;
4369
        quant_matrix = s->intra_matrix;
4370
        for(i=1;i<=nCoeffs;i++) {
4371
            int j= s->intra_scantable.permutated[i];
4372
            level = block[j];
4373
            if (level) {
4374
                if (level < 0) {
4375
                    level = -level;
4376
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
4377
                    level = -level;
4378
                } else {
4379
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
4380
                }
4381
#ifdef PARANOID
4382
                if (level < -2048 || level > 2047)
4383
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4384
#endif
4385
                block[j] = level;
4386
            }
4387
        }
4388
    } else {
4389
        int sum=-1;
4390
        i = 0;
4391
        quant_matrix = s->inter_matrix;
4392
        for(;i<=nCoeffs;i++) {
4393
            int j= s->intra_scantable.permutated[i];
4394
            level = block[j];
4395
            if (level) {
4396
                if (level < 0) {
4397
                    level = -level;
4398
                    level = (((level << 1) + 1) * qscale *
4399
                             ((int) (quant_matrix[j]))) >> 4;
4400
                    level = -level;
4401
                } else {
4402
                    level = (((level << 1) + 1) * qscale *
4403
                             ((int) (quant_matrix[j]))) >> 4;
4404
                }
4405
#ifdef PARANOID
4406
                if (level < -2048 || level > 2047)
4407
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4408
#endif
4409
                block[j] = level;
4410
                sum+=level;
4411
            }
4412
        }
4413
        block[63]^=sum&1;
4414
    }
4415
}
4416

    
4417

    
4418
static void dct_unquantize_h263_c(MpegEncContext *s, 
4419
                                  DCTELEM *block, int n, int qscale)
4420
{
4421
    int i, level, qmul, qadd;
4422
    int nCoeffs;
4423
    
4424
    assert(s->block_last_index[n]>=0);
4425
    
4426
    qadd = (qscale - 1) | 1;
4427
    qmul = qscale << 1;
4428
    
4429
    if (s->mb_intra) {
4430
        if (!s->h263_aic) {
4431
            if (n < 4) 
4432
                block[0] = block[0] * s->y_dc_scale;
4433
            else
4434
                block[0] = block[0] * s->c_dc_scale;
4435
        }else
4436
            qadd = 0;
4437
        i = 1;
4438
        nCoeffs= 63; //does not allways use zigzag table 
4439
    } else {
4440
        i = 0;
4441
        nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
4442
    }
4443

    
4444
    for(;i<=nCoeffs;i++) {
4445
        level = block[i];
4446
        if (level) {
4447
            if (level < 0) {
4448
                level = level * qmul - qadd;
4449
            } else {
4450
                level = level * qmul + qadd;
4451
            }
4452
#ifdef PARANOID
4453
                if (level < -2048 || level > 2047)
4454
                    fprintf(stderr, "unquant error %d %d\n", i, level);
4455
#endif
4456
            block[i] = level;
4457
        }
4458
    }
4459
}
4460

    
4461

    
4462
static const AVOption mpeg4_options[] =
4463
{
4464
    AVOPTION_CODEC_INT("bitrate", "desired video bitrate", bit_rate, 4, 240000000, 800000),
4465
    AVOPTION_CODEC_INT("ratetol", "number of bits the bitstream is allowed to diverge from the reference"
4466
                       "the reference can be CBR (for CBR pass1) or VBR (for pass2)",
4467
                       bit_rate_tolerance, 4, 240000000, 8000),
4468
    AVOPTION_CODEC_INT("qmin", "minimum quantizer", qmin, 1, 31, 2),
4469
    AVOPTION_CODEC_INT("qmax", "maximum quantizer", qmax, 1, 31, 31),
4470
    AVOPTION_CODEC_STRING("rc_eq", "rate control equation",
4471
                          rc_eq, "tex^qComp,option1,options2", 0),
4472
    AVOPTION_CODEC_INT("rc_minrate", "rate control minimum bitrate",
4473
                       rc_min_rate, 4, 24000000, 0),
4474
    AVOPTION_CODEC_INT("rc_maxrate", "rate control maximum bitrate",
4475
                       rc_max_rate, 4, 24000000, 0),
4476
    AVOPTION_CODEC_DOUBLE("rc_buf_aggresivity", "rate control buffer aggresivity",
4477
                          rc_buffer_aggressivity, 4, 24000000, 0),
4478
    AVOPTION_CODEC_DOUBLE("rc_initial_cplx", "initial complexity for pass1 ratecontrol",
4479
                          rc_initial_cplx, 0., 9999999., 0),
4480
    AVOPTION_CODEC_DOUBLE("i_quant_factor", "qscale factor between p and i frames",
4481
                          i_quant_factor, 0., 0., 0),
4482
    AVOPTION_CODEC_DOUBLE("i_quant_offset", "qscale offset between p and i frames",
4483
                          i_quant_factor, -999999., 999999., 0),
4484
    AVOPTION_CODEC_INT("dct_algo", "dct alghorithm",
4485
                       dct_algo, 0, 5, 0), // fixme - "Auto,FastInt,Int,MMX,MLib,Altivec"
4486
    AVOPTION_CODEC_DOUBLE("lumi_masking", "luminance masking",
4487
                          lumi_masking, 0., 999999., 0),
4488
    AVOPTION_CODEC_DOUBLE("temporal_cplx_masking", "temporary complexity masking",
4489
                          temporal_cplx_masking, 0., 999999., 0),
4490
    AVOPTION_CODEC_DOUBLE("spatial_cplx_masking", "spatial complexity masking",
4491
                          spatial_cplx_masking, 0., 999999., 0),
4492
    AVOPTION_CODEC_DOUBLE("p_masking", "p block masking",
4493
                          p_masking, 0., 999999., 0),
4494
    AVOPTION_CODEC_DOUBLE("dark_masking", "darkness masking",
4495
                          dark_masking, 0., 999999., 0),
4496
    AVOPTION_CODEC_INT("idct_algo", "idct alghorithm",
4497
                       idct_algo, 0, 8, 0), // fixme - "Auto,Int,Simple,SimpleMMX,LibMPEG2MMX,PS2,MLib,ARM,Altivec"
4498

    
4499
    AVOPTION_CODEC_INT("mb_qmin", "minimum MB quantizer",
4500
                       mb_qmin, 0, 8, 0),
4501
    AVOPTION_CODEC_INT("mb_qmax", "maximum MB quantizer",
4502
                       mb_qmin, 0, 8, 0),
4503

    
4504
    AVOPTION_CODEC_INT("me_cmp", "ME compare function",
4505
                       me_cmp, 0, 24000000, 0),
4506
    AVOPTION_CODEC_INT("me_sub_cmp", "subpixel ME compare function",
4507
                       me_sub_cmp, 0, 24000000, 0),
4508

    
4509

    
4510
    AVOPTION_CODEC_INT("dia_size", "ME diamond size & shape",
4511
                       dia_size, 0, 24000000, 0),
4512
    AVOPTION_CODEC_INT("last_predictor_count", "amount of previous MV predictors",
4513
                       last_predictor_count, 0, 24000000, 0),
4514

    
4515
    AVOPTION_CODEC_INT("pre_me", "pre pass for ME",
4516
                       pre_me, 0, 24000000, 0),
4517
    AVOPTION_CODEC_INT("me_pre_cmp", "ME pre pass compare function",
4518
                       me_pre_cmp, 0, 24000000, 0),
4519

    
4520
    AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4521
                       me_range, 0, 24000000, 0),
4522
    AVOPTION_CODEC_INT("pre_dia_size", "ME pre pass diamod size & shape",
4523
                       pre_dia_size, 0, 24000000, 0),
4524
    AVOPTION_CODEC_INT("me_subpel_quality", "subpel ME quality",
4525
                       me_subpel_quality, 0, 24000000, 0),
4526
    AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4527
                       me_range, 0, 24000000, 0),
4528
    AVOPTION_CODEC_FLAG("psnr", "calculate PSNR of compressed frames",
4529
                        flags, CODEC_FLAG_PSNR, 0),
4530
    AVOPTION_CODEC_RCOVERRIDE("rc_override", "ratecontrol override (=startframe,endframe,qscale,quality_factor)",
4531
                              rc_override),
4532
    AVOPTION_SUB(avoptions_common),
4533
    AVOPTION_END()
4534
};
4535

    
4536
#ifdef CONFIG_ENCODERS
4537

    
4538
AVCodec mpeg1video_encoder = {
4539
    "mpeg1video",
4540
    CODEC_TYPE_VIDEO,
4541
    CODEC_ID_MPEG1VIDEO,
4542
    sizeof(MpegEncContext),
4543
    MPV_encode_init,
4544
    MPV_encode_picture,
4545
    MPV_encode_end,
4546
};
4547

    
4548
#ifdef CONFIG_RISKY
4549

    
4550
AVCodec mpeg2video_encoder = {
4551
    "mpeg2video",
4552
    CODEC_TYPE_VIDEO,
4553
    CODEC_ID_MPEG2VIDEO,
4554
    sizeof(MpegEncContext),
4555
    MPV_encode_init,
4556
    MPV_encode_picture,
4557
    MPV_encode_end,
4558
};
4559

    
4560
AVCodec h263_encoder = {
4561
    "h263",
4562
    CODEC_TYPE_VIDEO,
4563
    CODEC_ID_H263,
4564
    sizeof(MpegEncContext),
4565
    MPV_encode_init,
4566
    MPV_encode_picture,
4567
    MPV_encode_end,
4568
};
4569

    
4570
AVCodec h263p_encoder = {
4571
    "h263p",
4572
    CODEC_TYPE_VIDEO,
4573
    CODEC_ID_H263P,
4574
    sizeof(MpegEncContext),
4575
    MPV_encode_init,
4576
    MPV_encode_picture,
4577
    MPV_encode_end,
4578
};
4579

    
4580
AVCodec flv_encoder = {
4581
    "flv",
4582
    CODEC_TYPE_VIDEO,
4583
    CODEC_ID_FLV1,
4584
    sizeof(MpegEncContext),
4585
    MPV_encode_init,
4586
    MPV_encode_picture,
4587
    MPV_encode_end,
4588
};
4589

    
4590
AVCodec rv10_encoder = {
4591
    "rv10",
4592
    CODEC_TYPE_VIDEO,
4593
    CODEC_ID_RV10,
4594
    sizeof(MpegEncContext),
4595
    MPV_encode_init,
4596
    MPV_encode_picture,
4597
    MPV_encode_end,
4598
};
4599

    
4600
AVCodec mpeg4_encoder = {
4601
    "mpeg4",
4602
    CODEC_TYPE_VIDEO,
4603
    CODEC_ID_MPEG4,
4604
    sizeof(MpegEncContext),
4605
    MPV_encode_init,
4606
    MPV_encode_picture,
4607
    MPV_encode_end,
4608
    .options = mpeg4_options,
4609
};
4610

    
4611
AVCodec msmpeg4v1_encoder = {
4612
    "msmpeg4v1",
4613
    CODEC_TYPE_VIDEO,
4614
    CODEC_ID_MSMPEG4V1,
4615
    sizeof(MpegEncContext),
4616
    MPV_encode_init,
4617
    MPV_encode_picture,
4618
    MPV_encode_end,
4619
    .options = mpeg4_options,
4620
};
4621

    
4622
AVCodec msmpeg4v2_encoder = {
4623
    "msmpeg4v2",
4624
    CODEC_TYPE_VIDEO,
4625
    CODEC_ID_MSMPEG4V2,
4626
    sizeof(MpegEncContext),
4627
    MPV_encode_init,
4628
    MPV_encode_picture,
4629
    MPV_encode_end,
4630
    .options = mpeg4_options,
4631
};
4632

    
4633
AVCodec msmpeg4v3_encoder = {
4634
    "msmpeg4",
4635
    CODEC_TYPE_VIDEO,
4636
    CODEC_ID_MSMPEG4V3,
4637
    sizeof(MpegEncContext),
4638
    MPV_encode_init,
4639
    MPV_encode_picture,
4640
    MPV_encode_end,
4641
    .options = mpeg4_options,
4642
};
4643

    
4644
AVCodec wmv1_encoder = {
4645
    "wmv1",
4646
    CODEC_TYPE_VIDEO,
4647
    CODEC_ID_WMV1,
4648
    sizeof(MpegEncContext),
4649
    MPV_encode_init,
4650
    MPV_encode_picture,
4651
    MPV_encode_end,
4652
    .options = mpeg4_options,
4653
};
4654

    
4655
#endif
4656

    
4657
AVCodec mjpeg_encoder = {
4658
    "mjpeg",
4659
    CODEC_TYPE_VIDEO,
4660
    CODEC_ID_MJPEG,
4661
    sizeof(MpegEncContext),
4662
    MPV_encode_init,
4663
    MPV_encode_picture,
4664
    MPV_encode_end,
4665
};
4666

    
4667
#endif //CONFIG_ENCODERS
4668