Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 0da71265

History | View | Annotate | Download (143 KB)

1
/*
2
 * The simplest mpeg encoder (well, it was the simplest!)
3
 * Copyright (c) 2000,2001 Fabrice Bellard.
4
 *
5
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9
 *
10
 * This library is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 *
19
 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
20
 */
21
 
22
/**
23
 * @file mpegvideo.c
24
 * The simplest mpeg encoder (well, it was the simplest!).
25
 */ 
26
 
27
#include <ctype.h>
28
#include <limits.h>
29
#include "avcodec.h"
30
#include "dsputil.h"
31
#include "mpegvideo.h"
32

    
33
#ifdef USE_FASTMEMCPY
34
#include "fastmemcpy.h"
35
#endif
36

    
37
//#undef NDEBUG
38
//#include <assert.h>
39

    
40
#ifdef CONFIG_ENCODERS
41
static void encode_picture(MpegEncContext *s, int picture_number);
42
#endif //CONFIG_ENCODERS
43
static void dct_unquantize_mpeg1_c(MpegEncContext *s, 
44
                                   DCTELEM *block, int n, int qscale);
45
static void dct_unquantize_mpeg2_c(MpegEncContext *s,
46
                                   DCTELEM *block, int n, int qscale);
47
static void dct_unquantize_h263_c(MpegEncContext *s, 
48
                                  DCTELEM *block, int n, int qscale);
49
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
50
#ifdef CONFIG_ENCODERS
51
static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
52
static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
53
#endif //CONFIG_ENCODERS
54

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

    
57

    
58
/* enable all paranoid tests for rounding, overflows, etc... */
59
//#define PARANOID
60

    
61
//#define DEBUG
62

    
63

    
64
/* for jpeg fast DCT */
65
#define CONST_BITS 14
66

    
67
static const uint16_t aanscales[64] = {
68
    /* precomputed values scaled up by 14 bits */
69
    16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
70
    22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
71
    21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
72
    19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
73
    16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
74
    12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
75
    8867 , 12299, 11585, 10426,  8867,  6967,  4799,  2446,
76
    4520 ,  6270,  5906,  5315,  4520,  3552,  2446,  1247
77
};
78

    
79
static const uint8_t h263_chroma_roundtab[16] = {
80
//  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
81
    0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
82
};
83

    
84
#ifdef CONFIG_ENCODERS
85
static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
86
static uint8_t default_fcode_tab[MAX_MV*2+1];
87

    
88
enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
89

    
90
static void convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[64], uint16_t (*qmat16_bias)[64],
91
                           const uint16_t *quant_matrix, int bias, int qmin, int qmax)
92
{
93
    int qscale;
94

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

    
131
                if(qmat16[qscale][i]==0 || qmat16[qscale][i]==128*256) qmat16[qscale][i]=128*256-1;
132
                qmat16_bias[qscale][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][i]);
133
            }
134
        }
135
    }
136
}
137
#endif //CONFIG_ENCODERS
138

    
139
// move into common.c perhaps 
140
#define CHECKED_ALLOCZ(p, size)\
141
{\
142
    p= av_mallocz(size);\
143
    if(p==NULL){\
144
        perror("malloc");\
145
        goto fail;\
146
    }\
147
}
148

    
149
void ff_init_scantable(MpegEncContext *s, ScanTable *st, const uint8_t *src_scantable){
150
    int i;
151
    int end;
152
    
153
    st->scantable= src_scantable;
154

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

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

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

    
203
#ifdef CONFIG_ENCODERS
204
    s->fast_dct_quantize= s->dct_quantize;
205

    
206
    if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
207
        s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
208
    }
209

    
210
#endif //CONFIG_ENCODERS
211

    
212
    /* load & permutate scantables
213
       note: only wmv uses differnt ones 
214
    */
215
    ff_init_scantable(s, &s->inter_scantable  , ff_zigzag_direct);
216
    ff_init_scantable(s, &s->intra_scantable  , ff_zigzag_direct);
217
    ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);
218
    ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
219

    
220
    s->picture_structure= PICT_FRAME;
221
    
222
    return 0;
223
}
224

    
225
/**
226
 * allocates a Picture
227
 * The pixels are allocated/set by calling get_buffer() if shared=0
228
 */
229
static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
230
    const int big_mb_num= (s->mb_width+1)*(s->mb_height+1);
231
    int i;
232

    
233
    if(shared){
234
        assert(pic->data[0]);
235
        assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
236
        pic->type= FF_BUFFER_TYPE_SHARED;
237
    }else{
238
        int r;
239
        
240
        assert(!pic->data[0]);
241
        
242
        r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
243
        
244
        if(r<0 || !pic->age || !pic->type || !pic->data[0]){
245
            fprintf(stderr, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
246
            return -1;
247
        }
248

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

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

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

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

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

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

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

    
305
    av_freep(&pic->mb_var);
306
    av_freep(&pic->mc_mb_var);
307
    av_freep(&pic->mb_mean);
308
    av_freep(&pic->mb_cmp_score);
309
    av_freep(&pic->mbskip_table);
310
    av_freep(&pic->qscale_table);
311
    av_freep(&pic->mb_type_base);
312
    pic->mb_type= NULL;
313
    for(i=0; i<2; i++){
314
        av_freep(&pic->motion_val[i]);
315
        av_freep(&pic->ref_index[i]);
316
    }
317

    
318
    if(pic->type == FF_BUFFER_TYPE_INTERNAL){
319
        for(i=0; i<4; i++){
320
            av_freep(&pic->base[i]);
321
            pic->data[i]= NULL;
322
        }
323
        av_freep(&pic->opaque);
324
        pic->type= 0;
325
    }else if(pic->type == FF_BUFFER_TYPE_SHARED){
326
        for(i=0; i<4; i++){
327
            pic->base[i]=
328
            pic->data[i]= NULL;
329
        }
330
        pic->type= 0;        
331
    }
332
}
333

    
334
/* init common structure for both encoder and decoder */
335
int MPV_common_init(MpegEncContext *s)
336
{
337
    int y_size, c_size, yc_size, i;
338

    
339
    dsputil_init(&s->dsp, s->avctx);
340
    DCT_common_init(s);
341

    
342
    s->flags= s->avctx->flags;
343

    
344
    s->mb_width  = (s->width  + 15) / 16;
345
    s->mb_height = (s->height + 15) / 16;
346

    
347
    /* set default edge pos, will be overriden in decode_header if needed */
348
    s->h_edge_pos= s->mb_width*16;
349
    s->v_edge_pos= s->mb_height*16;
350

    
351
    s->mb_num = s->mb_width * s->mb_height;
352

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

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

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

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

    
368
    if (s->encoding) {
369
        int mv_table_size= (s->mb_width+2)*(s->mb_height+2);
370

    
371
        /* Allocate MV tables */
372
        CHECKED_ALLOCZ(s->p_mv_table            , mv_table_size * 2 * sizeof(int16_t))
373
        CHECKED_ALLOCZ(s->b_forw_mv_table       , mv_table_size * 2 * sizeof(int16_t))
374
        CHECKED_ALLOCZ(s->b_back_mv_table       , mv_table_size * 2 * sizeof(int16_t))
375
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table , mv_table_size * 2 * sizeof(int16_t))
376
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table , mv_table_size * 2 * sizeof(int16_t))
377
        CHECKED_ALLOCZ(s->b_direct_mv_table     , mv_table_size * 2 * sizeof(int16_t))
378

    
379
        //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
380
        CHECKED_ALLOCZ(s->me.scratchpad,  s->width*2*16*3*sizeof(uint8_t)) 
381
        
382
        CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
383
        CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
384

    
385
        if(s->codec_id==CODEC_ID_MPEG4){
386
            CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
387
            CHECKED_ALLOCZ(   s->pb2_buffer, PB_BUFFER_SIZE);
388
        }
389
        
390
        if(s->msmpeg4_version){
391
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
392
        }
393
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
394
    }
395
        
396
    CHECKED_ALLOCZ(s->error_status_table, s->mb_num*sizeof(uint8_t))
397
    
398
    if (s->out_format == FMT_H263 || s->encoding) {
399
        int size;
400
        /* Allocate MB type table */
401
        CHECKED_ALLOCZ(s->mb_type  , s->mb_num * sizeof(uint8_t))
402

    
403
        /* MV prediction */
404
        size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
405
        CHECKED_ALLOCZ(s->motion_val, size * 2 * sizeof(int16_t));
406
    }
407

    
408
    if(s->codec_id==CODEC_ID_MPEG4){
409
        /* interlaced direct mode decoding tables */
410
        CHECKED_ALLOCZ(s->field_mv_table, s->mb_num*2*2 * sizeof(int16_t))
411
        CHECKED_ALLOCZ(s->field_select_table, s->mb_num*2* sizeof(int8_t))
412
    }
413
    /* 4mv b frame decoding table */
414
    //note this is needed for h263 without b frames too (segfault on damaged streams otherwise)
415
    CHECKED_ALLOCZ(s->co_located_type_table, s->mb_num * sizeof(uint8_t))
416
    if (s->out_format == FMT_H263) {
417
        /* ac values */
418
        CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(int16_t) * 16);
419
        s->ac_val[1] = s->ac_val[0] + y_size;
420
        s->ac_val[2] = s->ac_val[1] + c_size;
421
        
422
        /* cbp values */
423
        CHECKED_ALLOCZ(s->coded_block, y_size);
424
        
425
        /* divx501 bitstream reorder buffer */
426
        CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
427

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

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

    
457
    s->parse_context.state= -1;
458

    
459
    s->context_initialized = 1;
460
    return 0;
461
 fail:
462
    MPV_common_end(s);
463
    return -1;
464
}
465

    
466

    
467
//extern int sads;
468

    
469
/* init common structure for both encoder and decoder */
470
void MPV_common_end(MpegEncContext *s)
471
{
472
    int i;
473

    
474
    av_freep(&s->mb_type);
475
    av_freep(&s->p_mv_table);
476
    av_freep(&s->b_forw_mv_table);
477
    av_freep(&s->b_back_mv_table);
478
    av_freep(&s->b_bidir_forw_mv_table);
479
    av_freep(&s->b_bidir_back_mv_table);
480
    av_freep(&s->b_direct_mv_table);
481
    av_freep(&s->motion_val);
482
    av_freep(&s->dc_val[0]);
483
    av_freep(&s->ac_val[0]);
484
    av_freep(&s->coded_block);
485
    av_freep(&s->mbintra_table);
486
    av_freep(&s->cbp_table);
487
    av_freep(&s->pred_dir_table);
488
    av_freep(&s->me.scratchpad);
489
    av_freep(&s->me.map);
490
    av_freep(&s->me.score_map);
491
    
492
    av_freep(&s->mbskip_table);
493
    av_freep(&s->prev_pict_types);
494
    av_freep(&s->bitstream_buffer);
495
    av_freep(&s->tex_pb_buffer);
496
    av_freep(&s->pb2_buffer);
497
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
498
    av_freep(&s->co_located_type_table);
499
    av_freep(&s->field_mv_table);
500
    av_freep(&s->field_select_table);
501
    av_freep(&s->avctx->stats_out);
502
    av_freep(&s->ac_stats);
503
    av_freep(&s->error_status_table);
504

    
505
    for(i=0; i<MAX_PICTURE_COUNT; i++){
506
        free_picture(s, &s->picture[i]);
507
    }
508
    s->context_initialized = 0;
509
}
510

    
511
#ifdef CONFIG_ENCODERS
512

    
513
/* init video encoder */
514
int MPV_encode_init(AVCodecContext *avctx)
515
{
516
    MpegEncContext *s = avctx->priv_data;
517
    int i;
518

    
519
    avctx->pix_fmt = PIX_FMT_YUV420P;
520

    
521
    s->bit_rate = avctx->bit_rate;
522
    s->bit_rate_tolerance = avctx->bit_rate_tolerance;
523
    s->width = avctx->width;
524
    s->height = avctx->height;
525
    if(avctx->gop_size > 600){
526
        fprintf(stderr, "Warning keyframe interval too large! reducing it ...\n");
527
        avctx->gop_size=600;
528
    }
529
    s->gop_size = avctx->gop_size;
530
    s->rtp_mode = avctx->rtp_mode;
531
    s->rtp_payload_size = avctx->rtp_payload_size;
532
    if (avctx->rtp_callback)
533
        s->rtp_callback = avctx->rtp_callback;
534
    s->max_qdiff= avctx->max_qdiff;
535
    s->qcompress= avctx->qcompress;
536
    s->qblur= avctx->qblur;
537
    s->avctx = avctx;
538
    s->flags= avctx->flags;
539
    s->max_b_frames= avctx->max_b_frames;
540
    s->b_frame_strategy= avctx->b_frame_strategy;
541
    s->codec_id= avctx->codec->id;
542
    s->luma_elim_threshold  = avctx->luma_elim_threshold;
543
    s->chroma_elim_threshold= avctx->chroma_elim_threshold;
544
    s->strict_std_compliance= avctx->strict_std_compliance;
545
    s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
546
    s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
547
    s->mpeg_quant= avctx->mpeg_quant;
548

    
549
    if (s->gop_size <= 1) {
550
        s->intra_only = 1;
551
        s->gop_size = 12;
552
    } else {
553
        s->intra_only = 0;
554
    }
555

    
556
    s->me_method = avctx->me_method;
557

    
558
    /* Fixed QSCALE */
559
    s->fixed_qscale = (avctx->flags & CODEC_FLAG_QSCALE);
560
    
561
    s->adaptive_quant= (   s->avctx->lumi_masking
562
                        || s->avctx->dark_masking
563
                        || s->avctx->temporal_cplx_masking 
564
                        || s->avctx->spatial_cplx_masking
565
                        || s->avctx->p_masking)
566
                       && !s->fixed_qscale;
567
    
568
    s->progressive_sequence= !(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
569

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

    
702
            default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
703
            memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
704
            memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
705

    
706
            for(i=-16; i<16; i++){
707
                default_fcode_tab[i + MAX_MV]= 1;
708
            }
709
        }
710
    }
711
    s->me.mv_penalty= default_mv_penalty;
712
    s->fcode_tab= default_fcode_tab;
713
    s->y_dc_scale_table=
714
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
715
 
716
    /* dont use mv_penalty table for crap MV as it would be confused */
717
    //FIXME remove after fixing / removing old ME
718
    if (s->me_method < ME_EPZS) s->me.mv_penalty = default_mv_penalty;
719

    
720
    s->encoding = 1;
721

    
722
    /* init */
723
    if (MPV_common_init(s) < 0)
724
        return -1;
725
    
726
    ff_init_me(s);
727

    
728
#ifdef CONFIG_ENCODERS
729
#ifdef CONFIG_RISKY
730
    if (s->out_format == FMT_H263)
731
        h263_encode_init(s);
732
    if(s->msmpeg4_version)
733
        ff_msmpeg4_encode_init(s);
734
#endif
735
    if (s->out_format == FMT_MPEG1)
736
        ff_mpeg1_encode_init(s);
737
#endif
738

    
739
    /* init default q matrix */
740
    for(i=0;i<64;i++) {
741
        int j= s->dsp.idct_permutation[i];
742
#ifdef CONFIG_RISKY
743
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
744
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
745
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
746
        }else if(s->out_format == FMT_H263){
747
            s->intra_matrix[j] =
748
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
749
        }else
750
#endif
751
        { /* mpeg1 */
752
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
753
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
754
        }
755
    }
756

    
757
    /* precompute matrix */
758
    /* for mjpeg, we do include qscale in the matrix */
759
    if (s->out_format != FMT_MJPEG) {
760
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, s->q_intra_matrix16_bias, 
761
                       s->intra_matrix, s->intra_quant_bias, 1, 31);
762
        convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16, s->q_inter_matrix16_bias, 
763
                       s->inter_matrix, s->inter_quant_bias, 1, 31);
764
    }
765

    
766
    if(ff_rate_control_init(s) < 0)
767
        return -1;
768

    
769
    s->picture_number = 0;
770
    s->picture_in_gop_number = 0;
771
    s->fake_picture_number = 0;
772
    /* motion detector init */
773
    s->f_code = 1;
774
    s->b_code = 1;
775

    
776
    return 0;
