Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 2c19981a

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

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

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

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

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

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

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

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

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

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

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

    
328
    s->mb_width  = (s->width  + 15) / 16;
329
    s->mb_height = (s->height + 15) / 16;
330

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

    
335
    s->mb_num = s->mb_width * s->mb_height;
336

    
337
    y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
338
    c_size = (s->mb_width + 2) * (s->mb_height + 2);
339
    yc_size = y_size + 2 * c_size;
340

    
341
    /* convert fourcc to upper case */
342
    s->avctx->codec_tag=   toupper( s->avctx->codec_tag     &0xFF)          
343
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
344
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16) 
345
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
346

    
347
    CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
348
    s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
349

    
350
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
351

    
352
    if (s->encoding) {
353
        int mv_table_size= (s->mb_width+2)*(s->mb_height+2);
354

    
355
        /* Allocate MV tables */
356
        CHECKED_ALLOCZ(s->p_mv_table            , mv_table_size * 2 * sizeof(int16_t))
357
        CHECKED_ALLOCZ(s->b_forw_mv_table       , mv_table_size * 2 * sizeof(int16_t))
358
        CHECKED_ALLOCZ(s->b_back_mv_table       , mv_table_size * 2 * sizeof(int16_t))
359
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table , mv_table_size * 2 * sizeof(int16_t))
360
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table , mv_table_size * 2 * sizeof(int16_t))
361
        CHECKED_ALLOCZ(s->b_direct_mv_table     , mv_table_size * 2 * sizeof(int16_t))
362

    
363
        //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
364
        CHECKED_ALLOCZ(s->me.scratchpad,  s->width*2*16*3*sizeof(uint8_t)) 
365
        
366
        CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
367
        CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
368

    
369
        if(s->codec_id==CODEC_ID_MPEG4){
370
            CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
371
            CHECKED_ALLOCZ(   s->pb2_buffer, PB_BUFFER_SIZE);
372
        }
373
        
374
        if(s->msmpeg4_version){
375
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
376
        }
377
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
378
    }
379
        
380
    CHECKED_ALLOCZ(s->error_status_table, s->mb_num*sizeof(uint8_t))
381
    
382
    if (s->out_format == FMT_H263 || s->encoding) {
383
        int size;
384
        /* Allocate MB type table */
385
        CHECKED_ALLOCZ(s->mb_type  , s->mb_num * sizeof(uint8_t))
386

    
387
        /* MV prediction */
388
        size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
389
        CHECKED_ALLOCZ(s->motion_val, size * 2 * sizeof(int16_t));
390
    }
391

    
392
    if(s->codec_id==CODEC_ID_MPEG4){
393
        /* interlaced direct mode decoding tables */
394
        CHECKED_ALLOCZ(s->field_mv_table, s->mb_num*2*2 * sizeof(int16_t))
395
        CHECKED_ALLOCZ(s->field_select_table, s->mb_num*2* sizeof(int8_t))
396
    }
397
    /* 4mv b frame decoding table */
398
    //note this is needed for h263 without b frames too (segfault on damaged streams otherwise)
399
    CHECKED_ALLOCZ(s->co_located_type_table, s->mb_num * sizeof(uint8_t))
400
    if (s->out_format == FMT_H263) {
401
        /* ac values */
402
        CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(int16_t) * 16);
403
        s->ac_val[1] = s->ac_val[0] + y_size;
404
        s->ac_val[2] = s->ac_val[1] + c_size;
405
        
406
        /* cbp values */
407
        CHECKED_ALLOCZ(s->coded_block, y_size);
408
        
409
        /* divx501 bitstream reorder buffer */
410
        CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
411

    
412
        /* cbp, ac_pred, pred_dir */
413
        CHECKED_ALLOCZ(s->cbp_table  , s->mb_num * sizeof(uint8_t))
414
        CHECKED_ALLOCZ(s->pred_dir_table, s->mb_num * sizeof(uint8_t))
415
    }
416
    
417
    if (s->h263_pred || s->h263_plus || !s->encoding) {
418
        /* dc values */
419
        //MN: we need these for error resilience of intra-frames
420
        CHECKED_ALLOCZ(s->dc_val[0], yc_size * sizeof(int16_t));
421
        s->dc_val[1] = s->dc_val[0] + y_size;
422
        s->dc_val[2] = s->dc_val[1] + c_size;
423
        for(i=0;i<yc_size;i++)
424
            s->dc_val[0][i] = 1024;
425
    }
426

    
427
    /* which mb is a intra block */
428
    CHECKED_ALLOCZ(s->mbintra_table, s->mb_num);
429
    memset(s->mbintra_table, 1, s->mb_num);
430
    
431
    /* default structure is frame */
432
    s->picture_structure = PICT_FRAME;
433
    
434
    /* init macroblock skip table */
435
    CHECKED_ALLOCZ(s->mbskip_table, s->mb_num+1);
436
    //Note the +1 is for a quicker mpeg4 slice_end detection
437
    CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
438
    
439
    s->block= s->blocks[0];
440

    
441
    s->parse_context.state= -1;
442

    
443
    s->context_initialized = 1;
444
    return 0;
445
 fail:
446
    MPV_common_end(s);
447
    return -1;
448
}
449

    
450

    
451
//extern int sads;
452

    
453
/* init common structure for both encoder and decoder */
454
void MPV_common_end(MpegEncContext *s)
455
{
456
    int i;
457

    
458
    av_freep(&s->mb_type);
459
    av_freep(&s->p_mv_table);
460
    av_freep(&s->b_forw_mv_table);
461
    av_freep(&s->b_back_mv_table);
462
    av_freep(&s->b_bidir_forw_mv_table);
463
    av_freep(&s->b_bidir_back_mv_table);
464
    av_freep(&s->b_direct_mv_table);
465
    av_freep(&s->motion_val);
466
    av_freep(&s->dc_val[0]);
467
    av_freep(&s->ac_val[0]);
468
    av_freep(&s->coded_block);
469
    av_freep(&s->mbintra_table);
470
    av_freep(&s->cbp_table);
471
    av_freep(&s->pred_dir_table);
472
    av_freep(&s->me.scratchpad);
473
    av_freep(&s->me.map);
474
    av_freep(&s->me.score_map);
475
    
476
    av_freep(&s->mbskip_table);
477
    av_freep(&s->prev_pict_types);
478
    av_freep(&s->bitstream_buffer);
479
    av_freep(&s->tex_pb_buffer);
480
    av_freep(&s->pb2_buffer);
481
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
482
    av_freep(&s->co_located_type_table);
483
    av_freep(&s->field_mv_table);
484
    av_freep(&s->field_select_table);
485
    av_freep(&s->avctx->stats_out);
486
    av_freep(&s->ac_stats);
487
    av_freep(&s->error_status_table);
488

    
489
    for(i=0; i<MAX_PICTURE_COUNT; i++){
490
        free_picture(s, &s->picture[i]);
491
    }
492
    s->context_initialized = 0;
493
}
494

    
495
#ifdef CONFIG_ENCODERS
496

    
497
/* init video encoder */
498
int MPV_encode_init(AVCodecContext *avctx)
499
{
500
    MpegEncContext *s = avctx->priv_data;
501
    int i;
502

    
503
    avctx->pix_fmt = PIX_FMT_YUV420P;
504

    
505
    s->bit_rate = avctx->bit_rate;
506
    s->bit_rate_tolerance = avctx->bit_rate_tolerance;
507
    s->width = avctx->width;
508
    s->height = avctx->height;
509
    if(avctx->gop_size > 600){
510
        fprintf(stderr, "Warning keyframe interval too large! reducing it ...\n");
511
        avctx->gop_size=600;
512
    }
513
    s->gop_size = avctx->gop_size;
514
    s->rtp_mode = avctx->rtp_mode;
515
    s->rtp_payload_size = avctx->rtp_payload_size;
516
    if (avctx->rtp_callback)
517
        s->rtp_callback = avctx->rtp_callback;
518
    s->max_qdiff= avctx->max_qdiff;
519
    s->qcompress= avctx->qcompress;
520
    s->qblur= avctx->qblur;
521
    s->avctx = avctx;
522
    s->flags= avctx->flags;
523
    s->max_b_frames= avctx->max_b_frames;
524
    s->b_frame_strategy= avctx->b_frame_strategy;
525
    s->codec_id= avctx->codec->id;
526
    s->luma_elim_threshold  = avctx->luma_elim_threshold;
527
    s->chroma_elim_threshold= avctx->chroma_elim_threshold;
528
    s->strict_std_compliance= avctx->strict_std_compliance;
529
    s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
530
    s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
531
    s->mpeg_quant= avctx->mpeg_quant;
532

    
533
    if (s->gop_size <= 1) {
534
        s->intra_only = 1;
535
        s->gop_size = 12;
536
    } else {
537
        s->intra_only = 0;
538
    }
539

    
540
    s->me_method = avctx->me_method;
541

    
542
    /* Fixed QSCALE */
543
    s->fixed_qscale = (avctx->flags & CODEC_FLAG_QSCALE);
544
    
545
    s->adaptive_quant= (   s->avctx->lumi_masking
546
                        || s->avctx->dark_masking
547
                        || s->avctx->temporal_cplx_masking 
548
                        || s->avctx->spatial_cplx_masking
549
                        || s->avctx->p_masking)
550
                       && !s->fixed_qscale;
551
    
552
    s->progressive_sequence= !(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
553

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

    
686
            default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
687
            memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
688
            memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
689

    
690
            for(i=-16; i<16; i++){
691
                default_fcode_tab[i + MAX_MV]= 1;
692
            }
693
        }
694
    }
695
    s->me.mv_penalty= default_mv_penalty;
696
    s->fcode_tab= default_fcode_tab;
697
    s->y_dc_scale_table=
698
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
699
 
700
    /* dont use mv_penalty table for crap MV as it would be confused */
701
    //FIXME remove after fixing / removing old ME
702
    if (s->me_method < ME_EPZS) s->me.mv_penalty = default_mv_penalty;
703

    
704
    s->encoding = 1;
705

    
706
    /* init */
707
    if (MPV_common_init(s) < 0)
708
        return -1;
709
    
710
    ff_init_me(s);
711

    
712
#ifdef CONFIG_ENCODERS
713
#ifdef CONFIG_RISKY
714
    if (s->out_format == FMT_H263)
715
        h263_encode_init(s);
716
    if(s->msmpeg4_version)
717
        ff_msmpeg4_encode_init(s);
718
#endif
719
    if (s->out_format == FMT_MPEG1)
720
        ff_mpeg1_encode_init(s);
721
#endif
722

    
723
    /* init default q matrix */
724
    for(i=0;i<64;i++) {
725
        int j= s->dsp.idct_permutation[i];
726
#ifdef CONFIG_RISKY
727
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
728
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
729
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
730
        }else if(s->out_format == FMT_H263){
731
            s->intra_matrix[j] =
732
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
733
        }else
734
#endif
735
        { /* mpeg1 */
736
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
737
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
738
        }
739
    }
740

    
741
    /* precompute matrix */
742
    /* for mjpeg, we do include qscale in the matrix */
743
    if (s->out_format != FMT_MJPEG) {
744
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, s->q_intra_matrix16_bias, 
745
                       s->intra_matrix, s->intra_quant_bias, 1, 31);
746
        convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16, s->q_inter_matrix16_bias, 
747
                       s->inter_matrix, s->inter_quant_bias, 1, 31);
748
    }
749

    
750
    if(ff_rate_control_init(s) < 0)
751
        return -1;
752

    
753
    s->picture_number = 0;
754
    s->picture_in_gop_number = 0;
755
    s->fake_picture_number = 0;
756
    /* motion detector init */
757
    s->f_code = 1;
758
    s->b_code = 1;
759

    
760
    return 0;
761
}
762

    
763
int MPV_encode_end(AVCodecContext *avctx)
764
{
765
    MpegEncContext *s = avctx->priv_data;
766

    
767
#ifdef STATS
768
    print_stats();
769
#endif
770

    
771
    ff_rate_control_uninit(s);
772

    
773
    MPV_common_end(s);
774
    if (s->out_format == FMT_MJPEG)
775
        mjpeg_close(s);
776
      
777
    return 0;
778
}
779

    
780
#endif //CONFIG_ENCODERS
781

    
782
void init_rl(RLTable *rl)
783
{
784
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
785
    uint8_t index_run[MAX_RUN+1];
786
    int last, run, level, start, end, i;
787

    
788
    /* compute max_level[], max_run[] and index_run[] */
789
    for(last=0;last<2;last++) {
790
        if (last == 0) {
791
            start = 0;
792
            end = rl->last;
793
        } else {
794
            start = rl->last;
795
            end = rl->n;
796
        }
797

    
798
        memset(max_level, 0, MAX_RUN + 1);
799
        memset(max_run, 0, MAX_LEVEL + 1);
800
        memset(index_run, rl->n, MAX_RUN + 1);
801
        for(i=start;i<end;i++) {
802
            run = rl->table_run[i];
803
            level = rl->table_level[i];
804
            if (index_run[run] == rl->n)
805
                index_run[run] = i;
806
            if (level > max_level[run])
807
                max_level[run] = level;
808
            if (run > max_run[level])
809
                max_run[level] = run;
810
        }
811
        rl->max_level[last] = av_malloc(MAX_RUN + 1);
812
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
813
        rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
814
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
815
        rl->index_run[last] = av_malloc(MAX_RUN + 1);
816
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
817
    }
818
}
819

    
820
/* draw the edges of width 'w' of an image of size width, height */
821
//FIXME check that this is ok for mpeg4 interlaced
822
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
823
{
824
    uint8_t *ptr, *last_line;
825
    int i;
826

    
827
    last_line = buf + (height - 1) * wrap;
828
    for(i=0;i<w;i++) {
829
        /* top and bottom */
830
        memcpy(buf - (i + 1) * wrap, buf, width);
831
        memcpy(last_line + (i + 1) * wrap, last_line, width);
832
    }
833
    /* left and right */
834
    ptr = buf;
835
    for(i=0;i<height;i++) {
836
        memset(ptr - w, ptr[0], w);
837
        memset(ptr + width, ptr[width-1], w);
838
        ptr += wrap;
839
    }
840
    /* corners */
841
    for(i=0;i<w;i++) {
842
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
843
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
844
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
845
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
846
    }
847
}
848

    
849
static int find_unused_picture(MpegEncContext *s, int shared){
850
    int i;
851
    
852
    if(shared){
853
        for(i=0; i<MAX_PICTURE_COUNT; i++){
854
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) break;
855
        }
856
    }else{
857
        for(i=0; i<MAX_PICTURE_COUNT; i++){
858
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) break;
859
        }
860
        for(i=0; i<MAX_PICTURE_COUNT; i++){
861
            if(s->picture[i].data[0]==NULL) break;
862
        }
863
    }
864

    
865
    assert(i<MAX_PICTURE_COUNT);
866
    return i;
867
}
868

    
869
/* generic function for encode/decode called before a frame is coded/decoded */
870
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
871
{
872
    int i;
873
    AVFrame *pic;
874

    
875
    s->mb_skiped = 0;
876
    
877
    /* mark&release old frames */
878
    if (s->pict_type != B_TYPE && s->last_picture_ptr) {
879
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
880

    
881
        /* release forgotten pictures */
882
        /* if(mpeg124/h263) */
883
        if(!s->encoding){
884
            for(i=0; i<MAX_PICTURE_COUNT; i++){
885
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
886
                    fprintf(stderr, "releasing zombie picture\n");
887
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
888
                }
889
            }
890
        }
891
    }
892
    
893
alloc:
894
    if(!s->encoding){
895
        i= find_unused_picture(s, 0);
896
    
897
        pic= (AVFrame*)&s->picture[i];
898
        pic->reference= s->pict_type != B_TYPE;
899

    
900
        if(s->current_picture_ptr)
901
            pic->coded_picture_number= s->current_picture_ptr->coded_picture_number+1;
902
        
903
        alloc_picture(s, (Picture*)pic, 0);
904

    
905
        s->current_picture_ptr= &s->picture[i];
906
    }
907

    
908
    if (s->pict_type != B_TYPE) {
909
        s->last_picture_ptr= s->next_picture_ptr;
910
        s->next_picture_ptr= s->current_picture_ptr;
911
    }
912
    s->current_picture= *s->current_picture_ptr;
913
    if(s->last_picture_ptr) s->last_picture= *s->last_picture_ptr;
914
    if(s->next_picture_ptr) s->next_picture= *s->next_picture_ptr;
915
    if(s->new_picture_ptr ) s->new_picture = *s->new_picture_ptr;
