Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 9f2e61b6

History | View | Annotate | Download (144 KB)

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

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

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

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

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

    
57

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

    
61
//#define DEBUG
62

    
63

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
210
#endif //CONFIG_ENCODERS
211

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
466

    
467
//extern int sads;
468

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

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

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

    
511
#ifdef CONFIG_ENCODERS
512

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

    
519
    avctx->pix_fmt = PIX_FMT_YUV420P;
520

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

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

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

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

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

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

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

    
720
    s->encoding = 1;
721

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

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

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

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

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

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

    
776
    return 0;
777
}
778

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

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

    
787
    ff_rate_control_uninit(s);
788

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

    
796
#endif //CONFIG_ENCODERS
797

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

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

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

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

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

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

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

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

    
891
    s->mb_skiped = 0;
892

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

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

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

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

    
926
    s->current_picture_ptr->pict_type= s->pict_type;
927
    s->current_picture_ptr->quality= s->qscale;
928

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

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

    
972
    return 0;
973
}
974

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

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

    
1025
    // clear copies, to avoid confusion
1026
#if 0
1027
    memset(&s->last_picture, 0, sizeof(Picture));
1028
    memset(&s->next_picture, 0, sizeof(Picture));
1029
    memset(&s->current_picture, 0, sizeof(Picture));
1030
#endif
1031
}
1032

    
1033
#ifdef CONFIG_ENCODERS
1034

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

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

    
1068

    
1069
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1070
    AVFrame *pic;
1071
    int i;
1072
    const int encoding_delay= s->max_b_frames;
1073
    int direct=1;
1074

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

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

    
1096
        pic= (AVFrame*)&s->picture[i];
1097
        pic->reference= 3;
1098

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

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

    
1145
    /* shift buffer entries */
1146
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1147
        s->input_picture[i-1]= s->input_picture[i];
1148
        
1149
    s->input_picture[encoding_delay]= (Picture*)pic;
1150

    
1151
    return 0;