777
}
778

    
779
int MPV_encode_end(AVCodecContext *avctx)
780
{
781
    MpegEncContext *s = avctx->priv_data;
782

    
783
#ifdef STATS
784
    print_stats();
785
#endif
786

    
787
    ff_rate_control_uninit(s);
788

    
789
    MPV_common_end(s);
790
    if (s->out_format == FMT_MJPEG)
791
        mjpeg_close(s);
792
      
793
    return 0;
794
}
795

    
796
#endif //CONFIG_ENCODERS
797

    
798
void init_rl(RLTable *rl)
799
{
800
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
801
    uint8_t index_run[MAX_RUN+1];
802
    int last, run, level, start, end, i;
803

    
804
    /* compute max_level[], max_run[] and index_run[] */
805
    for(last=0;last<2;last++) {
806
        if (last == 0) {
807
            start = 0;
808
            end = rl->last;
809
        } else {
810
            start = rl->last;
811
            end = rl->n;
812
        }
813

    
814
        memset(max_level, 0, MAX_RUN + 1);
815
        memset(max_run, 0, MAX_LEVEL + 1);
816
        memset(index_run, rl->n, MAX_RUN + 1);
817
        for(i=start;i<end;i++) {
818
            run = rl->table_run[i];
819
            level = rl->table_level[i];
820
            if (index_run[run] == rl->n)
821
                index_run[run] = i;
822
            if (level > max_level[run])
823
                max_level[run] = level;
824
            if (run > max_run[level])
825
                max_run[level] = run;
826
        }
827
        rl->max_level[last] = av_malloc(MAX_RUN + 1);
828
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
829
        rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
830
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
831
        rl->index_run[last] = av_malloc(MAX_RUN + 1);
832
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
833
    }
834
}
835

    
836
/* draw the edges of width 'w' of an image of size width, height */
837
//FIXME check that this is ok for mpeg4 interlaced
838
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
839
{
840
    uint8_t *ptr, *last_line;
841
    int i;
842

    
843
    last_line = buf + (height - 1) * wrap;
844
    for(i=0;i<w;i++) {
845
        /* top and bottom */
846
        memcpy(buf - (i + 1) * wrap, buf, width);
847
        memcpy(last_line + (i + 1) * wrap, last_line, width);
848
    }
849
    /* left and right */
850
    ptr = buf;
851
    for(i=0;i<height;i++) {
852
        memset(ptr - w, ptr[0], w);
853
        memset(ptr + width, ptr[width-1], w);
854
        ptr += wrap;
855
    }
856
    /* corners */
857
    for(i=0;i<w;i++) {
858
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
859
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
860
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
861
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
862
    }
863
}
864

    
865
static int find_unused_picture(MpegEncContext *s, int shared){
866
    int i;
867
    
868
    if(shared){
869
        for(i=0; i<MAX_PICTURE_COUNT; i++){
870
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) break;
871
        }
872
    }else{
873
        for(i=0; i<MAX_PICTURE_COUNT; i++){
874
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) break; //FIXME
875
        }
876
        for(i=0; i<MAX_PICTURE_COUNT; i++){
877
            if(s->picture[i].data[0]==NULL) break;
878
        }
879
    }
880

    
881
    assert(i<MAX_PICTURE_COUNT);
882
    return i;
883
}
884

    
885
/* generic function for encode/decode called before a frame is coded/decoded */
886
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
887
{
888
    int i;
889
    AVFrame *pic;
890

    
891
    s->mb_skiped = 0;
892

    
893
    assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264);
894
        
895
    /* mark&release old frames */
896
    if (s->pict_type != B_TYPE && s->last_picture_ptr) {
897
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
898

    
899
        /* release forgotten pictures */
900
        /* if(mpeg124/h263) */
901
        if(!s->encoding){
902
            for(i=0; i<MAX_PICTURE_COUNT; i++){
903
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
904
                    fprintf(stderr, "releasing zombie picture\n");
905
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
906
                }
907
            }
908
        }
909
    }
910
    
911
alloc:
912
    if(!s->encoding){
913
        i= find_unused_picture(s, 0);
914
    
915
        pic= (AVFrame*)&s->picture[i];
916
        pic->reference= s->pict_type != B_TYPE ? 3 : 0;
917

    
918
        if(s->current_picture_ptr)
919
            pic->coded_picture_number= s->current_picture_ptr->coded_picture_number+1;
920
        
921
        alloc_picture(s, (Picture*)pic, 0);
922

    
923
        s->current_picture_ptr= &s->picture[i];
924
    }
925

    
926
    s->current_picture= *s->current_picture_ptr;
927
  if(s->out_format != FMT_H264){
928
    if (s->pict_type != B_TYPE) {
929
        s->last_picture_ptr= s->next_picture_ptr;
930
        s->next_picture_ptr= s->current_picture_ptr;
931
    }
932
    if(s->last_picture_ptr) s->last_picture= *s->last_picture_ptr;
933
    if(s->next_picture_ptr) s->next_picture= *s->next_picture_ptr;
934
    if(s->new_picture_ptr ) s->new_picture = *s->new_picture_ptr;
935
    
936
    if(s->picture_structure!=PICT_FRAME){
937
        int i;
938
        for(i=0; i<4; i++){
939
            if(s->picture_structure == PICT_BOTTOM_FIELD){
940
                 s->current_picture.data[i] += s->current_picture.linesize[i];
941
            } 
942
            s->current_picture.linesize[i] *= 2;
943
            s->last_picture.linesize[i] *=2;
944
            s->next_picture.linesize[i] *=2;
945
        }
946
    }
947
    
948
    if(s->pict_type != I_TYPE && s->last_picture_ptr==NULL){
949
        fprintf(stderr, "warning: first frame is no keyframe\n");
950
        assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
951
        goto alloc;
952
    }
953
  }
954
   
955
    s->hurry_up= s->avctx->hurry_up;
956
    s->error_resilience= avctx->error_resilience;
957

    
958
    /* set dequantizer, we cant do it during init as it might change for mpeg4
959
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
960
    if(s->out_format == FMT_H263){
961
        if(s->mpeg_quant)
962
            s->dct_unquantize = s->dct_unquantize_mpeg2;
963
        else
964
            s->dct_unquantize = s->dct_unquantize_h263;
965
    }else 
966
        s->dct_unquantize = s->dct_unquantize_mpeg1;
967

    
968
    return 0;
969
}
970

    
971
/* generic function for encode/decode called after a frame has been coded/decoded */
972
void MPV_frame_end(MpegEncContext *s)
973
{
974
    int i;
975
    /* draw edge for correct motion prediction if outside */
976
    if(s->codec_id!=CODEC_ID_SVQ1){
977
        if (s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
978
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
979
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
980
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
981
        }
982
    }
983
    emms_c();
984
    
985
    s->last_pict_type    = s->pict_type;
986
    if(s->pict_type!=B_TYPE){
987
        s->last_non_b_pict_type= s->pict_type;
988
    }
989
#if 0
990
        /* copy back current_picture variables */
991
    for(i=0; i<MAX_PICTURE_COUNT; i++){
992
        if(s->picture[i].data[0] == s->current_picture.data[0]){
993
            s->picture[i]= s->current_picture;
994
            break;
995
        }    
996
    }
997
    assert(i<MAX_PICTURE_COUNT);
998
#endif    
999
    s->current_picture_ptr->quality= s->qscale; //FIXME get average of qscale_table
1000
    s->current_picture_ptr->pict_type= s->pict_type;
1001
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1002

    
1003
    /* release non refernce frames */
1004
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1005
        if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/)
1006
            s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1007
    }
1008
    if(s->avctx->debug&FF_DEBUG_SKIP){
1009
        int x,y;        
1010
        for(y=0; y<s->mb_height; y++){
1011
            for(x=0; x<s->mb_width; x++){
1012
                int count= s->mbskip_table[x + y*s->mb_width];
1013
                if(count>9) count=9;
1014
                printf(" %1d", count);
1015
            }
1016
            printf("\n");
1017
        }
1018
        printf("pict type: %d\n", s->pict_type);
1019
    }
1020

    
1021
    // clear copies, to avoid confusion
1022
#if 0
1023
    memset(&s->last_picture, 0, sizeof(Picture));
1024
    memset(&s->next_picture, 0, sizeof(Picture));
1025
    memset(&s->current_picture, 0, sizeof(Picture));
1026
#endif
1027
}
1028

    
1029
#ifdef CONFIG_ENCODERS
1030

    
1031
static int get_sae(uint8_t *src, int ref, int stride){
1032
    int x,y;
1033
    int acc=0;
1034
    
1035
    for(y=0; y<16; y++){
1036
        for(x=0; x<16; x++){
1037
            acc+= ABS(src[x+y*stride] - ref);
1038
        }
1039
    }
1040
    
1041
    return acc;
1042
}
1043

    
1044
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1045
    int x, y, w, h;
1046
    int acc=0;
1047
    
1048
    w= s->width &~15;
1049
    h= s->height&~15;
1050
    
1051
    for(y=0; y<h; y+=16){
1052
        for(x=0; x<w; x+=16){
1053
            int offset= x + y*stride;
1054
            int sad = s->dsp.pix_abs16x16(src + offset, ref + offset, stride);
1055
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1056
            int sae = get_sae(src + offset, mean, stride);
1057
            
1058
            acc+= sae + 500 < sad;
1059
        }
1060
    }
1061
    return acc;
1062
}
1063

    
1064

    
1065
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1066
    AVFrame *pic;
1067
    int i;
1068
    const int encoding_delay= s->max_b_frames;
1069
    int direct=1;
1070

    
1071
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1072
    if(pic_arg->linesize[0] != s->linesize) direct=0;
1073
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1074
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1075
  
1076
//    printf("%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1077
    
1078
    if(direct){
1079
        i= find_unused_picture(s, 1);
1080

    
1081
        pic= (AVFrame*)&s->picture[i];
1082
        pic->reference= 3;
1083
    
1084
        for(i=0; i<4; i++){
1085
            pic->data[i]= pic_arg->data[i];
1086
            pic->linesize[i]= pic_arg->linesize[i];
1087
        }
1088
        alloc_picture(s, (Picture*)pic, 1);
1089
    }else{
1090
        i= find_unused_picture(s, 0);
1091

    
1092
        pic= (AVFrame*)&s->picture[i];
1093
        pic->reference= 3;
1094

    
1095
        alloc_picture(s, (Picture*)pic, 0);
1096
        for(i=0; i<4; i++){
1097
            /* the input will be 16 pixels to the right relative to the actual buffer start
1098
             * and the current_pic, so the buffer can be reused, yes its not beatifull 
1099
             */
1100
            pic->data[i]+= 16; 
1101
        }
1102

    
1103
        if(   pic->data[0] == pic_arg->data[0] 
1104
           && pic->data[1] == pic_arg->data[1]
1105
           && pic->data[2] == pic_arg->data[2]){
1106
       // empty
1107
        }else{
1108
            int h_chroma_shift, v_chroma_shift;
1109
        
1110
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1111
        
1112
            for(i=0; i<3; i++){
1113
                int src_stride= pic_arg->linesize[i];
1114
                int dst_stride= i ? s->uvlinesize : s->linesize;
1115
                int h_shift= i ? h_chroma_shift : 0;
1116
                int v_shift= i ? v_chroma_shift : 0;
1117
                int w= s->width >>h_shift;
1118
                int h= s->height>>v_shift;
1119
                uint8_t *src= pic_arg->data[i];
1120
                uint8_t *dst= pic->data[i];
1121
            
1122
                if(src_stride==dst_stride)
1123
                    memcpy(dst, src, src_stride*h);
1124
                else{
1125
                    while(h--){
1126
                        memcpy(dst, src, w);
1127
                        dst += dst_stride;
1128
                        src += src_stride;
1129
                    }
1130
                }
1131
            }
1132
        }
1133
    }
1134
    pic->quality= pic_arg->quality;
1135
    pic->pict_type= pic_arg->pict_type;
1136
    pic->pts = pic_arg->pts;
1137
    
1138
    if(s->input_picture[encoding_delay])
1139
        pic->display_picture_number= s->input_picture[encoding_delay]->display_picture_number + 1;
1140

    
1141
    /* shift buffer entries */
1142
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1143
        s->input_picture[i-1]= s->input_picture[i];
1144
        
1145
    s->input_picture[encoding_delay]= (Picture*)pic;
1146

    
1147
    return 0;
1148
}
1149

    
1150
static void select_input_picture(MpegEncContext *s){
1151
    int i;
1152
    const int encoding_delay= s->max_b_frames;
1153
    int coded_pic_num=0;    
1154

    
1155
    if(s->reordered_input_picture[0])
1156
        coded_pic_num= s->reordered_input_picture[0]->coded_picture_number + 1;
1157

    
1158
    for(i=1; i<MAX_PICTURE_COUNT; i++)
1159
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1160
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1161

    
1162
    /* set next picture types & ordering */
1163
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1164
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
1165
            s->reordered_input_picture[0]= s->input_picture[0];
1166
            s->reordered_input_picture[0]->pict_type= I_TYPE;
1167
            s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1168
        }else{
1169
            int b_frames;
1170
            
1171
            if(s->flags&CODEC_FLAG_PASS2){
1172
                for(i=0; i<s->max_b_frames+1; i++){
1173
                    int pict_num= s->input_picture[0]->display_picture_number + i;
1174
                    int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1175
                    s->input_picture[i]->pict_type= pict_type;
1176
                    
1177
                    if(i + 1 >= s->rc_context.num_entries) break;
1178
                }
1179
            }
1180

    
1181
            if(s->input_picture[0]->pict_type){
1182
                /* user selected pict_type */
1183
                for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
1184
                    if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
1185
                }
1186
            
1187
                if(b_frames > s->max_b_frames){
1188
                    fprintf(stderr, "warning, too many bframes in a row\n");
1189
                    b_frames = s->max_b_frames;
1190
                }
1191
            }else if(s->b_frame_strategy==0){
1192
                b_frames= s->max_b_frames;
1193
            }else if(s->b_frame_strategy==1){
1194
                for(i=1; i<s->max_b_frames+1; i++){
1195
                    if(s->input_picture[i]->b_frame_score==0){
1196
                        s->input_picture[i]->b_frame_score= 
1197
                            get_intra_count(s, s->input_picture[i  ]->data[0], 
1198
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
1199
                    }
1200
                }
1201
                for(i=0; i<s->max_b_frames; i++){
1202
                    if(s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
1203
                }
1204
                                
1205
                b_frames= FFMAX(0, i-1);
1206
                
1207
                /* reset scores */
1208
                for(i=0; i<b_frames+1; i++){
1209
                    s->input_picture[i]->b_frame_score=0;
1210
                }
1211
            }else{
1212
                fprintf(stderr, "illegal b frame strategy\n");
1213
                b_frames=0;
1214
            }
1215

    
1216
            emms_c();
1217
//static int b_count=0;
1218
//b_count+= b_frames;
1219
//printf("b_frames: %d\n", b_count);
1220
                        
1221
            s->reordered_input_picture[0]= s->input_picture[b_frames];
1222
            if(   s->picture_in_gop_number + b_frames >= s->gop_size 
1223
               || s->reordered_input_picture[0]->pict_type== I_TYPE)
1224
                s->reordered_input_picture[0]->pict_type= I_TYPE;
1225
            else
1226
                s->reordered_input_picture[0]->pict_type= P_TYPE;
1227
            s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1228
            for(i=0; i<b_frames; i++){
1229
                coded_pic_num++;
1230
                s->reordered_input_picture[i+1]= s->input_picture[i];
1231
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
1232
                s->reordered_input_picture[i+1]->coded_picture_number= coded_pic_num;
1233
            }
1234
        }
1235
    }
1236
    
1237
    if(s->reordered_input_picture[0]){
1238
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
1239

    
1240
        s->new_picture= *s->reordered_input_picture[0];
1241

    
1242
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
1243
            // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
1244
        
1245
            int i= find_unused_picture(s, 0);
1246
            Picture *pic= &s->picture[i];
1247

    
1248
            /* mark us unused / free shared pic */
1249
            for(i=0; i<4; i++)
1250
                s->reordered_input_picture[0]->data[i]= NULL;
1251
            s->reordered_input_picture[0]->type= 0;
1252
            
1253
            //FIXME bad, copy * except
1254
            pic->pict_type = s->reordered_input_picture[0]->pict_type;
1255
            pic->quality   = s->reordered_input_picture[0]->quality;
1256
            pic->coded_picture_number = s->reordered_input_picture[0]->coded_picture_number;
1257
            pic->reference = s->reordered_input_picture[0]->reference;
1258
            
1259
            alloc_picture(s, pic, 0);
1260

    
1261
            s->current_picture_ptr= pic;
1262
        }else{
1263
            // input is not a shared pix -> reuse buffer for current_pix
1264

    
1265
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
1266
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
1267
            
1268
            s->current_picture_ptr= s->reordered_input_picture[0];
1269
            for(i=0; i<4; i++){
1270
                //reverse the +16 we did before storing the input
1271
                s->current_picture_ptr->data[i]-=16;
1272
            }
1273
        }
1274
        s->current_picture= *s->current_picture_ptr;
1275
    
1276
        s->picture_number= s->new_picture.display_picture_number;
1277
//printf("dpn:%d\n", s->picture_number);
1278
    }else{
1279
       memset(&s->new_picture, 0, sizeof(Picture));
1280
    }
1281
}
1282

    
1283
int MPV_encode_picture(AVCodecContext *avctx,
1284
                       unsigned char *buf, int buf_size, void *data)