916
    
917
    if(s->picture_structure!=PICT_FRAME){
918
        int i;
919
        for(i=0; i<4; i++){
920
            if(s->picture_structure == PICT_BOTTOM_FIELD){
921
                 s->current_picture.data[i] += s->current_picture.linesize[i];
922
            } 
923
            s->current_picture.linesize[i] *= 2;
924
            s->last_picture.linesize[i] *=2;
925
            s->next_picture.linesize[i] *=2;
926
        }
927
    }
928
    
929
    if(s->pict_type != I_TYPE && s->last_picture_ptr==NULL){
930
        fprintf(stderr, "warning: first frame is no keyframe\n");
931
        assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
932
        goto alloc;
933
    }
934
   
935
    s->hurry_up= s->avctx->hurry_up;
936
    s->error_resilience= avctx->error_resilience;
937

    
938
    /* set dequantizer, we cant do it during init as it might change for mpeg4
939
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
940
    if(s->out_format == FMT_H263){
941
        if(s->mpeg_quant)
942
            s->dct_unquantize = s->dct_unquantize_mpeg2;
943
        else
944
            s->dct_unquantize = s->dct_unquantize_h263;
945
    }else 
946
        s->dct_unquantize = s->dct_unquantize_mpeg1;
947

    
948
    return 0;
949
}
950

    
951
/* generic function for encode/decode called after a frame has been coded/decoded */
952
void MPV_frame_end(MpegEncContext *s)
953
{
954
    int i;
955
    /* draw edge for correct motion prediction if outside */
956
    if(s->codec_id!=CODEC_ID_SVQ1){
957
        if (s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
958
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
959
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
960
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
961
        }
962
    }
963
    emms_c();
964
    
965
    s->last_pict_type    = s->pict_type;
966
    if(s->pict_type!=B_TYPE){
967
        s->last_non_b_pict_type= s->pict_type;
968
    }
969
#if 0
970
        /* copy back current_picture variables */
971
    for(i=0; i<MAX_PICTURE_COUNT; i++){
972
        if(s->picture[i].data[0] == s->current_picture.data[0]){
973
            s->picture[i]= s->current_picture;
974
            break;
975
        }    
976
    }
977
    assert(i<MAX_PICTURE_COUNT);
978
#endif    
979
    s->current_picture_ptr->quality= s->qscale; //FIXME get average of qscale_table
980
    s->current_picture_ptr->pict_type= s->pict_type;
981
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
982

    
983
    /* release non refernce frames */
984
    for(i=0; i<MAX_PICTURE_COUNT; i++){
985
        if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/)
986
            s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
987
    }
988
    if(s->avctx->debug&FF_DEBUG_SKIP){
989
        int x,y;        
990
        for(y=0; y<s->mb_height; y++){
991
            for(x=0; x<s->mb_width; x++){
992
                int count= s->mbskip_table[x + y*s->mb_width];
993
                if(count>9) count=9;
994
                printf(" %1d", count);
995
            }
996
            printf("\n");
997
        }
998
        printf("pict type: %d\n", s->pict_type);
999
    }
1000

    
1001
    // clear copies, to avoid confusion
1002
#if 0
1003
    memset(&s->last_picture, 0, sizeof(Picture));
1004
    memset(&s->next_picture, 0, sizeof(Picture));
1005
    memset(&s->current_picture, 0, sizeof(Picture));
1006
#endif
1007
}
1008

    
1009
#ifdef CONFIG_ENCODERS
1010

    
1011
static int get_sae(uint8_t *src, int ref, int stride){
1012
    int x,y;
1013
    int acc=0;
1014
    
1015
    for(y=0; y<16; y++){
1016
        for(x=0; x<16; x++){
1017
            acc+= ABS(src[x+y*stride] - ref);
1018
        }
1019
    }
1020
    
1021
    return acc;
1022
}
1023

    
1024
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1025
    int x, y, w, h;
1026
    int acc=0;
1027
    
1028
    w= s->width &~15;
1029
    h= s->height&~15;
1030
    
1031
    for(y=0; y<h; y+=16){
1032
        for(x=0; x<w; x+=16){
1033
            int offset= x + y*stride;
1034
            int sad = s->dsp.pix_abs16x16(src + offset, ref + offset, stride);
1035
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1036
            int sae = get_sae(src + offset, mean, stride);
1037
            
1038
            acc+= sae + 500 < sad;
1039
        }
1040
    }
1041
    return acc;
1042
}
1043

    
1044

    
1045
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1046
    AVFrame *pic;
1047
    int i;
1048
    const int encoding_delay= s->max_b_frames;
1049
    int direct=1;
1050

    
1051
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1052
    if(pic_arg->linesize[0] != s->linesize) direct=0;
1053
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1054
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1055
  
1056
//    printf("%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1057
    
1058
    if(direct){
1059
        i= find_unused_picture(s, 1);
1060

    
1061
        pic= (AVFrame*)&s->picture[i];
1062
        pic->reference= 1;
1063
    
1064
        for(i=0; i<4; i++){
1065
            pic->data[i]= pic_arg->data[i];
1066
            pic->linesize[i]= pic_arg->linesize[i];
1067
        }
1068
        alloc_picture(s, (Picture*)pic, 1);
1069
    }else{
1070
        i= find_unused_picture(s, 0);
1071

    
1072
        pic= (AVFrame*)&s->picture[i];
1073
        pic->reference= 1;
1074

    
1075
        alloc_picture(s, (Picture*)pic, 0);
1076
        for(i=0; i<4; i++){
1077
            /* the input will be 16 pixels to the right relative to the actual buffer start
1078
             * and the current_pic, so the buffer can be reused, yes its not beatifull 
1079
             */
1080
            pic->data[i]+= 16; 
1081
        }
1082

    
1083
        if(   pic->data[0] == pic_arg->data[0] 
1084
           && pic->data[1] == pic_arg->data[1]
1085
           && pic->data[2] == pic_arg->data[2]){
1086
       // empty
1087
        }else{
1088
            int h_chroma_shift, v_chroma_shift;
1089
        
1090
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1091
        
1092
            for(i=0; i<3; i++){
1093
                int src_stride= pic_arg->linesize[i];
1094
                int dst_stride= i ? s->uvlinesize : s->linesize;
1095
                int h_shift= i ? h_chroma_shift : 0;
1096
                int v_shift= i ? v_chroma_shift : 0;
1097
                int w= s->width >>h_shift;
1098
                int h= s->height>>v_shift;
1099
                uint8_t *src= pic_arg->data[i];
1100
                uint8_t *dst= pic->data[i];
1101
            
1102
                if(src_stride==dst_stride)
1103
                    memcpy(dst, src, src_stride*h);
1104
                else{
1105
                    while(h--){
1106
                        memcpy(dst, src, w);
1107
                        dst += dst_stride;
1108
                        src += src_stride;
1109
                    }
1110
                }
1111
            }
1112
        }
1113
    }
1114
    pic->quality= pic_arg->quality;
1115
    pic->pict_type= pic_arg->pict_type;
1116
    pic->pts = pic_arg->pts;
1117
    
1118
    if(s->input_picture[encoding_delay])
1119
        pic->display_picture_number= s->input_picture[encoding_delay]->display_picture_number + 1;
1120

    
1121
    /* shift buffer entries */
1122
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1123
        s->input_picture[i-1]= s->input_picture[i];
1124
        
1125
    s->input_picture[encoding_delay]= (Picture*)pic;
1126

    
1127
    return 0;
1128
}
1129

    
1130
static void select_input_picture(MpegEncContext *s){
1131
    int i;
1132
    const int encoding_delay= s->max_b_frames;
1133
    int coded_pic_num=0;    
1134

    
1135
    if(s->reordered_input_picture[0])
1136
        coded_pic_num= s->reordered_input_picture[0]->coded_picture_number + 1;
1137

    
1138
    for(i=1; i<MAX_PICTURE_COUNT; i++)
1139
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1140
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1141

    
1142
    /* set next picture types & ordering */
1143
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1144
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
1145
            s->reordered_input_picture[0]= s->input_picture[0];
1146
            s->reordered_input_picture[0]->pict_type= I_TYPE;
1147
            s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1148
        }else{
1149
            int b_frames;
1150
            
1151
            if(s->flags&CODEC_FLAG_PASS2){
1152
                for(i=0; i<s->max_b_frames+1; i++){
1153
                    int pict_num= s->input_picture[0]->display_picture_number + i;
1154
                    int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1155
                    s->input_picture[i]->pict_type= pict_type;
1156
                    
1157
                    if(i + 1 >= s->rc_context.num_entries) break;
1158
                }
1159
            }
1160

    
1161
            if(s->input_picture[0]->pict_type){
1162
                /* user selected pict_type */
1163
                for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
1164
                    if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
1165
                }
1166
            
1167
                if(b_frames > s->max_b_frames){
1168
                    fprintf(stderr, "warning, too many bframes in a row\n");
1169
                    b_frames = s->max_b_frames;
1170
                }
1171
            }else if(s->b_frame_strategy==0){
1172
                b_frames= s->max_b_frames;
1173
            }else if(s->b_frame_strategy==1){
1174
                for(i=1; i<s->max_b_frames+1; i++){
1175
                    if(s->input_picture[i]->b_frame_score==0){
1176
                        s->input_picture[i]->b_frame_score= 
1177
                            get_intra_count(s, s->input_picture[i  ]->data[0], 
1178
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
1179
                    }
1180
                }
1181
                for(i=0; i<s->max_b_frames; i++){
1182
                    if(s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
1183
                }
1184
                                
1185
                b_frames= FFMAX(0, i-1);
1186
                
1187
                /* reset scores */
1188
                for(i=0; i<b_frames+1; i++){
1189
                    s->input_picture[i]->b_frame_score=0;
1190
                }
1191
            }else{
1192
                fprintf(stderr, "illegal b frame strategy\n");
1193
                b_frames=0;
1194
            }
1195

    
1196
            emms_c();
1197
//static int b_count=0;
1198
//b_count+= b_frames;
1199
//printf("b_frames: %d\n", b_count);
1200
                        
1201
            s->reordered_input_picture[0]= s->input_picture[b_frames];
1202
            if(   s->picture_in_gop_number + b_frames >= s->gop_size 
1203
               || s->reordered_input_picture[0]->pict_type== I_TYPE)
1204
                s->reordered_input_picture[0]->pict_type= I_TYPE;
1205
            else
1206
                s->reordered_input_picture[0]->pict_type= P_TYPE;
1207
            s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1208
            for(i=0; i<b_frames; i++){
1209
                coded_pic_num++;
1210
                s->reordered_input_picture[i+1]= s->input_picture[i];
1211
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
1212
                s->reordered_input_picture[i+1]->coded_picture_number= coded_pic_num;
1213
            }
1214
        }
1215
    }
1216
    
1217
    if(s->reordered_input_picture[0]){
1218
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE;
1219

    
1220
        s->new_picture= *s->reordered_input_picture[0];
1221

    
1222
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
1223
            // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
1224
        
1225
            int i= find_unused_picture(s, 0);
1226
            Picture *pic= &s->picture[i];
1227

    
1228
            /* mark us unused / free shared pic */
1229
            for(i=0; i<4; i++)
1230
                s->reordered_input_picture[0]->data[i]= NULL;
1231
            s->reordered_input_picture[0]->type= 0;
1232
            
1233
            //FIXME bad, copy * except
1234
            pic->pict_type = s->reordered_input_picture[0]->pict_type;
1235
            pic->quality   = s->reordered_input_picture[0]->quality;
1236
            pic->coded_picture_number = s->reordered_input_picture[0]->coded_picture_number;
1237
            pic->reference = s->reordered_input_picture[0]->reference;
1238
            
1239
            alloc_picture(s, pic, 0);
1240

    
1241
            s->current_picture_ptr= pic;
1242
        }else{
1243
            // input is not a shared pix -> reuse buffer for current_pix
1244

    
1245
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
1246
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
1247
            
1248
            s->current_picture_ptr= s->reordered_input_picture[0];
1249
            for(i=0; i<4; i++){
1250
                //reverse the +16 we did before storing the input
1251
                s->current_picture_ptr->data[i]-=16;
1252
            }
1253
        }
1254
        s->current_picture= *s->current_picture_ptr;
1255
    
1256
        s->picture_number= s->new_picture.display_picture_number;
1257
//printf("dpn:%d\n", s->picture_number);
1258
    }else{
1259
       memset(&s->new_picture, 0, sizeof(Picture));
1260
    }
1261
}
1262

    
1263
int MPV_encode_picture(AVCodecContext *avctx,
1264
                       unsigned char *buf, int buf_size, void *data)
1265
{
1266
    MpegEncContext *s = avctx->priv_data;
1267
    AVFrame *pic_arg = data;
1268
    int i;
1269

    
1270
    init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
1271

    
1272
    s->picture_in_gop_number++;
1273

    
1274
    load_input_picture(s, pic_arg);
1275
    
1276
    select_input_picture(s);
1277
    
1278
    /* output? */
1279
    if(s->new_picture.data[0]){
1280

    
1281
        s->pict_type= s->new_picture.pict_type;
1282
        if (s->fixed_qscale){ /* the ratecontrol needs the last qscale so we dont touch it for CBR */
1283
            s->qscale= (int)(s->new_picture.quality+0.5);
1284
            assert(s->qscale);
1285
        }
1286
//emms_c();
1287
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
1288
        MPV_frame_start(s, avctx);
1289

    
1290
        encode_picture(s, s->picture_number);
1291
        
1292
        avctx->real_pict_num  = s->picture_number;
1293
        avctx->header_bits = s->header_bits;
1294
        avctx->mv_bits     = s->mv_bits;
1295
        avctx->misc_bits   = s->misc_bits;
1296
        avctx->i_tex_bits  = s->i_tex_bits;
1297
        avctx->p_tex_bits  = s->p_tex_bits;
1298
        avctx->i_count     = s->i_count;
1299
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
1300
        avctx->skip_count  = s->skip_count;
1301

    
1302
        MPV_frame_end(s);
1303

    
1304
        if (s->out_format == FMT_MJPEG)
1305
            mjpeg_picture_trailer(s);
1306
        
1307
        if(s->flags&CODEC_FLAG_PASS1)
1308
            ff_write_pass1_stats(s);
1309

    
1310
        for(i=0; i<4; i++){
1311
            avctx->error[i] += s->current_picture_ptr->error[i];
1312
        }
1313
    }
1314

    
1315
    s->input_picture_number++;
1316

    
1317
    flush_put_bits(&s->pb);
1318
    s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1319
    
1320
    s->total_bits += s->frame_bits;
1321
    avctx->frame_bits  = s->frame_bits;
1322
    
1323
    return pbBufPtr(&s->pb) - s->pb.buf;
1324
}
1325

    
1326
#endif //CONFIG_ENCODERS
1327

    
1328
static inline void gmc1_motion(MpegEncContext *s,
1329
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1330
                               int dest_offset,
1331
                               uint8_t **ref_picture, int src_offset)