1152
}
1153

    
1154
static void select_input_picture(MpegEncContext *s){
1155
    int i;
1156
    const int encoding_delay= s->max_b_frames;
1157
    int coded_pic_num=0;    
1158

    
1159
    if(s->reordered_input_picture[0])
1160
        coded_pic_num= s->reordered_input_picture[0]->coded_picture_number + 1;
1161

    
1162
    for(i=1; i<MAX_PICTURE_COUNT; i++)
1163
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1164
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1165

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

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

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

    
1244
        s->new_picture= *s->reordered_input_picture[0];
1245

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

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

    
1265
            s->current_picture_ptr= pic;
1266
        }else{
1267
            // input is not a shared pix -> reuse buffer for current_pix
1268

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

    
1287
int MPV_encode_picture(AVCodecContext *avctx,
1288
                       unsigned char *buf, int buf_size, void *data)
1289
{
1290
    MpegEncContext *s = avctx->priv_data;
1291
    AVFrame *pic_arg = data;
1292
    int i;
1293

    
1294
    init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
1295

    
1296
    s->picture_in_gop_number++;
1297

    
1298
    load_input_picture(s, pic_arg);
1299
    
1300
    select_input_picture(s);
1301
    
1302
    /* output? */
1303
    if(s->new_picture.data[0]){
1304

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

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

    
1326
        MPV_frame_end(s);
1327

    
1328
        if (s->out_format == FMT_MJPEG)
1329
            mjpeg_picture_trailer(s);
1330
        
1331
        if(s->flags&CODEC_FLAG_PASS1)
1332
            ff_write_pass1_stats(s);
1333

    
1334
        for(i=0; i<4; i++){
1335
            avctx->error[i] += s->current_picture_ptr->error[i];
1336
        }
1337
    }
1338

    
1339
    s->input_picture_number++;
1340

    
1341
    flush_put_bits(&s->pb);
1342
    s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1343
    
1344
    s->total_bits += s->frame_bits;
1345
    avctx->frame_bits  = s->frame_bits;
1346
    
1347
    return pbBufPtr(&s->pb) - s->pb.buf;
1348
}
1349

    
1350
#endif //CONFIG_ENCODERS
1351

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

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

    
1375
    linesize = s->linesize;
1376
    uvlinesize = s->uvlinesize;
1377
    
1378
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1379

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

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

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

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

    
1450
    linesize = s->linesize;
1451
    uvlinesize = s->uvlinesize;
1452

    
1453
    ptr = ref_picture[0] + src_offset;
1454

    
1455
    dest_y+=dest_offset;
1456
    
1457
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
1458
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
1459

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

    
1475
    if(s->flags&CODEC_FLAG_GRAY) return;
1476

    
1477

    
1478
    dest_cb+=dest_offset>>1;
1479
    dest_cr+=dest_offset>>1;
1480
    
1481
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
1482
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
1483

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

    
1503

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

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

    
1525
    start_y= FFMAX(0, -src_y);
1526
    start_x= FFMAX(0, -src_x);
1527
    end_y= FFMIN(block_h, h-src_y);
1528
    end_x= FFMIN(block_w, w-src_x);
1529

    
1530
    // copy existing part
1531
    for(y=start_y; y<end_y; y++){
1532
        for(x=start_x; x<end_x; x++){
1533
            buf[x + y*linesize]= src[x + y*linesize];
1534
        }
1535
    }
1536

    
1537
    //top
1538
    for(y=0; y<start_y; y++){
1539
        for(x=start_x; x<end_x; x++){
1540
            buf[x + y*linesize]= buf[x + start_y*linesize];
1541
        }
1542
    }
1543

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

    
1564

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

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

    
1612
    if(s->flags&CODEC_FLAG_GRAY) return;
1613

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

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

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

    
1668
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1669
    src_x = s->mb_x * 16 + (motion_x >> 2);
1670
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
1671

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

    
1704
    if(s->flags&CODEC_FLAG_GRAY) return;
1705

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

    
1723
    dxy= (mx&1) | ((my&1)<<1);
1724
    mx>>=1;
1725
    my>>=1;
1726

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

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

    
1754
inline int ff_h263_round_chroma(int x){
1755
    if (x >= 0)
1756
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
1757
    else {
1758
        x = -x;
1759
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
1760
    }
1761
}
1762

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

    
1773
    mb_x = s->mb_x;
1774
    mb_y = s->mb_y;
1775

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

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

    
1836
                mx += s->mv[dir][i][0]/2;
1837
                my += s->mv[dir][i][1]/2;
1838
            }
1839
        }else{
1840
            for(i=0;i<4;i++) {
1841
                motion_x = s->mv[dir][i][0];
1842
                motion_y = s->mv[dir][i][1];
1843

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

    
1867
                mx += s->mv[dir][i][0];
1868
                my += s->mv[dir][i][1];
1869
            }
1870
        }
1871

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

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

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

    
1943
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1944
                        ref_picture, offset,
1945
                        0, pix_op,
1946
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1947
        }
1948
        break;
1949
    }
1950
}
1951

    
1952

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

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

    
1970
static inline void add_dequant_dct(MpegEncContext *s, 
1971
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
1972
{
1973
    if (s->block_last_index[i] >= 0) {
1974
        s->dct_unquantize(s, block, i, s->qscale);
1975

    
1976
        s->dsp.idct_add (dest, line_size, block);
1977
    }
1978
}
1979

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

    
2013
/* generic function called after a macroblock has been parsed by the
2014
   decoder or after it has been encoded by the encoder.
2015

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

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

    
2031
    s->current_picture.qscale_table[mb_xy]= s->qscale;
2032

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

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

    
2099
        /* avoid copy if macroblock skipped in last frame too */
2100
        if (s->pict_type != B_TYPE) {
2101
            s->current_picture.mbskip_table[mb_xy]= s->mb_skiped;
2102
        }
2103

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

    
2109
            assert(age);
2110

    
2111
            if (s->mb_skiped) {
2112
                s->mb_skiped= 0;
2113
                assert(s->pict_type!=I_TYPE);
2114
 
2115
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
2116
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2117

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

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

    
2141
        if (s->interlaced_dct) {
2142
            dct_linesize = linesize * 2;
2143
            dct_offset = linesize;
2144
        } else {
2145
            dct_linesize = linesize;
2146
            dct_offset = linesize * 8;
2147
        }
2148

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

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

    
2171
            /* skip dequant / idct if we are really late ;) */
2172
            if(s->hurry_up>1) return;
2173

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

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

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

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

    
2220
                if(!(s->flags&CODEC_FLAG_GRAY)){
2221
                    s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2222
                    s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2223
                }
2224
            }
2225
        }