1285
{
1286
    MpegEncContext *s = avctx->priv_data;
1287
    AVFrame *pic_arg = data;
1288
    int i;
1289

    
1290
    init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
1291

    
1292
    s->picture_in_gop_number++;
1293

    
1294
    load_input_picture(s, pic_arg);
1295
    
1296
    select_input_picture(s);
1297
    
1298
    /* output? */
1299
    if(s->new_picture.data[0]){
1300

    
1301
        s->pict_type= s->new_picture.pict_type;
1302
        if (s->fixed_qscale){ /* the ratecontrol needs the last qscale so we dont touch it for CBR */
1303
            s->qscale= (int)(s->new_picture.quality+0.5);
1304
            assert(s->qscale);
1305
        }
1306
//emms_c();
1307
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
1308
        MPV_frame_start(s, avctx);
1309

    
1310
        encode_picture(s, s->picture_number);
1311
        
1312
        avctx->real_pict_num  = s->picture_number;
1313
        avctx->header_bits = s->header_bits;
1314
        avctx->mv_bits     = s->mv_bits;
1315
        avctx->misc_bits   = s->misc_bits;
1316
        avctx->i_tex_bits  = s->i_tex_bits;
1317
        avctx->p_tex_bits  = s->p_tex_bits;
1318
        avctx->i_count     = s->i_count;
1319
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
1320
        avctx->skip_count  = s->skip_count;
1321

    
1322
        MPV_frame_end(s);
1323

    
1324
        if (s->out_format == FMT_MJPEG)
1325
            mjpeg_picture_trailer(s);
1326
        
1327
        if(s->flags&CODEC_FLAG_PASS1)
1328
            ff_write_pass1_stats(s);
1329

    
1330
        for(i=0; i<4; i++){
1331
            avctx->error[i] += s->current_picture_ptr->error[i];
1332
        }
1333
    }
1334

    
1335
    s->input_picture_number++;
1336

    
1337
    flush_put_bits(&s->pb);
1338
    s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1339
    
1340
    s->total_bits += s->frame_bits;
1341
    avctx->frame_bits  = s->frame_bits;
1342
    
1343
    return pbBufPtr(&s->pb) - s->pb.buf;
1344
}
1345

    
1346
#endif //CONFIG_ENCODERS
1347

    
1348
static inline void gmc1_motion(MpegEncContext *s,
1349
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1350
                               int dest_offset,
1351
                               uint8_t **ref_picture, int src_offset)
1352
{
1353
    uint8_t *ptr;
1354
    int offset, src_x, src_y, linesize, uvlinesize;
1355
    int motion_x, motion_y;
1356
    int emu=0;
1357

    
1358
    motion_x= s->sprite_offset[0][0];
1359
    motion_y= s->sprite_offset[0][1];
1360
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1361
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1362
    motion_x<<=(3-s->sprite_warping_accuracy);
1363
    motion_y<<=(3-s->sprite_warping_accuracy);
1364
    src_x = clip(src_x, -16, s->width);
1365
    if (src_x == s->width)
1366
        motion_x =0;
1367
    src_y = clip(src_y, -16, s->height);
1368
    if (src_y == s->height)
1369
        motion_y =0;
1370

    
1371
    linesize = s->linesize;
1372
    uvlinesize = s->uvlinesize;
1373
    
1374
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1375

    
1376
    dest_y+=dest_offset;
1377
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1378
        if(src_x<0 || src_y<0 || src_x + 17 >= s->h_edge_pos
1379
                              || src_y + 17 >= s->v_edge_pos){
1380
            ff_emulated_edge_mc(s, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1381
            ptr= s->edge_emu_buffer;
1382
        }
1383
    }
1384
    
1385
    if((motion_x|motion_y)&7){
1386
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1387
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1388
    }else{
1389
        int dxy;
1390
        
1391
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
1392
        if (s->no_rounding){
1393
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
1394
        }else{
1395
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
1396
        }
1397
    }
1398
    
1399
    if(s->flags&CODEC_FLAG_GRAY) return;
1400

    
1401
    motion_x= s->sprite_offset[1][0];
1402
    motion_y= s->sprite_offset[1][1];
1403
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
1404
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
1405
    motion_x<<=(3-s->sprite_warping_accuracy);
1406
    motion_y<<=(3-s->sprite_warping_accuracy);
1407
    src_x = clip(src_x, -8, s->width>>1);
1408
    if (src_x == s->width>>1)
1409
        motion_x =0;
1410
    src_y = clip(src_y, -8, s->height>>1);
1411
    if (src_y == s->height>>1)
1412
        motion_y =0;
1413

    
1414
    offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
1415
    ptr = ref_picture[1] + offset;
1416
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1417
        if(src_x<0 || src_y<0 || src_x + 9 >= s->h_edge_pos>>1
1418
                              || src_y + 9 >= s->v_edge_pos>>1){
1419
            ff_emulated_edge_mc(s, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1420
            ptr= s->edge_emu_buffer;
1421
            emu=1;
1422
        }
1423
    }
1424
    s->dsp.gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1425
    
1426
    ptr = ref_picture[2] + offset;
1427
    if(emu){
1428
        ff_emulated_edge_mc(s, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1429
        ptr= s->edge_emu_buffer;
1430
    }
1431
    s->dsp.gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1432
    
1433
    return;
1434
}
1435

    
1436
static inline void gmc_motion(MpegEncContext *s,
1437
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1438
                               int dest_offset,
1439
                               uint8_t **ref_picture, int src_offset)
1440
{
1441
    uint8_t *ptr;
1442
    int linesize, uvlinesize;
1443
    const int a= s->sprite_warping_accuracy;
1444
    int ox, oy;
1445

    
1446
    linesize = s->linesize;
1447
    uvlinesize = s->uvlinesize;
1448

    
1449
    ptr = ref_picture[0] + src_offset;
1450

    
1451
    dest_y+=dest_offset;
1452
    
1453
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
1454
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
1455

    
1456
    s->dsp.gmc(dest_y, ptr, linesize, 16,
1457
           ox, 
1458
           oy, 
1459
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1460
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1461
           a+1, (1<<(2*a+1)) - s->no_rounding,
1462
           s->h_edge_pos, s->v_edge_pos);
1463
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
1464
           ox + s->sprite_delta[0][0]*8, 
1465
           oy + s->sprite_delta[1][0]*8, 
1466
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1467
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1468
           a+1, (1<<(2*a+1)) - s->no_rounding,
1469
           s->h_edge_pos, s->v_edge_pos);
1470

    
1471
    if(s->flags&CODEC_FLAG_GRAY) return;
1472

    
1473

    
1474
    dest_cb+=dest_offset>>1;
1475
    dest_cr+=dest_offset>>1;
1476
    
1477
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
1478
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
1479

    
1480
    ptr = ref_picture[1] + (src_offset>>1);
1481
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
1482
           ox, 
1483
           oy, 
1484
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1485
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1486
           a+1, (1<<(2*a+1)) - s->no_rounding,
1487
           s->h_edge_pos>>1, s->v_edge_pos>>1);
1488
    
1489
    ptr = ref_picture[2] + (src_offset>>1);
1490
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
1491
           ox, 
1492
           oy, 
1493
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1494
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1495
           a+1, (1<<(2*a+1)) - s->no_rounding,
1496
           s->h_edge_pos>>1, s->v_edge_pos>>1);
1497
}
1498

    
1499

    
1500
void ff_emulated_edge_mc(MpegEncContext *s, uint8_t *src, int linesize, int block_w, int block_h, 
1501
                                    int src_x, int src_y, int w, int h){
1502
    int x, y;
1503
    int start_y, start_x, end_y, end_x;
1504
    uint8_t *buf= s->edge_emu_buffer;
1505

    
1506
    if(src_y>= h){
1507
        src+= (h-1-src_y)*linesize;
1508
        src_y=h-1;
1509
    }else if(src_y<=-block_h){
1510
        src+= (1-block_h-src_y)*linesize;
1511
        src_y=1-block_h;
1512
    }
1513
    if(src_x>= w){
1514
        src+= (w-1-src_x);
1515
        src_x=w-1;
1516
    }else if(src_x<=-block_w){
1517
        src+= (1-block_w-src_x);
1518
        src_x=1-block_w;
1519
    }
1520

    
1521
    start_y= FFMAX(0, -src_y);
1522
    start_x= FFMAX(0, -src_x);
1523
    end_y= FFMIN(block_h, h-src_y);
1524
    end_x= FFMIN(block_w, w-src_x);
1525

    
1526
    // copy existing part
1527
    for(y=start_y; y<end_y; y++){
1528
        for(x=start_x; x<end_x; x++){
1529
            buf[x + y*linesize]= src[x + y*linesize];
1530
        }
1531
    }
1532

    
1533
    //top
1534
    for(y=0; y<start_y; y++){
1535
        for(x=start_x; x<end_x; x++){
1536
            buf[x + y*linesize]= buf[x + start_y*linesize];
1537
        }
1538
    }
1539

    
1540
    //bottom
1541
    for(y=end_y; y<block_h; y++){
1542
        for(x=start_x; x<end_x; x++){
1543
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1544
        }
1545
    }
1546
                                    
1547
    for(y=0; y<block_h; y++){
1548
       //left
1549
        for(x=0; x<start_x; x++){
1550
            buf[x + y*linesize]= buf[start_x + y*linesize];
1551
        }
1552
       
1553
       //right
1554
        for(x=end_x; x<block_w; x++){
1555
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1556
        }
1557
    }
1558
}
1559

    
1560

    
1561
/* apply one mpeg motion vector to the three components */
1562
static inline void mpeg_motion(MpegEncContext *s,
1563
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1564
                               int dest_offset,
1565
                               uint8_t **ref_picture, int src_offset,
1566
                               int field_based, op_pixels_func (*pix_op)[4],
1567
                               int motion_x, int motion_y, int h)
1568
{
1569
    uint8_t *ptr;
1570
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1571
    int emu=0;
1572
#if 0    
1573
if(s->quarter_sample)
1574
{
1575
    motion_x>>=1;
1576
    motion_y>>=1;
1577
}
1578
#endif
1579
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1580
    src_x = s->mb_x * 16 + (motion_x >> 1);
1581
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 1);
1582
                
1583
    /* WARNING: do no forget half pels */
1584
    height = s->height >> field_based;
1585
    v_edge_pos = s->v_edge_pos >> field_based;
1586
    src_x = clip(src_x, -16, s->width);
1587
    if (src_x == s->width)
1588
        dxy &= ~1;
1589
    src_y = clip(src_y, -16, height);
1590
    if (src_y == height)
1591
        dxy &= ~2;
1592
    linesize   = s->current_picture.linesize[0] << field_based;
1593
    uvlinesize = s->current_picture.linesize[1] << field_based;
1594
    ptr = ref_picture[0] + (src_y * linesize) + (src_x) + src_offset;
1595
    dest_y += dest_offset;
1596

    
1597
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1598
        if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 16 > s->h_edge_pos
1599
                              || src_y + (motion_y&1) + h  > v_edge_pos){
1600
            ff_emulated_edge_mc(s, ptr - src_offset, s->linesize, 17, 17+field_based,  //FIXME linesize? and uv below
1601
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1602
            ptr= s->edge_emu_buffer + src_offset;
1603
            emu=1;
1604
        }
1605
    }
1606
    pix_op[0][dxy](dest_y, ptr, linesize, h);
1607

    
1608
    if(s->flags&CODEC_FLAG_GRAY) return;
1609

    
1610
    if (s->out_format == FMT_H263) {
1611
        dxy = 0;
1612
        if ((motion_x & 3) != 0)
1613
            dxy |= 1;
1614
        if ((motion_y & 3) != 0)
1615
            dxy |= 2;
1616
        mx = motion_x >> 2;
1617
        my = motion_y >> 2;
1618
    } else {
1619
        mx = motion_x / 2;
1620
        my = motion_y / 2;
1621
        dxy = ((my & 1) << 1) | (mx & 1);
1622
        mx >>= 1;
1623
        my >>= 1;
1624
    }
1625
    
1626
    src_x = s->mb_x * 8 + mx;
1627
    src_y = s->mb_y * (8 >> field_based) + my;
1628
    src_x = clip(src_x, -8, s->width >> 1);
1629
    if (src_x == (s->width >> 1))
1630
        dxy &= ~1;
1631
    src_y = clip(src_y, -8, height >> 1);
1632
    if (src_y == (height >> 1))
1633
        dxy &= ~2;
1634
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1635
    ptr = ref_picture[1] + offset;
1636
    if(emu){
1637
        ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
1638
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1639
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1640
    }
1641
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1642

    
1643
    ptr = ref_picture[2] + offset;
1644
    if(emu){
1645
        ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
1646
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1647
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1648
    }
1649
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1650
}
1651

    
1652
static inline void qpel_motion(MpegEncContext *s,
1653
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1654
                               int dest_offset,
1655
                               uint8_t **ref_picture, int src_offset,
1656
                               int field_based, op_pixels_func (*pix_op)[4],
1657
                               qpel_mc_func (*qpix_op)[16],
1658
                               int motion_x, int motion_y, int h)
1659
{
1660
    uint8_t *ptr;
1661
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1662
    int emu=0;
1663

    
1664
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1665
    src_x = s->mb_x * 16 + (motion_x >> 2);
1666
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
1667

    
1668
    height = s->height >> field_based;
1669
    v_edge_pos = s->v_edge_pos >> field_based;
1670
    src_x = clip(src_x, -16, s->width);
1671
    if (src_x == s->width)
1672
        dxy &= ~3;
1673
    src_y = clip(src_y, -16, height);
1674
    if (src_y == height)
1675
        dxy &= ~12;
1676
    linesize = s->linesize << field_based;
1677
    uvlinesize = s->uvlinesize << field_based;
1678
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1679
    dest_y += dest_offset;
1680
//printf("%d %d %d\n", src_x, src_y, dxy);
1681
    
1682
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1683
        if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 16 > s->h_edge_pos
1684
                              || src_y + (motion_y&3) + h  > v_edge_pos){
1685
            ff_emulated_edge_mc(s, ptr - src_offset, s->linesize, 17, 17+field_based, 
1686
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1687
            ptr= s->edge_emu_buffer + src_offset;
1688
            emu=1;
1689
        }
1690
    }
1691
    if(!field_based)
1692
        qpix_op[0][dxy](dest_y, ptr, linesize);
1693
    else{
1694
        //damn interlaced mode
1695
        //FIXME boundary mirroring is not exactly correct here
1696
        qpix_op[1][dxy](dest_y  , ptr  , linesize);
1697
        qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
1698
    }
1699

    
1700
    if(s->flags&CODEC_FLAG_GRAY) return;
1701

    
1702
    if(field_based){
1703
        mx= motion_x/2;
1704
        my= motion_y>>1;
1705
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
1706
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
1707
        mx= (motion_x>>1) + rtab[motion_x&7];
1708
        my= (motion_y>>1) + rtab[motion_y&7];
1709
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
1710
        mx= (motion_x>>1)|(motion_x&1);
1711
        my= (motion_y>>1)|(motion_y&1);
1712
    }else{
1713
        mx= motion_x/2;
1714
        my= motion_y/2;
1715
    }
1716
    mx= (mx>>1)|(mx&1);
1717
    my= (my>>1)|(my&1);
1718

    
1719
    dxy= (mx&1) | ((my&1)<<1);
1720
    mx>>=1;
1721
    my>>=1;
1722

    
1723
    src_x = s->mb_x * 8 + mx;
1724
    src_y = s->mb_y * (8 >> field_based) + my;
1725
    src_x = clip(src_x, -8, s->width >> 1);
1726
    if (src_x == (s->width >> 1))
1727
        dxy &= ~1;
1728
    src_y = clip(src_y, -8, height >> 1);
1729
    if (src_y == (height >> 1))
1730
        dxy &= ~2;
1731

    
1732
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1733
    ptr = ref_picture[1] + offset;
1734
    if(emu){
1735
        ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
1736
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1737
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1738
    }
1739
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1740
    
1741
    ptr = ref_picture[2] + offset;
1742
    if(emu){
1743
        ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
1744
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1745
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1746
    }
1747
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1748
}
1749

    
1750
inline int ff_h263_round_chroma(int x){
1751
    if (x >= 0)
1752
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
1753
    else {
1754
        x = -x;
1755
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
1756
    }
1757
}
1758

    
1759
static inline void MPV_motion(MpegEncContext *s, 
1760
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1761
                              int dir, uint8_t **ref_picture, 
1762
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
1763
{
1764
    int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
1765
    int mb_x, mb_y, i;
1766
    uint8_t *ptr, *dest;
1767
    int emu=0;
1768

    
1769
    mb_x = s->mb_x;
1770
    mb_y = s->mb_y;
1771

    
1772
    switch(s->mv_type) {
1773
    case MV_TYPE_16X16:
1774
#ifdef CONFIG_RISKY
1775
        if(s->mcsel){
1776
            if(s->real_sprite_warping_points==1){
1777
                gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
1778
                            ref_picture, 0);
1779
            }else{
1780
                gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
1781
                            ref_picture, 0);
1782
            }
1783
        }else if(s->quarter_sample){
1784
            qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1785
                        ref_picture, 0,
1786
                        0, pix_op, qpix_op,
1787
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1788
        }else if(s->mspel){
1789
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
1790
                        ref_picture, pix_op,
1791
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1792
        }else
1793
#endif
1794
        {
1795
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1796
                        ref_picture, 0,
1797
                        0, pix_op,
1798
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1799
        }           
1800
        break;
1801
    case MV_TYPE_8X8:
1802
        mx = 0;
1803
        my = 0;
1804
        if(s->quarter_sample){
1805
            for(i=0;i<4;i++) {
1806
                motion_x = s->mv[dir][i][0];
1807
                motion_y = s->mv[dir][i][1];
1808

    
1809
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1810
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
1811
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
1812
                    
1813
                /* WARNING: do no forget half pels */
1814
                src_x = clip(src_x, -16, s->width);
1815
                if (src_x == s->width)
1816
                    dxy &= ~3;
1817
                src_y = clip(src_y, -16, s->height);
1818
                if (src_y == s->height)
1819
                    dxy &= ~12;
1820
                    
1821
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1822
                if(s->flags&CODEC_FLAG_EMU_EDGE){
1823
                    if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 8 > s->h_edge_pos
1824
                                          || src_y + (motion_y&3) + 8 > s->v_edge_pos){
1825
                        ff_emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1826
                        ptr= s->edge_emu_buffer;
1827
                    }
1828
                }
1829
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1830
                qpix_op[1][dxy](dest, ptr, s->linesize);
1831

    
1832
                mx += s->mv[dir][i][0]/2;
1833
                my += s->mv[dir][i][1]/2;
1834
            }
1835
        }else{
1836
            for(i=0;i<4;i++) {
1837
                motion_x = s->mv[dir][i][0];
1838
                motion_y = s->mv[dir][i][1];
1839

    
1840
                dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1841
                src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;
1842
                src_y = mb_y * 16 + (motion_y >> 1) + (i >>1) * 8;
1843
                    
1844
                /* WARNING: do no forget half pels */
1845
                src_x = clip(src_x, -16, s->width);
1846
                if (src_x == s->width)
1847
                    dxy &= ~1;
1848
                src_y = clip(src_y, -16, s->height);
1849
                if (src_y == s->height)
1850
                    dxy &= ~2;
1851
                    
1852
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1853
                if(s->flags&CODEC_FLAG_EMU_EDGE){
1854
                    if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 8 > s->h_edge_pos
1855
                                          || src_y + (motion_y&1) + 8 > s->v_edge_pos){
1856
                        ff_emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1857
                        ptr= s->edge_emu_buffer;
1858
                    }
1859
                }
1860
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1861
                pix_op[1][dxy](dest, ptr, s->linesize, 8);
1862

    
1863
                mx += s->mv[dir][i][0];
1864
                my += s->mv[dir][i][1];
1865
            }