1332
{
1333
    uint8_t *ptr;
1334
    int offset, src_x, src_y, linesize, uvlinesize;
1335
    int motion_x, motion_y;
1336
    int emu=0;
1337

    
1338
    motion_x= s->sprite_offset[0][0];
1339
    motion_y= s->sprite_offset[0][1];
1340
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1341
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1342
    motion_x<<=(3-s->sprite_warping_accuracy);
1343
    motion_y<<=(3-s->sprite_warping_accuracy);
1344
    src_x = clip(src_x, -16, s->width);
1345
    if (src_x == s->width)
1346
        motion_x =0;
1347
    src_y = clip(src_y, -16, s->height);
1348
    if (src_y == s->height)
1349
        motion_y =0;
1350

    
1351
    linesize = s->linesize;
1352
    uvlinesize = s->uvlinesize;
1353
    
1354
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1355

    
1356
    dest_y+=dest_offset;
1357
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1358
        if(src_x<0 || src_y<0 || src_x + 17 >= s->h_edge_pos
1359
                              || src_y + 17 >= s->v_edge_pos){
1360
            ff_emulated_edge_mc(s, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1361
            ptr= s->edge_emu_buffer;
1362
        }
1363
    }
1364
    
1365
    if((motion_x|motion_y)&7){
1366
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1367
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1368
    }else{
1369
        int dxy;
1370
        
1371
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
1372
        if (s->no_rounding){
1373
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
1374
        }else{
1375
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
1376
        }
1377
    }
1378
    
1379
    if(s->flags&CODEC_FLAG_GRAY) return;
1380

    
1381
    motion_x= s->sprite_offset[1][0];
1382
    motion_y= s->sprite_offset[1][1];
1383
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
1384
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
1385
    motion_x<<=(3-s->sprite_warping_accuracy);
1386
    motion_y<<=(3-s->sprite_warping_accuracy);
1387
    src_x = clip(src_x, -8, s->width>>1);
1388
    if (src_x == s->width>>1)
1389
        motion_x =0;
1390
    src_y = clip(src_y, -8, s->height>>1);
1391
    if (src_y == s->height>>1)
1392
        motion_y =0;
1393

    
1394
    offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
1395
    ptr = ref_picture[1] + offset;
1396
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1397
        if(src_x<0 || src_y<0 || src_x + 9 >= s->h_edge_pos>>1
1398
                              || src_y + 9 >= s->v_edge_pos>>1){
1399
            ff_emulated_edge_mc(s, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1400
            ptr= s->edge_emu_buffer;
1401
            emu=1;
1402
        }
1403
    }
1404
    s->dsp.gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1405
    
1406
    ptr = ref_picture[2] + offset;
1407
    if(emu){
1408
        ff_emulated_edge_mc(s, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1409
        ptr= s->edge_emu_buffer;
1410
    }
1411
    s->dsp.gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1412
    
1413
    return;
1414
}
1415

    
1416
static inline void gmc_motion(MpegEncContext *s,
1417
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1418
                               int dest_offset,
1419
                               uint8_t **ref_picture, int src_offset)
1420
{
1421
    uint8_t *ptr;
1422
    int linesize, uvlinesize;
1423
    const int a= s->sprite_warping_accuracy;
1424
    int ox, oy;
1425

    
1426
    linesize = s->linesize;
1427
    uvlinesize = s->uvlinesize;
1428

    
1429
    ptr = ref_picture[0] + src_offset;
1430

    
1431
    dest_y+=dest_offset;
1432
    
1433
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
1434
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
1435

    
1436
    s->dsp.gmc(dest_y, ptr, linesize, 16,
1437
           ox, 
1438
           oy, 
1439
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1440
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1441
           a+1, (1<<(2*a+1)) - s->no_rounding,
1442
           s->h_edge_pos, s->v_edge_pos);
1443
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
1444
           ox + s->sprite_delta[0][0]*8, 
1445
           oy + s->sprite_delta[1][0]*8, 
1446
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1447
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1448
           a+1, (1<<(2*a+1)) - s->no_rounding,
1449
           s->h_edge_pos, s->v_edge_pos);
1450

    
1451
    if(s->flags&CODEC_FLAG_GRAY) return;
1452

    
1453

    
1454
    dest_cb+=dest_offset>>1;
1455
    dest_cr+=dest_offset>>1;
1456
    
1457
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
1458
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
1459

    
1460
    ptr = ref_picture[1] + (src_offset>>1);
1461
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
1462
           ox, 
1463
           oy, 
1464
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1465
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1466
           a+1, (1<<(2*a+1)) - s->no_rounding,
1467
           s->h_edge_pos>>1, s->v_edge_pos>>1);
1468
    
1469
    ptr = ref_picture[2] + (src_offset>>1);
1470
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
1471
           ox, 
1472
           oy, 
1473
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1474
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1475
           a+1, (1<<(2*a+1)) - s->no_rounding,
1476
           s->h_edge_pos>>1, s->v_edge_pos>>1);
1477
}
1478

    
1479

    
1480
void ff_emulated_edge_mc(MpegEncContext *s, uint8_t *src, int linesize, int block_w, int block_h, 
1481
                                    int src_x, int src_y, int w, int h){
1482
    int x, y;
1483
    int start_y, start_x, end_y, end_x;
1484
    uint8_t *buf= s->edge_emu_buffer;
1485

    
1486
    if(src_y>= h){
1487
        src+= (h-1-src_y)*linesize;
1488
        src_y=h-1;
1489
    }else if(src_y<=-block_h){
1490
        src+= (1-block_h-src_y)*linesize;
1491
        src_y=1-block_h;
1492
    }
1493
    if(src_x>= w){
1494
        src+= (w-1-src_x);
1495
        src_x=w-1;
1496
    }else if(src_x<=-block_w){
1497
        src+= (1-block_w-src_x);
1498
        src_x=1-block_w;
1499
    }
1500

    
1501
    start_y= FFMAX(0, -src_y);
1502
    start_x= FFMAX(0, -src_x);
1503
    end_y= FFMIN(block_h, h-src_y);
1504
    end_x= FFMIN(block_w, w-src_x);
1505

    
1506
    // copy existing part
1507
    for(y=start_y; y<end_y; y++){
1508
        for(x=start_x; x<end_x; x++){
1509
            buf[x + y*linesize]= src[x + y*linesize];
1510
        }
1511
    }
1512

    
1513
    //top
1514
    for(y=0; y<start_y; y++){
1515
        for(x=start_x; x<end_x; x++){
1516
            buf[x + y*linesize]= buf[x + start_y*linesize];
1517
        }
1518
    }
1519

    
1520
    //bottom
1521
    for(y=end_y; y<block_h; y++){
1522
        for(x=start_x; x<end_x; x++){
1523
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1524
        }
1525
    }
1526
                                    
1527
    for(y=0; y<block_h; y++){
1528
       //left
1529
        for(x=0; x<start_x; x++){
1530
            buf[x + y*linesize]= buf[start_x + y*linesize];
1531
        }
1532
       
1533
       //right
1534
        for(x=end_x; x<block_w; x++){
1535
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1536
        }
1537
    }
1538
}
1539

    
1540

    
1541
/* apply one mpeg motion vector to the three components */
1542
static inline void mpeg_motion(MpegEncContext *s,
1543
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1544
                               int dest_offset,
1545
                               uint8_t **ref_picture, int src_offset,
1546
                               int field_based, op_pixels_func (*pix_op)[4],
1547
                               int motion_x, int motion_y, int h)
1548
{
1549
    uint8_t *ptr;
1550
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1551
    int emu=0;
1552
#if 0    
1553
if(s->quarter_sample)
1554
{
1555
    motion_x>>=1;
1556
    motion_y>>=1;
1557
}
1558
#endif
1559
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1560
    src_x = s->mb_x * 16 + (motion_x >> 1);
1561
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 1);
1562
                
1563
    /* WARNING: do no forget half pels */
1564
    height = s->height >> field_based;
1565
    v_edge_pos = s->v_edge_pos >> field_based;
1566
    src_x = clip(src_x, -16, s->width);
1567
    if (src_x == s->width)
1568
        dxy &= ~1;
1569
    src_y = clip(src_y, -16, height);
1570
    if (src_y == height)
1571
        dxy &= ~2;
1572
    linesize   = s->current_picture.linesize[0] << field_based;
1573
    uvlinesize = s->current_picture.linesize[1] << field_based;
1574
    ptr = ref_picture[0] + (src_y * linesize) + (src_x) + src_offset;
1575
    dest_y += dest_offset;
1576

    
1577
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1578
        if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 16 > s->h_edge_pos
1579
                              || src_y + (motion_y&1) + h  > v_edge_pos){
1580
            ff_emulated_edge_mc(s, ptr - src_offset, s->linesize, 17, 17+field_based,  //FIXME linesize? and uv below
1581
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1582
            ptr= s->edge_emu_buffer + src_offset;
1583
            emu=1;
1584
        }
1585
    }
1586
    pix_op[0][dxy](dest_y, ptr, linesize, h);
1587

    
1588
    if(s->flags&CODEC_FLAG_GRAY) return;
1589

    
1590
    if (s->out_format == FMT_H263) {
1591
        dxy = 0;
1592
        if ((motion_x & 3) != 0)
1593
            dxy |= 1;
1594
        if ((motion_y & 3) != 0)
1595
            dxy |= 2;
1596
        mx = motion_x >> 2;
1597
        my = motion_y >> 2;
1598
    } else {
1599
        mx = motion_x / 2;
1600
        my = motion_y / 2;
1601
        dxy = ((my & 1) << 1) | (mx & 1);
1602
        mx >>= 1;
1603
        my >>= 1;
1604
    }
1605
    
1606
    src_x = s->mb_x * 8 + mx;
1607
    src_y = s->mb_y * (8 >> field_based) + my;
1608
    src_x = clip(src_x, -8, s->width >> 1);
1609
    if (src_x == (s->width >> 1))
1610
        dxy &= ~1;
1611
    src_y = clip(src_y, -8, height >> 1);
1612
    if (src_y == (height >> 1))
1613
        dxy &= ~2;
1614
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1615
    ptr = ref_picture[1] + offset;
1616
    if(emu){
1617
        ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
1618
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1619
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1620
    }
1621
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1622

    
1623
    ptr = ref_picture[2] + offset;
1624
    if(emu){
1625
        ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
1626
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1627
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1628
    }
1629
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1630
}
1631

    
1632
static inline void qpel_motion(MpegEncContext *s,
1633
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1634
                               int dest_offset,
1635
                               uint8_t **ref_picture, int src_offset,
1636
                               int field_based, op_pixels_func (*pix_op)[4],
1637
                               qpel_mc_func (*qpix_op)[16],
1638
                               int motion_x, int motion_y, int h)
1639
{
1640
    uint8_t *ptr;
1641
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1642
    int emu=0;
1643

    
1644
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1645
    src_x = s->mb_x * 16 + (motion_x >> 2);
1646
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
1647

    
1648
    height = s->height >> field_based;
1649
    v_edge_pos = s->v_edge_pos >> field_based;
1650
    src_x = clip(src_x, -16, s->width);
1651
    if (src_x == s->width)
1652
        dxy &= ~3;
1653
    src_y = clip(src_y, -16, height);
1654
    if (src_y == height)
1655
        dxy &= ~12;
1656
    linesize = s->linesize << field_based;
1657
    uvlinesize = s->uvlinesize << field_based;
1658
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1659
    dest_y += dest_offset;
1660
//printf("%d %d %d\n", src_x, src_y, dxy);
1661
    
1662
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1663
        if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 16 > s->h_edge_pos
1664
                              || src_y + (motion_y&3) + h  > v_edge_pos){
1665
            ff_emulated_edge_mc(s, ptr - src_offset, s->linesize, 17, 17+field_based, 
1666
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1667
            ptr= s->edge_emu_buffer + src_offset;
1668
            emu=1;
1669
        }
1670
    }
1671
    if(!field_based)
1672
        qpix_op[0][dxy](dest_y, ptr, linesize);
1673
    else{
1674
        //damn interlaced mode
1675
        //FIXME boundary mirroring is not exactly correct here
1676
        qpix_op[1][dxy](dest_y  , ptr  , linesize);
1677
        qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
1678
    }
1679

    
1680
    if(s->flags&CODEC_FLAG_GRAY) return;
1681

    
1682
    if(field_based){
1683
        mx= motion_x/2;
1684
        my= motion_y>>1;
1685
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
1686
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
1687
        mx= (motion_x>>1) + rtab[motion_x&7];
1688
        my= (motion_y>>1) + rtab[motion_y&7];
1689
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
1690
        mx= (motion_x>>1)|(motion_x&1);
1691
        my= (motion_y>>1)|(motion_y&1);
1692
    }else{
1693
        mx= motion_x/2;
1694
        my= motion_y/2;
1695
    }
1696
    mx= (mx>>1)|(mx&1);
1697
    my= (my>>1)|(my&1);
1698

    
1699
    dxy= (mx&1) | ((my&1)<<1);
1700
    mx>>=1;
1701
    my>>=1;
1702

    
1703
    src_x = s->mb_x * 8 + mx;
1704
    src_y = s->mb_y * (8 >> field_based) + my;
1705
    src_x = clip(src_x, -8, s->width >> 1);
1706
    if (src_x == (s->width >> 1))
1707
        dxy &= ~1;
1708
    src_y = clip(src_y, -8, height >> 1);
1709
    if (src_y == (height >> 1))
1710
        dxy &= ~2;
1711

    
1712
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1713
    ptr = ref_picture[1] + offset;
1714
    if(emu){
1715
        ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
1716
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1717
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1718
    }
1719
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1720
    
1721
    ptr = ref_picture[2] + offset;
1722
    if(emu){
1723
        ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
1724
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1725
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1726
    }
1727
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1728
}
1729

    
1730
inline int ff_h263_round_chroma(int x){
1731
    if (x >= 0)
1732
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
1733
    else {
1734
        x = -x;
1735
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
1736
    }
1737
}
1738

    
1739
static inline void MPV_motion(MpegEncContext *s, 
1740
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1741
                              int dir, uint8_t **ref_picture, 
1742
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
1743
{
1744
    int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
1745
    int mb_x, mb_y, i;
1746
    uint8_t *ptr, *dest;
1747
    int emu=0;
1748

    
1749
    mb_x = s->mb_x;
1750
    mb_y = s->mb_y;
1751

    
1752
    switch(s->mv_type) {
1753
    case MV_TYPE_16X16:
1754
#ifdef CONFIG_RISKY
1755
        if(s->mcsel){
1756
            if(s->real_sprite_warping_points==1){
1757
                gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
1758
                            ref_picture, 0);
1759
            }else{
1760
                gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
1761
                            ref_picture, 0);
1762
            }
1763
        }else if(s->quarter_sample){
1764
            qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1765
                        ref_picture, 0,
1766
                        0, pix_op, qpix_op,
1767
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1768
        }else if(s->mspel){
1769
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
1770
                        ref_picture, pix_op,
1771
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1772
        }else
1773
#endif
1774
        {
1775
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1776
                        ref_picture, 0,
1777
                        0, pix_op,
1778
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1779
        }           
1780
        break;
1781
    case MV_TYPE_8X8:
1782
        mx = 0;
1783
        my = 0;
1784
        if(s->quarter_sample){
1785
            for(i=0;i<4;i++) {
1786
                motion_x = s->mv[dir][i][0];
1787
                motion_y = s->mv[dir][i][1];
1788

    
1789
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1790
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
1791
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
1792
                    
1793
                /* WARNING: do no forget half pels */
1794
                src_x = clip(src_x, -16, s->width);
1795
                if (src_x == s->width)
1796
                    dxy &= ~3;
1797
                src_y = clip(src_y, -16, s->height);
1798
                if (src_y == s->height)
1799
                    dxy &= ~12;
1800
                    
1801
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1802
                if(s->flags&CODEC_FLAG_EMU_EDGE){
1803
                    if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 8 > s->h_edge_pos
1804
                                          || src_y + (motion_y&3) + 8 > s->v_edge_pos){
1805
                        ff_emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1806
                        ptr= s->edge_emu_buffer;
1807
                    }
1808
                }
1809
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1810
                qpix_op[1][dxy](dest, ptr, s->linesize);
1811

    
1812
                mx += s->mv[dir][i][0]/2;
1813
                my += s->mv[dir][i][1]/2;
1814
            }
1815
        }else{
1816
            for(i=0;i<4;i++) {
1817
                motion_x = s->mv[dir][i][0];
1818
                motion_y = s->mv[dir][i][1];
1819

    
1820
                dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1821
                src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;
1822
                src_y = mb_y * 16 + (motion_y >> 1) + (i >>1) * 8;
1823
                    
1824
                /* WARNING: do no forget half pels */
1825
                src_x = clip(src_x, -16, s->width);
1826
                if (src_x == s->width)
1827
                    dxy &= ~1;
1828
                src_y = clip(src_y, -16, s->height);
1829
                if (src_y == s->height)
1830
                    dxy &= ~2;
1831
                    
1832
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1833
                if(s->flags&CODEC_FLAG_EMU_EDGE){
1834
                    if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 8 > s->h_edge_pos
1835
                                          || src_y + (motion_y&1) + 8 > s->v_edge_pos){
1836
                        ff_emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1837
                        ptr= s->edge_emu_buffer;
1838
                    }
1839
                }
1840
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1841
                pix_op[1][dxy](dest, ptr, s->linesize, 8);
1842

    
1843
                mx += s->mv[dir][i][0];
1844
                my += s->mv[dir][i][1];
1845
            }
1846
        }
1847

    
1848
        if(s->flags&CODEC_FLAG_GRAY) break;
1849
        /* In case of 8X8, we construct a single chroma motion vector
1850
           with a special rounding */
1851
        mx= ff_h263_round_chroma(mx);
1852
        my= ff_h263_round_chroma(my);
1853
        dxy = ((my & 1) << 1) | (mx & 1);
1854
        mx >>= 1;
1855
        my >>= 1;
1856

    
1857
        src_x = mb_x * 8 + mx;