2226
    }
2227
}
2228

    
2229
#ifdef CONFIG_ENCODERS
2230

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

    
2249
    if(threshold<0){
2250
        skip_dc=0;
2251
        threshold= -threshold;
2252
    }else
2253
        skip_dc=1;
2254

    
2255
    /* are all which we could set to zero are allready zero? */
2256
    if(last_index<=skip_dc - 1) return;
2257

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

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

    
2298
        block[j]= level;
2299
    }
2300
}
2301

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

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

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

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

    
2365
#endif
2366

    
2367
#endif //CONFIG_ENCODERS
2368

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

    
2380
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME)
2381
            offset = 0;
2382
        else
2383
            offset = y * s->linesize;
2384

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

    
2396
        s->avctx->draw_horiz_band(s->avctx, src_ptr, s->linesize,
2397
                               y, s->width, h);
2398
    }
2399
}
2400

    
2401
#ifdef CONFIG_ENCODERS
2402

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

    
2416
        if(s->out_format==FMT_H263){
2417
            if     (s->dquant> 2) s->dquant= 2;
2418
            else if(s->dquant<-2) s->dquant=-2;
2419
        }
2420
            
2421
        if(s->codec_id==CODEC_ID_MPEG4){        
2422
            if(!s->mb_intra){
2423
                if(s->mv_dir&MV_DIRECT)
2424
                    s->dquant=0;
2425

    
2426
                assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
2427
            }
2428
        }
2429
        s->qscale+= s->dquant;
2430
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2431
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2432
    }
2433

    
2434
    if (s->mb_intra) {
2435
        uint8_t *ptr;
2436
        int wrap_y;
2437
        int emu=0;
2438

    
2439
        wrap_y = s->linesize;
2440
        ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2441

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

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

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

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

    
2504
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
2505
            op_pix = s->dsp.put_pixels_tab;
2506
            op_qpix= s->dsp.put_qpel_pixels_tab;
2507
        }else{
2508
            op_pix = s->dsp.put_no_rnd_pixels_tab;
2509
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2510
        }
2511

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

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

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

    
2632
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
2633
        s->block_last_index[4]=
2634
        s->block_last_index[5]= 0;
2635
        s->block[4][0]=
2636
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
2637
    }
2638

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

    
2664
#endif //CONFIG_ENCODERS
2665

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

    
2675
    if(next==-1){
2676
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
2677

    
2678
        memcpy(&pc->buffer[pc->index], *buf, *buf_size);
2679
        pc->index += *buf_size;
2680
        return -1;
2681
    }
2682

    
2683
    if(pc->index){
2684
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
2685

    
2686
        memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
2687
        pc->index = 0;
2688
        *buf= pc->buffer;
2689
        *buf_size= pc->last_index + next;
2690
    }
2691

    
2692
    return 0;
2693
}
2694

    
2695
#ifdef CONFIG_ENCODERS
2696
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
2697
{
2698
    int bytes= length>>4;
2699
    int bits= length&15;
2700
    int i;
2701

    
2702
    if(length==0) return;
2703

    
2704
    for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
2705
    put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
2706
}
2707

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

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

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

    
2729
    d->mb_skiped= s->mb_skiped;
2730
    d->qscale= s->qscale;
2731
}
2732

    
2733
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2734
    int i;
2735

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

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

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

    
2778
    s->block= s->blocks[*next_block];
2779
    s->pb= pb[*next_block];
2780
    if(s->data_partitioning){
2781
        s->pb2   = pb2   [*next_block];
2782
        s->tex_pb= tex_pb[*next_block];
2783
    }
2784

    
2785
    encode_mb(s, motion_x, motion_y);
2786

    
2787
    bits_count= get_bit_count(&s->pb);