1866
        }
1867

    
1868
        if(s->flags&CODEC_FLAG_GRAY) break;
1869
        /* In case of 8X8, we construct a single chroma motion vector
1870
           with a special rounding */
1871
        mx= ff_h263_round_chroma(mx);
1872
        my= ff_h263_round_chroma(my);
1873
        dxy = ((my & 1) << 1) | (mx & 1);
1874
        mx >>= 1;
1875
        my >>= 1;
1876

    
1877
        src_x = mb_x * 8 + mx;
1878
        src_y = mb_y * 8 + my;
1879
        src_x = clip(src_x, -8, s->width/2);
1880
        if (src_x == s->width/2)
1881
            dxy &= ~1;
1882
        src_y = clip(src_y, -8, s->height/2);
1883
        if (src_y == s->height/2)
1884
            dxy &= ~2;
1885
        
1886
        offset = (src_y * (s->uvlinesize)) + src_x;
1887
        ptr = ref_picture[1] + offset;
1888
        if(s->flags&CODEC_FLAG_EMU_EDGE){
1889
                if(src_x<0 || src_y<0 || src_x + (dxy &1) + 8 > s->h_edge_pos>>1
1890
                                      || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
1891
                    ff_emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1892
                    ptr= s->edge_emu_buffer;
1893
                    emu=1;
1894
                }
1895
            }
1896
        pix_op[1][dxy](dest_cb, ptr, s->uvlinesize, 8);
1897

    
1898
        ptr = ref_picture[2] + offset;
1899
        if(emu){
1900
            ff_emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1901
            ptr= s->edge_emu_buffer;
1902
        }
1903
        pix_op[1][dxy](dest_cr, ptr, s->uvlinesize, 8);
1904
        break;
1905
    case MV_TYPE_FIELD:
1906
        if (s->picture_structure == PICT_FRAME) {
1907
            if(s->quarter_sample){
1908
                /* top field */
1909
                qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1910
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
1911
                            1, pix_op, qpix_op,
1912
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
1913
                /* bottom field */
1914
                qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
1915
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
1916
                            1, pix_op, qpix_op,
1917
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
1918
            }else{
1919
                /* top field */       
1920
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1921
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
1922
                            1, pix_op,
1923
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
1924
                /* bottom field */
1925
                mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
1926
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
1927
                            1, pix_op,
1928
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
1929
            }
1930
        } else {
1931
            int offset;
1932
            if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
1933
                offset= s->field_select[dir][0] ? s->linesize : 0;
1934
            }else{
1935
                ref_picture= s->current_picture.data;
1936
                offset= s->field_select[dir][0] ? s->linesize : -s->linesize; 
1937
            } 
1938

    
1939
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1940
                        ref_picture, offset,
1941
                        0, pix_op,
1942
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1943
        }
1944
        break;
1945
    }
1946
}
1947

    
1948

    
1949
/* put block[] to dest[] */
1950
static inline void put_dct(MpegEncContext *s, 
1951
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
1952
{
1953
    s->dct_unquantize(s, block, i, s->qscale);
1954
    s->dsp.idct_put (dest, line_size, block);
1955
}
1956

    
1957
/* add block[] to dest[] */
1958
static inline void add_dct(MpegEncContext *s, 
1959
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
1960
{
1961
    if (s->block_last_index[i] >= 0) {
1962
        s->dsp.idct_add (dest, line_size, block);
1963
    }
1964
}
1965

    
1966
static inline void add_dequant_dct(MpegEncContext *s, 
1967
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
1968
{
1969
    if (s->block_last_index[i] >= 0) {
1970
        s->dct_unquantize(s, block, i, s->qscale);
1971

    
1972
        s->dsp.idct_add (dest, line_size, block);
1973
    }
1974
}
1975

    
1976
/**
1977
 * cleans dc, ac, coded_block for the current non intra MB
1978
 */
1979
void ff_clean_intra_table_entries(MpegEncContext *s)
1980
{
1981
    int wrap = s->block_wrap[0];
1982
    int xy = s->block_index[0];
1983
    
1984
    s->dc_val[0][xy           ] = 
1985
    s->dc_val[0][xy + 1       ] = 
1986
    s->dc_val[0][xy     + wrap] =
1987
    s->dc_val[0][xy + 1 + wrap] = 1024;
1988
    /* ac pred */
1989
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
1990
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1991
    if (s->msmpeg4_version>=3) {
1992
        s->coded_block[xy           ] =
1993
        s->coded_block[xy + 1       ] =
1994
        s->coded_block[xy     + wrap] =
1995
        s->coded_block[xy + 1 + wrap] = 0;
1996
    }
1997
    /* chroma */
1998
    wrap = s->block_wrap[4];
1999
    xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
2000
    s->dc_val[1][xy] =
2001
    s->dc_val[2][xy] = 1024;
2002
    /* ac pred */
2003
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2004
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2005
    
2006
    s->mbintra_table[s->mb_x + s->mb_y*s->mb_width]= 0;
2007
}
2008

    
2009
/* generic function called after a macroblock has been parsed by the
2010
   decoder or after it has been encoded by the encoder.
2011

2012
   Important variables used:
2013
   s->mb_intra : true if intra macroblock
2014
   s->mv_dir   : motion vector direction
2015
   s->mv_type  : motion vector type
2016
   s->mv       : motion vector
2017
   s->interlaced_dct : true if interlaced dct used (mpeg2)
2018
 */
2019
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
2020
{
2021
    int mb_x, mb_y;
2022
    const int mb_xy = s->mb_y * s->mb_width + s->mb_x;
2023

    
2024
    mb_x = s->mb_x;
2025
    mb_y = s->mb_y;
2026

    
2027
    s->current_picture.qscale_table[mb_xy]= s->qscale;
2028

    
2029
    /* update DC predictors for P macroblocks */
2030
    if (!s->mb_intra) {
2031
        if (s->h263_pred || s->h263_aic) {
2032
            if(s->mbintra_table[mb_xy])
2033
                ff_clean_intra_table_entries(s);
2034
        } else {
2035
            s->last_dc[0] =
2036
            s->last_dc[1] =
2037
            s->last_dc[2] = 128 << s->intra_dc_precision;
2038
        }
2039
    }
2040
    else if (s->h263_pred || s->h263_aic)
2041
        s->mbintra_table[mb_xy]=1;
2042

    
2043
    /* update motion predictor, not for B-frames as they need the motion_val from the last P/S-Frame */
2044
    if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) { //FIXME move into h263.c if possible, format specific stuff shouldnt be here
2045
        //FIXME a lot of thet is only needed for !low_delay
2046
        const int wrap = s->block_wrap[0];
2047
        const int xy = s->block_index[0];
2048
        const int mb_index= s->mb_x + s->mb_y*s->mb_width;
2049
        if(s->mv_type == MV_TYPE_8X8){
2050
            s->co_located_type_table[mb_index]= CO_LOCATED_TYPE_4MV;
2051
        } else {
2052
            int motion_x, motion_y;
2053
            if (s->mb_intra) {
2054
                motion_x = 0;
2055
                motion_y = 0;
2056
                if(s->co_located_type_table)
2057
                    s->co_located_type_table[mb_index]= 0;
2058
            } else if (s->mv_type == MV_TYPE_16X16) {
2059
                motion_x = s->mv[0][0][0];
2060
                motion_y = s->mv[0][0][1];
2061
                if(s->co_located_type_table)
2062
                    s->co_located_type_table[mb_index]= 0;
2063
            } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
2064
                int i;
2065
                motion_x = s->mv[0][0][0] + s->mv[0][1][0];
2066
                motion_y = s->mv[0][0][1] + s->mv[0][1][1];
2067
                motion_x = (motion_x>>1) | (motion_x&1);
2068
                for(i=0; i<2; i++){
2069
                    s->field_mv_table[mb_index][i][0]= s->mv[0][i][0];
2070
                    s->field_mv_table[mb_index][i][1]= s->mv[0][i][1];
2071
                    s->field_select_table[mb_index][i]= s->field_select[0][i];
2072
                }
2073
                s->co_located_type_table[mb_index]= CO_LOCATED_TYPE_FIELDMV;
2074
            }
2075
            /* no update if 8X8 because it has been done during parsing */
2076
            s->motion_val[xy][0] = motion_x;
2077
            s->motion_val[xy][1] = motion_y;
2078
            s->motion_val[xy + 1][0] = motion_x;
2079
            s->motion_val[xy + 1][1] = motion_y;
2080
            s->motion_val[xy + wrap][0] = motion_x;
2081
            s->motion_val[xy + wrap][1] = motion_y;
2082
            s->motion_val[xy + 1 + wrap][0] = motion_x;
2083
            s->motion_val[xy + 1 + wrap][1] = motion_y;
2084
        }
2085
    }
2086
    
2087
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
2088
        uint8_t *dest_y, *dest_cb, *dest_cr;
2089
        int dct_linesize, dct_offset;
2090
        op_pixels_func (*op_pix)[4];
2091
        qpel_mc_func (*op_qpix)[16];
2092
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
2093
        const int uvlinesize= s->current_picture.linesize[1];
2094

    
2095
        /* avoid copy if macroblock skipped in last frame too */
2096
        if (s->pict_type != B_TYPE) {
2097
            s->current_picture.mbskip_table[mb_xy]= s->mb_skiped;
2098
        }
2099

    
2100
        /* skip only during decoding as we might trash the buffers during encoding a bit */
2101
        if(!s->encoding){
2102
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2103
            const int age= s->current_picture.age;
2104

    
2105
            assert(age);
2106

    
2107
            if (s->mb_skiped) {
2108
                s->mb_skiped= 0;
2109
                assert(s->pict_type!=I_TYPE);
2110
 
2111
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
2112
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2113

    
2114
                /* if previous was skipped too, then nothing to do !  */
2115
                if (*mbskip_ptr >= age && s->current_picture.reference){
2116
                    return;
2117
                }
2118
            } else if(!s->current_picture.reference){
2119
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2120
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2121
            } else{
2122
                *mbskip_ptr = 0; /* not skipped */
2123
            }
2124
        }else
2125
            s->mb_skiped= 0;
2126

    
2127
        if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){ //FIXME precalc
2128
            dest_y  = s->current_picture.data[0] + mb_x * 16;
2129
            dest_cb = s->current_picture.data[1] + mb_x * 8;
2130
            dest_cr = s->current_picture.data[2] + mb_x * 8;
2131
        }else{
2132
            dest_y  = s->current_picture.data[0] + (mb_y * 16* linesize  ) + mb_x * 16;
2133
            dest_cb = s->current_picture.data[1] + (mb_y * 8 * uvlinesize) + mb_x * 8;
2134
            dest_cr = s->current_picture.data[2] + (mb_y * 8 * uvlinesize) + mb_x * 8;
2135
        }
2136

    
2137
        if (s->interlaced_dct) {
2138
            dct_linesize = linesize * 2;
2139
            dct_offset = linesize;
2140
        } else {
2141
            dct_linesize = linesize;
2142
            dct_offset = linesize * 8;
2143
        }
2144

    
2145
        if (!s->mb_intra) {
2146
            /* motion handling */
2147
            /* decoding or more than one mb_type (MC was allready done otherwise) */
2148
            if((!s->encoding) || (s->mb_type[mb_xy]&(s->mb_type[mb_xy]-1))){
2149
                if ((!s->no_rounding) || s->pict_type==B_TYPE){                
2150
                    op_pix = s->dsp.put_pixels_tab;
2151
                    op_qpix= s->dsp.put_qpel_pixels_tab;
2152
                }else{
2153
                    op_pix = s->dsp.put_no_rnd_pixels_tab;
2154
                    op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2155
                }
2156

    
2157
                if (s->mv_dir & MV_DIR_FORWARD) {
2158
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2159
                    op_pix = s->dsp.avg_pixels_tab;
2160
                    op_qpix= s->dsp.avg_qpel_pixels_tab;
2161
                }
2162
                if (s->mv_dir & MV_DIR_BACKWARD) {
2163
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2164
                }
2165
            }
2166

    
2167
            /* skip dequant / idct if we are really late ;) */
2168
            if(s->hurry_up>1) return;
2169

    
2170
            /* add dct residue */
2171
            if(s->encoding || !(   s->mpeg2 || s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO 
2172
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2173
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
2174
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2175
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2176
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2177

    
2178
                if(!(s->flags&CODEC_FLAG_GRAY)){
2179
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize);
2180
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize);
2181
                }
2182
            } else if(s->codec_id != CODEC_ID_WMV2){
2183
                add_dct(s, block[0], 0, dest_y, dct_linesize);
2184
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2185
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2186
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2187

    
2188
                if(!(s->flags&CODEC_FLAG_GRAY)){
2189
                    add_dct(s, block[4], 4, dest_cb, uvlinesize);
2190
                    add_dct(s, block[5], 5, dest_cr, uvlinesize);
2191
                }
2192
            } 
2193
#ifdef CONFIG_RISKY
2194
            else{
2195
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2196
            }
2197
#endif
2198
        } else {
2199
            /* dct only in intra block */
2200
            if(s->encoding || !(s->mpeg2 || s->codec_id==CODEC_ID_MPEG1VIDEO)){
2201
                put_dct(s, block[0], 0, dest_y, dct_linesize);
2202
                put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2203
                put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2204
                put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2205

    
2206
                if(!(s->flags&CODEC_FLAG_GRAY)){
2207
                    put_dct(s, block[4], 4, dest_cb, uvlinesize);
2208
                    put_dct(s, block[5], 5, dest_cr, uvlinesize);
2209
                }
2210
            }else{
2211
                s->dsp.idct_put(dest_y                 , dct_linesize, block[0]);
2212
                s->dsp.idct_put(dest_y              + 8, dct_linesize, block[1]);
2213
                s->dsp.idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
2214
                s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
2215

    
2216
                if(!(s->flags&CODEC_FLAG_GRAY)){
2217
                    s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2218
                    s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2219
                }
2220
            }
2221
        }
2222
    }
2223
}
2224

    
2225
#ifdef CONFIG_ENCODERS
2226

    
2227
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
2228
{
2229
    static const char tab[64]=
2230
        {3,2,2,1,1,1,1,1,
2231
         1,1,1,1,1,1,1,1,
2232
         1,1,1,1,1,1,1,1,
2233
         0,0,0,0,0,0,0,0,
2234
         0,0,0,0,0,0,0,0,
2235
         0,0,0,0,0,0,0,0,
2236
         0,0,0,0,0,0,0,0,
2237
         0,0,0,0,0,0,0,0};
2238
    int score=0;
2239
    int run=0;
2240
    int i;
2241
    DCTELEM *block= s->block[n];
2242
    const int last_index= s->block_last_index[n];
2243
    int skip_dc;
2244

    
2245
    if(threshold<0){
2246
        skip_dc=0;
2247
        threshold= -threshold;
2248
    }else
2249
        skip_dc=1;
2250

    
2251
    /* are all which we could set to zero are allready zero? */
2252
    if(last_index<=skip_dc - 1) return;
2253

    
2254
    for(i=0; i<=last_index; i++){
2255
        const int j = s->intra_scantable.permutated[i];
2256
        const int level = ABS(block[j]);
2257
        if(level==1){
2258
            if(skip_dc && i==0) continue;
2259
            score+= tab[run];
2260
            run=0;
2261
        }else if(level>1){
2262
            return;
2263
        }else{
2264
            run++;
2265
        }
2266
    }
2267
    if(score >= threshold) return;
2268
    for(i=skip_dc; i<=last_index; i++){
2269
        const int j = s->intra_scantable.permutated[i];
2270
        block[j]=0;
2271
    }
2272
    if(block[0]) s->block_last_index[n]= 0;
2273
    else         s->block_last_index[n]= -1;
2274
}
2275

    
2276
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
2277
{
2278
    int i;
2279
    const int maxlevel= s->max_qcoeff;
2280
    const int minlevel= s->min_qcoeff;
2281
    
2282
    if(s->mb_intra){
2283
        i=1; //skip clipping of intra dc
2284
    }else
2285
        i=0;
2286
    
2287
    for(;i<=last_index; i++){
2288
        const int j= s->intra_scantable.permutated[i];
2289
        int level = block[j];
2290
       
2291
        if     (level>maxlevel) level=maxlevel;
2292
        else if(level<minlevel) level=minlevel;
2293

    
2294
        block[j]= level;
2295
    }
2296
}
2297

    
2298
#if 0
2299
static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
2300
    int score=0;