1858
        src_y = mb_y * 8 + my;
1859
        src_x = clip(src_x, -8, s->width/2);
1860
        if (src_x == s->width/2)
1861
            dxy &= ~1;
1862
        src_y = clip(src_y, -8, s->height/2);
1863
        if (src_y == s->height/2)
1864
            dxy &= ~2;
1865
        
1866
        offset = (src_y * (s->uvlinesize)) + src_x;
1867
        ptr = ref_picture[1] + offset;
1868
        if(s->flags&CODEC_FLAG_EMU_EDGE){
1869
                if(src_x<0 || src_y<0 || src_x + (dxy &1) + 8 > s->h_edge_pos>>1
1870
                                      || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
1871
                    ff_emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1872
                    ptr= s->edge_emu_buffer;
1873
                    emu=1;
1874
                }
1875
            }
1876
        pix_op[1][dxy](dest_cb, ptr, s->uvlinesize, 8);
1877

    
1878
        ptr = ref_picture[2] + offset;
1879
        if(emu){
1880
            ff_emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1881
            ptr= s->edge_emu_buffer;
1882
        }
1883
        pix_op[1][dxy](dest_cr, ptr, s->uvlinesize, 8);
1884
        break;
1885
    case MV_TYPE_FIELD:
1886
        if (s->picture_structure == PICT_FRAME) {
1887
            if(s->quarter_sample){
1888
                /* top field */
1889
                qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1890
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
1891
                            1, pix_op, qpix_op,
1892
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
1893
                /* bottom field */
1894
                qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
1895
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
1896
                            1, pix_op, qpix_op,
1897
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
1898
            }else{
1899
                /* top field */       
1900
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1901
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
1902
                            1, pix_op,
1903
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
1904
                /* bottom field */
1905
                mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
1906
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
1907
                            1, pix_op,
1908
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
1909
            }
1910
        } else {
1911
            int offset;
1912
            if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
1913
                offset= s->field_select[dir][0] ? s->linesize : 0;
1914
            }else{
1915
                ref_picture= s->current_picture.data;
1916
                offset= s->field_select[dir][0] ? s->linesize : -s->linesize; 
1917
            } 
1918

    
1919
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1920
                        ref_picture, offset,
1921
                        0, pix_op,
1922
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1923
        }
1924
        break;
1925
    }
1926
}
1927

    
1928

    
1929
/* put block[] to dest[] */
1930
static inline void put_dct(MpegEncContext *s, 
1931
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
1932
{
1933
    s->dct_unquantize(s, block, i, s->qscale);
1934
    s->dsp.idct_put (dest, line_size, block);
1935
}
1936

    
1937
/* add block[] to dest[] */
1938
static inline void add_dct(MpegEncContext *s, 
1939
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
1940
{
1941
    if (s->block_last_index[i] >= 0) {
1942
        s->dsp.idct_add (dest, line_size, block);
1943
    }
1944
}
1945

    
1946
static inline void add_dequant_dct(MpegEncContext *s, 
1947
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
1948
{
1949
    if (s->block_last_index[i] >= 0) {
1950
        s->dct_unquantize(s, block, i, s->qscale);
1951

    
1952
        s->dsp.idct_add (dest, line_size, block);
1953
    }
1954
}
1955

    
1956
/**
1957
 * cleans dc, ac, coded_block for the current non intra MB
1958
 */
1959
void ff_clean_intra_table_entries(MpegEncContext *s)
1960
{
1961
    int wrap = s->block_wrap[0];
1962
    int xy = s->block_index[0];
1963
    
1964
    s->dc_val[0][xy           ] = 
1965
    s->dc_val[0][xy + 1       ] = 
1966
    s->dc_val[0][xy     + wrap] =
1967
    s->dc_val[0][xy + 1 + wrap] = 1024;
1968
    /* ac pred */
1969
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
1970
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1971
    if (s->msmpeg4_version>=3) {
1972
        s->coded_block[xy           ] =
1973
        s->coded_block[xy + 1       ] =
1974
        s->coded_block[xy     + wrap] =
1975
        s->coded_block[xy + 1 + wrap] = 0;
1976
    }
1977
    /* chroma */
1978
    wrap = s->block_wrap[4];
1979
    xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
1980
    s->dc_val[1][xy] =
1981
    s->dc_val[2][xy] = 1024;
1982
    /* ac pred */
1983
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1984
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1985
    
1986
    s->mbintra_table[s->mb_x + s->mb_y*s->mb_width]= 0;
1987
}
1988

    
1989
/* generic function called after a macroblock has been parsed by the
1990
   decoder or after it has been encoded by the encoder.
1991

1992
   Important variables used:
1993
   s->mb_intra : true if intra macroblock
1994
   s->mv_dir   : motion vector direction
1995
   s->mv_type  : motion vector type
1996
   s->mv       : motion vector
1997
   s->interlaced_dct : true if interlaced dct used (mpeg2)
1998
 */
1999
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
2000
{
2001
    int mb_x, mb_y;
2002
    const int mb_xy = s->mb_y * s->mb_width + s->mb_x;
2003

    
2004
    mb_x = s->mb_x;
2005
    mb_y = s->mb_y;
2006

    
2007
    s->current_picture.qscale_table[mb_xy]= s->qscale;
2008

    
2009
    /* update DC predictors for P macroblocks */
2010
    if (!s->mb_intra) {
2011
        if (s->h263_pred || s->h263_aic) {
2012
            if(s->mbintra_table[mb_xy])
2013
                ff_clean_intra_table_entries(s);
2014
        } else {
2015
            s->last_dc[0] =
2016
            s->last_dc[1] =
2017
            s->last_dc[2] = 128 << s->intra_dc_precision;
2018
        }
2019
    }
2020
    else if (s->h263_pred || s->h263_aic)
2021
        s->mbintra_table[mb_xy]=1;
2022

    
2023
    /* update motion predictor, not for B-frames as they need the motion_val from the last P/S-Frame */
2024
    if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) { //FIXME move into h263.c if possible, format specific stuff shouldnt be here
2025
        //FIXME a lot of thet is only needed for !low_delay
2026
        const int wrap = s->block_wrap[0];
2027
        const int xy = s->block_index[0];
2028
        const int mb_index= s->mb_x + s->mb_y*s->mb_width;
2029
        if(s->mv_type == MV_TYPE_8X8){
2030
            s->co_located_type_table[mb_index]= CO_LOCATED_TYPE_4MV;
2031
        } else {
2032
            int motion_x, motion_y;
2033
            if (s->mb_intra) {
2034
                motion_x = 0;
2035
                motion_y = 0;
2036
                if(s->co_located_type_table)
2037
                    s->co_located_type_table[mb_index]= 0;
2038
            } else if (s->mv_type == MV_TYPE_16X16) {
2039
                motion_x = s->mv[0][0][0];
2040
                motion_y = s->mv[0][0][1];
2041
                if(s->co_located_type_table)
2042
                    s->co_located_type_table[mb_index]= 0;
2043
            } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
2044
                int i;
2045
                motion_x = s->mv[0][0][0] + s->mv[0][1][0];
2046
                motion_y = s->mv[0][0][1] + s->mv[0][1][1];
2047
                motion_x = (motion_x>>1) | (motion_x&1);
2048
                for(i=0; i<2; i++){
2049
                    s->field_mv_table[mb_index][i][0]= s->mv[0][i][0];
2050
                    s->field_mv_table[mb_index][i][1]= s->mv[0][i][1];
2051
                    s->field_select_table[mb_index][i]= s->field_select[0][i];
2052
                }
2053
                s->co_located_type_table[mb_index]= CO_LOCATED_TYPE_FIELDMV;
2054
            }
2055
            /* no update if 8X8 because it has been done during parsing */
2056
            s->motion_val[xy][0] = motion_x;
2057
            s->motion_val[xy][1] = motion_y;
2058
            s->motion_val[xy + 1][0] = motion_x;
2059
            s->motion_val[xy + 1][1] = motion_y;
2060
            s->motion_val[xy + wrap][0] = motion_x;
2061
            s->motion_val[xy + wrap][1] = motion_y;
2062
            s->motion_val[xy + 1 + wrap][0] = motion_x;
2063
            s->motion_val[xy + 1 + wrap][1] = motion_y;
2064
        }
2065
    }
2066
    
2067
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
2068
        uint8_t *dest_y, *dest_cb, *dest_cr;
2069
        int dct_linesize, dct_offset;
2070
        op_pixels_func (*op_pix)[4];
2071
        qpel_mc_func (*op_qpix)[16];
2072
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
2073
        const int uvlinesize= s->current_picture.linesize[1];
2074

    
2075
        /* avoid copy if macroblock skipped in last frame too */
2076
        if (s->pict_type != B_TYPE) {
2077
            s->current_picture.mbskip_table[mb_xy]= s->mb_skiped;
2078
        }
2079

    
2080
        /* skip only during decoding as we might trash the buffers during encoding a bit */
2081
        if(!s->encoding){
2082
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2083
            const int age= s->current_picture.age;
2084

    
2085
            assert(age);
2086

    
2087
            if (s->mb_skiped) {
2088
                s->mb_skiped= 0;
2089
                assert(s->pict_type!=I_TYPE);
2090
 
2091
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
2092
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2093

    
2094
                /* if previous was skipped too, then nothing to do !  */
2095
                if (*mbskip_ptr >= age && s->current_picture.reference){
2096
                    return;
2097
                }
2098
            } else if(!s->current_picture.reference){
2099
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2100
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2101
            } else{
2102
                *mbskip_ptr = 0; /* not skipped */
2103
            }
2104
        }else
2105
            s->mb_skiped= 0;
2106

    
2107
        if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){ //FIXME precalc
2108
            dest_y  = s->current_picture.data[0] + mb_x * 16;
2109
            dest_cb = s->current_picture.data[1] + mb_x * 8;
2110
            dest_cr = s->current_picture.data[2] + mb_x * 8;
2111
        }else{
2112
            dest_y  = s->current_picture.data[0] + (mb_y * 16* linesize  ) + mb_x * 16;
2113
            dest_cb = s->current_picture.data[1] + (mb_y * 8 * uvlinesize) + mb_x * 8;
2114
            dest_cr = s->current_picture.data[2] + (mb_y * 8 * uvlinesize) + mb_x * 8;
2115
        }
2116

    
2117
        if (s->interlaced_dct) {
2118
            dct_linesize = linesize * 2;
2119
            dct_offset = linesize;
2120
        } else {
2121
            dct_linesize = linesize;
2122
            dct_offset = linesize * 8;
2123
        }
2124

    
2125
        if (!s->mb_intra) {
2126
            /* motion handling */
2127
            /* decoding or more than one mb_type (MC was allready done otherwise) */
2128
            if((!s->encoding) || (s->mb_type[mb_xy]&(s->mb_type[mb_xy]-1))){
2129
                if ((!s->no_rounding) || s->pict_type==B_TYPE){                
2130
                    op_pix = s->dsp.put_pixels_tab;
2131
                    op_qpix= s->dsp.put_qpel_pixels_tab;
2132
                }else{
2133
                    op_pix = s->dsp.put_no_rnd_pixels_tab;
2134
                    op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2135
                }
2136

    
2137
                if (s->mv_dir & MV_DIR_FORWARD) {
2138
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2139
                    op_pix = s->dsp.avg_pixels_tab;
2140
                    op_qpix= s->dsp.avg_qpel_pixels_tab;
2141
                }
2142
                if (s->mv_dir & MV_DIR_BACKWARD) {
2143
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2144
                }
2145
            }
2146

    
2147
            /* skip dequant / idct if we are really late ;) */
2148
            if(s->hurry_up>1) return;
2149

    
2150
            /* add dct residue */
2151
            if(s->encoding || !(   s->mpeg2 || s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO 
2152
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2153
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
2154
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2155
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2156
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2157

    
2158
                if(!(s->flags&CODEC_FLAG_GRAY)){
2159
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize);
2160
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize);
2161
                }
2162
            } else if(s->codec_id != CODEC_ID_WMV2){
2163
                add_dct(s, block[0], 0, dest_y, dct_linesize);
2164
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2165
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2166
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2167

    
2168
                if(!(s->flags&CODEC_FLAG_GRAY)){
2169
                    add_dct(s, block[4], 4, dest_cb, uvlinesize);
2170
                    add_dct(s, block[5], 5, dest_cr, uvlinesize);
2171
                }
2172
            } 
2173
#ifdef CONFIG_RISKY
2174
            else{
2175
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2176
            }
2177
#endif
2178
        } else {
2179
            /* dct only in intra block */
2180
            if(s->encoding || !(s->mpeg2 || s->codec_id==CODEC_ID_MPEG1VIDEO)){
2181
                put_dct(s, block[0], 0, dest_y, dct_linesize);
2182
                put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2183
                put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2184
                put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2185

    
2186
                if(!(s->flags&CODEC_FLAG_GRAY)){
2187
                    put_dct(s, block[4], 4, dest_cb, uvlinesize);
2188
                    put_dct(s, block[5], 5, dest_cr, uvlinesize);
2189
                }
2190
            }else{
2191
                s->dsp.idct_put(dest_y                 , dct_linesize, block[0]);
2192
                s->dsp.idct_put(dest_y              + 8, dct_linesize, block[1]);
2193
                s->dsp.idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
2194
                s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
2195

    
2196
                if(!(s->flags&CODEC_FLAG_GRAY)){
2197
                    s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2198
                    s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2199
                }
2200
            }
2201
        }
2202
    }
2203
}
2204

    
2205
#ifdef CONFIG_ENCODERS
2206

    
2207
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
2208
{
2209
    static const char tab[64]=
2210
        {3,2,2,1,1,1,1,1,
2211
         1,1,1,1,1,1,1,1,
2212
         1,1,1,1,1,1,1,1,
2213
         0,0,0,0,0,0,0,0,
2214
         0,0,0,0,0,0,0,0,
2215
         0,0,0,0,0,0,0,0,
2216
         0,0,0,0,0,0,0,0,
2217
         0,0,0,0,0,0,0,0};
2218
    int score=0;
2219
    int run=0;
2220
    int i;
2221
    DCTELEM *block= s->block[n];
2222
    const int last_index= s->block_last_index[n];
2223
    int skip_dc;
2224

    
2225
    if(threshold<0){
2226
        skip_dc=0;
2227
        threshold= -threshold;
2228
    }else
2229
        skip_dc=1;
2230

    
2231
    /* are all which we could set to zero are allready zero? */
2232
    if(last_index<=skip_dc - 1) return;
2233

    
2234
    for(i=0; i<=last_index; i++){
2235
        const int j = s->intra_scantable.permutated[i];
2236
        const int level = ABS(block[j]);
2237
        if(level==1){
2238
            if(skip_dc && i==0) continue;
2239
            score+= tab[run];
2240
            run=0;
2241
        }else if(level>1){
2242
            return;
2243
        }else{
2244
            run++;
2245
        }
2246
    }
2247
    if(score >= threshold) return;
2248
    for(i=skip_dc; i<=last_index; i++){
2249
        const int j = s->intra_scantable.permutated[i];
2250
        block[j]=0;
2251
    }
2252
    if(block[0]) s->block_last_index[n]= 0;
2253
    else         s->block_last_index[n]= -1;
2254
}
2255

    
2256
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
2257
{
2258
    int i;
2259
    const int maxlevel= s->max_qcoeff;
2260
    const int minlevel= s->min_qcoeff;
2261
    
2262
    if(s->mb_intra){
2263
        i=1; //skip clipping of intra dc
2264
    }else
2265
        i=0;
2266
    
2267
    for(;i<=last_index; i++){
2268
        const int j= s->intra_scantable.permutated[i];
2269
        int level = block[j];
2270
       
2271
        if     (level>maxlevel) level=maxlevel;
2272
        else if(level<minlevel) level=minlevel;
2273

    
2274
        block[j]= level;
2275
    }
2276
}
2277

    
2278
#if 0
2279
static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
2280
    int score=0;
2281
    int x,y;
2282
    
2283
    for(y=0; y<7; y++){
2284
        for(x=0; x<16; x+=4){
2285
            score+= ABS(s[x  ] - s[x  +stride]) + ABS(s[x+1] - s[x+1+stride]) 
2286
                   +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
2287
        }
2288
        s+= stride;
2289
    }
2290
    
2291
    return score;
2292
}
2293

2294
static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
2295
    int score=0;
2296
    int x,y;
2297
    