2788
    if(s->data_partitioning){
2789
        bits_count+= get_bit_count(&s->pb2);
2790
        bits_count+= get_bit_count(&s->tex_pb);
2791
    }
2792

    
2793
    if(bits_count<*dmin){
2794
        *dmin= bits_count;
2795
        *next_block^=1;
2796

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

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

    
2833
    for(i=0; i<2; i++){
2834
        init_put_bits(&pb    [i], bit_buf    [i], 3000, NULL, NULL);
2835
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000, NULL, NULL);
2836
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
2837
    }
2838

    
2839
    s->picture_number = picture_number;
2840

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

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

    
2879
                for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) {
2880
                    for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) {
2881
                        s->mb_x = mb_x;
2882
                        s->mb_y = mb_y;
2883
                        ff_pre_estimate_p_frame_motion(s, mb_x, mb_y);
2884
                    }
2885
                }
2886
                s->me.pre_pass=0;
2887
            }
2888
        }
2889

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

    
2930
                    s->current_picture.mb_var [s->mb_width * mb_y + mb_x] = varc;
2931
                    s->current_picture.mb_mean[s->mb_width * mb_y + mb_x] = (sum+128)>>8;
2932
                    s->current_picture.mb_var_sum    += varc;
2933
                }
2934
            }
2935
        }
2936
    }
2937
    emms_c();
2938

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

    
2945
    if(!s->umvplus){
2946
        if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
2947
            s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
2948
        
2949
            ff_fix_long_p_mvs(s);
2950
        }
2951

    
2952
        if(s->pict_type==B_TYPE){
2953
            int a, b;
2954

    
2955
            a = ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
2956
            b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, MB_TYPE_BIDIR);
2957
            s->f_code = FFMAX(a, b);
2958

    
2959
            a = ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
2960
            b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, MB_TYPE_BIDIR);
2961
            s->b_code = FFMAX(a, b);
2962

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

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

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

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

    
3008
    if(s->current_picture.key_frame)
3009
        s->picture_in_gop_number=0;
3010

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

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

    
3061
#ifdef CONFIG_RISKY
3062
    if (s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P)
3063
        s->gob_index = ff_h263_get_gob_height(s);
3064

    
3065
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3066
        ff_mpeg4_init_partitions(s);
3067
#endif
3068

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

    
3089
            s->mb_x = mb_x;
3090
            s->mb_y = mb_y;
3091
            s->block_index[0]+=2;
3092
            s->block_index[1]+=2;
3093
            s->block_index[2]+=2;
3094
            s->block_index[3]+=2;
3095
            s->block_index[4]++;
3096
            s->block_index[5]++;
3097

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

    
3110
                        if(s->partitioned_frame){
3111
                            ff_mpeg4_merge_partitions(s);
3112
                            ff_mpeg4_init_partitions(s);
3113
                        }
3114
                        ff_mpeg4_encode_video_packet_header(s);
3115

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

    
3140
                if(is_gob_start){
3141
                    s->ptr_lastgob = pbBufPtr(&s->pb);
3142
                    s->first_slice_line=1;
3143
                    s->resync_mb_x=mb_x;
3144
                    s->resync_mb_y=mb_y;
3145
                }
3146
            }
3147
#endif
3148

    
3149
            if(  (s->resync_mb_x   == s->mb_x)
3150
               && s->resync_mb_y+1 == s->mb_y){
3151
                s->first_slice_line=0; 
3152
            }
3153

    
3154
            if(mb_type & (mb_type-1)){ // more than 1 MB type possible
3155
                int next_block=0;
3156
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3157

    
3158
                copy_context_before_encode(&backup_s, s, -1);
3159
                backup_s.pb= s->pb;
3160
                best_s.data_partitioning= s->data_partitioning;
3161
                best_s.partitioned_frame= s->partitioned_frame;
3162
                if(s->data_partitioning){
3163
                    backup_s.pb2= s->pb2;
3164
                    backup_s.tex_pb= s->tex_pb;
3165
                }
3166

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

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

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

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

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

    
3408
                encode_mb(s, motion_x, motion_y);
3409

    
3410
                // RAL: Update last macrobloc type
3411
                s->last_mv_dir = s->mv_dir;
3412
            }