2301
    int x,y;
2302
    
2303
    for(y=0; y<7; y++){
2304
        for(x=0; x<16; x+=4){
2305
            score+= ABS(s[x  ] - s[x  +stride]) + ABS(s[x+1] - s[x+1+stride]) 
2306
                   +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
2307
        }
2308
        s+= stride;
2309
    }
2310
    
2311
    return score;
2312
}
2313

2314
static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
2315
    int score=0;
2316
    int x,y;
2317
    
2318
    for(y=0; y<7; y++){
2319
        for(x=0; x<16; x++){
2320
            score+= ABS(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2321
        }
2322
        s1+= stride;
2323
        s2+= stride;
2324
    }
2325
    
2326
    return score;
2327
}
2328
#else
2329
#define SQ(a) ((a)*(a))
2330

    
2331
static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
2332
    int score=0;
2333
    int x,y;
2334
    
2335
    for(y=0; y<7; y++){
2336
        for(x=0; x<16; x+=4){
2337
            score+= SQ(s[x  ] - s[x  +stride]) + SQ(s[x+1] - s[x+1+stride]) 
2338
                   +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
2339
        }
2340
        s+= stride;
2341
    }
2342
    
2343
    return score;
2344
}
2345

    
2346
static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
2347
    int score=0;
2348
    int x,y;
2349
    
2350
    for(y=0; y<7; y++){
2351
        for(x=0; x<16; x++){
2352
            score+= SQ(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2353
        }
2354
        s1+= stride;
2355
        s2+= stride;
2356
    }
2357
    
2358
    return score;
2359
}
2360

    
2361
#endif
2362

    
2363
#endif //CONFIG_ENCODERS
2364

    
2365
/**
2366
 *
2367
 * @param h is the normal height, this will be reduced automatically if needed for the last row
2368
 */
2369
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2370
    if (    s->avctx->draw_horiz_band 
2371
        && (s->last_picture_ptr || s->low_delay) ) {
2372
        uint8_t *src_ptr[3];
2373
        int offset;
2374
        h= FFMIN(h, s->height - y);
2375

    
2376
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME)
2377
            offset = 0;
2378
        else
2379
            offset = y * s->linesize;
2380

    
2381
        if(s->pict_type==B_TYPE || s->low_delay){
2382
            src_ptr[0] = s->current_picture.data[0] + offset;
2383
            src_ptr[1] = s->current_picture.data[1] + (offset >> 2);
2384
            src_ptr[2] = s->current_picture.data[2] + (offset >> 2);
2385
        } else {
2386
            src_ptr[0] = s->last_picture.data[0] + offset;
2387
            src_ptr[1] = s->last_picture.data[1] + (offset >> 2);
2388
            src_ptr[2] = s->last_picture.data[2] + (offset >> 2);
2389
        }
2390
        emms_c();
2391

    
2392
        s->avctx->draw_horiz_band(s->avctx, src_ptr, s->linesize,
2393
                               y, s->width, h);
2394
    }
2395
}
2396

    
2397
#ifdef CONFIG_ENCODERS
2398

    
2399
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2400
{
2401
    const int mb_x= s->mb_x;
2402
    const int mb_y= s->mb_y;
2403
    int i;
2404
    int skip_dct[6];
2405
    int dct_offset   = s->linesize*8; //default for progressive frames
2406
    
2407
    for(i=0; i<6; i++) skip_dct[i]=0;
2408
    
2409
    if(s->adaptive_quant){
2410
        s->dquant= s->current_picture.qscale_table[mb_x + mb_y*s->mb_width] - s->qscale;
2411

    
2412
        if(s->out_format==FMT_H263){
2413
            if     (s->dquant> 2) s->dquant= 2;
2414
            else if(s->dquant<-2) s->dquant=-2;
2415
        }
2416
            
2417
        if(s->codec_id==CODEC_ID_MPEG4){        
2418
            if(!s->mb_intra){
2419
                if(s->mv_dir&MV_DIRECT)
2420
                    s->dquant=0;
2421

    
2422
                assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
2423
            }
2424
        }
2425
        s->qscale+= s->dquant;
2426
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2427
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2428
    }
2429

    
2430
    if (s->mb_intra) {
2431
        uint8_t *ptr;
2432
        int wrap_y;
2433
        int emu=0;
2434

    
2435
        wrap_y = s->linesize;
2436
        ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2437

    
2438
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2439
            ff_emulated_edge_mc(s, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2440
            ptr= s->edge_emu_buffer;
2441
            emu=1;
2442
        }
2443
        
2444
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2445
            int progressive_score, interlaced_score;
2446
            
2447
            progressive_score= pix_vcmp16x8(ptr, wrap_y  ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
2448
            interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y  , wrap_y*2);
2449
            
2450
            if(progressive_score > interlaced_score + 100){
2451
                s->interlaced_dct=1;
2452
            
2453
                dct_offset= wrap_y;
2454
                wrap_y<<=1;
2455
            }else
2456
                s->interlaced_dct=0;
2457
        }
2458
        
2459
        s->dsp.get_pixels(s->block[0], ptr                 , wrap_y);
2460
        s->dsp.get_pixels(s->block[1], ptr              + 8, wrap_y);
2461
        s->dsp.get_pixels(s->block[2], ptr + dct_offset    , wrap_y);
2462
        s->dsp.get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
2463

    
2464
        if(s->flags&CODEC_FLAG_GRAY){
2465
            skip_dct[4]= 1;
2466
            skip_dct[5]= 1;
2467
        }else{
2468
            int wrap_c = s->uvlinesize;
2469
            ptr = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2470
            if(emu){
2471
                ff_emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2472
                ptr= s->edge_emu_buffer;
2473
            }
2474
            s->dsp.get_pixels(s->block[4], ptr, wrap_c);
2475

    
2476
            ptr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2477
            if(emu){
2478
                ff_emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2479
                ptr= s->edge_emu_buffer;
2480
            }
2481
            s->dsp.get_pixels(s->block[5], ptr, wrap_c);
2482
        }
2483
    }else{
2484
        op_pixels_func (*op_pix)[4];
2485
        qpel_mc_func (*op_qpix)[16];
2486
        uint8_t *dest_y, *dest_cb, *dest_cr;
2487
        uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2488
        int wrap_y, wrap_c;
2489
        int emu=0;
2490

    
2491
        dest_y  = s->current_picture.data[0] + (mb_y * 16 * s->linesize    ) + mb_x * 16;
2492
        dest_cb = s->current_picture.data[1] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2493
        dest_cr = s->current_picture.data[2] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2494
        wrap_y = s->linesize;
2495
        wrap_c = s->uvlinesize;
2496
        ptr_y  = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2497
        ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2498
        ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2499

    
2500
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
2501
            op_pix = s->dsp.put_pixels_tab;
2502
            op_qpix= s->dsp.put_qpel_pixels_tab;
2503
        }else{
2504
            op_pix = s->dsp.put_no_rnd_pixels_tab;
2505
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2506
        }
2507

    
2508
        if (s->mv_dir & MV_DIR_FORWARD) {
2509
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2510
            op_pix = s->dsp.avg_pixels_tab;
2511
            op_qpix= s->dsp.avg_qpel_pixels_tab;
2512
        }
2513
        if (s->mv_dir & MV_DIR_BACKWARD) {
2514
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2515
        }
2516

    
2517
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2518
            ff_emulated_edge_mc(s, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2519
            ptr_y= s->edge_emu_buffer;
2520
            emu=1;
2521
        }
2522
        
2523
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2524
            int progressive_score, interlaced_score;
2525
            
2526
            progressive_score= pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y  ) 
2527
                             + pix_diff_vcmp16x8(ptr_y + wrap_y*8, dest_y + wrap_y*8, wrap_y  );
2528
            interlaced_score = pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y*2)
2529
                             + pix_diff_vcmp16x8(ptr_y + wrap_y  , dest_y + wrap_y  , wrap_y*2);
2530
            
2531
            if(progressive_score > interlaced_score + 600){
2532
                s->interlaced_dct=1;
2533
            
2534
                dct_offset= wrap_y;
2535
                wrap_y<<=1;
2536
            }else
2537
                s->interlaced_dct=0;
2538
        }
2539
        
2540
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
2541
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
2542
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
2543
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
2544
        
2545
        if(s->flags&CODEC_FLAG_GRAY){
2546
            skip_dct[4]= 1;
2547
            skip_dct[5]= 1;
2548
        }else{
2549
            if(emu){
2550
                ff_emulated_edge_mc(s, ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2551
                ptr_cb= s->edge_emu_buffer;
2552
            }
2553
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2554
            if(emu){
2555
                ff_emulated_edge_mc(s, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2556
                ptr_cr= s->edge_emu_buffer;
2557
            }
2558
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2559
        }
2560
        /* pre quantization */         
2561
        if(s->current_picture.mc_mb_var[s->mb_width*mb_y+ mb_x]<2*s->qscale*s->qscale){
2562
            //FIXME optimize
2563
            if(s->dsp.pix_abs8x8(ptr_y               , dest_y               , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
2564
            if(s->dsp.pix_abs8x8(ptr_y            + 8, dest_y            + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
2565
            if(s->dsp.pix_abs8x8(ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
2566
            if(s->dsp.pix_abs8x8(ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
2567
            if(s->dsp.pix_abs8x8(ptr_cb              , dest_cb              , wrap_c) < 20*s->qscale) skip_dct[4]= 1;
2568
            if(s->dsp.pix_abs8x8(ptr_cr              , dest_cr              , wrap_c) < 20*s->qscale) skip_dct[5]= 1;
2569
#if 0
2570
{
2571
 static int stat[7];
2572
 int num=0;
2573
 for(i=0; i<6; i++)
2574
  if(skip_dct[i]) num++;
2575
 stat[num]++;
2576
 
2577
 if(s->mb_x==0 && s->mb_y==0){
2578
  for(i=0; i<7; i++){
2579
   printf("%6d %1d\n", stat[i], i);
2580
  }
2581
 }
2582
}
2583
#endif
2584
        }
2585

    
2586
    }
2587
            
2588
#if 0
2589
            {
2590
                float adap_parm;
2591
                
2592
                adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_width*mb_y+mb_x] + 1.0) /
2593
                            ((s->mb_var[s->mb_width*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);
2594
            
2595
                printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d", 
2596
                        (s->mb_type[s->mb_width*mb_y+mb_x] > 0) ? 'I' : 'P', 
2597
                        s->qscale, adap_parm, s->qscale*adap_parm,
2598
                        s->mb_var[s->mb_width*mb_y+mb_x], s->avg_mb_var);
2599
            }
2600
#endif
2601
    /* DCT & quantize */
2602
    if(s->out_format==FMT_MJPEG){
2603
        for(i=0;i<6;i++) {
2604
            int overflow;
2605
            s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
2606
            if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2607
        }
2608
    }else{
2609
        for(i=0;i<6;i++) {
2610
            if(!skip_dct[i]){
2611
                int overflow;
2612
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2613
            // FIXME we could decide to change to quantizer instead of clipping
2614
            // JS: I don't think that would be a good idea it could lower quality instead
2615
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
2616
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2617
            }else
2618
                s->block_last_index[i]= -1;
2619
        }
2620
        if(s->luma_elim_threshold && !s->mb_intra)
2621
            for(i=0; i<4; i++)
2622
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2623
        if(s->chroma_elim_threshold && !s->mb_intra)
2624
            for(i=4; i<6; i++)
2625
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2626
    }
2627

    
2628
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
2629
        s->block_last_index[4]=
2630
        s->block_last_index[5]= 0;
2631
        s->block[4][0]=
2632
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
2633
    }
2634

    
2635
    /* huffman encode */
2636
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2637
    case CODEC_ID_MPEG1VIDEO:
2638
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
2639
#ifdef CONFIG_RISKY
2640
    case CODEC_ID_MPEG4:
2641
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
2642
    case CODEC_ID_MSMPEG4V2:
2643
    case CODEC_ID_MSMPEG4V3:
2644
    case CODEC_ID_WMV1:
2645
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
2646
    case CODEC_ID_WMV2:
2647
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
2648
    case CODEC_ID_H263:
2649
    case CODEC_ID_H263P:
2650
    case CODEC_ID_RV10:
2651
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
2652
#endif
2653
    case CODEC_ID_MJPEG:
2654
        mjpeg_encode_mb(s, s->block); break;
2655
    default:
2656
        assert(0);
2657
    }
2658
}
2659

    
2660
#endif //CONFIG_ENCODERS
2661

    
2662
/**
2663
 * combines the (truncated) bitstream to a complete frame
2664
 * @returns -1 if no complete frame could be created
2665
 */
2666
int ff_combine_frame( MpegEncContext *s, int next, uint8_t **buf, int *buf_size){
2667
    ParseContext *pc= &s->parse_context;
2668
        
2669
    pc->last_index= pc->index;
2670

    
2671
    if(next==-1){
2672
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
2673

    
2674
        memcpy(&pc->buffer[pc->index], *buf, *buf_size);
2675
        pc->index += *buf_size;
2676
        return -1;
2677
    }
2678

    
2679
    if(pc->index){
2680
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
2681

    
2682
        memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
2683
        pc->index = 0;
2684
        *buf= pc->buffer;
2685
        *buf_size= pc->last_index + next;
2686
    }
2687

    
2688
    return 0;
2689
}
2690

    
2691
#ifdef CONFIG_ENCODERS
2692
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
2693
{
2694
    int bytes= length>>4;
2695
    int bits= length&15;
2696
    int i;
2697

    
2698
    if(length==0) return;
2699

    
2700
    for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
2701
    put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
2702
}
2703

    
2704
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2705
    int i;
2706

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

    
2709
    /* mpeg1 */
2710
    d->mb_skip_run= s->mb_skip_run;
2711
    for(i=0; i<3; i++)
2712
        d->last_dc[i]= s->last_dc[i];
2713
    
2714
    /* statistics */
2715
    d->mv_bits= s->mv_bits;
2716
    d->i_tex_bits= s->i_tex_bits;
2717
    d->p_tex_bits= s->p_tex_bits;
2718
    d->i_count= s->i_count;
2719
    d->f_count= s->f_count;
2720
    d->b_count= s->b_count;
2721
    d->skip_count= s->skip_count;
2722
    d->misc_bits= s->misc_bits;
2723
    d->last_bits= 0;
2724

    
2725
    d->mb_skiped= s->mb_skiped;
2726
    d->qscale= s->qscale;
2727
}
2728

    
2729
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2730
    int i;
2731

    
2732
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
2733
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
2734
    
2735
    /* mpeg1 */
2736
    d->mb_skip_run= s->mb_skip_run;
2737
    for(i=0; i<3; i++)
2738
        d->last_dc[i]= s->last_dc[i];
2739
    
2740
    /* statistics */
2741
    d->mv_bits= s->mv_bits;
2742
    d->i_tex_bits= s->i_tex_bits;
2743
    d->p_tex_bits= s->p_tex_bits;
2744
    d->i_count= s->i_count;
2745
    d->f_count= s->f_count;
2746
    d->b_count= s->b_count;
2747
    d->skip_count= s->skip_count;
2748
    d->misc_bits= s->misc_bits;
2749

    
2750
    d->mb_intra= s->mb_intra;
2751
    d->mb_skiped= s->mb_skiped;
2752
    d->mv_type= s->mv_type;
2753
    d->mv_dir= s->mv_dir;
2754
    d->pb= s->pb;
2755
    if(s->data_partitioning){
2756
        d->pb2= s->pb2;
2757
        d->tex_pb= s->tex_pb;
2758
    }
2759
    d->block= s->block;
2760
    for(i=0; i<6; i++)
2761
        d->block_last_index[i]= s->block_last_index[i];
2762
    d->interlaced_dct= s->interlaced_dct;
2763
    d->qscale= s->qscale;
2764
}
2765

    
2766
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
2767
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2768
                           int *dmin, int *next_block, int motion_x, int motion_y)
2769
{
2770
    int bits_count;
2771
    
2772
    copy_context_before_encode(s, backup, type);
2773

    
2774
    s->block= s->blocks[*next_block];
2775
    s->pb= pb[*next_block];
2776
    if(s->data_partitioning){
2777
        s->pb2   = pb2   [*next_block];
2778
        s->tex_pb= tex_pb[*next_block];
2779
    }
2780

    
2781
    encode_mb(s, motion_x, motion_y);
2782

    
2783
    bits_count= get_bit_count(&s->pb);
2784
    if(s->data_partitioning){
2785
        bits_count+= get_bit_count(&s->pb2);
2786
        bits_count+= get_bit_count(&s->tex_pb);
2787
    }
2788

    
2789
    if(bits_count<*dmin){
2790
        *dmin= bits_count;
2791
        *next_block^=1;
2792

    
2793
        copy_context_after_encode(best, s, type);
2794
    }
2795
}
2796
                
2797
static inline int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2798
    uint32_t *sq = squareTbl + 256;
2799
    int acc=0;
2800
    int x,y;
2801
    
2802
    if(w==16 && h==16) 
2803
        return s->dsp.sse[0](NULL, src1, src2, stride);
2804
    else if(w==8 && h==8)
2805
        return s->dsp.sse[1](NULL, src1, src2, stride);
2806
    
2807
    for(y=0; y<h; y++){
2808
        for(x=0; x<w; x++){
2809
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2810
        } 
2811
    }
2812
    
2813
    assert(acc>=0);
2814
    
2815
    return acc;
2816
}
2817

    
2818
static void encode_picture(MpegEncContext *s, int picture_number)
2819
{
2820
    int mb_x, mb_y, pdif = 0;
2821
    int i;
2822
    int bits;
2823
    MpegEncContext best_s, backup_s;
2824
    uint8_t bit_buf[2][3000];
2825
    uint8_t bit_buf2[2][3000];
2826
    uint8_t bit_buf_tex[2][3000];
2827
    PutBitContext pb[2], pb2[2], tex_pb[2];
2828

    
2829
    for(i=0; i<2; i++){
2830
        init_put_bits(&pb    [i], bit_buf    [i], 3000, NULL, NULL);
2831
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000, NULL, NULL);
2832
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
2833
    }
2834

    
2835
    s->picture_number = picture_number;
2836

    
2837
    s->block_wrap[0]=
2838
    s->block_wrap[1]=
2839
    s->block_wrap[2]=
2840
    s->block_wrap[3]= s->mb_width*2 + 2;
2841
    s->block_wrap[4]=
2842
    s->block_wrap[5]= s->mb_width + 2;
2843
    
2844
    /* Reset the average MB variance */
2845
    s->current_picture.mb_var_sum = 0;
2846
    s->current_picture.mc_mb_var_sum = 0;
2847

    
2848
#ifdef CONFIG_RISKY
2849
    /* we need to initialize some time vars before we can encode b-frames */
2850
    // RAL: Condition added for MPEG1VIDEO
2851
    if (s->codec_id == CODEC_ID_MPEG1VIDEO || (s->h263_pred && !s->h263_msmpeg4))
2852
        ff_set_mpeg4_time(s, s->picture_number); 
2853
#endif
2854
        
2855
    s->scene_change_score=0;
2856
    
2857
    s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
2858
    
2859
    if(s->pict_type==I_TYPE){
2860
        if(s->msmpeg4_version >= 3) s->no_rounding=1;
2861
        else                        s->no_rounding=0;
2862
    }else if(s->pict_type!=B_TYPE){
2863
        if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
2864
            s->no_rounding ^= 1;          
2865
    }
2866
    
2867
    /* Estimate motion for every MB */
2868
    s->mb_intra=0; //for the rate distoration & bit compare functions
2869
    if(s->pict_type != I_TYPE){
2870
        if(s->pict_type != B_TYPE){
2871
            if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
2872
                s->me.pre_pass=1;
2873
                s->me.dia_size= s->avctx->pre_dia_size;
2874

    
2875
                for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) {
2876
                    for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) {
2877
                        s->mb_x = mb_x;
2878
                        s->mb_y = mb_y;
2879
                        ff_pre_estimate_p_frame_motion(s, mb_x, mb_y);
2880
                    }
2881
                }
2882
                s->me.pre_pass=0;
2883
            }