2298
    for(y=0; y<7; y++){
2299
        for(x=0; x<16; x++){
2300
            score+= ABS(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2301
        }
2302
        s1+= stride;
2303
        s2+= stride;
2304
    }
2305
    
2306
    return score;
2307
}
2308
#else
2309
#define SQ(a) ((a)*(a))
2310

    
2311
static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
2312
    int score=0;
2313
    int x,y;
2314
    
2315
    for(y=0; y<7; y++){
2316
        for(x=0; x<16; x+=4){
2317
            score+= SQ(s[x  ] - s[x  +stride]) + SQ(s[x+1] - s[x+1+stride]) 
2318
                   +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
2319
        }
2320
        s+= stride;
2321
    }
2322
    
2323
    return score;
2324
}
2325

    
2326
static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
2327
    int score=0;
2328
    int x,y;
2329
    
2330
    for(y=0; y<7; y++){
2331
        for(x=0; x<16; x++){
2332
            score+= SQ(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2333
        }
2334
        s1+= stride;
2335
        s2+= stride;
2336
    }
2337
    
2338
    return score;
2339
}
2340

    
2341
#endif
2342

    
2343
#endif //CONFIG_ENCODERS
2344

    
2345
/**
2346
 *
2347
 * @param h is the normal height, this will be reduced automatically if needed for the last row
2348
 */
2349
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2350
    if (    s->avctx->draw_horiz_band 
2351
        && (s->last_picture_ptr || s->low_delay) ) {
2352
        uint8_t *src_ptr[3];
2353
        int offset;
2354
        h= FFMIN(h, s->height - y);
2355

    
2356
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME)
2357
            offset = 0;
2358
        else
2359
            offset = y * s->linesize;
2360

    
2361
        if(s->pict_type==B_TYPE || s->low_delay){
2362
            src_ptr[0] = s->current_picture.data[0] + offset;
2363
            src_ptr[1] = s->current_picture.data[1] + (offset >> 2);
2364
            src_ptr[2] = s->current_picture.data[2] + (offset >> 2);
2365
        } else {
2366
            src_ptr[0] = s->last_picture.data[0] + offset;
2367
            src_ptr[1] = s->last_picture.data[1] + (offset >> 2);
2368
            src_ptr[2] = s->last_picture.data[2] + (offset >> 2);
2369
        }
2370
        emms_c();
2371

    
2372
        s->avctx->draw_horiz_band(s->avctx, src_ptr, s->linesize,
2373
                               y, s->width, h);
2374
    }
2375
}
2376

    
2377
#ifdef CONFIG_ENCODERS
2378

    
2379
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2380
{
2381
    const int mb_x= s->mb_x;
2382
    const int mb_y= s->mb_y;
2383
    int i;
2384
    int skip_dct[6];
2385
    int dct_offset   = s->linesize*8; //default for progressive frames
2386
    
2387
    for(i=0; i<6; i++) skip_dct[i]=0;
2388
    
2389
    if(s->adaptive_quant){
2390
        s->dquant= s->current_picture.qscale_table[mb_x + mb_y*s->mb_width] - s->qscale;
2391

    
2392
        if(s->out_format==FMT_H263){
2393
            if     (s->dquant> 2) s->dquant= 2;
2394
            else if(s->dquant<-2) s->dquant=-2;
2395
        }
2396
            
2397
        if(s->codec_id==CODEC_ID_MPEG4){        
2398
            if(!s->mb_intra){
2399
                if(s->mv_dir&MV_DIRECT)
2400
                    s->dquant=0;
2401

    
2402
                assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
2403
            }
2404
        }
2405
        s->qscale+= s->dquant;
2406
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2407
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2408
    }
2409

    
2410
    if (s->mb_intra) {
2411
        uint8_t *ptr;
2412
        int wrap_y;
2413
        int emu=0;
2414

    
2415
        wrap_y = s->linesize;
2416
        ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2417

    
2418
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2419
            ff_emulated_edge_mc(s, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2420
            ptr= s->edge_emu_buffer;
2421
            emu=1;
2422
        }
2423
        
2424
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2425
            int progressive_score, interlaced_score;
2426
            
2427
            progressive_score= pix_vcmp16x8(ptr, wrap_y  ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
2428
            interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y  , wrap_y*2);
2429
            
2430
            if(progressive_score > interlaced_score + 100){
2431
                s->interlaced_dct=1;
2432
            
2433
                dct_offset= wrap_y;
2434
                wrap_y<<=1;
2435
            }else
2436
                s->interlaced_dct=0;
2437
        }
2438
        
2439
        s->dsp.get_pixels(s->block[0], ptr                 , wrap_y);
2440
        s->dsp.get_pixels(s->block[1], ptr              + 8, wrap_y);
2441
        s->dsp.get_pixels(s->block[2], ptr + dct_offset    , wrap_y);
2442
        s->dsp.get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
2443

    
2444
        if(s->flags&CODEC_FLAG_GRAY){
2445
            skip_dct[4]= 1;
2446
            skip_dct[5]= 1;
2447
        }else{
2448
            int wrap_c = s->uvlinesize;
2449
            ptr = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2450
            if(emu){
2451
                ff_emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2452
                ptr= s->edge_emu_buffer;
2453
            }
2454
            s->dsp.get_pixels(s->block[4], ptr, wrap_c);
2455

    
2456
            ptr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2457
            if(emu){
2458
                ff_emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2459
                ptr= s->edge_emu_buffer;
2460
            }
2461
            s->dsp.get_pixels(s->block[5], ptr, wrap_c);
2462
        }
2463
    }else{
2464
        op_pixels_func (*op_pix)[4];
2465
        qpel_mc_func (*op_qpix)[16];
2466
        uint8_t *dest_y, *dest_cb, *dest_cr;
2467
        uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2468
        int wrap_y, wrap_c;
2469
        int emu=0;
2470

    
2471
        dest_y  = s->current_picture.data[0] + (mb_y * 16 * s->linesize    ) + mb_x * 16;
2472
        dest_cb = s->current_picture.data[1] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2473
        dest_cr = s->current_picture.data[2] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2474
        wrap_y = s->linesize;
2475
        wrap_c = s->uvlinesize;
2476
        ptr_y  = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2477
        ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2478
        ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2479

    
2480
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
2481
            op_pix = s->dsp.put_pixels_tab;
2482
            op_qpix= s->dsp.put_qpel_pixels_tab;
2483
        }else{
2484
            op_pix = s->dsp.put_no_rnd_pixels_tab;
2485
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2486
        }
2487

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

    
2497
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2498
            ff_emulated_edge_mc(s, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2499
            ptr_y= s->edge_emu_buffer;
2500
            emu=1;
2501
        }
2502
        
2503
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2504
            int progressive_score, interlaced_score;
2505
            
2506
            progressive_score= pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y  ) 
2507
                             + pix_diff_vcmp16x8(ptr_y + wrap_y*8, dest_y + wrap_y*8, wrap_y  );
2508
            interlaced_score = pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y*2)
2509
                             + pix_diff_vcmp16x8(ptr_y + wrap_y  , dest_y + wrap_y  , wrap_y*2);
2510
            
2511
            if(progressive_score > interlaced_score + 600){
2512
                s->interlaced_dct=1;
2513
            
2514
                dct_offset= wrap_y;
2515
                wrap_y<<=1;
2516
            }else
2517
                s->interlaced_dct=0;
2518
        }
2519
        
2520
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
2521
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
2522
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
2523
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
2524
        
2525
        if(s->flags&CODEC_FLAG_GRAY){
2526
            skip_dct[4]= 1;
2527
            skip_dct[5]= 1;
2528
        }else{
2529
            if(emu){
2530
                ff_emulated_edge_mc(s, ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2531
                ptr_cb= s->edge_emu_buffer;
2532
            }
2533
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2534
            if(emu){
2535
                ff_emulated_edge_mc(s, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2536
                ptr_cr= s->edge_emu_buffer;
2537
            }
2538
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2539
        }
2540
        /* pre quantization */         
2541
        if(s->current_picture.mc_mb_var[s->mb_width*mb_y+ mb_x]<2*s->qscale*s->qscale){
2542
            //FIXME optimize
2543
            if(s->dsp.pix_abs8x8(ptr_y               , dest_y               , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
2544
            if(s->dsp.pix_abs8x8(ptr_y            + 8, dest_y            + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
2545
            if(s->dsp.pix_abs8x8(ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
2546
            if(s->dsp.pix_abs8x8(ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
2547
            if(s->dsp.pix_abs8x8(ptr_cb              , dest_cb              , wrap_c) < 20*s->qscale) skip_dct[4]= 1;
2548
            if(s->dsp.pix_abs8x8(ptr_cr              , dest_cr              , wrap_c) < 20*s->qscale) skip_dct[5]= 1;
2549
#if 0
2550
{
2551
 static int stat[7];
2552
 int num=0;
2553
 for(i=0; i<6; i++)
2554
  if(skip_dct[i]) num++;
2555
 stat[num]++;
2556
 
2557
 if(s->mb_x==0 && s->mb_y==0){
2558
  for(i=0; i<7; i++){
2559
   printf("%6d %1d\n", stat[i], i);
2560
  }
2561
 }
2562
}
2563
#endif
2564
        }
2565

    
2566
    }
2567
            
2568
#if 0
2569
            {
2570
                float adap_parm;
2571
                
2572
                adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_width*mb_y+mb_x] + 1.0) /
2573
                            ((s->mb_var[s->mb_width*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);
2574
            
2575
                printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d", 
2576
                        (s->mb_type[s->mb_width*mb_y+mb_x] > 0) ? 'I' : 'P', 
2577
                        s->qscale, adap_parm, s->qscale*adap_parm,
2578
                        s->mb_var[s->mb_width*mb_y+mb_x], s->avg_mb_var);
2579
            }
2580
#endif
2581
    /* DCT & quantize */
2582
    if(s->out_format==FMT_MJPEG){
2583
        for(i=0;i<6;i++) {
2584
            int overflow;
2585
            s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
2586
            if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2587
        }
2588
    }else{
2589
        for(i=0;i<6;i++) {
2590
            if(!skip_dct[i]){
2591
                int overflow;
2592
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2593
            // FIXME we could decide to change to quantizer instead of clipping
2594
            // JS: I don't think that would be a good idea it could lower quality instead
2595
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
2596
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2597
            }else
2598
                s->block_last_index[i]= -1;
2599
        }
2600
        if(s->luma_elim_threshold && !s->mb_intra)
2601
            for(i=0; i<4; i++)
2602
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2603
        if(s->chroma_elim_threshold && !s->mb_intra)
2604
            for(i=4; i<6; i++)
2605
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2606
    }
2607

    
2608
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
2609
        s->block_last_index[4]=
2610
        s->block_last_index[5]= 0;
2611
        s->block[4][0]=
2612
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
2613
    }
2614

    
2615
    /* huffman encode */
2616
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2617
    case CODEC_ID_MPEG1VIDEO:
2618
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
2619
#ifdef CONFIG_RISKY
2620
    case CODEC_ID_MPEG4:
2621
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
2622
    case CODEC_ID_MSMPEG4V2:
2623
    case CODEC_ID_MSMPEG4V3:
2624
    case CODEC_ID_WMV1:
2625
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
2626
    case CODEC_ID_WMV2:
2627
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
2628
    case CODEC_ID_H263:
2629
    case CODEC_ID_H263P:
2630
    case CODEC_ID_RV10:
2631
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
2632
#endif
2633
    case CODEC_ID_MJPEG:
2634
        mjpeg_encode_mb(s, s->block); break;
2635
    default:
2636
        assert(0);
2637
    }
2638
}
2639

    
2640
#endif //CONFIG_ENCODERS
2641

    
2642
/**
2643
 * combines the (truncated) bitstream to a complete frame
2644
 * @returns -1 if no complete frame could be created
2645
 */
2646
int ff_combine_frame( MpegEncContext *s, int next, uint8_t **buf, int *buf_size){
2647
    ParseContext *pc= &s->parse_context;
2648
        
2649
    pc->last_index= pc->index;
2650

    
2651
    if(next==-1){
2652
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
2653

    
2654
        memcpy(&pc->buffer[pc->index], *buf, *buf_size);
2655
        pc->index += *buf_size;
2656
        return -1;
2657
    }
2658

    
2659
    if(pc->index){
2660
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
2661

    
2662
        memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
2663
        pc->index = 0;
2664
        *buf= pc->buffer;
2665
        *buf_size= pc->last_index + next;
2666
    }
2667

    
2668
    return 0;
2669
}
2670

    
2671
#ifdef CONFIG_ENCODERS
2672
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
2673
{
2674
    int bytes= length>>4;
2675
    int bits= length&15;
2676
    int i;
2677

    
2678
    if(length==0) return;
2679

    
2680
    for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
2681
    put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
2682
}
2683

    
2684
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2685
    int i;
2686

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

    
2689
    /* mpeg1 */
2690
    d->mb_skip_run= s->mb_skip_run;
2691
    for(i=0; i<3; i++)
2692
        d->last_dc[i]= s->last_dc[i];
2693
    
2694
    /* statistics */
2695
    d->mv_bits= s->mv_bits;
2696
    d->i_tex_bits= s->i_tex_bits;
2697
    d->p_tex_bits= s->p_tex_bits;
2698
    d->i_count= s->i_count;
2699
    d->f_count= s->f_count;
2700
    d->b_count= s->b_count;
2701
    d->skip_count= s->skip_count;
2702
    d->misc_bits= s->misc_bits;
2703
    d->last_bits= 0;
2704

    
2705
    d->mb_skiped= s->mb_skiped;
2706
    d->qscale= s->qscale;
2707
}
2708

    
2709
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2710
    int i;
2711

    
2712
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
2713
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
2714
    
2715
    /* mpeg1 */
2716
    d->mb_skip_run= s->mb_skip_run;
2717
    for(i=0; i<3; i++)
2718
        d->last_dc[i]= s->last_dc[i];
2719
    
2720
    /* statistics */
2721
    d->mv_bits= s->mv_bits;
2722
    d->i_tex_bits= s->i_tex_bits;
2723
    d->p_tex_bits= s->p_tex_bits;
2724
    d->i_count= s->i_count;
2725
    d->f_count= s->f_count;
2726
    d->b_count= s->b_count;
2727
    d->skip_count= s->skip_count;
2728
    d->misc_bits= s->misc_bits;
2729

    
2730
    d->mb_intra= s->mb_intra;
2731
    d->mb_skiped= s->mb_skiped;
2732
    d->mv_type= s->mv_type;
2733
    d->mv_dir= s->mv_dir;
2734
    d->pb= s->pb;
2735
    if(s->data_partitioning){
2736
        d->pb2= s->pb2;
2737
        d->tex_pb= s->tex_pb;
2738
    }
2739
    d->block= s->block;
2740
    for(i=0; i<6; i++)
2741
        d->block_last_index[i]= s->block_last_index[i];
2742
    d->interlaced_dct= s->interlaced_dct;
2743
    d->qscale= s->qscale;
2744
}
2745

    
2746
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
2747
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2748
                           int *dmin, int *next_block, int motion_x, int motion_y)
2749
{
2750
    int bits_count;
2751
    
2752
    copy_context_before_encode(s, backup, type);
2753

    
2754
    s->block= s->blocks[*next_block];
2755
    s->pb= pb[*next_block];
2756
    if(s->data_partitioning){
2757
        s->pb2   = pb2   [*next_block];
2758
        s->tex_pb= tex_pb[*next_block];
2759
    }
2760

    
2761
    encode_mb(s, motion_x, motion_y);
2762

    
2763
    bits_count= get_bit_count(&s->pb);
2764
    if(s->data_partitioning){
2765
        bits_count+= get_bit_count(&s->pb2);
2766
        bits_count+= get_bit_count(&s->tex_pb);
2767
    }
2768

    
2769
    if(bits_count<*dmin){
2770
        *dmin= bits_count;
2771
        *next_block^=1;
2772

    
2773
        copy_context_after_encode(best, s, type);
2774
    }
2775
}
2776
                
2777
static inline int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2778
    uint32_t *sq = squareTbl + 256;
2779
    int acc=0;
2780
    int x,y;
2781
    
2782
    if(w==16 && h==16) 
2783
        return s->dsp.sse[0](NULL, src1, src2, stride);
2784
    else if(w==8 && h==8)
2785
        return s->dsp.sse[1](NULL, src1, src2, stride);
2786
    
2787
    for(y=0; y<h; y++){
2788
        for(x=0; x<w; x++){
2789
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2790
        } 
2791
    }
2792
    
2793
    assert(acc>=0);
2794
    
2795
    return acc;
2796
}
2797

    
2798
static void encode_picture(MpegEncContext *s, int picture_number)
2799
{
2800
    int mb_x, mb_y, pdif = 0;
2801
    int i;
2802
    int bits;
2803
    MpegEncContext best_s, backup_s;
2804
    uint8_t bit_buf[2][3000];
2805
    uint8_t bit_buf2[2][3000];
2806
    uint8_t bit_buf_tex[2][3000];
2807
    PutBitContext pb[2], pb2[2], tex_pb[2];
2808

    
2809
    for(i=0; i<2; i++){
2810
        init_put_bits(&pb    [i], bit_buf    [i], 3000, NULL, NULL);
2811
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000, NULL, NULL);
2812
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
2813
    }
2814

    
2815
    s->picture_number = picture_number;
2816

    
2817
    s->block_wrap[0]=
2818
    s->block_wrap[1]=
2819
    s->block_wrap[2]=
2820
    s->block_wrap[3]= s->mb_width*2 + 2;
2821
    s->block_wrap[4]=
2822
    s->block_wrap[5]= s->mb_width + 2;
2823
    
2824
    /* Reset the average MB variance */
2825
    s->current_picture.mb_var_sum = 0;
2826
    s->current_picture.mc_mb_var_sum = 0;
2827

    
2828
#ifdef CONFIG_RISKY
2829
    /* we need to initialize some time vars before we can encode b-frames */
2830
    // RAL: Condition added for MPEG1VIDEO
2831
    if (s->codec_id == CODEC_ID_MPEG1VIDEO || (s->h263_pred && !s->h263_msmpeg4))
2832
        ff_set_mpeg4_time(s, s->picture_number); 
2833
#endif
2834
        
2835
    s->scene_change_score=0;
2836
    
2837
    s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
2838
    
2839
    if(s->pict_type==I_TYPE){
2840
        if(s->msmpeg4_version >= 3) s->no_rounding=1;
2841
        else                        s->no_rounding=0;
2842
    }else if(s->pict_type!=B_TYPE){
2843
        if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
2844
            s->no_rounding ^= 1;          
2845
    }
2846
    
2847
    /* Estimate motion for every MB */
2848
    s->mb_intra=0; //for the rate distoration & bit compare functions
2849
    if(s->pict_type != I_TYPE){
2850
        if(s->pict_type != B_TYPE){
2851
            if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
2852
                s->me.pre_pass=1;
2853
                s->me.dia_size= s->avctx->pre_dia_size;
2854

    
2855
                for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) {
2856
                    for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) {
2857
                        s->mb_x = mb_x;
2858
                        s->mb_y = mb_y;
2859
                        ff_pre_estimate_p_frame_motion(s, mb_x, mb_y);
2860
                    }
2861
                }
2862
                s->me.pre_pass=0;
2863
            }