3413

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

    
3420
            MPV_decode_mb(s, s->block);
3421
            
3422
            if(s->flags&CODEC_FLAG_PSNR){
3423
                int w= 16;
3424
                int h= 16;
3425

    
3426
                if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3427
                if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3428

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

    
3450
#ifdef CONFIG_RISKY
3451
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3452
        ff_mpeg4_merge_partitions(s);
3453

    
3454
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
3455
        msmpeg4_encode_ext_header(s);
3456

    
3457
    if(s->codec_id==CODEC_ID_MPEG4) 
3458
        ff_mpeg4_stuffing(&s->pb);
3459
#endif
3460

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

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

    
3502
    qmul= qscale*16;
3503
    qadd= ((qscale-1)|1)*8;
3504

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

    
3536
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
3537
    threshold2= (threshold1<<1);
3538

    
3539
    for(i=start_i; i<64; i++) {
3540
        const int j = scantable[i];
3541
        const int k= i-start_i;
3542
        int level = block[j];
3543
        level = level * qmat[j];
3544

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

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

    
3584
        last_score += zero_distoration;
3585
        for(level_index=0; level_index < coeff_count[i]; level_index++){
3586
            int distoration;
3587
            int level= coeff[level_index][i];
3588
            int unquant_coeff;
3589
            
3590
            assert(level);
3591

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

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

    
3635
                if(s->out_format == FMT_H263){
3636
                    for(run=0; run<=i - left_limit; run++){
3637
                        int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3638
                        score += 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
            }else{
3648
                distoration += esc_length*lambda;
3649
                for(run=0; run<=i - left_limit; run++){
3650
                    int score= distoration + score_tab[i-run];
3651
                    
3652
                    if(score < best_score){
3653
                        best_score= 
3654
                        score_tab[i+1]= score;
3655
                        run_tab[i+1]= run;
3656
                        level_tab[i+1]= level-64;
3657
                    }
3658
                }
3659

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

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

    
3685
        //FIXME add some cbp penalty
3686

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

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

    
3721
    return last_non_zero;
3722
}
3723

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

    
3735
    s->dsp.fdct (block);
3736

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

    
3763
    for(;i<64;i++) {
3764
        j = scantable[i];
3765
        level = block[j];
3766
        level = level * qmat[j];
3767

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

    
3790
    return last_non_zero;
3791
}
3792

    
3793
#endif //CONFIG_ENCODERS
3794

    
3795
static void dct_unquantize_mpeg1_c(MpegEncContext *s, 
3796
                                   DCTELEM *block, int n, int qscale)
3797
{
3798
    int i, level, nCoeffs;
3799
    const uint16_t *quant_matrix;
3800

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

    
3858
static void dct_unquantize_mpeg2_c(MpegEncContext *s, 
3859
                                   DCTELEM *block, int n, int qscale)
3860
{
3861
    int i, level, nCoeffs;
3862
    const uint16_t *quant_matrix;
3863

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

    
3920

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

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

    
3964

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

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

    
4015
    AVOPTION_CODEC_INT("mb_qmin", "minimum MB quantizer",
4016
                       mb_qmin, 0, 8, 0),
4017
    AVOPTION_CODEC_INT("mb_qmax", "maximum MB quantizer",
4018
                       mb_qmin, 0, 8, 0),
4019

    
4020
    AVOPTION_CODEC_INT("me_cmp", "ME compare function",
4021
                       me_cmp, 0, 24000000, 0),
4022
    AVOPTION_CODEC_INT("me_sub_cmp", "subpixel ME compare function",
4023
                       me_sub_cmp, 0, 24000000, 0),
4024

    
4025

    
4026
    AVOPTION_CODEC_INT("dia_size", "ME diamond size & shape",
4027
                       dia_size, 0, 24000000, 0),
4028
    AVOPTION_CODEC_INT("last_predictor_count", "amount of previous MV predictors",
4029
                       last_predictor_count, 0, 24000000, 0),
4030

    
4031
    AVOPTION_CODEC_INT("pre_me", "pre pass for ME",
4032
                       pre_me, 0, 24000000, 0),
4033
    AVOPTION_CODEC_INT("me_pre_cmp", "ME pre pass compare function",
4034
                       me_pre_cmp, 0, 24000000, 0),
4035

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

    
4052
#ifdef CONFIG_ENCODERS
4053

    
4054
AVCodec mpeg1video_encoder = {
4055
    "mpeg1video",
4056
    CODEC_TYPE_VIDEO,
4057
    CODEC_ID_MPEG1VIDEO,
4058
    sizeof(MpegEncContext),
4059
    MPV_encode_init,
4060
    MPV_encode_picture,
4061
    MPV_encode_end,
4062
};
4063

    
4064
#ifdef CONFIG_RISKY
4065

    
4066
AVCodec h263_encoder = {
4067
    "h263",
4068
    CODEC_TYPE_VIDEO,
4069
    CODEC_ID_H263,
4070
    sizeof(MpegEncContext),
4071
    MPV_encode_init,
4072
    MPV_encode_picture,
4073
    MPV_encode_end,
4074
};
4075

    
4076
AVCodec h263p_encoder = {
4077
    "h263p",
4078
    CODEC_TYPE_VIDEO,
4079
    CODEC_ID_H263P,
4080
    sizeof(MpegEncContext),
4081
    MPV_encode_init,
4082
    MPV_encode_picture,
4083
    MPV_encode_end,
4084
};
4085

    
4086
AVCodec rv10_encoder = {
4087
    "rv10",
4088
    CODEC_TYPE_VIDEO,
4089
    CODEC_ID_RV10,
4090
    sizeof(MpegEncContext),
4091
    MPV_encode_init,
4092
    MPV_encode_picture,
4093
    MPV_encode_end,
4094
};
4095

    
4096
AVCodec mpeg4_encoder = {
4097
    "mpeg4",
4098
    CODEC_TYPE_VIDEO,
4099
    CODEC_ID_MPEG4,
4100
    sizeof(MpegEncContext),
4101
    MPV_encode_init,
4102
    MPV_encode_picture,
4103
    MPV_encode_end,
4104
    .options = mpeg4_options,
4105
};
4106

    
4107
AVCodec msmpeg4v1_encoder = {
4108
    "msmpeg4v1",
4109
    CODEC_TYPE_VIDEO,
4110
    CODEC_ID_MSMPEG4V1,
4111
    sizeof(MpegEncContext),
4112
    MPV_encode_init,
4113
    MPV_encode_picture,
4114
    MPV_encode_end,
4115
    .options = mpeg4_options,
4116
};
4117

    
4118
AVCodec msmpeg4v2_encoder = {
4119
    "msmpeg4v2",
4120
    CODEC_TYPE_VIDEO,
4121
    CODEC_ID_MSMPEG4V2,
4122
    sizeof(MpegEncContext),
4123
    MPV_encode_init,
4124
    MPV_encode_picture,
4125
    MPV_encode_end,
4126
    .options = mpeg4_options,
4127
};
4128

    
4129
AVCodec msmpeg4v3_encoder = {
4130
    "msmpeg4",
4131
    CODEC_TYPE_VIDEO,
4132
    CODEC_ID_MSMPEG4V3,
4133
    sizeof(MpegEncContext),
4134
    MPV_encode_init,
4135
    MPV_encode_picture,
4136
    MPV_encode_end,
4137
    .options = mpeg4_options,
4138
};
4139

    
4140
AVCodec wmv1_encoder = {
4141
    "wmv1",
4142
    CODEC_TYPE_VIDEO,
4143
    CODEC_ID_WMV1,
4144
    sizeof(MpegEncContext),
4145
    MPV_encode_init,
4146
    MPV_encode_picture,
4147
    MPV_encode_end,
4148
    .options = mpeg4_options,
4149
};
4150

    
4151
#endif
4152

    
4153
AVCodec mjpeg_encoder = {
4154
    "mjpeg",
4155
    CODEC_TYPE_VIDEO,
4156
    CODEC_ID_MJPEG,
4157
    sizeof(MpegEncContext),
4158
    MPV_encode_init,
4159
    MPV_encode_picture,
4160
    MPV_encode_end,
4161
};
4162

    
4163
#endif //CONFIG_ENCODERS
4164