2884
        }
2885

    
2886
        s->me.dia_size= s->avctx->dia_size;
2887
        for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2888
            s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
2889
            s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
2890
            s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
2891
            s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
2892
            for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2893
                s->mb_x = mb_x;
2894
                s->mb_y = mb_y;
2895
                s->block_index[0]+=2;
2896
                s->block_index[1]+=2;
2897
                s->block_index[2]+=2;
2898
                s->block_index[3]+=2;
2899
                
2900
                /* compute motion vector & mb_type and store in context */
2901
                if(s->pict_type==B_TYPE)
2902
                    ff_estimate_b_frame_motion(s, mb_x, mb_y);
2903
                else
2904
                    ff_estimate_p_frame_motion(s, mb_x, mb_y);
2905
            }
2906
        }
2907
    }else /* if(s->pict_type == I_TYPE) */{
2908
        /* I-Frame */
2909
        //FIXME do we need to zero them?
2910
        memset(s->motion_val[0], 0, sizeof(int16_t)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
2911
        memset(s->p_mv_table   , 0, sizeof(int16_t)*(s->mb_width+2)*(s->mb_height+2)*2);
2912
        memset(s->mb_type      , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_width*s->mb_height);
2913
        
2914
        if(!s->fixed_qscale){
2915
            /* finding spatial complexity for I-frame rate control */
2916
            for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2917
                for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2918
                    int xx = mb_x * 16;
2919
                    int yy = mb_y * 16;
2920
                    uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
2921
                    int varc;
2922
                    int sum = s->dsp.pix_sum(pix, s->linesize);
2923
    
2924
                    varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
2925

    
2926
                    s->current_picture.mb_var [s->mb_width * mb_y + mb_x] = varc;
2927
                    s->current_picture.mb_mean[s->mb_width * mb_y + mb_x] = (sum+128)>>8;
2928
                    s->current_picture.mb_var_sum    += varc;
2929
                }
2930
            }
2931
        }
2932
    }
2933
    emms_c();
2934

    
2935
    if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
2936
        s->pict_type= I_TYPE;
2937
        memset(s->mb_type   , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_width*s->mb_height);
2938
//printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
2939
    }
2940

    
2941
    if(!s->umvplus){
2942
        if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
2943
            s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
2944
        
2945
            ff_fix_long_p_mvs(s);
2946
        }
2947

    
2948
        if(s->pict_type==B_TYPE){
2949
            int a, b;
2950

    
2951
            a = ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
2952
            b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, MB_TYPE_BIDIR);
2953
            s->f_code = FFMAX(a, b);
2954

    
2955
            a = ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
2956
            b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, MB_TYPE_BIDIR);
2957
            s->b_code = FFMAX(a, b);
2958

    
2959
            ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
2960
            ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
2961
            ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
2962
            ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
2963
        }
2964
    }
2965
    
2966
    if (s->fixed_qscale) 
2967
        s->frame_qscale = s->current_picture.quality;
2968
    else
2969
        s->frame_qscale = ff_rate_estimate_qscale(s);
2970

    
2971
    if(s->adaptive_quant){
2972
#ifdef CONFIG_RISKY
2973
        switch(s->codec_id){
2974
        case CODEC_ID_MPEG4:
2975
            ff_clean_mpeg4_qscales(s);
2976
            break;
2977
        case CODEC_ID_H263:
2978
        case CODEC_ID_H263P:
2979
            ff_clean_h263_qscales(s);
2980
            break;
2981
        }
2982
#endif
2983

    
2984
        s->qscale= s->current_picture.qscale_table[0];
2985
    }else
2986
        s->qscale= (int)(s->frame_qscale + 0.5);
2987
        
2988
    if (s->out_format == FMT_MJPEG) {
2989
        /* for mjpeg, we do include qscale in the matrix */
2990
        s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
2991
        for(i=1;i<64;i++){
2992
            int j= s->dsp.idct_permutation[i];
2993

    
2994
            s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
2995
        }
2996
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, 
2997
                       s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
2998
    }
2999
    
3000
    //FIXME var duplication
3001
    s->current_picture.key_frame= s->pict_type == I_TYPE;
3002
    s->current_picture.pict_type= s->pict_type;
3003

    
3004
    if(s->current_picture.key_frame)
3005
        s->picture_in_gop_number=0;
3006

    
3007
    s->last_bits= get_bit_count(&s->pb);
3008
    switch(s->out_format) {
3009
    case FMT_MJPEG:
3010
        mjpeg_picture_header(s);
3011
        break;
3012
#ifdef CONFIG_RISKY
3013
    case FMT_H263:
3014
        if (s->codec_id == CODEC_ID_WMV2) 
3015
            ff_wmv2_encode_picture_header(s, picture_number);
3016
        else if (s->h263_msmpeg4) 
3017
            msmpeg4_encode_picture_header(s, picture_number);
3018
        else if (s->h263_pred)
3019
            mpeg4_encode_picture_header(s, picture_number);
3020
        else if (s->h263_rv10) 
3021
            rv10_encode_picture_header(s, picture_number);
3022
        else
3023
            h263_encode_picture_header(s, picture_number);
3024
        break;
3025
#endif
3026
    case FMT_MPEG1:
3027
        mpeg1_encode_picture_header(s, picture_number);
3028
        break;
3029
    }
3030
    bits= get_bit_count(&s->pb);
3031
    s->header_bits= bits - s->last_bits;
3032
    s->last_bits= bits;
3033
    s->mv_bits=0;
3034
    s->misc_bits=0;
3035
    s->i_tex_bits=0;
3036
    s->p_tex_bits=0;
3037
    s->i_count=0;
3038
    s->f_count=0;
3039
    s->b_count=0;
3040
    s->skip_count=0;
3041

    
3042
    for(i=0; i<3; i++){
3043
        /* init last dc values */
3044
        /* note: quant matrix value (8) is implied here */
3045
        s->last_dc[i] = 128;
3046
        
3047
        s->current_picture_ptr->error[i] = 0;
3048
    }
3049
    s->mb_skip_run = 0;
3050
    s->last_mv[0][0][0] = 0;
3051
    s->last_mv[0][0][1] = 0;
3052
    s->last_mv[1][0][0] = 0;
3053
    s->last_mv[1][0][1] = 0;
3054
     
3055
    s->last_mv_dir = 0;
3056

    
3057
#ifdef CONFIG_RISKY
3058
    if (s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P)
3059
        s->gob_index = ff_h263_get_gob_height(s);
3060

    
3061
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3062
        ff_mpeg4_init_partitions(s);
3063
#endif
3064

    
3065
    s->resync_mb_x=0;
3066
    s->resync_mb_y=0;
3067
    s->first_slice_line = 1;
3068
    s->ptr_lastgob = s->pb.buf;
3069
    for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3070
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
3071
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
3072
        
3073
        s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3074
        s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3075
        s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3076
        s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3077
        s->block_index[4]= s->block_wrap[4]*(mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2);
3078
        s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
3079
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3080
            int mb_type= s->mb_type[mb_y * s->mb_width + mb_x];
3081
            const int xy= (mb_y+1) * (s->mb_width+2) + mb_x + 1;
3082
//            int d;
3083
            int dmin=10000000;
3084

    
3085
            s->mb_x = mb_x;
3086
            s->mb_y = mb_y;
3087
            s->block_index[0]+=2;
3088
            s->block_index[1]+=2;
3089
            s->block_index[2]+=2;
3090
            s->block_index[3]+=2;
3091
            s->block_index[4]++;
3092
            s->block_index[5]++;
3093

    
3094
            /* write gob / video packet header  */
3095
#ifdef CONFIG_RISKY
3096
            if(s->rtp_mode){
3097
                int current_packet_size, is_gob_start;
3098
                
3099
                current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
3100
                is_gob_start=0;
3101
                
3102
                if(s->codec_id==CODEC_ID_MPEG4){
3103
                    if(current_packet_size >= s->rtp_payload_size
3104
                       && s->mb_y + s->mb_x>0){
3105

    
3106
                        if(s->partitioned_frame){
3107
                            ff_mpeg4_merge_partitions(s);
3108
                            ff_mpeg4_init_partitions(s);
3109
                        }
3110
                        ff_mpeg4_encode_video_packet_header(s);
3111

    
3112
                        if(s->flags&CODEC_FLAG_PASS1){
3113
                            int bits= get_bit_count(&s->pb);
3114
                            s->misc_bits+= bits - s->last_bits;
3115
                            s->last_bits= bits;
3116
                        }
3117
                        ff_mpeg4_clean_buffers(s);
3118
                        is_gob_start=1;
3119
                    }
3120
                }else if(s->codec_id==CODEC_ID_MPEG1VIDEO){
3121
                    if(   current_packet_size >= s->rtp_payload_size 
3122
                       && s->mb_y + s->mb_x>0 && s->mb_skip_run==0){
3123
                        ff_mpeg1_encode_slice_header(s);
3124
                        ff_mpeg1_clean_buffers(s);
3125
                        is_gob_start=1;
3126
                    }
3127
                }else{
3128
                    if(current_packet_size >= s->rtp_payload_size
3129
                       && s->mb_x==0 && s->mb_y>0 && s->mb_y%s->gob_index==0){
3130
                       
3131
                        h263_encode_gob_header(s, mb_y);                       
3132
                        is_gob_start=1;
3133
                    }
3134
                }
3135

    
3136
                if(is_gob_start){
3137
                    s->ptr_lastgob = pbBufPtr(&s->pb);
3138
                    s->first_slice_line=1;
3139
                    s->resync_mb_x=mb_x;
3140
                    s->resync_mb_y=mb_y;
3141
                }
3142
            }
3143
#endif
3144

    
3145
            if(  (s->resync_mb_x   == s->mb_x)
3146
               && s->resync_mb_y+1 == s->mb_y){
3147
                s->first_slice_line=0; 
3148
            }
3149

    
3150
            if(mb_type & (mb_type-1)){ // more than 1 MB type possible
3151
                int next_block=0;
3152
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3153

    
3154
                copy_context_before_encode(&backup_s, s, -1);
3155
                backup_s.pb= s->pb;
3156
                best_s.data_partitioning= s->data_partitioning;
3157
                best_s.partitioned_frame= s->partitioned_frame;
3158
                if(s->data_partitioning){
3159
                    backup_s.pb2= s->pb2;
3160
                    backup_s.tex_pb= s->tex_pb;
3161
                }
3162

    
3163
                if(mb_type&MB_TYPE_INTER){
3164
                    s->mv_dir = MV_DIR_FORWARD;
3165
                    s->mv_type = MV_TYPE_16X16;
3166
                    s->mb_intra= 0;
3167
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
3168
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
3169
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb, 
3170
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3171
                }
3172
                if(mb_type&MB_TYPE_INTER4V){                 
3173
                    s->mv_dir = MV_DIR_FORWARD;
3174
                    s->mv_type = MV_TYPE_8X8;
3175
                    s->mb_intra= 0;
3176
                    for(i=0; i<4; i++){
3177
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3178
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3179
                    }
3180
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb, 
3181
                                 &dmin, &next_block, 0, 0);
3182
                }
3183
                if(mb_type&MB_TYPE_FORWARD){
3184
                    s->mv_dir = MV_DIR_FORWARD;
3185
                    s->mv_type = MV_TYPE_16X16;
3186
                    s->mb_intra= 0;
3187
                    s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3188
                    s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3189
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb, 
3190
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3191
                }
3192
                if(mb_type&MB_TYPE_BACKWARD){
3193
                    s->mv_dir = MV_DIR_BACKWARD;
3194
                    s->mv_type = MV_TYPE_16X16;
3195
                    s->mb_intra= 0;
3196
                    s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3197
                    s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3198
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb, 
3199
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3200
                }
3201
                if(mb_type&MB_TYPE_BIDIR){
3202
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3203
                    s->mv_type = MV_TYPE_16X16;
3204
                    s->mb_intra= 0;
3205
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3206
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3207
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3208
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3209
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb, 
3210
                                 &dmin, &next_block, 0, 0);
3211
                }
3212
                if(mb_type&MB_TYPE_DIRECT){
3213
                    int mx= s->b_direct_mv_table[xy][0];
3214
                    int my= s->b_direct_mv_table[xy][1];
3215
                    
3216
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3217
                    s->mb_intra= 0;
3218
#ifdef CONFIG_RISKY
3219
                    ff_mpeg4_set_direct_mv(s, mx, my);
3220
#endif
3221
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb, 
3222
                                 &dmin, &next_block, mx, my);
3223
                }
3224
                if(mb_type&MB_TYPE_INTRA){
3225
                    s->mv_dir = 0;
3226
                    s->mv_type = MV_TYPE_16X16;
3227
                    s->mb_intra= 1;
3228
                    s->mv[0][0][0] = 0;
3229
                    s->mv[0][0][1] = 0;
3230
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb, 
3231
                                 &dmin, &next_block, 0, 0);
3232
                    /* force cleaning of ac/dc pred stuff if needed ... */
3233
                    if(s->h263_pred || s->h263_aic)
3234
                        s->mbintra_table[mb_x + mb_y*s->mb_width]=1;
3235
                }
3236
                copy_context_after_encode(s, &best_s, -1);
3237
                
3238
                pb_bits_count= get_bit_count(&s->pb);
3239
                flush_put_bits(&s->pb);
3240
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3241
                s->pb= backup_s.pb;
3242
                
3243
                if(s->data_partitioning){
3244
                    pb2_bits_count= get_bit_count(&s->pb2);
3245
                    flush_put_bits(&s->pb2);
3246
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3247
                    s->pb2= backup_s.pb2;
3248
                    
3249
                    tex_pb_bits_count= get_bit_count(&s->tex_pb);
3250
                    flush_put_bits(&s->tex_pb);
3251
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3252
                    s->tex_pb= backup_s.tex_pb;
3253
                }
3254
                s->last_bits= get_bit_count(&s->pb);