2864
        }
2865

    
2866
        s->me.dia_size= s->avctx->dia_size;
2867
        for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2868
            s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
2869
            s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
2870
            s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
2871
            s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
2872
            for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2873
                s->mb_x = mb_x;
2874
                s->mb_y = mb_y;
2875
                s->block_index[0]+=2;
2876
                s->block_index[1]+=2;
2877
                s->block_index[2]+=2;
2878
                s->block_index[3]+=2;
2879
                
2880
                /* compute motion vector & mb_type and store in context */
2881
                if(s->pict_type==B_TYPE)
2882
                    ff_estimate_b_frame_motion(s, mb_x, mb_y);
2883
                else
2884
                    ff_estimate_p_frame_motion(s, mb_x, mb_y);
2885
            }
2886
        }
2887
    }else /* if(s->pict_type == I_TYPE) */{
2888
        /* I-Frame */
2889
        //FIXME do we need to zero them?
2890
        memset(s->motion_val[0], 0, sizeof(int16_t)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
2891
        memset(s->p_mv_table   , 0, sizeof(int16_t)*(s->mb_width+2)*(s->mb_height+2)*2);
2892
        memset(s->mb_type      , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_width*s->mb_height);
2893
        
2894
        if(!s->fixed_qscale){
2895
            /* finding spatial complexity for I-frame rate control */
2896
            for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2897
                for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2898
                    int xx = mb_x * 16;
2899
                    int yy = mb_y * 16;
2900
                    uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
2901
                    int varc;
2902
                    int sum = s->dsp.pix_sum(pix, s->linesize);
2903
    
2904
                    varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
2905

    
2906
                    s->current_picture.mb_var [s->mb_width * mb_y + mb_x] = varc;
2907
                    s->current_picture.mb_mean[s->mb_width * mb_y + mb_x] = (sum+128)>>8;
2908
                    s->current_picture.mb_var_sum    += varc;
2909
                }
2910
            }
2911
        }
2912
    }
2913
    emms_c();
2914

    
2915
    if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
2916
        s->pict_type= I_TYPE;
2917
        memset(s->mb_type   , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_width*s->mb_height);
2918
//printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
2919
    }
2920

    
2921
    if(!s->umvplus){
2922
        if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
2923
            s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
2924
        
2925
            ff_fix_long_p_mvs(s);
2926
        }
2927

    
2928
        if(s->pict_type==B_TYPE){
2929
            int a, b;
2930

    
2931
            a = ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
2932
            b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, MB_TYPE_BIDIR);
2933
            s->f_code = FFMAX(a, b);
2934

    
2935
            a = ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
2936
            b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, MB_TYPE_BIDIR);
2937
            s->b_code = FFMAX(a, b);
2938

    
2939
            ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
2940
            ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
2941
            ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
2942
            ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
2943
        }
2944
    }
2945
    
2946
    if (s->fixed_qscale) 
2947
        s->frame_qscale = s->current_picture.quality;
2948
    else
2949
        s->frame_qscale = ff_rate_estimate_qscale(s);
2950

    
2951
    if(s->adaptive_quant){
2952
#ifdef CONFIG_RISKY
2953
        switch(s->codec_id){
2954
        case CODEC_ID_MPEG4:
2955
            ff_clean_mpeg4_qscales(s);
2956
            break;
2957
        case CODEC_ID_H263:
2958
        case CODEC_ID_H263P:
2959
            ff_clean_h263_qscales(s);
2960
            break;
2961
        }
2962
#endif
2963

    
2964
        s->qscale= s->current_picture.qscale_table[0];
2965
    }else
2966
        s->qscale= (int)(s->frame_qscale + 0.5);
2967
        
2968
    if (s->out_format == FMT_MJPEG) {
2969
        /* for mjpeg, we do include qscale in the matrix */
2970
        s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
2971
        for(i=1;i<64;i++){
2972
            int j= s->dsp.idct_permutation[i];
2973

    
2974
            s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
2975
        }
2976
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, 
2977
                       s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
2978
    }
2979
    
2980
    //FIXME var duplication
2981
    s->current_picture.key_frame= s->pict_type == I_TYPE;
2982
    s->current_picture.pict_type= s->pict_type;
2983

    
2984
    if(s->current_picture.key_frame)
2985
        s->picture_in_gop_number=0;
2986

    
2987
    s->last_bits= get_bit_count(&s->pb);
2988
    switch(s->out_format) {
2989
    case FMT_MJPEG:
2990
        mjpeg_picture_header(s);
2991
        break;
2992
#ifdef CONFIG_RISKY
2993
    case FMT_H263:
2994
        if (s->codec_id == CODEC_ID_WMV2) 
2995
            ff_wmv2_encode_picture_header(s, picture_number);
2996
        else if (s->h263_msmpeg4) 
2997
            msmpeg4_encode_picture_header(s, picture_number);
2998
        else if (s->h263_pred)
2999
            mpeg4_encode_picture_header(s, picture_number);
3000
        else if (s->h263_rv10) 
3001
            rv10_encode_picture_header(s, picture_number);
3002
        else
3003
            h263_encode_picture_header(s, picture_number);
3004
        break;
3005
#endif
3006
    case FMT_MPEG1:
3007
        mpeg1_encode_picture_header(s, picture_number);
3008
        break;
3009
    }
3010
    bits= get_bit_count(&s->pb);
3011
    s->header_bits= bits - s->last_bits;
3012
    s->last_bits= bits;
3013
    s->mv_bits=0;
3014
    s->misc_bits=0;
3015
    s->i_tex_bits=0;
3016
    s->p_tex_bits=0;
3017
    s->i_count=0;
3018
    s->f_count=0;
3019
    s->b_count=0;
3020
    s->skip_count=0;
3021

    
3022
    for(i=0; i<3; i++){
3023
        /* init last dc values */
3024
        /* note: quant matrix value (8) is implied here */
3025
        s->last_dc[i] = 128;
3026
        
3027
        s->current_picture_ptr->error[i] = 0;
3028
    }
3029
    s->mb_skip_run = 0;
3030
    s->last_mv[0][0][0] = 0;
3031
    s->last_mv[0][0][1] = 0;
3032
    s->last_mv[1][0][0] = 0;
3033
    s->last_mv[1][0][1] = 0;
3034
     
3035
    s->last_mv_dir = 0;
3036

    
3037
#ifdef CONFIG_RISKY
3038
    if (s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P)
3039
        s->gob_index = ff_h263_get_gob_height(s);
3040

    
3041
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3042
        ff_mpeg4_init_partitions(s);
3043
#endif
3044

    
3045
    s->resync_mb_x=0;
3046
    s->resync_mb_y=0;
3047
    s->first_slice_line = 1;
3048
    s->ptr_lastgob = s->pb.buf;
3049
    for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3050
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
3051
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
3052
        
3053
        s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3054
        s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3055
        s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3056
        s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3057
        s->block_index[4]= s->block_wrap[4]*(mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2);
3058
        s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
3059
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3060
            int mb_type= s->mb_type[mb_y * s->mb_width + mb_x];
3061
            const int xy= (mb_y+1) * (s->mb_width+2) + mb_x + 1;
3062
//            int d;
3063
            int dmin=10000000;
3064

    
3065
            s->mb_x = mb_x;
3066
            s->mb_y = mb_y;
3067
            s->block_index[0]+=2;
3068
            s->block_index[1]+=2;
3069
            s->block_index[2]+=2;
3070
            s->block_index[3]+=2;
3071
            s->block_index[4]++;
3072
            s->block_index[5]++;
3073

    
3074
            /* write gob / video packet header  */
3075
#ifdef CONFIG_RISKY
3076
            if(s->rtp_mode){
3077
                int current_packet_size, is_gob_start;
3078
                
3079
                current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
3080
                is_gob_start=0;
3081
                
3082
                if(s->codec_id==CODEC_ID_MPEG4){
3083
                    if(current_packet_size >= s->rtp_payload_size
3084
                       && s->mb_y + s->mb_x>0){
3085

    
3086
                        if(s->partitioned_frame){
3087
                            ff_mpeg4_merge_partitions(s);
3088
                            ff_mpeg4_init_partitions(s);
3089
                        }
3090
                        ff_mpeg4_encode_video_packet_header(s);
3091

    
3092
                        if(s->flags&CODEC_FLAG_PASS1){
3093
                            int bits= get_bit_count(&s->pb);
3094
                            s->misc_bits+= bits - s->last_bits;
3095
                            s->last_bits= bits;
3096
                        }
3097
                        ff_mpeg4_clean_buffers(s);
3098
                        is_gob_start=1;
3099
                    }
3100
                }else if(s->codec_id==CODEC_ID_MPEG1VIDEO){
3101
                    if(   current_packet_size >= s->rtp_payload_size 
3102
                       && s->mb_y + s->mb_x>0 && s->mb_skip_run==0){
3103
                        ff_mpeg1_encode_slice_header(s);
3104
                        ff_mpeg1_clean_buffers(s);
3105
                        is_gob_start=1;
3106
                    }
3107
                }else{
3108
                    if(current_packet_size >= s->rtp_payload_size
3109
                       && s->mb_x==0 && s->mb_y>0 && s->mb_y%s->gob_index==0){
3110
                       
3111
                        h263_encode_gob_header(s, mb_y);                       
3112
                        is_gob_start=1;
3113
                    }
3114
                }
3115

    
3116
                if(is_gob_start){
3117
                    s->ptr_lastgob = pbBufPtr(&s->pb);
3118
                    s->first_slice_line=1;
3119
                    s->resync_mb_x=mb_x;
3120
                    s->resync_mb_y=mb_y;
3121
                }
3122
            }
3123
#endif
3124

    
3125
            if(  (s->resync_mb_x   == s->mb_x)
3126
               && s->resync_mb_y+1 == s->mb_y){
3127
                s->first_slice_line=0; 
3128
            }
3129

    
3130
            if(mb_type & (mb_type-1)){ // more than 1 MB type possible
3131
                int next_block=0;
3132
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3133

    
3134
                copy_context_before_encode(&backup_s, s, -1);
3135
                backup_s.pb= s->pb;
3136
                best_s.data_partitioning= s->data_partitioning;
3137
                best_s.partitioned_frame= s->partitioned_frame;
3138
                if(s->data_partitioning){
3139
                    backup_s.pb2= s->pb2;
3140
                    backup_s.tex_pb= s->tex_pb;
3141
                }
3142

    
3143
                if(mb_type&MB_TYPE_INTER){
3144
                    s->mv_dir = MV_DIR_FORWARD;
3145
                    s->mv_type = MV_TYPE_16X16;
3146
                    s->mb_intra= 0;
3147
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
3148
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
3149
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb, 
3150
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3151
                }
3152
                if(mb_type&MB_TYPE_INTER4V){                 
3153
                    s->mv_dir = MV_DIR_FORWARD;
3154
                    s->mv_type = MV_TYPE_8X8;
3155
                    s->mb_intra= 0;
3156
                    for(i=0; i<4; i++){
3157
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3158
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3159
                    }
3160
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb, 
3161
                                 &dmin, &next_block, 0, 0);
3162
                }
3163
                if(mb_type&MB_TYPE_FORWARD){
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->b_forw_mv_table[xy][0];
3168
                    s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3169
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, 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_BACKWARD){
3173
                    s->mv_dir = MV_DIR_BACKWARD;
3174
                    s->mv_type = MV_TYPE_16X16;
3175
                    s->mb_intra= 0;
3176
                    s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3177
                    s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3178
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb, 
3179
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3180
                }
3181
                if(mb_type&MB_TYPE_BIDIR){
3182
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3183
                    s->mv_type = MV_TYPE_16X16;
3184
                    s->mb_intra= 0;
3185
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3186
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3187
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3188
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3189
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb, 
3190
                                 &dmin, &next_block, 0, 0);
3191
                }
3192
                if(mb_type&MB_TYPE_DIRECT){
3193
                    int mx= s->b_direct_mv_table[xy][0];
3194
                    int my= s->b_direct_mv_table[xy][1];
3195
                    
3196
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3197
                    s->mb_intra= 0;
3198
#ifdef CONFIG_RISKY
3199
                    ff_mpeg4_set_direct_mv(s, mx, my);
3200
#endif
3201
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb, 
3202
                                 &dmin, &next_block, mx, my);
3203
                }
3204
                if(mb_type&MB_TYPE_INTRA){
3205
                    s->mv_dir = 0;
3206
                    s->mv_type = MV_TYPE_16X16;
3207
                    s->mb_intra= 1;
3208
                    s->mv[0][0][0] = 0;
3209
                    s->mv[0][0][1] = 0;
3210
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb, 
3211
                                 &dmin, &next_block, 0, 0);
3212
                    /* force cleaning of ac/dc pred stuff if needed ... */
3213
                    if(s->h263_pred || s->h263_aic)
3214
                        s->mbintra_table[mb_x + mb_y*s->mb_width]=1;
3215
                }
3216
                copy_context_after_encode(s, &best_s, -1);
3217
                
3218
                pb_bits_count= get_bit_count(&s->pb);
3219
                flush_put_bits(&s->pb);
3220
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3221
                s->pb= backup_s.pb;
3222
                
3223
                if(s->data_partitioning){
3224
                    pb2_bits_count= get_bit_count(&s->pb2);
3225
                    flush_put_bits(&s->pb2);
3226
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3227
                    s->pb2= backup_s.pb2;
3228
                    
3229
                    tex_pb_bits_count= get_bit_count(&s->tex_pb);
3230
                    flush_put_bits(&s->tex_pb);
3231
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3232
                    s->tex_pb= backup_s.tex_pb;
3233
                }
3234
                s->last_bits= get_bit_count(&s->pb);
3235
            } else {
3236
                int motion_x, motion_y;
3237
                int intra_score;
3238
                int inter_score= s->current_picture.mb_cmp_score[mb_x + mb_y*s->mb_width];
3239
                
3240
              if(!(s->flags&CODEC_FLAG_HQ) && s->pict_type==P_TYPE){
3241
                /* get luma score */
3242
                if((s->avctx->mb_cmp&0xFF)==FF_CMP_SSE){
3243
                    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
3244
                }else{
3245
                    uint8_t *dest_y;
3246

    
3247
                    int mean= s->current_picture.mb_mean[mb_x + mb_y*s->mb_width]; //FIXME
3248
                    mean*= 0x01010101;
3249
                    
3250
                    dest_y  = s->new_picture.data[0] + (mb_y * 16 * s->linesize    ) + mb_x * 16;
3251
                
3252
                    for(i=0; i<16; i++){
3253
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 0]) = mean;
3254
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 4]) = mean;
3255
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 8]) = mean;
3256
                        *(uint32_t*)(&s->me.scratchpad[i*s->linesize+12]) = mean;
3257
                    }
3258

    
3259
                    s->mb_intra=1;
3260
                    intra_score= s->dsp.mb_cmp[0](s, s->me.scratchpad, dest_y, s->linesize);
3261
                                        
3262
/*                    printf("intra:%7d inter:%7d var:%7d mc_var.%7d\n", intra_score>>8, inter_score>>8, 
3263
                        s->current_picture.mb_var[mb_x + mb_y*s->mb_width],
3264
                        s->current_picture.mc_mb_var[mb_x + mb_y*s->mb_width]);*/
3265
                }
3266
                
3267
                /* get chroma score */
3268
                if(s->avctx->mb_cmp&FF_CMP_CHROMA){
3269
                    int i;
3270
                    
3271
                    s->mb_intra=1;
3272
                    for(i=1; i<3; i++){
3273
                        uint8_t *dest_c;
3274
                        int mean;
3275
                        
3276
                        if(s->out_format == FMT_H263){
3277
                            mean= (s->dc_val[i][mb_x + (mb_y+1)*(s->mb_width+2)] + 4)>>3; //FIXME not exact but simple ;)
3278
                        }else{
3279
                            mean= (s->last_dc[i] + 4)>>3;
3280
                        }
3281
                        dest_c = s->new_picture.data[i] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
3282
                        
3283
                        mean*= 0x01010101;
3284
                        for(i=0; i<8; i++){
3285
                            *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 0]) = mean;
3286
                            *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 4]) = mean;
3287
                        }
3288
                        
3289
                        intra_score+= s->dsp.mb_cmp[1](s, s->me.scratchpad, dest_c, s->uvlinesize);
3290
                    }                
3291
                }
3292

    
3293
                /* bias */
3294
                switch(s->avctx->mb_cmp&0xFF){
3295
                default:
3296
                case FF_CMP_SAD:
3297
                    intra_score+= 32*s->qscale;
3298
                    break;
3299
                case FF_CMP_SSE:
3300
                    intra_score+= 24*s->qscale*s->qscale;
3301
                    break;
3302
                case FF_CMP_SATD:
3303
                    intra_score+= 96*s->qscale;
3304
                    break;
3305
                case FF_CMP_DCT:
3306
                    intra_score+= 48*s->qscale;
3307
                    break;
3308
                case FF_CMP_BIT:
3309
                    intra_score+= 16;
3310
                    break;
3311
                case FF_CMP_PSNR:
3312
                case FF_CMP_RD:
3313
                    intra_score+= (s->qscale*s->qscale*109*8 + 64)>>7;
3314
                    break;
3315
                }
3316

    
3317
                if(intra_score < inter_score)
3318
                    mb_type= MB_TYPE_INTRA;
3319
              }  
3320
                
3321
                s->mv_type=MV_TYPE_16X16;
3322
                // only one MB-Type possible
3323
                
3324
                switch(mb_type){
3325
                case MB_TYPE_INTRA:
3326
                    s->mv_dir = 0;
3327
                    s->mb_intra= 1;
3328
                    motion_x= s->mv[0][0][0] = 0;
3329
                    motion_y= s->mv[0][0][1] = 0;
3330
                    break;
3331
                case MB_TYPE_INTER:
3332
                    s->mv_dir = MV_DIR_FORWARD;
3333
                    s->mb_intra= 0;
3334
                    motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3335
                    motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3336
                    break;
3337
                case MB_TYPE_INTER4V:
3338
                    s->mv_dir = MV_DIR_FORWARD;
3339
                    s->mv_type = MV_TYPE_8X8;
3340
                    s->mb_intra= 0;
3341
                    for(i=0; i<4; i++){
3342
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3343
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3344
                    }
3345
                    motion_x= motion_y= 0;
3346
                    break;
3347
                case MB_TYPE_DIRECT:
3348
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3349
                    s->mb_intra= 0;
3350
                    motion_x=s->b_direct_mv_table[xy][0];
3351
                    motion_y=s->b_direct_mv_table[xy][1];
3352
#ifdef CONFIG_RISKY
3353
                    ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3354
#endif
3355
                    break;
3356
                case MB_TYPE_BIDIR:
3357
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3358
                    s->mb_intra= 0;
3359
                    motion_x=0;
3360
                    motion_y=0;
3361
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3362
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3363
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3364
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3365
                    break;
3366
                case MB_TYPE_BACKWARD:
3367
                    s->mv_dir = MV_DIR_BACKWARD;
3368
                    s->mb_intra= 0;
3369
                    motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3370
                    motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3371
                    break;
3372
                case MB_TYPE_FORWARD:
3373
                    s->mv_dir = MV_DIR_FORWARD;
3374
                    s->mb_intra= 0;
3375
                    motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3376
                    motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3377
//                    printf(" %d %d ", motion_x, motion_y);
3378
                    break;
3379
                default:
3380
                    motion_x=motion_y=0; //gcc warning fix
3381
                    printf("illegal MB type\n");
3382
                }
3383

    
3384
                encode_mb(s, motion_x, motion_y);
3385

    
3386
                // RAL: Update last macrobloc type
3387
                s->last_mv_dir = s->mv_dir;
3388
            }
3389

    
3390
            /* clean the MV table in IPS frames for direct mode in B frames */
3391
            if(s->mb_intra /* && I,P,S_TYPE */){
3392
                s->p_mv_table[xy][0]=0;
3393
                s->p_mv_table[xy][1]=0;
3394
            }
3395

    
3396
            MPV_decode_mb(s, s->block);
3397
            
3398
            if(s->flags&CODEC_FLAG_PSNR){
3399
                int w= 16;
3400
                int h= 16;
3401

    
3402
                if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3403
                if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3404

    
3405
                s->current_picture_ptr->error[0] += sse(
3406
                    s,
3407
                    s->new_picture    .data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3408
                    s->current_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3409
                    w, h, s->linesize);
3410
                s->current_picture_ptr->error[1] += sse(
3411
                    s,
3412
                    s->new_picture    .data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3413
                    s->current_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3414
                    w>>1, h>>1, s->uvlinesize);
3415
                s->current_picture_ptr->error[2] += sse(
3416
                    s,
3417
                    s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3418
                    s->current_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3419
                    w>>1, h>>1, s->uvlinesize);
3420
            }
3421
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_width, get_bit_count(&s->pb));
3422
        }
3423
    }
3424
    emms_c();
3425

    
3426
#ifdef CONFIG_RISKY
3427
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3428
        ff_mpeg4_merge_partitions(s);
3429

    
3430
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
3431
        msmpeg4_encode_ext_header(s);
3432

    
3433
    if(s->codec_id==CODEC_ID_MPEG4) 
3434
        ff_mpeg4_stuffing(&s->pb);
3435
#endif
3436

    
3437
    //if (s->gob_number)
3438
    //    fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
3439
    
3440
    /* Send the last GOB if RTP */    
3441
    if (s->rtp_mode) {
3442
        flush_put_bits(&s->pb);
3443
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
3444
        /* Call the RTP callback to send the last GOB */
3445
        if (s->rtp_callback)
3446
            s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
3447
        s->ptr_lastgob = pbBufPtr(&s->pb);
3448
        //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
3449
    }