3255
            } else {
3256
                int motion_x, motion_y;
3257
                int intra_score;
3258
                int inter_score= s->current_picture.mb_cmp_score[mb_x + mb_y*s->mb_width];
3259
                
3260
              if(!(s->flags&CODEC_FLAG_HQ) && s->pict_type==P_TYPE){
3261
                /* get luma score */
3262
                if((s->avctx->mb_cmp&0xFF)==FF_CMP_SSE){
3263
                    intra_score= (s->current_picture.mb_var[mb_x + mb_y*s->mb_width]<<8) - 500; //FIXME dont scale it down so we dont have to fix it
3264
                }else{
3265
                    uint8_t *dest_y;
3266

    
3267
                    int mean= s->current_picture.mb_mean[mb_x + mb_y*s->mb_width]; //FIXME
3268
                    mean*= 0x01010101;
3269
                    
3270
                    dest_y  = s->new_picture.data[0] + (mb_y * 16 * s->linesize    ) + mb_x * 16;
3271
                
3272
                    for(i=0; i<16; i++){
3273
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 0]) = mean;
3274
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 4]) = mean;
3275
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 8]) = mean;
3276
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+12]) = mean;
3277
                    }
3278

    
3279
                    s->mb_intra=1;
3280
                    intra_score= s->dsp.mb_cmp[0](s, s->me.scratchpad, dest_y, s->linesize);
3281
                                        
3282
/*                    printf("intra:%7d inter:%7d var:%7d mc_var.%7d\n", intra_score>>8, inter_score>>8, 
3283
                        s->current_picture.mb_var[mb_x + mb_y*s->mb_width],
3284
                        s->current_picture.mc_mb_var[mb_x + mb_y*s->mb_width]);*/
3285
                }
3286
                
3287
                /* get chroma score */
3288
                if(s->avctx->mb_cmp&FF_CMP_CHROMA){
3289
                    int i;
3290
                    
3291
                    s->mb_intra=1;
3292
                    for(i=1; i<3; i++){
3293
                        uint8_t *dest_c;
3294
                        int mean;
3295
                        
3296
                        if(s->out_format == FMT_H263){
3297
                            mean= (s->dc_val[i][mb_x + (mb_y+1)*(s->mb_width+2)] + 4)>>3; //FIXME not exact but simple ;)
3298
                        }else{
3299
                            mean= (s->last_dc[i] + 4)>>3;
3300
                        }
3301
                        dest_c = s->new_picture.data[i] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
3302
                        
3303
                        mean*= 0x01010101;
3304
                        for(i=0; i<8; i++){
3305
                            *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 0]) = mean;
3306
                            *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 4]) = mean;
3307
                        }
3308
                        
3309
                        intra_score+= s->dsp.mb_cmp[1](s, s->me.scratchpad, dest_c, s->uvlinesize);
3310
                    }                
3311
                }
3312

    
3313
                /* bias */
3314
                switch(s->avctx->mb_cmp&0xFF){
3315
                default:
3316
                case FF_CMP_SAD:
3317
                    intra_score+= 32*s->qscale;
3318
                    break;
3319
                case FF_CMP_SSE:
3320
                    intra_score+= 24*s->qscale*s->qscale;
3321
                    break;
3322
                case FF_CMP_SATD:
3323
                    intra_score+= 96*s->qscale;
3324
                    break;
3325
                case FF_CMP_DCT:
3326
                    intra_score+= 48*s->qscale;
3327
                    break;
3328
                case FF_CMP_BIT:
3329
                    intra_score+= 16;
3330
                    break;
3331
                case FF_CMP_PSNR:
3332
                case FF_CMP_RD:
3333
                    intra_score+= (s->qscale*s->qscale*109*8 + 64)>>7;
3334
                    break;
3335
                }
3336

    
3337
                if(intra_score < inter_score)
3338
                    mb_type= MB_TYPE_INTRA;
3339
              }  
3340
                
3341
                s->mv_type=MV_TYPE_16X16;
3342
                // only one MB-Type possible
3343
                
3344
                switch(mb_type){
3345
                case MB_TYPE_INTRA:
3346
                    s->mv_dir = 0;
3347
                    s->mb_intra= 1;
3348
                    motion_x= s->mv[0][0][0] = 0;
3349
                    motion_y= s->mv[0][0][1] = 0;
3350
                    break;
3351
                case MB_TYPE_INTER:
3352
                    s->mv_dir = MV_DIR_FORWARD;
3353
                    s->mb_intra= 0;
3354
                    motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3355
                    motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3356
                    break;
3357
                case MB_TYPE_INTER4V:
3358
                    s->mv_dir = MV_DIR_FORWARD;
3359
                    s->mv_type = MV_TYPE_8X8;
3360
                    s->mb_intra= 0;
3361
                    for(i=0; i<4; i++){
3362
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3363
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3364
                    }
3365
                    motion_x= motion_y= 0;
3366
                    break;
3367
                case MB_TYPE_DIRECT:
3368
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3369
                    s->mb_intra= 0;
3370
                    motion_x=s->b_direct_mv_table[xy][0];
3371
                    motion_y=s->b_direct_mv_table[xy][1];
3372
#ifdef CONFIG_RISKY
3373
                    ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3374
#endif
3375
                    break;
3376
                case MB_TYPE_BIDIR:
3377
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3378
                    s->mb_intra= 0;
3379
                    motion_x=0;
3380
                    motion_y=0;
3381
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3382
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3383
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3384
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3385
                    break;
3386
                case MB_TYPE_BACKWARD:
3387
                    s->mv_dir = MV_DIR_BACKWARD;
3388
                    s->mb_intra= 0;
3389
                    motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3390
                    motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3391
                    break;
3392
                case MB_TYPE_FORWARD:
3393
                    s->mv_dir = MV_DIR_FORWARD;
3394
                    s->mb_intra= 0;
3395
                    motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3396
                    motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3397
//                    printf(" %d %d ", motion_x, motion_y);
3398
                    break;
3399
                default:
3400
                    motion_x=motion_y=0; //gcc warning fix
3401
                    printf("illegal MB type\n");
3402
                }
3403

    
3404
                encode_mb(s, motion_x, motion_y);
3405

    
3406
                // RAL: Update last macrobloc type
3407
                s->last_mv_dir = s->mv_dir;
3408
            }
3409

    
3410
            /* clean the MV table in IPS frames for direct mode in B frames */
3411
            if(s->mb_intra /* && I,P,S_TYPE */){
3412
                s->p_mv_table[xy][0]=0;
3413
                s->p_mv_table[xy][1]=0;
3414
            }
3415

    
3416
            MPV_decode_mb(s, s->block);
3417
            
3418
            if(s->flags&CODEC_FLAG_PSNR){
3419
                int w= 16;
3420
                int h= 16;
3421

    
3422
                if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3423
                if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3424

    
3425
                s->current_picture_ptr->error[0] += sse(
3426
                    s,
3427
                    s->new_picture    .data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3428
                    s->current_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3429
                    w, h, s->linesize);
3430
                s->current_picture_ptr->error[1] += sse(
3431
                    s,
3432
                    s->new_picture    .data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3433
                    s->current_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3434
                    w>>1, h>>1, s->uvlinesize);
3435
                s->current_picture_ptr->error[2] += sse(
3436
                    s,
3437
                    s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3438
                    s->current_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3439
                    w>>1, h>>1, s->uvlinesize);
3440
            }
3441
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_width, get_bit_count(&s->pb));
3442
        }
3443
    }
3444
    emms_c();
3445

    
3446
#ifdef CONFIG_RISKY
3447
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3448
        ff_mpeg4_merge_partitions(s);
3449

    
3450
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
3451
        msmpeg4_encode_ext_header(s);
3452

    
3453
    if(s->codec_id==CODEC_ID_MPEG4) 
3454
        ff_mpeg4_stuffing(&s->pb);
3455
#endif
3456

    
3457
    //if (s->gob_number)
3458
    //    fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
3459
    
3460
    /* Send the last GOB if RTP */    
3461
    if (s->rtp_mode) {
3462
        flush_put_bits(&s->pb);
3463
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
3464
        /* Call the RTP callback to send the last GOB */
3465
        if (s->rtp_callback)
3466
            s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
3467
        s->ptr_lastgob = pbBufPtr(&s->pb);
3468
        //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
3469
    }