3450
}
3451

    
3452
static int dct_quantize_trellis_c(MpegEncContext *s, 
3453
                        DCTELEM *block, int n,
3454
                        int qscale, int *overflow){
3455
    const int *qmat;
3456
    const uint8_t *scantable= s->intra_scantable.scantable;
3457
    int max=0;
3458
    unsigned int threshold1, threshold2;
3459
    int bias=0;
3460
    int run_tab[65];
3461
    int level_tab[65];
3462
    int score_tab[65];
3463
    int last_run=0;
3464
    int last_level=0;
3465
    int last_score= 0;
3466
    int last_i= 0;
3467
    int coeff[3][64];
3468
    int coeff_count[64];
3469
    int lambda, qmul, qadd, start_i, last_non_zero, i;
3470
    const int esc_length= s->ac_esc_length;
3471
    uint8_t * length;
3472
    uint8_t * last_length;
3473
    int score_limit=0;
3474
    int left_limit= 0;
3475
        
3476
    s->dsp.fdct (block);
3477

    
3478
    qmul= qscale*16;
3479
    qadd= ((qscale-1)|1)*8;
3480

    
3481
    if (s->mb_intra) {
3482
        int q;
3483
        if (!s->h263_aic) {
3484
            if (n < 4)
3485
                q = s->y_dc_scale;
3486
            else
3487
                q = s->c_dc_scale;
3488
            q = q << 3;
3489
        } else{
3490
            /* For AIC we skip quant/dequant of INTRADC */
3491
            q = 1 << 3;
3492
            qadd=0;
3493
        }
3494
            
3495
        /* note: block[0] is assumed to be positive */
3496
        block[0] = (block[0] + (q >> 1)) / q;
3497
        start_i = 1;
3498
        last_non_zero = 0;
3499
        qmat = s->q_intra_matrix[qscale];
3500
        if(s->mpeg_quant || s->codec_id== CODEC_ID_MPEG1VIDEO)
3501
            bias= 1<<(QMAT_SHIFT-1);
3502
        length     = s->intra_ac_vlc_length;
3503
        last_length= s->intra_ac_vlc_last_length;
3504
    } else {
3505
        start_i = 0;
3506
        last_non_zero = -1;
3507
        qmat = s->q_inter_matrix[qscale];
3508
        length     = s->inter_ac_vlc_length;
3509
        last_length= s->inter_ac_vlc_last_length;
3510
    }
3511

    
3512
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
3513
    threshold2= (threshold1<<1);
3514

    
3515
    for(i=start_i; i<64; i++) {
3516
        const int j = scantable[i];
3517
        const int k= i-start_i;
3518
        int level = block[j];
3519
        level = level * qmat[j];
3520

    
3521
//        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
3522
//           || bias-level >= (1<<(QMAT_SHIFT - 3))){
3523
        if(((unsigned)(level+threshold1))>threshold2){
3524
            if(level>0){
3525
                level= (bias + level)>>QMAT_SHIFT;
3526
                coeff[0][k]= level;
3527
                coeff[1][k]= level-1;
3528
//                coeff[2][k]= level-2;
3529
            }else{
3530
                level= (bias - level)>>QMAT_SHIFT;
3531
                coeff[0][k]= -level;
3532
                coeff[1][k]= -level+1;
3533
//                coeff[2][k]= -level+2;
3534
            }
3535
            coeff_count[k]= FFMIN(level, 2);
3536
            max |=level;
3537
            last_non_zero = i;
3538
        }else{
3539
            coeff[0][k]= (level>>31)|1;
3540
            coeff_count[k]= 1;
3541
        }
3542
    }
3543
    
3544
    *overflow= s->max_qcoeff < max; //overflow might have happend
3545
    
3546
    if(last_non_zero < start_i){
3547
        memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3548
        return last_non_zero;
3549
    }
3550

    
3551
    lambda= (qscale*qscale*64*105 + 64)>>7; //FIXME finetune
3552
        
3553
    score_tab[0]= 0;
3554
    for(i=0; i<=last_non_zero - start_i; i++){
3555
        int level_index, run, j;
3556
        const int dct_coeff= block[ scantable[i + start_i] ];
3557
        const int zero_distoration= dct_coeff*dct_coeff;
3558
        int best_score=256*256*256*120;
3559

    
3560
        last_score += zero_distoration;
3561
        for(level_index=0; level_index < coeff_count[i]; level_index++){
3562
            int distoration;
3563
            int level= coeff[level_index][i];
3564
            int unquant_coeff;
3565
            
3566
            assert(level);
3567

    
3568
            if(s->out_format == FMT_H263){
3569
                if(level>0){
3570
                    unquant_coeff= level*qmul + qadd;
3571
                }else{
3572
                    unquant_coeff= level*qmul - qadd;
3573
                }
3574
            }else{ //MPEG1
3575
                j= s->dsp.idct_permutation[ scantable[i + start_i] ]; //FIXME optimize
3576
                if(s->mb_intra){
3577
                    if (level < 0) {
3578
                        unquant_coeff = (int)((-level) * qscale * s->intra_matrix[j]) >> 3;
3579
                        unquant_coeff = -((unquant_coeff - 1) | 1);
3580
                    } else {
3581
                        unquant_coeff = (int)(  level  * qscale * s->intra_matrix[j]) >> 3;
3582
                        unquant_coeff =   (unquant_coeff - 1) | 1;
3583
                    }
3584
                }else{
3585
                    if (level < 0) {
3586
                        unquant_coeff = ((((-level) << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3587
                        unquant_coeff = -((unquant_coeff - 1) | 1);
3588
                    } else {
3589
                        unquant_coeff = (((  level  << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3590
                        unquant_coeff =   (unquant_coeff - 1) | 1;
3591
                    }
3592
                }
3593
                unquant_coeff<<= 3;
3594
            }
3595

    
3596
            distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff);
3597
            level+=64;
3598
            if((level&(~127)) == 0){
3599
                for(run=0; run<=i - left_limit; run++){
3600
                    int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3601
                    score += score_tab[i-run];
3602
                    
3603
                    if(score < best_score){
3604
                        best_score= 
3605
                        score_tab[i+1]= score;
3606
                        run_tab[i+1]= run;
3607
                        level_tab[i+1]= level-64;
3608
                    }
3609
                }
3610

    
3611
                if(s->out_format == FMT_H263){
3612
                    for(run=0; run<=i - left_limit; run++){
3613
                        int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3614
                        score += score_tab[i-run];
3615
                        if(score < last_score){
3616
                            last_score= score;
3617
                            last_run= run;
3618
                            last_level= level-64;
3619
                            last_i= i+1;
3620
                        }
3621
                    }
3622
                }
3623
            }else{
3624
                distoration += esc_length*lambda;
3625
                for(run=0; run<=i - left_limit; run++){
3626
                    int score= distoration + score_tab[i-run];
3627
                    
3628
                    if(score < best_score){
3629
                        best_score= 
3630
                        score_tab[i+1]= score;
3631
                        run_tab[i+1]= run;
3632
                        level_tab[i+1]= level-64;
3633
                    }
3634
                }
3635

    
3636
                if(s->out_format == FMT_H263){
3637
                    for(run=0; run<=i - left_limit; run++){
3638
                        int score= distoration + score_tab[i-run];
3639
                        if(score < last_score){
3640
                            last_score= score;
3641
                            last_run= run;
3642
                            last_level= level-64;
3643
                            last_i= i+1;
3644
                        }
3645
                    }
3646
                }
3647
            }
3648
        }
3649

    
3650
        for(j=left_limit; j<=i; j++){
3651
            score_tab[j] += zero_distoration;
3652
        }
3653
        score_limit+= zero_distoration;
3654
        if(score_tab[i+1] < score_limit)
3655
            score_limit= score_tab[i+1];
3656
        
3657
        //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3658
        while(score_tab[ left_limit ] > score_limit + lambda) left_limit++;
3659
    }
3660

    
3661
        //FIXME add some cbp penalty
3662

    
3663
    if(s->out_format != FMT_H263){
3664
        last_score= 256*256*256*120;
3665
        for(i= left_limit; i<=last_non_zero - start_i + 1; i++){
3666
            int score= score_tab[i];
3667
            if(i) score += lambda*2; //FIXME exacter?
3668

    
3669
            if(score < last_score){
3670
                last_score= score;
3671
                last_i= i;
3672
                last_level= level_tab[i];
3673
                last_run= run_tab[i];
3674
            }
3675
        }
3676
    }
3677
    
3678
    last_non_zero= last_i - 1 + start_i;
3679
    memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3680
    
3681
    if(last_non_zero < start_i)
3682
        return last_non_zero;
3683
    
3684
    i= last_i;
3685
    assert(last_level);
3686
//FIXME use permutated scantable
3687
    block[ s->dsp.idct_permutation[ scantable[last_non_zero] ] ]= last_level;
3688
    i -= last_run + 1;
3689
    
3690
    for(;i>0 ; i -= run_tab[i] + 1){
3691
        const int j= s->dsp.idct_permutation[ scantable[i - 1 + start_i] ];
3692
    
3693
        block[j]= level_tab[i];
3694
        assert(block[j]);
3695
    }
3696

    
3697
    return last_non_zero;
3698
}
3699

    
3700
static int dct_quantize_c(MpegEncContext *s, 
3701
                        DCTELEM *block, int n,
3702
                        int qscale, int *overflow)
3703
{
3704
    int i, j, level, last_non_zero, q;
3705
    const int *qmat;
3706
    const uint8_t *scantable= s->intra_scantable.scantable;
3707
    int bias;
3708
    int max=0;
3709
    unsigned int threshold1, threshold2;
3710

    
3711
    s->dsp.fdct (block);
3712

    
3713
    if (s->mb_intra) {
3714
        if (!s->h263_aic) {
3715
            if (n < 4)
3716
                q = s->y_dc_scale;
3717
            else
3718
                q = s->c_dc_scale;
3719
            q = q << 3;
3720
        } else
3721
            /* For AIC we skip quant/dequant of INTRADC */
3722
            q = 1 << 3;
3723
            
3724
        /* note: block[0] is assumed to be positive */
3725
        block[0] = (block[0] + (q >> 1)) / q;
3726
        i = 1;
3727
        last_non_zero = 0;
3728
        qmat = s->q_intra_matrix[qscale];
3729
        bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
3730
    } else {
3731
        i = 0;
3732
        last_non_zero = -1;
3733
        qmat = s->q_inter_matrix[qscale];
3734
        bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
3735
    }
3736
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
3737
    threshold2= (threshold1<<1);
3738

    
3739
    for(;i<64;i++) {
3740
        j = scantable[i];
3741
        level = block[j];
3742
        level = level * qmat[j];
3743

    
3744
//        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
3745
//           || bias-level >= (1<<(QMAT_SHIFT - 3))){
3746
        if(((unsigned)(level+threshold1))>threshold2){
3747
            if(level>0){
3748
                level= (bias + level)>>QMAT_SHIFT;
3749
                block[j]= level;
3750
            }else{
3751
                level= (bias - level)>>QMAT_SHIFT;
3752
                block[j]= -level;
3753
            }
3754
            max |=level;
3755
            last_non_zero = i;
3756
        }else{
3757
            block[j]=0;
3758
        }
3759
    }
3760
    *overflow= s->max_qcoeff < max; //overflow might have happend
3761
    
3762
    /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
3763
    if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
3764
        ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
3765

    
3766
    return last_non_zero;
3767
}
3768

    
3769
#endif //CONFIG_ENCODERS
3770

    
3771
static void dct_unquantize_mpeg1_c(MpegEncContext *s, 
3772
                                   DCTELEM *block, int n, int qscale)
3773
{
3774
    int i, level, nCoeffs;
3775
    const uint16_t *quant_matrix;
3776

    
3777
    nCoeffs= s->block_last_index[n];
3778
    
3779
    if (s->mb_intra) {
3780
        if (n < 4) 
3781
            block[0] = block[0] * s->y_dc_scale;
3782
        else
3783
            block[0] = block[0] * s->c_dc_scale;
3784
        /* XXX: only mpeg1 */
3785
        quant_matrix = s->intra_matrix;
3786
        for(i=1;i<=nCoeffs;i++) {
3787
            int j= s->intra_scantable.permutated[i];
3788
            level = block[j];
3789
            if (level) {
3790
                if (level < 0) {
3791
                    level = -level;
3792
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3793
                    level = (level - 1) | 1;
3794
                    level = -level;
3795
                } else {
3796
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3797
                    level = (level - 1) | 1;
3798
                }
3799
#ifdef PARANOID
3800
                if (level < -2048 || level > 2047)
3801
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3802
#endif
3803
                block[j] = level;
3804
            }
3805
        }
3806
    } else {
3807
        i = 0;
3808
        quant_matrix = s->inter_matrix;
3809
        for(;i<=nCoeffs;i++) {
3810
            int j= s->intra_scantable.permutated[i];
3811
            level = block[j];
3812
            if (level) {
3813
                if (level < 0) {
3814
                    level = -level;
3815
                    level = (((level << 1) + 1) * qscale *
3816
                             ((int) (quant_matrix[j]))) >> 4;
3817
                    level = (level - 1) | 1;
3818
                    level = -level;
3819
                } else {
3820
                    level = (((level << 1) + 1) * qscale *
3821
                             ((int) (quant_matrix[j]))) >> 4;
3822
                    level = (level - 1) | 1;
3823
                }
3824
#ifdef PARANOID
3825
                if (level < -2048 || level > 2047)
3826
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3827
#endif
3828
                block[j] = level;
3829
            }
3830
        }
3831
    }
3832
}
3833

    
3834
static void dct_unquantize_mpeg2_c(MpegEncContext *s, 
3835
                                   DCTELEM *block, int n, int qscale)
3836
{
3837
    int i, level, nCoeffs;
3838
    const uint16_t *quant_matrix;
3839

    
3840
    if(s->alternate_scan) nCoeffs= 63;
3841
    else nCoeffs= s->block_last_index[n];
3842
    
3843
    if (s->mb_intra) {
3844
        if (n < 4) 
3845
            block[0] = block[0] * s->y_dc_scale;
3846
        else
3847
            block[0] = block[0] * s->c_dc_scale;
3848
        quant_matrix = s->intra_matrix;
3849
        for(i=1;i<=nCoeffs;i++) {
3850
            int j= s->intra_scantable.permutated[i];
3851
            level = block[j];
3852
            if (level) {
3853
                if (level < 0) {
3854
                    level = -level;
3855
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3856
                    level = -level;
3857
                } else {
3858
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3859
                }
3860
#ifdef PARANOID
3861
                if (level < -2048 || level > 2047)
3862
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3863
#endif
3864
                block[j] = level;
3865
            }
3866
        }
3867
    } else {
3868
        int sum=-1;
3869
        i = 0;
3870
        quant_matrix = s->inter_matrix;
3871
        for(;i<=nCoeffs;i++) {
3872
            int j= s->intra_scantable.permutated[i];
3873
            level = block[j];
3874
            if (level) {
3875
                if (level < 0) {
3876
                    level = -level;
3877
                    level = (((level << 1) + 1) * qscale *
3878
                             ((int) (quant_matrix[j]))) >> 4;
3879
                    level = -level;
3880
                } else {
3881
                    level = (((level << 1) + 1) * qscale *
3882
                             ((int) (quant_matrix[j]))) >> 4;
3883
                }
3884
#ifdef PARANOID
3885
                if (level < -2048 || level > 2047)
3886
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3887
#endif
3888
                block[j] = level;
3889
                sum+=level;
3890
            }
3891
        }
3892
        block[63]^=sum&1;
3893
    }
3894
}
3895

    
3896

    
3897
static void dct_unquantize_h263_c(MpegEncContext *s, 
3898
                                  DCTELEM *block, int n, int qscale)
3899
{
3900
    int i, level, qmul, qadd;
3901
    int nCoeffs;
3902
    
3903
    assert(s->block_last_index[n]>=0);
3904
    
3905
    qadd = (qscale - 1) | 1;
3906
    qmul = qscale << 1;
3907
    
3908
    if (s->mb_intra) {
3909
        if (!s->h263_aic) {
3910
            if (n < 4) 
3911
                block[0] = block[0] * s->y_dc_scale;
3912
            else
3913
                block[0] = block[0] * s->c_dc_scale;
3914
        }else
3915
            qadd = 0;
3916
        i = 1;
3917
        nCoeffs= 63; //does not allways use zigzag table 
3918
    } else {
3919
        i = 0;
3920
        nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
3921
    }
3922

    
3923
    for(;i<=nCoeffs;i++) {
3924
        level = block[i];
3925
        if (level) {
3926
            if (level < 0) {
3927
                level = level * qmul - qadd;
3928
            } else {
3929
                level = level * qmul + qadd;
3930
            }
3931
#ifdef PARANOID
3932
                if (level < -2048 || level > 2047)
3933
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3934
#endif
3935
            block[i] = level;
3936
        }
3937
    }
3938
}
3939

    
3940

    
3941
char ff_get_pict_type_char(int pict_type){
3942
    switch(pict_type){
3943
    case I_TYPE: return 'I'; 
3944
    case P_TYPE: return 'P'; 
3945
    case B_TYPE: return 'B'; 
3946
    case S_TYPE: return 'S'; 
3947
    default:     return '?';
3948
    }
3949
}
3950

    
3951
static const AVOption mpeg4_options[] =
3952
{
3953
    AVOPTION_CODEC_INT("bitrate", "desired video bitrate", bit_rate, 4, 240000000, 800000),
3954
    AVOPTION_CODEC_FLAG("vhq", "very high quality", flags, CODEC_FLAG_HQ, 0),
3955
    AVOPTION_CODEC_INT("ratetol", "number of bits the bitstream is allowed to diverge from the reference"
3956
                       "the reference can be CBR (for CBR pass1) or VBR (for pass2)",
3957
                       bit_rate_tolerance, 4, 240000000, 8000),
3958
    AVOPTION_CODEC_INT("qmin", "minimum quantizer", qmin, 1, 31, 2),
3959
    AVOPTION_CODEC_INT("qmax", "maximum quantizer", qmax, 1, 31, 31),
3960
    AVOPTION_CODEC_STRING("rc_eq", "rate control equation",
3961
                          rc_eq, "tex^qComp,option1,options2", 0),
3962
    AVOPTION_CODEC_INT("rc_minrate", "rate control minimum bitrate",
3963
                       rc_min_rate, 4, 24000000, 0),
3964
    AVOPTION_CODEC_INT("rc_maxrate", "rate control maximum bitrate",
3965
                       rc_max_rate, 4, 24000000, 0),
3966
    AVOPTION_CODEC_DOUBLE("rc_buf_aggresivity", "rate control buffer aggresivity",
3967
                          rc_buffer_aggressivity, 4, 24000000, 0),
3968
    AVOPTION_CODEC_DOUBLE("rc_initial_cplx", "initial complexity for pass1 ratecontrol",
3969
                          rc_initial_cplx, 0., 9999999., 0),
3970
    AVOPTION_CODEC_DOUBLE("i_quant_factor", "qscale factor between p and i frames",
3971
                          i_quant_factor, 0., 0., 0),
3972
    AVOPTION_CODEC_DOUBLE("i_quant_offset", "qscale offset between p and i frames",
3973
                          i_quant_factor, -999999., 999999., 0),
3974
    AVOPTION_CODEC_INT("dct_algo", "dct alghorithm",
3975
                       dct_algo, 0, 5, 0), // fixme - "Auto,FastInt,Int,MMX,MLib,Altivec"
3976
    AVOPTION_CODEC_DOUBLE("lumi_masking", "luminance masking",
3977
                          lumi_masking, 0., 999999., 0),
3978
    AVOPTION_CODEC_DOUBLE("temporal_cplx_masking", "temporary complexity masking",
3979
                          temporal_cplx_masking, 0., 999999., 0),
3980
    AVOPTION_CODEC_DOUBLE("spatial_cplx_masking", "spatial complexity masking",
3981
                          spatial_cplx_masking, 0., 999999., 0),
3982
    AVOPTION_CODEC_DOUBLE("p_masking", "p block masking",
3983
                          p_masking, 0., 999999., 0),
3984
    AVOPTION_CODEC_DOUBLE("dark_masking", "darkness masking",
3985
                          dark_masking, 0., 999999., 0),
3986
    AVOPTION_CODEC_INT("idct_algo", "idct alghorithm",
3987
                       idct_algo, 0, 8, 0), // fixme - "Auto,Int,Simple,SimpleMMX,LibMPEG2MMX,PS2,MLib,ARM,Altivec"
3988

    
3989
    AVOPTION_CODEC_INT("mb_qmin", "minimum MB quantizer",
3990
                       mb_qmin, 0, 8, 0),
3991
    AVOPTION_CODEC_INT("mb_qmax", "maximum MB quantizer",
3992
                       mb_qmin, 0, 8, 0),
3993

    
3994
    AVOPTION_CODEC_INT("me_cmp", "ME compare function",
3995
                       me_cmp, 0, 24000000, 0),
3996
    AVOPTION_CODEC_INT("me_sub_cmp", "subpixel ME compare function",
3997
                       me_sub_cmp, 0, 24000000, 0),
3998

    
3999

    
4000
    AVOPTION_CODEC_INT("dia_size", "ME diamond size & shape",
4001
                       dia_size, 0, 24000000, 0),
4002
    AVOPTION_CODEC_INT("last_predictor_count", "amount of previous MV predictors",
4003
                       last_predictor_count, 0, 24000000, 0),
4004

    
4005
    AVOPTION_CODEC_INT("pre_me", "pre pass for ME",
4006
                       pre_me, 0, 24000000, 0),
4007
    AVOPTION_CODEC_INT("me_pre_cmp", "ME pre pass compare function",
4008
                       me_pre_cmp, 0, 24000000, 0),
4009

    
4010
    AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4011
                       me_range, 0, 24000000, 0),
4012
    AVOPTION_CODEC_INT("pre_dia_size", "ME pre pass diamod size & shape",
4013
                       pre_dia_size, 0, 24000000, 0),
4014
    AVOPTION_CODEC_INT("me_subpel_quality", "subpel ME quality",
4015
                       me_subpel_quality, 0, 24000000, 0),
4016
    AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4017
                       me_range, 0, 24000000, 0),
4018
    AVOPTION_CODEC_FLAG("psnr", "calculate PSNR of compressed frames",
4019
                        flags, CODEC_FLAG_PSNR, 0),
4020
    AVOPTION_CODEC_RCOVERRIDE("rc_override", "ratecontrol override (=startframe,endframe,qscale,quality_factor)",
4021
                              rc_override),
4022
    AVOPTION_SUB(avoptions_common),
4023
    AVOPTION_END()
4024
};
4025

    
4026
#ifdef CONFIG_ENCODERS
4027

    
4028
AVCodec mpeg1video_encoder = {
4029
    "mpeg1video",
4030
    CODEC_TYPE_VIDEO,
4031
    CODEC_ID_MPEG1VIDEO,
4032
    sizeof(MpegEncContext),
4033
    MPV_encode_init,
4034
    MPV_encode_picture,
4035
    MPV_encode_end,
4036
};
4037

    
4038
#ifdef CONFIG_RISKY
4039

    
4040
AVCodec h263_encoder = {
4041
    "h263",
4042
    CODEC_TYPE_VIDEO,
4043
    CODEC_ID_H263,
4044
    sizeof(MpegEncContext),
4045
    MPV_encode_init,
4046
    MPV_encode_picture,
4047
    MPV_encode_end,
4048
};
4049

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

    
4060
AVCodec rv10_encoder = {
4061
    "rv10",
4062
    CODEC_TYPE_VIDEO,
4063
    CODEC_ID_RV10,
4064
    sizeof(MpegEncContext),
4065
    MPV_encode_init,
4066
    MPV_encode_picture,
4067
    MPV_encode_end,
4068
};
4069

    
4070
AVCodec mpeg4_encoder = {
4071
    "mpeg4",
4072
    CODEC_TYPE_VIDEO,
4073
    CODEC_ID_MPEG4,
4074
    sizeof(MpegEncContext),
4075
    MPV_encode_init,
4076
    MPV_encode_picture,
4077
    MPV_encode_end,
4078
    .options = mpeg4_options,
4079
};
4080

    
4081
AVCodec msmpeg4v1_encoder = {
4082
    "msmpeg4v1",
4083
    CODEC_TYPE_VIDEO,
4084
    CODEC_ID_MSMPEG4V1,
4085
    sizeof(MpegEncContext),
4086
    MPV_encode_init,
4087
    MPV_encode_picture,
4088
    MPV_encode_end,
4089
    .options = mpeg4_options,
4090
};
4091

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

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

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

    
4125
#endif
4126

    
4127
AVCodec mjpeg_encoder = {
4128
    "mjpeg",
4129
    CODEC_TYPE_VIDEO,
4130
    CODEC_ID_MJPEG,
4131
    sizeof(MpegEncContext),
4132
    MPV_encode_init,
4133
    MPV_encode_picture,
4134
    MPV_encode_end,
4135
};
4136

    
4137
#endif //CONFIG_ENCODERS
4138