3470
}
3471

    
3472
static int dct_quantize_trellis_c(MpegEncContext *s, 
3473
                        DCTELEM *block, int n,
3474
                        int qscale, int *overflow){
3475
    const int *qmat;
3476
    const uint8_t *scantable= s->intra_scantable.scantable;
3477
    int max=0;
3478
    unsigned int threshold1, threshold2;
3479
    int bias=0;
3480
    int run_tab[65];
3481
    int level_tab[65];
3482
    int score_tab[65];
3483
    int last_run=0;
3484
    int last_level=0;
3485
    int last_score= 0;
3486
    int last_i= 0;
3487
    int coeff[3][64];
3488
    int coeff_count[64];
3489
    int lambda, qmul, qadd, start_i, last_non_zero, i;
3490
    const int esc_length= s->ac_esc_length;
3491
    uint8_t * length;
3492
    uint8_t * last_length;
3493
    int score_limit=0;
3494
    int left_limit= 0;
3495
        
3496
    s->dsp.fdct (block);
3497

    
3498
    qmul= qscale*16;
3499
    qadd= ((qscale-1)|1)*8;
3500

    
3501
    if (s->mb_intra) {
3502
        int q;
3503
        if (!s->h263_aic) {
3504
            if (n < 4)
3505
                q = s->y_dc_scale;
3506
            else
3507
                q = s->c_dc_scale;
3508
            q = q << 3;
3509
        } else{
3510
            /* For AIC we skip quant/dequant of INTRADC */
3511
            q = 1 << 3;
3512
            qadd=0;
3513
        }
3514
            
3515
        /* note: block[0] is assumed to be positive */
3516
        block[0] = (block[0] + (q >> 1)) / q;
3517
        start_i = 1;
3518
        last_non_zero = 0;
3519
        qmat = s->q_intra_matrix[qscale];
3520
        if(s->mpeg_quant || s->codec_id== CODEC_ID_MPEG1VIDEO)
3521
            bias= 1<<(QMAT_SHIFT-1);
3522
        length     = s->intra_ac_vlc_length;
3523
        last_length= s->intra_ac_vlc_last_length;
3524
    } else {
3525
        start_i = 0;
3526
        last_non_zero = -1;
3527
        qmat = s->q_inter_matrix[qscale];
3528
        length     = s->inter_ac_vlc_length;
3529
        last_length= s->inter_ac_vlc_last_length;
3530
    }
3531

    
3532
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
3533
    threshold2= (threshold1<<1);
3534

    
3535
    for(i=start_i; i<64; i++) {
3536
        const int j = scantable[i];
3537
        const int k= i-start_i;
3538
        int level = block[j];
3539
        level = level * qmat[j];
3540

    
3541
//        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
3542
//           || bias-level >= (1<<(QMAT_SHIFT - 3))){
3543
        if(((unsigned)(level+threshold1))>threshold2){
3544
            if(level>0){
3545
                level= (bias + level)>>QMAT_SHIFT;
3546
                coeff[0][k]= level;
3547
                coeff[1][k]= level-1;
3548
//                coeff[2][k]= level-2;
3549
            }else{
3550
                level= (bias - level)>>QMAT_SHIFT;
3551
                coeff[0][k]= -level;
3552
                coeff[1][k]= -level+1;
3553
//                coeff[2][k]= -level+2;
3554
            }
3555
            coeff_count[k]= FFMIN(level, 2);
3556
            max |=level;
3557
            last_non_zero = i;
3558
        }else{
3559
            coeff[0][k]= (level>>31)|1;
3560
            coeff_count[k]= 1;
3561
        }
3562
    }
3563
    
3564
    *overflow= s->max_qcoeff < max; //overflow might have happend
3565
    
3566
    if(last_non_zero < start_i){
3567
        memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3568
        return last_non_zero;
3569
    }
3570

    
3571
    lambda= (qscale*qscale*64*105 + 64)>>7; //FIXME finetune
3572
        
3573
    score_tab[0]= 0;
3574
    for(i=0; i<=last_non_zero - start_i; i++){
3575
        int level_index, run, j;
3576
        const int dct_coeff= block[ scantable[i + start_i] ];
3577
        const int zero_distoration= dct_coeff*dct_coeff;
3578
        int best_score=256*256*256*120;
3579

    
3580
        last_score += zero_distoration;
3581
        for(level_index=0; level_index < coeff_count[i]; level_index++){
3582
            int distoration;
3583
            int level= coeff[level_index][i];
3584
            int unquant_coeff;
3585
            
3586
            assert(level);
3587

    
3588
            if(s->out_format == FMT_H263){
3589
                if(level>0){
3590
                    unquant_coeff= level*qmul + qadd;
3591
                }else{
3592
                    unquant_coeff= level*qmul - qadd;
3593
                }
3594
            }else{ //MPEG1
3595
                j= s->dsp.idct_permutation[ scantable[i + start_i] ]; //FIXME optimize
3596
                if(s->mb_intra){
3597
                    if (level < 0) {
3598
                        unquant_coeff = (int)((-level) * qscale * s->intra_matrix[j]) >> 3;
3599
                        unquant_coeff = -((unquant_coeff - 1) | 1);
3600
                    } else {
3601
                        unquant_coeff = (int)(  level  * qscale * s->intra_matrix[j]) >> 3;
3602
                        unquant_coeff =   (unquant_coeff - 1) | 1;
3603
                    }
3604
                }else{
3605
                    if (level < 0) {
3606
                        unquant_coeff = ((((-level) << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3607
                        unquant_coeff = -((unquant_coeff - 1) | 1);
3608
                    } else {
3609
                        unquant_coeff = (((  level  << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3610
                        unquant_coeff =   (unquant_coeff - 1) | 1;
3611
                    }
3612
                }
3613
                unquant_coeff<<= 3;
3614
            }
3615

    
3616
            distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff);
3617
            level+=64;
3618
            if((level&(~127)) == 0){
3619
                for(run=0; run<=i - left_limit; run++){
3620
                    int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3621
                    score += score_tab[i-run];
3622
                    
3623
                    if(score < best_score){
3624
                        best_score= 
3625
                        score_tab[i+1]= score;
3626
                        run_tab[i+1]= run;
3627
                        level_tab[i+1]= level-64;
3628
                    }
3629
                }
3630

    
3631
                if(s->out_format == FMT_H263){
3632
                    for(run=0; run<=i - left_limit; run++){
3633
                        int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3634
                        score += score_tab[i-run];
3635
                        if(score < last_score){
3636
                            last_score= score;
3637
                            last_run= run;
3638
                            last_level= level-64;
3639
                            last_i= i+1;
3640
                        }
3641
                    }
3642
                }
3643
            }else{
3644
                distoration += esc_length*lambda;
3645
                for(run=0; run<=i - left_limit; run++){
3646
                    int score= distoration + score_tab[i-run];
3647
                    
3648
                    if(score < best_score){
3649
                        best_score= 
3650
                        score_tab[i+1]= score;
3651
                        run_tab[i+1]= run;
3652
                        level_tab[i+1]= level-64;
3653
                    }
3654
                }
3655

    
3656
                if(s->out_format == FMT_H263){
3657
                    for(run=0; run<=i - left_limit; run++){
3658
                        int score= distoration + score_tab[i-run];
3659
                        if(score < last_score){
3660
                            last_score= score;
3661
                            last_run= run;
3662
                            last_level= level-64;
3663
                            last_i= i+1;
3664
                        }
3665
                    }
3666
                }
3667
            }
3668
        }
3669

    
3670
        for(j=left_limit; j<=i; j++){
3671
            score_tab[j] += zero_distoration;
3672
        }
3673
        score_limit+= zero_distoration;
3674
        if(score_tab[i+1] < score_limit)
3675
            score_limit= score_tab[i+1];
3676
        
3677
        //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3678
        while(score_tab[ left_limit ] > score_limit + lambda) left_limit++;
3679
    }
3680

    
3681
        //FIXME add some cbp penalty
3682

    
3683
    if(s->out_format != FMT_H263){
3684
        last_score= 256*256*256*120;
3685
        for(i= left_limit; i<=last_non_zero - start_i + 1; i++){
3686
            int score= score_tab[i];
3687
            if(i) score += lambda*2; //FIXME exacter?
3688

    
3689
            if(score < last_score){
3690
                last_score= score;
3691
                last_i= i;
3692
                last_level= level_tab[i];
3693
                last_run= run_tab[i];
3694
            }
3695
        }
3696
    }
3697
    
3698
    last_non_zero= last_i - 1 + start_i;
3699
    memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3700
    
3701
    if(last_non_zero < start_i)
3702
        return last_non_zero;
3703
    
3704
    i= last_i;
3705
    assert(last_level);
3706
//FIXME use permutated scantable
3707
    block[ s->dsp.idct_permutation[ scantable[last_non_zero] ] ]= last_level;
3708
    i -= last_run + 1;
3709
    
3710
    for(;i>0 ; i -= run_tab[i] + 1){
3711
        const int j= s->dsp.idct_permutation[ scantable[i - 1 + start_i] ];
3712
    
3713
        block[j]= level_tab[i];
3714
        assert(block[j]);
3715
    }
3716

    
3717
    return last_non_zero;
3718
}
3719

    
3720
static int dct_quantize_c(MpegEncContext *s, 
3721
                        DCTELEM *block, int n,
3722
                        int qscale, int *overflow)
3723
{
3724
    int i, j, level, last_non_zero, q;
3725
    const int *qmat;
3726
    const uint8_t *scantable= s->intra_scantable.scantable;
3727
    int bias;
3728
    int max=0;
3729
    unsigned int threshold1, threshold2;
3730

    
3731
    s->dsp.fdct (block);
3732

    
3733
    if (s->mb_intra) {
3734
        if (!s->h263_aic) {
3735
            if (n < 4)
3736
                q = s->y_dc_scale;
3737
            else
3738
                q = s->c_dc_scale;
3739
            q = q << 3;
3740
        } else
3741
            /* For AIC we skip quant/dequant of INTRADC */
3742
            q = 1 << 3;
3743
            
3744
        /* note: block[0] is assumed to be positive */
3745
        block[0] = (block[0] + (q >> 1)) / q;
3746
        i = 1;
3747
        last_non_zero = 0;
3748
        qmat = s->q_intra_matrix[qscale];
3749
        bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
3750
    } else {
3751
        i = 0;
3752
        last_non_zero = -1;
3753
        qmat = s->q_inter_matrix[qscale];
3754
        bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
3755
    }
3756
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
3757
    threshold2= (threshold1<<1);
3758

    
3759
    for(;i<64;i++) {
3760
        j = scantable[i];
3761
        level = block[j];
3762
        level = level * qmat[j];
3763

    
3764
//        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
3765
//           || bias-level >= (1<<(QMAT_SHIFT - 3))){
3766
        if(((unsigned)(level+threshold1))>threshold2){
3767
            if(level>0){
3768
                level= (bias + level)>>QMAT_SHIFT;
3769
                block[j]= level;
3770
            }else{
3771
                level= (bias - level)>>QMAT_SHIFT;
3772
                block[j]= -level;
3773
            }
3774
            max |=level;
3775
            last_non_zero = i;
3776
        }else{
3777
            block[j]=0;
3778
        }
3779
    }
3780
    *overflow= s->max_qcoeff < max; //overflow might have happend
3781
    
3782
    /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
3783
    if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
3784
        ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
3785

    
3786
    return last_non_zero;
3787
}
3788

    
3789
#endif //CONFIG_ENCODERS
3790

    
3791
static void dct_unquantize_mpeg1_c(MpegEncContext *s, 
3792
                                   DCTELEM *block, int n, int qscale)
3793
{
3794
    int i, level, nCoeffs;
3795
    const uint16_t *quant_matrix;
3796

    
3797
    nCoeffs= s->block_last_index[n];
3798
    
3799
    if (s->mb_intra) {
3800
        if (n < 4) 
3801
            block[0] = block[0] * s->y_dc_scale;
3802
        else
3803
            block[0] = block[0] * s->c_dc_scale;
3804
        /* XXX: only mpeg1 */
3805
        quant_matrix = s->intra_matrix;
3806
        for(i=1;i<=nCoeffs;i++) {
3807
            int j= s->intra_scantable.permutated[i];
3808
            level = block[j];
3809
            if (level) {
3810
                if (level < 0) {
3811
                    level = -level;
3812
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3813
                    level = (level - 1) | 1;
3814
                    level = -level;
3815
                } else {
3816
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3817
                    level = (level - 1) | 1;
3818
                }
3819
#ifdef PARANOID
3820
                if (level < -2048 || level > 2047)
3821
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3822
#endif
3823
                block[j] = level;
3824
            }
3825
        }
3826
    } else {
3827
        i = 0;
3828
        quant_matrix = s->inter_matrix;
3829
        for(;i<=nCoeffs;i++) {
3830
            int j= s->intra_scantable.permutated[i];
3831
            level = block[j];
3832
            if (level) {
3833
                if (level < 0) {
3834
                    level = -level;
3835
                    level = (((level << 1) + 1) * qscale *
3836
                             ((int) (quant_matrix[j]))) >> 4;
3837
                    level = (level - 1) | 1;
3838
                    level = -level;
3839
                } else {
3840
                    level = (((level << 1) + 1) * qscale *
3841
                             ((int) (quant_matrix[j]))) >> 4;
3842
                    level = (level - 1) | 1;
3843
                }
3844
#ifdef PARANOID
3845
                if (level < -2048 || level > 2047)
3846
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3847
#endif
3848
                block[j] = level;
3849
            }
3850
        }
3851
    }
3852
}
3853

    
3854
static void dct_unquantize_mpeg2_c(MpegEncContext *s, 
3855
                                   DCTELEM *block, int n, int qscale)
3856
{
3857
    int i, level, nCoeffs;
3858
    const uint16_t *quant_matrix;
3859

    
3860
    if(s->alternate_scan) nCoeffs= 63;
3861
    else nCoeffs= s->block_last_index[n];
3862
    
3863
    if (s->mb_intra) {
3864
        if (n < 4) 
3865
            block[0] = block[0] * s->y_dc_scale;
3866
        else
3867
            block[0] = block[0] * s->c_dc_scale;
3868
        quant_matrix = s->intra_matrix;
3869
        for(i=1;i<=nCoeffs;i++) {
3870
            int j= s->intra_scantable.permutated[i];
3871
            level = block[j];
3872
            if (level) {
3873
                if (level < 0) {
3874
                    level = -level;
3875
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3876
                    level = -level;
3877
                } else {
3878
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3879
                }
3880
#ifdef PARANOID
3881
                if (level < -2048 || level > 2047)
3882
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3883
#endif
3884
                block[j] = level;
3885
            }
3886
        }
3887
    } else {
3888
        int sum=-1;
3889
        i = 0;
3890
        quant_matrix = s->inter_matrix;
3891
        for(;i<=nCoeffs;i++) {
3892
            int j= s->intra_scantable.permutated[i];
3893
            level = block[j];
3894
            if (level) {
3895
                if (level < 0) {
3896
                    level = -level;
3897
                    level = (((level << 1) + 1) * qscale *
3898
                             ((int) (quant_matrix[j]))) >> 4;
3899
                    level = -level;
3900
                } else {
3901
                    level = (((level << 1) + 1) * qscale *
3902
                             ((int) (quant_matrix[j]))) >> 4;
3903
                }
3904
#ifdef PARANOID
3905
                if (level < -2048 || level > 2047)
3906
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3907
#endif
3908
                block[j] = level;
3909
                sum+=level;
3910
            }
3911
        }
3912
        block[63]^=sum&1;
3913
    }
3914
}
3915

    
3916

    
3917
static void dct_unquantize_h263_c(MpegEncContext *s, 
3918
                                  DCTELEM *block, int n, int qscale)
3919
{
3920
    int i, level, qmul, qadd;
3921
    int nCoeffs;
3922
    
3923
    assert(s->block_last_index[n]>=0);
3924
    
3925
    qadd = (qscale - 1) | 1;
3926
    qmul = qscale << 1;
3927
    
3928
    if (s->mb_intra) {
3929
        if (!s->h263_aic) {
3930
            if (n < 4) 
3931
                block[0] = block[0] * s->y_dc_scale;
3932
            else
3933
                block[0] = block[0] * s->c_dc_scale;
3934
        }else
3935
            qadd = 0;
3936
        i = 1;
3937
        nCoeffs= 63; //does not allways use zigzag table 
3938
    } else {
3939
        i = 0;
3940
        nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
3941
    }
3942

    
3943
    for(;i<=nCoeffs;i++) {
3944
        level = block[i];
3945
        if (level) {
3946
            if (level < 0) {
3947
                level = level * qmul - qadd;
3948
            } else {
3949
                level = level * qmul + qadd;
3950
            }
3951
#ifdef PARANOID
3952
                if (level < -2048 || level > 2047)
3953
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3954
#endif
3955
            block[i] = level;
3956
        }
3957
    }
3958
}
3959

    
3960

    
3961
char ff_get_pict_type_char(int pict_type){
3962
    switch(pict_type){
3963
    case I_TYPE: return 'I'; 
3964
    case P_TYPE: return 'P'; 
3965
    case B_TYPE: return 'B'; 
3966
    case S_TYPE: return 'S'; 
3967
    case SI_TYPE:return 'i'; 
3968
    case SP_TYPE:return 'p'; 
3969
    default:     return '?';
3970
    }
3971
}
3972

    
3973
static const AVOption mpeg4_options[] =
3974
{
3975
    AVOPTION_CODEC_INT("bitrate", "desired video bitrate", bit_rate, 4, 240000000, 800000),
3976
    AVOPTION_CODEC_FLAG("vhq", "very high quality", flags, CODEC_FLAG_HQ, 0),
3977
    AVOPTION_CODEC_INT("ratetol", "number of bits the bitstream is allowed to diverge from the reference"
3978
                       "the reference can be CBR (for CBR pass1) or VBR (for pass2)",
3979
                       bit_rate_tolerance, 4, 240000000, 8000),
3980
    AVOPTION_CODEC_INT("qmin", "minimum quantizer", qmin, 1, 31, 2),
3981
    AVOPTION_CODEC_INT("qmax", "maximum quantizer", qmax, 1, 31, 31),
3982
    AVOPTION_CODEC_STRING("rc_eq", "rate control equation",
3983
                          rc_eq, "tex^qComp,option1,options2", 0),
3984
    AVOPTION_CODEC_INT("rc_minrate", "rate control minimum bitrate",
3985
                       rc_min_rate, 4, 24000000, 0),
3986
    AVOPTION_CODEC_INT("rc_maxrate", "rate control maximum bitrate",
3987
                       rc_max_rate, 4, 24000000, 0),
3988
    AVOPTION_CODEC_DOUBLE("rc_buf_aggresivity", "rate control buffer aggresivity",
3989
                          rc_buffer_aggressivity, 4, 24000000, 0),
3990
    AVOPTION_CODEC_DOUBLE("rc_initial_cplx", "initial complexity for pass1 ratecontrol",
3991
                          rc_initial_cplx, 0., 9999999., 0),
3992
    AVOPTION_CODEC_DOUBLE("i_quant_factor", "qscale factor between p and i frames",
3993
                          i_quant_factor, 0., 0., 0),
3994
    AVOPTION_CODEC_DOUBLE("i_quant_offset", "qscale offset between p and i frames",
3995
                          i_quant_factor, -999999., 999999., 0),
3996
    AVOPTION_CODEC_INT("dct_algo", "dct alghorithm",
3997
                       dct_algo, 0, 5, 0), // fixme - "Auto,FastInt,Int,MMX,MLib,Altivec"
3998
    AVOPTION_CODEC_DOUBLE("lumi_masking", "luminance masking",
3999
                          lumi_masking, 0., 999999., 0),
4000
    AVOPTION_CODEC_DOUBLE("temporal_cplx_masking", "temporary complexity masking",
4001
                          temporal_cplx_masking, 0., 999999., 0),
4002
    AVOPTION_CODEC_DOUBLE("spatial_cplx_masking", "spatial complexity masking",
4003
                          spatial_cplx_masking, 0., 999999., 0),
4004
    AVOPTION_CODEC_DOUBLE("p_masking", "p block masking",
4005
                          p_masking, 0., 999999., 0),
4006
    AVOPTION_CODEC_DOUBLE("dark_masking", "darkness masking",
4007
                          dark_masking, 0., 999999., 0),
4008
    AVOPTION_CODEC_INT("idct_algo", "idct alghorithm",
4009
                       idct_algo, 0, 8, 0), // fixme - "Auto,Int,Simple,SimpleMMX,LibMPEG2MMX,PS2,MLib,ARM,Altivec"
4010

    
4011
    AVOPTION_CODEC_INT("mb_qmin", "minimum MB quantizer",
4012
                       mb_qmin, 0, 8, 0),
4013
    AVOPTION_CODEC_INT("mb_qmax", "maximum MB quantizer",
4014
                       mb_qmin, 0, 8, 0),
4015

    
4016
    AVOPTION_CODEC_INT("me_cmp", "ME compare function",
4017
                       me_cmp, 0, 24000000, 0),
4018
    AVOPTION_CODEC_INT("me_sub_cmp", "subpixel ME compare function",
4019
                       me_sub_cmp, 0, 24000000, 0),
4020

    
4021

    
4022
    AVOPTION_CODEC_INT("dia_size", "ME diamond size & shape",
4023
                       dia_size, 0, 24000000, 0),
4024
    AVOPTION_CODEC_INT("last_predictor_count", "amount of previous MV predictors",
4025
                       last_predictor_count, 0, 24000000, 0),
4026

    
4027
    AVOPTION_CODEC_INT("pre_me", "pre pass for ME",
4028
                       pre_me, 0, 24000000, 0),
4029
    AVOPTION_CODEC_INT("me_pre_cmp", "ME pre pass compare function",
4030
                       me_pre_cmp, 0, 24000000, 0),
4031

    
4032
    AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4033
                       me_range, 0, 24000000, 0),
4034
    AVOPTION_CODEC_INT("pre_dia_size", "ME pre pass diamod size & shape",
4035
                       pre_dia_size, 0, 24000000, 0),
4036
    AVOPTION_CODEC_INT("me_subpel_quality", "subpel ME quality",
4037
                       me_subpel_quality, 0, 24000000, 0),
4038
    AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4039
                       me_range, 0, 24000000, 0),
4040
    AVOPTION_CODEC_FLAG("psnr", "calculate PSNR of compressed frames",
4041
                        flags, CODEC_FLAG_PSNR, 0),
4042
    AVOPTION_CODEC_RCOVERRIDE("rc_override", "ratecontrol override (=startframe,endframe,qscale,quality_factor)",
4043
                              rc_override),
4044
    AVOPTION_SUB(avoptions_common),
4045
    AVOPTION_END()
4046
};
4047

    
4048
#ifdef CONFIG_ENCODERS
4049

    
4050
AVCodec mpeg1video_encoder = {
4051
    "mpeg1video",
4052
    CODEC_TYPE_VIDEO,
4053
    CODEC_ID_MPEG1VIDEO,
4054
    sizeof(MpegEncContext),
4055
    MPV_encode_init,
4056
    MPV_encode_picture,
4057
    MPV_encode_end,
4058
};
4059

    
4060
#ifdef CONFIG_RISKY
4061

    
4062
AVCodec h263_encoder = {
4063
    "h263",
4064
    CODEC_TYPE_VIDEO,
4065
    CODEC_ID_H263,
4066
    sizeof(MpegEncContext),
4067
    MPV_encode_init,
4068
    MPV_encode_picture,
4069
    MPV_encode_end,
4070
};
4071

    
4072
AVCodec h263p_encoder = {
4073
    "h263p",
4074
    CODEC_TYPE_VIDEO,
4075
    CODEC_ID_H263P,
4076
    sizeof(MpegEncContext),
4077
    MPV_encode_init,
4078
    MPV_encode_picture,
4079
    MPV_encode_end,
4080
};
4081

    
4082
AVCodec rv10_encoder = {
4083
    "rv10",
4084
    CODEC_TYPE_VIDEO,
4085
    CODEC_ID_RV10,
4086
    sizeof(MpegEncContext),
4087
    MPV_encode_init,
4088
    MPV_encode_picture,
4089
    MPV_encode_end,
4090
};
4091

    
4092
AVCodec mpeg4_encoder = {
4093
    "mpeg4",
4094
    CODEC_TYPE_VIDEO,
4095
    CODEC_ID_MPEG4,
4096
    sizeof(MpegEncContext),
4097
    MPV_encode_init,
4098
    MPV_encode_picture,
4099
    MPV_encode_end,
4100
    .options = mpeg4_options,
4101
};
4102

    
4103
AVCodec msmpeg4v1_encoder = {
4104
    "msmpeg4v1",
4105
    CODEC_TYPE_VIDEO,
4106
    CODEC_ID_MSMPEG4V1,
4107
    sizeof(MpegEncContext),
4108
    MPV_encode_init,
4109
    MPV_encode_picture,
4110
    MPV_encode_end,
4111
    .options = mpeg4_options,
4112
};
4113

    
4114
AVCodec msmpeg4v2_encoder = {
4115
    "msmpeg4v2",
4116
    CODEC_TYPE_VIDEO,
4117
    CODEC_ID_MSMPEG4V2,
4118
    sizeof(MpegEncContext),
4119
    MPV_encode_init,
4120
    MPV_encode_picture,
4121
    MPV_encode_end,
4122
    .options = mpeg4_options,
4123
};
4124

    
4125
AVCodec msmpeg4v3_encoder = {
4126
    "msmpeg4",
4127
    CODEC_TYPE_VIDEO,
4128
    CODEC_ID_MSMPEG4V3,
4129
    sizeof(MpegEncContext),
4130
    MPV_encode_init,
4131
    MPV_encode_picture,
4132
    MPV_encode_end,
4133
    .options = mpeg4_options,
4134
};
4135

    
4136
AVCodec wmv1_encoder = {
4137
    "wmv1",
4138
    CODEC_TYPE_VIDEO,
4139
    CODEC_ID_WMV1,
4140
    sizeof(MpegEncContext),
4141
    MPV_encode_init,
4142
    MPV_encode_picture,
4143
    MPV_encode_end,
4144
    .options = mpeg4_options,
4145
};
4146

    
4147
#endif
4148

    
4149
AVCodec mjpeg_encoder = {
4150
    "mjpeg",
4151
    CODEC_TYPE_VIDEO,
4152
    CODEC_ID_MJPEG,
4153
    sizeof(MpegEncContext),
4154
    MPV_encode_init,
4155
    MPV_encode_picture,
4156
    MPV_encode_end,
4157
};
4158

    
4159
#endif //CONFIG_ENCODERS
4160