Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 140cb663

History | View | Annotate | Download (118 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
#include <ctype.h>
23
#include "avcodec.h"
24
#include "dsputil.h"
25
#include "mpegvideo.h"
26
#include "simple_idct.h"
27

    
28
#ifdef USE_FASTMEMCPY
29
#include "fastmemcpy.h"
30
#endif
31

    
32
//#undef NDEBUG
33
//#include <assert.h>
34

    
35
static void encode_picture(MpegEncContext *s, int picture_number);
36
static void dct_unquantize_mpeg1_c(MpegEncContext *s, 
37
                                   DCTELEM *block, int n, int qscale);
38
static void dct_unquantize_mpeg2_c(MpegEncContext *s,
39
                                   DCTELEM *block, int n, int qscale);
40
static void dct_unquantize_h263_c(MpegEncContext *s, 
41
                                  DCTELEM *block, int n, int qscale);
42
static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w);
43
static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
44

    
45
void (*draw_edges)(UINT8 *buf, int wrap, int width, int height, int w)= draw_edges_c;
46
static void emulated_edge_mc(MpegEncContext *s, UINT8 *src, int linesize, int block_w, int block_h, 
47
                                    int src_x, int src_y, int w, int h);
48

    
49

    
50
/* enable all paranoid tests for rounding, overflows, etc... */
51
//#define PARANOID
52

    
53
//#define DEBUG
54

    
55

    
56
/* for jpeg fast DCT */
57
#define CONST_BITS 14
58

    
59
static const uint16_t aanscales[64] = {
60
    /* precomputed values scaled up by 14 bits */
61
    16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
62
    22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
63
    21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
64
    19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
65
    16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
66
    12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
67
    8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
68
    4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
69
};
70

    
71
/* Input permutation for the simple_idct_mmx */
72
static const uint8_t simple_mmx_permutation[64]={
73
        0x00, 0x08, 0x04, 0x09, 0x01, 0x0C, 0x05, 0x0D, 
74
        0x10, 0x18, 0x14, 0x19, 0x11, 0x1C, 0x15, 0x1D, 
75
        0x20, 0x28, 0x24, 0x29, 0x21, 0x2C, 0x25, 0x2D, 
76
        0x12, 0x1A, 0x16, 0x1B, 0x13, 0x1E, 0x17, 0x1F, 
77
        0x02, 0x0A, 0x06, 0x0B, 0x03, 0x0E, 0x07, 0x0F, 
78
        0x30, 0x38, 0x34, 0x39, 0x31, 0x3C, 0x35, 0x3D, 
79
        0x22, 0x2A, 0x26, 0x2B, 0x23, 0x2E, 0x27, 0x2F, 
80
        0x32, 0x3A, 0x36, 0x3B, 0x33, 0x3E, 0x37, 0x3F,
81
};
82

    
83
static const uint8_t h263_chroma_roundtab[16] = {
84
    0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
85
};
86

    
87
static UINT16 (*default_mv_penalty)[MAX_MV*2+1]=NULL;
88
static UINT8 default_fcode_tab[MAX_MV*2+1];
89

    
90
/* default motion estimation */
91
int motion_estimation_method = ME_EPZS;
92

    
93
static void convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[64], uint16_t (*qmat16_bias)[64],
94
                           const UINT16 *quant_matrix, int bias, int qmin, int qmax)
95
{
96
    int qscale;
97

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

    
133
                if(qmat16[qscale][i]==0 || qmat16[qscale][i]==128*256) qmat16[qscale][i]=128*256-1;
134
                qmat16_bias[qscale][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][i]);
135
            }
136
        }
137
    }
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 *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->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
/* XXX: those functions should be suppressed ASAP when all IDCTs are
174
 converted */
175
// *FIXME* this is ugly hack using local static
176
static void (*ff_put_pixels_clamped)(const DCTELEM *block, UINT8 *pixels, int line_size);
177
static void (*ff_add_pixels_clamped)(const DCTELEM *block, UINT8 *pixels, int line_size);
178
static void ff_jref_idct_put(UINT8 *dest, int line_size, DCTELEM *block)
179
{
180
    j_rev_dct (block);
181
    ff_put_pixels_clamped(block, dest, line_size);
182
}
183
static void ff_jref_idct_add(UINT8 *dest, int line_size, DCTELEM *block)
184
{
185
    j_rev_dct (block);
186
    ff_add_pixels_clamped(block, dest, line_size);
187
}
188

    
189
/* init common dct for both encoder and decoder */
190
int DCT_common_init(MpegEncContext *s)
191
{
192
    int i;
193

    
194
    ff_put_pixels_clamped = s->dsp.put_pixels_clamped;
195
    ff_add_pixels_clamped = s->dsp.add_pixels_clamped;
196

    
197
    s->dct_unquantize_h263 = dct_unquantize_h263_c;
198
    s->dct_unquantize_mpeg1 = dct_unquantize_mpeg1_c;
199
    s->dct_unquantize_mpeg2 = dct_unquantize_mpeg2_c;
200
    s->dct_quantize= dct_quantize_c;
201

    
202
    if(s->avctx->dct_algo==FF_DCT_FASTINT)
203
        s->fdct = fdct_ifast;
204
    else
205
        s->fdct = ff_jpeg_fdct_islow; //slow/accurate/default
206

    
207
    if(s->avctx->idct_algo==FF_IDCT_INT){
208
        s->idct_put= ff_jref_idct_put;
209
        s->idct_add= ff_jref_idct_add;
210
        s->idct_permutation_type= FF_LIBMPEG2_IDCT_PERM;
211
    }else{ //accurate/default
212
        s->idct_put= simple_idct_put;
213
        s->idct_add= simple_idct_add;
214
        s->idct_permutation_type= FF_NO_IDCT_PERM;
215
    }
216
        
217
#ifdef HAVE_MMX
218
    MPV_common_init_mmx(s);
219
#endif
220
#ifdef ARCH_ALPHA
221
    MPV_common_init_axp(s);
222
#endif
223
#ifdef HAVE_MLIB
224
    MPV_common_init_mlib(s);
225
#endif
226
#ifdef HAVE_MMI
227
    MPV_common_init_mmi(s);
228
#endif
229
#ifdef ARCH_ARMV4L
230
    MPV_common_init_armv4l(s);
231
#endif
232
#ifdef ARCH_POWERPC
233
    MPV_common_init_ppc(s);
234
#endif
235

    
236
    switch(s->idct_permutation_type){
237
    case FF_NO_IDCT_PERM:
238
        for(i=0; i<64; i++)
239
            s->idct_permutation[i]= i;
240
        break;
241
    case FF_LIBMPEG2_IDCT_PERM:
242
        for(i=0; i<64; i++)
243
            s->idct_permutation[i]= (i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2);
244
        break;
245
    case FF_SIMPLE_IDCT_PERM:
246
        for(i=0; i<64; i++)
247
            s->idct_permutation[i]= simple_mmx_permutation[i];
248
        break;
249
    case FF_TRANSPOSE_IDCT_PERM:
250
        for(i=0; i<64; i++)
251
            s->idct_permutation[i]= ((i&7)<<3) | (i>>3);
252
        break;
253
    default:
254
        fprintf(stderr, "Internal error, IDCT permutation not set\n");
255
        return -1;
256
    }
257

    
258

    
259
    /* load & permutate scantables
260
       note: only wmv uses differnt ones 
261
    */
262
    ff_init_scantable(s, &s->inter_scantable  , ff_zigzag_direct);
263
    ff_init_scantable(s, &s->intra_scantable  , ff_zigzag_direct);
264
    ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);
265
    ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
266

    
267
    return 0;
268
}
269

    
270
/**
271
 * allocates various arrays for a Picture structure, except the pixels themself.
272
 * The pixels are allocated/set in te get_buffer()
273
 */
274
static int alloc_picture(MpegEncContext *s, Picture *pic){
275
    if (s->encoding) {        
276
        CHECKED_ALLOCZ(pic->mb_var   , s->mb_num * sizeof(INT16))
277
        CHECKED_ALLOCZ(pic->mc_mb_var, s->mb_num * sizeof(INT16))
278
        CHECKED_ALLOCZ(pic->mb_mean  , s->mb_num * sizeof(INT8))
279
    }
280

    
281
    CHECKED_ALLOCZ(pic->mbskip_table , s->mb_num * sizeof(UINT8)+1) //the +1 is for the slice end check
282
    CHECKED_ALLOCZ(pic->qscale_table , s->mb_num * sizeof(UINT8))
283
    pic->qstride= s->mb_width;
284
    
285
    return 0;
286
fail: //for the CHECKED_ALLOCZ macro
287
    return -1;
288
}
289

    
290
static void free_picture(MpegEncContext *s, Picture *pic){
291
    int i;
292
    
293
    av_freep(&pic->mb_var);
294
    av_freep(&pic->mc_mb_var);
295
    av_freep(&pic->mb_mean);
296
    av_freep(&pic->mbskip_table);
297
    av_freep(&pic->qscale_table);
298
    
299
    if(s->avctx->get_buffer == avcodec_default_get_buffer){
300
        for(i=0; i<4; i++){
301
            av_freep(&pic->base[i]);
302
            pic->data[i]= NULL;
303
        }
304
        av_freep(&pic->opaque);
305
    }
306
}
307

    
308
/* init common structure for both encoder and decoder */
309
int MPV_common_init(MpegEncContext *s)
310
{
311
    int y_size, c_size, yc_size, i;
312

    
313
    dsputil_init(&s->dsp, s->avctx->dsp_mask);
314
    DCT_common_init(s);
315

    
316
    s->flags= s->avctx->flags;
317

    
318
    s->mb_width  = (s->width  + 15) / 16;
319
    s->mb_height = (s->height + 15) / 16;
320

    
321
    /* set default edge pos, will be overriden in decode_header if needed */
322
    s->h_edge_pos= s->mb_width*16;
323
    s->v_edge_pos= s->mb_height*16;
324

    
325
    s->mb_num = s->mb_width * s->mb_height;
326

    
327
    y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
328
    c_size = (s->mb_width + 2) * (s->mb_height + 2);
329
    yc_size = y_size + 2 * c_size;
330

    
331
    /* convert fourcc to upper case */
332
    s->avctx->fourcc=   toupper( s->avctx->fourcc     &0xFF)          
333
                     + (toupper((s->avctx->fourcc>>8 )&0xFF)<<8 )
334
                     + (toupper((s->avctx->fourcc>>16)&0xFF)<<16) 
335
                     + (toupper((s->avctx->fourcc>>24)&0xFF)<<24);
336

    
337
    CHECKED_ALLOCZ(s->edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
338

    
339
    s->avctx->coded_picture= (AVVideoFrame*)&s->current_picture;
340

    
341
    if (s->encoding) {
342
        int mv_table_size= (s->mb_width+2)*(s->mb_height+2);
343

    
344
        /* Allocate MV tables */
345
        CHECKED_ALLOCZ(s->p_mv_table            , mv_table_size * 2 * sizeof(INT16))
346
        CHECKED_ALLOCZ(s->b_forw_mv_table       , mv_table_size * 2 * sizeof(INT16))
347
        CHECKED_ALLOCZ(s->b_back_mv_table       , mv_table_size * 2 * sizeof(INT16))
348
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table , mv_table_size * 2 * sizeof(INT16))
349
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table , mv_table_size * 2 * sizeof(INT16))
350
        CHECKED_ALLOCZ(s->b_direct_forw_mv_table, mv_table_size * 2 * sizeof(INT16))
351
        CHECKED_ALLOCZ(s->b_direct_back_mv_table, mv_table_size * 2 * sizeof(INT16))
352
        CHECKED_ALLOCZ(s->b_direct_mv_table     , mv_table_size * 2 * sizeof(INT16))
353

    
354
        //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
355
        CHECKED_ALLOCZ(s->me_scratchpad,  s->width*2*16*3*sizeof(uint8_t)) 
356
        
357
        CHECKED_ALLOCZ(s->me_map      , ME_MAP_SIZE*sizeof(uint32_t))
358
        CHECKED_ALLOCZ(s->me_score_map, ME_MAP_SIZE*sizeof(uint16_t))
359

    
360
        if(s->codec_id==CODEC_ID_MPEG4){
361
            CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
362
            CHECKED_ALLOCZ(   s->pb2_buffer, PB_BUFFER_SIZE);
363
        }
364
        
365
        if(s->msmpeg4_version){
366
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
367
        }
368
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
369
    }
370
        
371
    CHECKED_ALLOCZ(s->error_status_table, s->mb_num*sizeof(UINT8))
372
    
373
    if (s->out_format == FMT_H263 || s->encoding) {
374
        int size;
375
        /* Allocate MB type table */
376
        CHECKED_ALLOCZ(s->mb_type  , s->mb_num * sizeof(UINT8))
377

    
378
        /* MV prediction */
379
        size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
380
        CHECKED_ALLOCZ(s->motion_val, size * 2 * sizeof(INT16));
381
    }
382

    
383
    if(s->codec_id==CODEC_ID_MPEG4){
384
        /* interlaced direct mode decoding tables */
385
        CHECKED_ALLOCZ(s->field_mv_table, s->mb_num*2*2 * sizeof(INT16))
386
        CHECKED_ALLOCZ(s->field_select_table, s->mb_num*2* sizeof(INT8))
387
    }
388
    /* 4mv b frame decoding table */
389
    //note this is needed for h263 without b frames too (segfault on damaged streams otherwise)
390
    CHECKED_ALLOCZ(s->co_located_type_table, s->mb_num * sizeof(UINT8))
391
    if (s->out_format == FMT_H263) {
392
        /* ac values */
393
        CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(INT16) * 16);
394
        s->ac_val[1] = s->ac_val[0] + y_size;
395
        s->ac_val[2] = s->ac_val[1] + c_size;
396
        
397
        /* cbp values */
398
        CHECKED_ALLOCZ(s->coded_block, y_size);
399
        
400
        /* divx501 bitstream reorder buffer */
401
        CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
402

    
403
        /* cbp, ac_pred, pred_dir */
404
        CHECKED_ALLOCZ(s->cbp_table  , s->mb_num * sizeof(UINT8))
405
        CHECKED_ALLOCZ(s->pred_dir_table, s->mb_num * sizeof(UINT8))
406
    }
407
    
408
    if (s->h263_pred || s->h263_plus || !s->encoding) {
409
        /* dc values */
410
        //MN: we need these for error resilience of intra-frames
411
        CHECKED_ALLOCZ(s->dc_val[0], yc_size * sizeof(INT16));
412
        s->dc_val[1] = s->dc_val[0] + y_size;
413
        s->dc_val[2] = s->dc_val[1] + c_size;
414
        for(i=0;i<yc_size;i++)
415
            s->dc_val[0][i] = 1024;
416
    }
417

    
418
    /* which mb is a intra block */
419
    CHECKED_ALLOCZ(s->mbintra_table, s->mb_num);
420
    memset(s->mbintra_table, 1, s->mb_num);
421
    
422
    /* default structure is frame */
423
    s->picture_structure = PICT_FRAME;
424
    
425
    /* init macroblock skip table */
426
    CHECKED_ALLOCZ(s->mbskip_table, s->mb_num+1);
427
    //Note the +1 is for a quicker mpeg4 slice_end detection
428
    
429
    s->block= s->blocks[0];
430

    
431
    s->parse_context.state= -1;
432

    
433
    s->context_initialized = 1;
434
    return 0;
435
 fail:
436
    MPV_common_end(s);
437
    return -1;
438
}
439

    
440

    
441
//extern int sads;
442

    
443
/* init common structure for both encoder and decoder */
444
void MPV_common_end(MpegEncContext *s)
445
{
446
    int i;
447

    
448
    for(i=0; i<MAX_PICTURE_COUNT; i++){
449
        if(s->picture[i].data[0]){
450
            s->avctx->release_buffer(s->avctx, (AVVideoFrame*)&s->picture[i]);
451
        }
452
    }
453
    
454
    av_freep(&s->mb_type);
455
    av_freep(&s->p_mv_table);
456
    av_freep(&s->b_forw_mv_table);
457
    av_freep(&s->b_back_mv_table);
458
    av_freep(&s->b_bidir_forw_mv_table);
459
    av_freep(&s->b_bidir_back_mv_table);
460
    av_freep(&s->b_direct_forw_mv_table);
461
    av_freep(&s->b_direct_back_mv_table);
462
    av_freep(&s->b_direct_mv_table);
463
    av_freep(&s->motion_val);
464
    av_freep(&s->dc_val[0]);
465
    av_freep(&s->ac_val[0]);
466
    av_freep(&s->coded_block);
467
    av_freep(&s->mbintra_table);
468
    av_freep(&s->cbp_table);
469
    av_freep(&s->pred_dir_table);
470
    av_freep(&s->me_scratchpad);
471
    av_freep(&s->me_map);
472
    av_freep(&s->me_score_map);
473
    
474
    av_freep(&s->mbskip_table);
475
    av_freep(&s->bitstream_buffer);
476
    av_freep(&s->tex_pb_buffer);
477
    av_freep(&s->pb2_buffer);
478
    av_freep(&s->edge_emu_buffer);
479
    av_freep(&s->co_located_type_table);
480
    av_freep(&s->field_mv_table);
481
    av_freep(&s->field_select_table);
482
    av_freep(&s->avctx->stats_out);
483
    av_freep(&s->ac_stats);
484
    av_freep(&s->error_status_table);
485

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

    
492
/* init video encoder */
493
int MPV_encode_init(AVCodecContext *avctx)
494
{
495
    MpegEncContext *s = avctx->priv_data;
496
    int i;
497

    
498
    avctx->pix_fmt = PIX_FMT_YUV420P;
499

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

    
530
    if (s->gop_size <= 1) {
531
        s->intra_only = 1;
532
        s->gop_size = 12;
533
    } else {
534
        s->intra_only = 0;
535
    }
536

    
537
    /* ME algorithm */
538
    if (avctx->me_method == 0)
539
        /* For compatibility */
540
        s->me_method = motion_estimation_method;
541
    else
542
        s->me_method = avctx->me_method;
543

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

    
556
    switch(avctx->codec->id) {
557
    case CODEC_ID_MPEG1VIDEO:
558
        s->out_format = FMT_MPEG1;
559
        avctx->delay=0; //FIXME not sure, should check the spec
560
        break;
561
    case CODEC_ID_MJPEG:
562
        s->out_format = FMT_MJPEG;
563
        s->intra_only = 1; /* force intra only for jpeg */
564
        s->mjpeg_write_tables = 1; /* write all tables */
565
        s->mjpeg_data_only_frames = 0; /* write all the needed headers */
566
        s->mjpeg_vsample[0] = 2; /* set up default sampling factors */
567
        s->mjpeg_vsample[1] = 1; /* the only currently supported values */
568
        s->mjpeg_vsample[2] = 1; 
569
        s->mjpeg_hsample[0] = 2;
570
        s->mjpeg_hsample[1] = 1; 
571
        s->mjpeg_hsample[2] = 1; 
572
        if (mjpeg_init(s) < 0)
573
            return -1;
574
        avctx->delay=0;
575
        break;
576
    case CODEC_ID_H263:
577
        if (h263_get_picture_format(s->width, s->height) == 7) {
578
            printf("Input picture size isn't suitable for h263 codec! try h263+\n");
579
            return -1;
580
        }
581
        s->out_format = FMT_H263;
582
        avctx->delay=0;
583
        break;
584
    case CODEC_ID_H263P:
585
        s->out_format = FMT_H263;
586
        s->h263_plus = 1;
587
        s->unrestricted_mv = 1;
588
        s->h263_aic = 1;
589
        
590
        /* These are just to be sure */
591
        s->umvplus = 0;
592
        s->umvplus_dec = 0;
593
        avctx->delay=0;
594
        break;
595
    case CODEC_ID_RV10:
596
        s->out_format = FMT_H263;
597
        s->h263_rv10 = 1;
598
        avctx->delay=0;
599
        break;
600
    case CODEC_ID_MPEG4:
601
        s->out_format = FMT_H263;
602
        s->h263_pred = 1;
603
        s->unrestricted_mv = 1;
604
        s->has_b_frames= s->max_b_frames ? 1 : 0;
605
        s->low_delay= !s->has_b_frames;
606
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
607
        break;
608
    case CODEC_ID_MSMPEG4V1:
609
        s->out_format = FMT_H263;
610
        s->h263_msmpeg4 = 1;
611
        s->h263_pred = 1;
612
        s->unrestricted_mv = 1;
613
        s->msmpeg4_version= 1;
614
        avctx->delay=0;
615
        break;
616
    case CODEC_ID_MSMPEG4V2:
617
        s->out_format = FMT_H263;
618
        s->h263_msmpeg4 = 1;
619
        s->h263_pred = 1;
620
        s->unrestricted_mv = 1;
621
        s->msmpeg4_version= 2;
622
        avctx->delay=0;
623
        break;
624
    case CODEC_ID_MSMPEG4V3:
625
        s->out_format = FMT_H263;
626
        s->h263_msmpeg4 = 1;
627
        s->h263_pred = 1;
628
        s->unrestricted_mv = 1;
629
        s->msmpeg4_version= 3;
630
        avctx->delay=0;
631
        break;
632
    case CODEC_ID_WMV1:
633
        s->out_format = FMT_H263;
634
        s->h263_msmpeg4 = 1;
635
        s->h263_pred = 1;
636
        s->unrestricted_mv = 1;
637
        s->msmpeg4_version= 4;
638
        avctx->delay=0;
639
        break;
640
    case CODEC_ID_WMV2:
641
        s->out_format = FMT_H263;
642
        s->h263_msmpeg4 = 1;
643
        s->h263_pred = 1;
644
        s->unrestricted_mv = 1;
645
        s->msmpeg4_version= 5;
646
        avctx->delay=0;
647
        break;
648
    default:
649
        return -1;
650
    }
651
    
652
    { /* set up some save defaults, some codecs might override them later */
653
        static int done=0;
654
        if(!done){
655
            int i;
656
            done=1;
657

    
658
            default_mv_penalty= av_mallocz( sizeof(UINT16)*(MAX_FCODE+1)*(2*MAX_MV+1) );
659
            memset(default_mv_penalty, 0, sizeof(UINT16)*(MAX_FCODE+1)*(2*MAX_MV+1));
660
            memset(default_fcode_tab , 0, sizeof(UINT8)*(2*MAX_MV+1));
661

    
662
            for(i=-16; i<16; i++){
663
                default_fcode_tab[i + MAX_MV]= 1;
664
            }
665
        }
666
    }
667
    s->mv_penalty= default_mv_penalty;
668
    s->fcode_tab= default_fcode_tab;
669
    s->y_dc_scale_table=
670
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
671
 
672
    /* dont use mv_penalty table for crap MV as it would be confused */
673
    if (s->me_method < ME_EPZS) s->mv_penalty = default_mv_penalty;
674

    
675
    s->encoding = 1;
676

    
677
    /* init */
678
    if (MPV_common_init(s) < 0)
679
        return -1;
680
    
681
#ifdef CONFIG_ENCODERS
682
    if (s->out_format == FMT_H263)
683
        h263_encode_init(s);
684
    else if (s->out_format == FMT_MPEG1)
685
        ff_mpeg1_encode_init(s);
686
    if(s->msmpeg4_version)
687
        ff_msmpeg4_encode_init(s);
688
#endif
689

    
690
    /* init default q matrix */
691
    for(i=0;i<64;i++) {
692
        int j= s->idct_permutation[i];
693
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
694
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
695
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
696
        }else if(s->out_format == FMT_H263){
697
            s->intra_matrix[j] =
698
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
699
        }else{ /* mpeg1 */
700
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
701
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
702
        }
703
    }
704

    
705
    /* precompute matrix */
706
    /* for mjpeg, we do include qscale in the matrix */
707
    if (s->out_format != FMT_MJPEG) {
708
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, s->q_intra_matrix16_bias, 
709
                       s->intra_matrix, s->intra_quant_bias, 1, 31);
710
        convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16, s->q_inter_matrix16_bias, 
711
                       s->inter_matrix, s->inter_quant_bias, 1, 31);
712
    }
713

    
714
    if(ff_rate_control_init(s) < 0)
715
        return -1;
716

    
717
    s->picture_number = 0;
718
    s->picture_in_gop_number = 0;
719
    s->fake_picture_number = 0;
720
    /* motion detector init */
721
    s->f_code = 1;
722
    s->b_code = 1;
723

    
724
    return 0;
725
}
726

    
727
int MPV_encode_end(AVCodecContext *avctx)
728
{
729
    MpegEncContext *s = avctx->priv_data;
730

    
731
#ifdef STATS
732
    print_stats();
733
#endif
734

    
735
    ff_rate_control_uninit(s);
736

    
737
    MPV_common_end(s);
738
    if (s->out_format == FMT_MJPEG)
739
        mjpeg_close(s);
740
      
741
    return 0;
742
}
743

    
744
/* draw the edges of width 'w' of an image of size width, height */
745
//FIXME check that this is ok for mpeg4 interlaced
746
static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w)
747
{
748
    UINT8 *ptr, *last_line;
749
    int i;
750

    
751
    last_line = buf + (height - 1) * wrap;
752
    for(i=0;i<w;i++) {
753
        /* top and bottom */
754
        memcpy(buf - (i + 1) * wrap, buf, width);
755
        memcpy(last_line + (i + 1) * wrap, last_line, width);
756
    }
757
    /* left and right */
758
    ptr = buf;
759
    for(i=0;i<height;i++) {
760
        memset(ptr - w, ptr[0], w);
761
        memset(ptr + width, ptr[width-1], w);
762
        ptr += wrap;
763
    }
764
    /* corners */
765
    for(i=0;i<w;i++) {
766
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
767
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
768
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
769
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
770
    }
771
}
772

    
773
/* generic function for encode/decode called before a frame is coded/decoded */
774
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
775
{
776
    int i, r;
777
    AVVideoFrame *pic;
778

    
779
    s->mb_skiped = 0;
780
    
781
    /* mark&release old frames */
782
    if (s->pict_type != B_TYPE && s->last_picture.data[0]) {
783
        Picture *pic= NULL;
784
        for(i=0; i<MAX_PICTURE_COUNT; i++){
785
            if(s->picture[i].data[0] == s->last_picture.data[0]){
786
//                s->picture[i].reference=0;
787
                avctx->release_buffer(avctx, (AVVideoFrame*)&s->picture[i]);
788
                break;
789
            }    
790
        }
791
        assert(i<MAX_PICTURE_COUNT);
792

    
793
        /* release forgotten pictures */
794
        /* if(mpeg124/h263) */
795
        if(!s->encoding){
796
            for(i=0; i<MAX_PICTURE_COUNT; i++){
797
                if(s->picture[i].data[0] && s->picture[i].data[0] != s->next_picture.data[0] && s->picture[i].reference){
798
                    fprintf(stderr, "releasing zombie picture\n");
799
                    avctx->release_buffer(avctx, (AVVideoFrame*)&s->picture[i]);                
800
                }
801
            }
802
        }
803
    }
804

    
805
    if(!s->encoding){        
806
        /* find unused Picture */
807
        for(i=0; i<MAX_PICTURE_COUNT; i++){
808
            if(s->picture[i].data[0]==NULL) break;
809
        }
810
        assert(i<MAX_PICTURE_COUNT);
811
    
812
        pic= (AVVideoFrame*)&s->picture[i];
813
        pic->reference= s->pict_type != B_TYPE;
814
        pic->coded_picture_number= s->current_picture.coded_picture_number+1;
815
        
816
        r= avctx->get_buffer(avctx, pic);
817
    
818
        if(r<0 || (s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1]))){
819
            fprintf(stderr, "get_buffer() failed (stride changed), bye bye\n");
820
            return -1;
821
        }
822

    
823
        s->linesize  = pic->linesize[0];
824
        s->uvlinesize= pic->linesize[1];
825
    
826
        if(pic->qscale_table==NULL)
827
            alloc_picture(s, (Picture*)pic);
828

    
829
        s->current_picture= s->picture[i];
830
    }
831

    
832
    s->hurry_up= s->avctx->hurry_up;
833
    s->error_resilience= avctx->error_resilience;
834

    
835
    if (s->pict_type != B_TYPE) {
836
        s->last_picture= s->next_picture;
837
        s->next_picture= s->current_picture;
838
    }
839
   
840
    /* set dequantizer, we cant do it during init as it might change for mpeg4
841
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
842
    if(s->out_format == FMT_H263){
843
        if(s->mpeg_quant)
844
            s->dct_unquantize = s->dct_unquantize_mpeg2;
845
        else
846
            s->dct_unquantize = s->dct_unquantize_h263;
847
    }else 
848
        s->dct_unquantize = s->dct_unquantize_mpeg1;
849

    
850
    return 0;
851
}
852

    
853
/* generic function for encode/decode called after a frame has been coded/decoded */
854
void MPV_frame_end(MpegEncContext *s)
855
{
856
    int i;
857

    
858
    /* draw edge for correct motion prediction if outside */
859
    if(s->codec_id!=CODEC_ID_SVQ1){
860
        if (s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
861
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
862
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
863
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
864
        }
865
    }
866
    emms_c();
867
    
868
    s->last_pict_type    = s->pict_type;
869
    if(s->pict_type!=B_TYPE){
870
        s->last_non_b_pict_type= s->pict_type;
871
        s->num_available_buffers++;
872
        if(s->num_available_buffers>2) s->num_available_buffers= 2;
873
    }
874
    
875
    s->current_picture.quality= s->qscale; //FIXME get average of qscale_table
876
    s->current_picture.pict_type= s->pict_type;
877
    s->current_picture.key_frame= s->pict_type == I_TYPE;
878
    
879
    /* copy back current_picture variables */
880
    for(i=0; i<MAX_PICTURE_COUNT; i++){
881
        if(s->picture[i].data[0] == s->current_picture.data[0]){
882
            s->picture[i]= s->current_picture;
883
            break;
884
        }    
885
    }
886
    assert(i<MAX_PICTURE_COUNT);
887

    
888
    /* release non refernce frames */
889
    for(i=0; i<MAX_PICTURE_COUNT; i++){
890
        if(s->picture[i].data[0] && !s->picture[i].reference)
891
            s->avctx->release_buffer(s->avctx, (AVVideoFrame*)&s->picture[i]);
892
    }
893
}
894

    
895
static int load_input_picture(MpegEncContext *s, AVVideoFrame *pic_arg){
896
    AVVideoFrame *pic;
897
    int i,r;
898
    const int encoding_delay= s->max_b_frames;
899

    
900
    /* find unused Picture */
901
    for(i=0; i<MAX_PICTURE_COUNT; i++){
902
        if(s->picture[i].data[0]==NULL) break;
903
    }
904
    assert(i<MAX_PICTURE_COUNT);
905
        
906
    pic= (AVVideoFrame*)&s->picture[i];
907
    pic->reference= 1;
908
    
909
//    assert(avctx->get_buffer == default_get_buffer || avctx->get_buffer==NULL);
910
    r= s->avctx->get_buffer(s->avctx, pic);
911

    
912
    if(r<0 || (s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1]))){
913
        fprintf(stderr, "get_buffer() failed (stride changed), bye bye\n");
914
        return -1;
915
    }
916
    
917
    assert(s->linesize==0   || s->linesize  ==pic->linesize[0]);
918
    assert(s->uvlinesize==0 || s->uvlinesize==pic->linesize[1]);
919
    assert(pic->linesize[1] == pic->linesize[2]);
920
    s->linesize  = pic->linesize[0];
921
    s->uvlinesize= pic->linesize[1];
922
    
923
    if(pic->qscale_table==NULL)
924
        alloc_picture(s, (Picture*)pic);
925

    
926
//    assert(s->input_picture[0]==NULL || s->input_picture[0]->data[0]==NULL);
927
    
928
    if(s->input_picture[encoding_delay])
929
        pic->display_picture_number= s->input_picture[encoding_delay]->display_picture_number + 1;
930
//printf("dpn2:%d\n", pic->display_picture_number);
931

    
932
    /* shift buffer entries */
933
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
934
        s->input_picture[i-1]= s->input_picture[i];
935
        
936
    s->input_picture[encoding_delay]= (Picture*)pic;
937
    pic->pict_type= pic_arg->pict_type;
938
    pic->quality= pic_arg->quality;
939
    
940
    if(   pic->data[0] == pic_arg->data[0] 
941
       && pic->data[1] == pic_arg->data[1]
942
       && pic->data[2] == pic_arg->data[2]){
943
       // empty
944
    }else{
945
        int h_chroma_shift, v_chroma_shift;
946
        
947
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
948
        
949
        for(i=0; i<3; i++){
950
            int src_stride= pic_arg->linesize[i];
951
            int dst_stride= i ? s->uvlinesize : s->linesize;
952
            int h_shift= i ? h_chroma_shift : 0;
953
            int v_shift= i ? v_chroma_shift : 0;
954
            int w= s->width >>h_shift;
955
            int h= s->height>>v_shift;
956
            uint8_t *src= pic_arg->data[i];
957
            uint8_t *dst= pic->data[i] + 16;
958
            
959
            if(src_stride==dst_stride)
960
                memcpy(dst, src, src_stride*h);
961
            else{
962
                while(h--){
963
                    memcpy(dst, src, w);
964
                    dst += dst_stride;
965
                    src += src_stride;
966
                }
967
            }
968
        }
969
    }
970

    
971
    return 0;
972
}
973

    
974
static void select_input_picture(MpegEncContext *s){
975
    int i;
976
    const int encoding_delay= s->max_b_frames;
977
    int coded_pic_num=0;    
978

    
979
    if(s->reordered_input_picture[0])
980
        coded_pic_num= s->reordered_input_picture[0]->coded_picture_number + 1;
981
//printf("cpn:%d\n", coded_pic_num);
982
    for(i=1; i<MAX_PICTURE_COUNT; i++)
983
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
984
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
985

    
986
    /* set next picture types & ordering */
987
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
988
        if(s->input_picture[0]->pict_type){
989
            /* user selected pict_type */
990
            if(s->input_picture[0]->pict_type == I_TYPE){
991
                s->reordered_input_picture[0]= s->input_picture[0];
992
                s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
993
            }else{
994
                int b_frames;
995

    
996
                for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
997
                    if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
998
                }
999
                
1000
                if(b_frames > s->max_b_frames){
1001
                    fprintf(stderr, "warning, too many bframes in a row\n");
1002
                    b_frames = s->max_b_frames;
1003
                    s->input_picture[b_frames]->pict_type= I_TYPE;
1004
                }
1005
                
1006
                s->reordered_input_picture[0]= s->input_picture[b_frames];
1007
                s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1008
                for(i=0; i<b_frames; i++){
1009
                    coded_pic_num++;
1010
                    s->reordered_input_picture[i+1]= s->input_picture[i];
1011
                    s->reordered_input_picture[i+1]->coded_picture_number= coded_pic_num;
1012
                }    
1013
            }
1014
        }else{
1015
            if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture.data[0]==NULL || s->intra_only){
1016
                s->reordered_input_picture[0]= s->input_picture[0];
1017
                s->reordered_input_picture[0]->pict_type= I_TYPE;
1018
                s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1019
            }else{
1020
                s->reordered_input_picture[0]= s->input_picture[s->max_b_frames];
1021
                if(s->picture_in_gop_number + s->max_b_frames >= s->gop_size)
1022
                    s->reordered_input_picture[0]->pict_type= I_TYPE;
1023
                else
1024
                    s->reordered_input_picture[0]->pict_type= P_TYPE;
1025
                s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1026
                for(i=0; i<s->max_b_frames; i++){
1027
                    coded_pic_num++;
1028
                    s->reordered_input_picture[i+1]= s->input_picture[i];
1029
                    s->reordered_input_picture[i+1]->pict_type= B_TYPE;
1030
                    s->reordered_input_picture[i+1]->coded_picture_number= coded_pic_num;
1031
                }    
1032
            }
1033
        }
1034
    }
1035
    
1036
    if(s->reordered_input_picture[0]){
1037
        if(s->reordered_input_picture[0]->pict_type==B_TYPE){
1038
            s->reordered_input_picture[0]->reference=0;
1039
        }
1040
        s->current_picture= *s->reordered_input_picture[0];
1041
        s->new_picture= s->current_picture;
1042
        s->new_picture.data[0]+=16;
1043
        s->new_picture.data[1]+=16;
1044
        s->new_picture.data[2]+=16;
1045
    
1046
        s->picture_number= s->new_picture.display_picture_number;
1047
//printf("dpn:%d\n", s->picture_number);
1048
    }else{
1049
       memset(&s->new_picture, 0, sizeof(Picture));
1050
    }
1051
}
1052

    
1053
int MPV_encode_picture(AVCodecContext *avctx,
1054
                       unsigned char *buf, int buf_size, void *data)
1055
{
1056
    MpegEncContext *s = avctx->priv_data;
1057
    AVVideoFrame *pic_arg = data;
1058
    int i;
1059

    
1060
    init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
1061

    
1062
    s->picture_in_gop_number++;
1063

    
1064
    load_input_picture(s, pic_arg);
1065
    
1066
    select_input_picture(s);
1067
    
1068
    /* output? */
1069
    if(s->new_picture.data[0]){
1070

    
1071
        s->pict_type= s->new_picture.pict_type;
1072
        if (s->fixed_qscale){ /* the ratecontrol needs the last qscale so we dont touch it for CBR */
1073
            s->qscale= (int)(s->new_picture.quality+0.5);
1074
            assert(s->qscale);
1075
        }
1076
//emms_c();
1077
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
1078
        MPV_frame_start(s, avctx);
1079

    
1080
        encode_picture(s, s->picture_number);
1081
        
1082
        avctx->real_pict_num  = s->picture_number;
1083
        avctx->header_bits = s->header_bits;
1084
        avctx->mv_bits     = s->mv_bits;
1085
        avctx->misc_bits   = s->misc_bits;
1086
        avctx->i_tex_bits  = s->i_tex_bits;
1087
        avctx->p_tex_bits  = s->p_tex_bits;
1088
        avctx->i_count     = s->i_count;
1089
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
1090
        avctx->skip_count  = s->skip_count;
1091

    
1092
        MPV_frame_end(s);
1093

    
1094
        if (s->out_format == FMT_MJPEG)
1095
            mjpeg_picture_trailer(s);
1096
        
1097
        if(s->flags&CODEC_FLAG_PASS1)
1098
            ff_write_pass1_stats(s);
1099
    }
1100

    
1101
    s->input_picture_number++;
1102

    
1103
    flush_put_bits(&s->pb);
1104
    s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1105
    
1106
    s->total_bits += s->frame_bits;
1107
    avctx->frame_bits  = s->frame_bits;
1108

    
1109
    for(i=0; i<4; i++){
1110
        avctx->error[i] += s->current_picture.error[i];
1111
    }
1112
    
1113
    return pbBufPtr(&s->pb) - s->pb.buf;
1114
}
1115

    
1116
static inline void gmc1_motion(MpegEncContext *s,
1117
                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1118
                               int dest_offset,
1119
                               UINT8 **ref_picture, int src_offset)
1120
{
1121
    UINT8 *ptr;
1122
    int offset, src_x, src_y, linesize, uvlinesize;
1123
    int motion_x, motion_y;
1124
    int emu=0;
1125

    
1126
    motion_x= s->sprite_offset[0][0];
1127
    motion_y= s->sprite_offset[0][1];
1128
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1129
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1130
    motion_x<<=(3-s->sprite_warping_accuracy);
1131
    motion_y<<=(3-s->sprite_warping_accuracy);
1132
    src_x = clip(src_x, -16, s->width);
1133
    if (src_x == s->width)
1134
        motion_x =0;
1135
    src_y = clip(src_y, -16, s->height);
1136
    if (src_y == s->height)
1137
        motion_y =0;
1138

    
1139
    linesize = s->linesize;
1140
    uvlinesize = s->uvlinesize;
1141
    
1142
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1143

    
1144
    dest_y+=dest_offset;
1145
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1146
        if(src_x<0 || src_y<0 || src_x + (motion_x&15) + 16 > s->h_edge_pos
1147
                              || src_y + (motion_y&15) + 16 > s->v_edge_pos){
1148
            emulated_edge_mc(s, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1149
            ptr= s->edge_emu_buffer;
1150
            emu=1;
1151
        }
1152
    }
1153
    
1154
    if((motion_x|motion_y)&7){
1155
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1156
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1157
    }else{
1158
        int dxy;
1159
        
1160
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
1161
        if (s->no_rounding){
1162
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
1163
        }else{
1164
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
1165
        }
1166
    }
1167
    
1168
    if(s->flags&CODEC_FLAG_GRAY) return;
1169

    
1170
    motion_x= s->sprite_offset[1][0];
1171
    motion_y= s->sprite_offset[1][1];
1172
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
1173
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
1174
    motion_x<<=(3-s->sprite_warping_accuracy);
1175
    motion_y<<=(3-s->sprite_warping_accuracy);
1176
    src_x = clip(src_x, -8, s->width>>1);
1177
    if (src_x == s->width>>1)
1178
        motion_x =0;
1179
    src_y = clip(src_y, -8, s->height>>1);
1180
    if (src_y == s->height>>1)
1181
        motion_y =0;
1182

    
1183
    offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
1184
    ptr = ref_picture[1] + offset;
1185
    if(emu){
1186
        emulated_edge_mc(s, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1187
        ptr= s->edge_emu_buffer;
1188
    }
1189
    s->dsp.gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1190
    
1191
    ptr = ref_picture[2] + offset;
1192
    if(emu){
1193
        emulated_edge_mc(s, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1194
        ptr= s->edge_emu_buffer;
1195
    }
1196
    s->dsp.gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1197
    
1198
    return;
1199
}
1200

    
1201
static inline void gmc_motion(MpegEncContext *s,
1202
                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1203
                               int dest_offset,
1204
                               UINT8 **ref_picture, int src_offset)
1205
{
1206
    UINT8 *ptr;
1207
    int linesize, uvlinesize;
1208
    const int a= s->sprite_warping_accuracy;
1209
    int ox, oy;
1210

    
1211
    linesize = s->linesize;
1212
    uvlinesize = s->uvlinesize;
1213

    
1214
    ptr = ref_picture[0] + src_offset;
1215

    
1216
    dest_y+=dest_offset;
1217
    
1218
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
1219
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
1220

    
1221
    s->dsp.gmc(dest_y, ptr, linesize, 16,
1222
           ox, 
1223
           oy, 
1224
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1225
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1226
           a+1, (1<<(2*a+1)) - s->no_rounding,
1227
           s->h_edge_pos, s->v_edge_pos);
1228
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
1229
           ox + s->sprite_delta[0][0]*8, 
1230
           oy + s->sprite_delta[1][0]*8, 
1231
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1232
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1233
           a+1, (1<<(2*a+1)) - s->no_rounding,
1234
           s->h_edge_pos, s->v_edge_pos);
1235

    
1236
    if(s->flags&CODEC_FLAG_GRAY) return;
1237

    
1238

    
1239
    dest_cb+=dest_offset>>1;
1240
    dest_cr+=dest_offset>>1;
1241
    
1242
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
1243
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
1244

    
1245
    ptr = ref_picture[1] + (src_offset>>1);
1246
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
1247
           ox, 
1248
           oy, 
1249
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1250
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1251
           a+1, (1<<(2*a+1)) - s->no_rounding,
1252
           s->h_edge_pos>>1, s->v_edge_pos>>1);
1253
    
1254
    ptr = ref_picture[2] + (src_offset>>1);
1255
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
1256
           ox, 
1257
           oy, 
1258
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1259
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1260
           a+1, (1<<(2*a+1)) - s->no_rounding,
1261
           s->h_edge_pos>>1, s->v_edge_pos>>1);
1262
}
1263

    
1264

    
1265
static void emulated_edge_mc(MpegEncContext *s, UINT8 *src, int linesize, int block_w, int block_h, 
1266
                                    int src_x, int src_y, int w, int h){
1267
    int x, y;
1268
    int start_y, start_x, end_y, end_x;
1269
    UINT8 *buf= s->edge_emu_buffer;
1270

    
1271
    if(src_y>= h){
1272
        src+= (h-1-src_y)*linesize;
1273
        src_y=h-1;
1274
    }else if(src_y<=-block_h){
1275
        src+= (1-block_h-src_y)*linesize;
1276
        src_y=1-block_h;
1277
    }
1278
    if(src_x>= w){
1279
        src+= (w-1-src_x);
1280
        src_x=w-1;
1281
    }else if(src_x<=-block_w){
1282
        src+= (1-block_w-src_x);
1283
        src_x=1-block_w;
1284
    }
1285

    
1286
    start_y= FFMAX(0, -src_y);
1287
    start_x= FFMAX(0, -src_x);
1288
    end_y= FFMIN(block_h, h-src_y);
1289
    end_x= FFMIN(block_w, w-src_x);
1290

    
1291
    // copy existing part
1292
    for(y=start_y; y<end_y; y++){
1293
        for(x=start_x; x<end_x; x++){
1294
            buf[x + y*linesize]= src[x + y*linesize];
1295
        }
1296
    }
1297

    
1298
    //top
1299
    for(y=0; y<start_y; y++){
1300
        for(x=start_x; x<end_x; x++){
1301
            buf[x + y*linesize]= buf[x + start_y*linesize];
1302
        }
1303
    }
1304

    
1305
    //bottom
1306
    for(y=end_y; y<block_h; y++){
1307
        for(x=start_x; x<end_x; x++){
1308
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1309
        }
1310
    }
1311
                                    
1312
    for(y=0; y<block_h; y++){
1313
       //left
1314
        for(x=0; x<start_x; x++){
1315
            buf[x + y*linesize]= buf[start_x + y*linesize];
1316
        }
1317
       
1318
       //right
1319
        for(x=end_x; x<block_w; x++){
1320
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1321
        }
1322
    }
1323
}
1324

    
1325

    
1326
/* apply one mpeg motion vector to the three components */
1327
static inline void mpeg_motion(MpegEncContext *s,
1328
                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1329
                               int dest_offset,
1330
                               UINT8 **ref_picture, int src_offset,
1331
                               int field_based, op_pixels_func (*pix_op)[4],
1332
                               int motion_x, int motion_y, int h)
1333
{
1334
    UINT8 *ptr;
1335
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1336
    int emu=0;
1337
#if 0    
1338
if(s->quarter_sample)
1339
{
1340
    motion_x>>=1;
1341
    motion_y>>=1;
1342
}
1343
#endif
1344
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1345
    src_x = s->mb_x * 16 + (motion_x >> 1);
1346
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 1);
1347
                
1348
    /* WARNING: do no forget half pels */
1349
    height = s->height >> field_based;
1350
    v_edge_pos = s->v_edge_pos >> field_based;
1351
    src_x = clip(src_x, -16, s->width);
1352
    if (src_x == s->width)
1353
        dxy &= ~1;
1354
    src_y = clip(src_y, -16, height);
1355
    if (src_y == height)
1356
        dxy &= ~2;
1357
    linesize   = s->linesize << field_based;
1358
    uvlinesize = s->uvlinesize << field_based;
1359
    ptr = ref_picture[0] + (src_y * linesize) + (src_x) + src_offset;
1360
    dest_y += dest_offset;
1361

    
1362
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1363
        if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 16 > s->h_edge_pos
1364
                              || src_y + (motion_y&1) + h  > v_edge_pos){
1365
            emulated_edge_mc(s, ptr - src_offset, s->linesize, 17, 17+field_based, 
1366
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1367
            ptr= s->edge_emu_buffer + src_offset;
1368
            emu=1;
1369
        }
1370
    }
1371
    pix_op[0][dxy](dest_y, ptr, linesize, h);
1372

    
1373
    if(s->flags&CODEC_FLAG_GRAY) return;
1374

    
1375
    if (s->out_format == FMT_H263) {
1376
        dxy = 0;
1377
        if ((motion_x & 3) != 0)
1378
            dxy |= 1;
1379
        if ((motion_y & 3) != 0)
1380
            dxy |= 2;
1381
        mx = motion_x >> 2;
1382
        my = motion_y >> 2;
1383
    } else {
1384
        mx = motion_x / 2;
1385
        my = motion_y / 2;
1386
        dxy = ((my & 1) << 1) | (mx & 1);
1387
        mx >>= 1;
1388
        my >>= 1;
1389
    }
1390
    
1391
    src_x = s->mb_x * 8 + mx;
1392
    src_y = s->mb_y * (8 >> field_based) + my;
1393
    src_x = clip(src_x, -8, s->width >> 1);
1394
    if (src_x == (s->width >> 1))
1395
        dxy &= ~1;
1396
    src_y = clip(src_y, -8, height >> 1);
1397
    if (src_y == (height >> 1))
1398
        dxy &= ~2;
1399
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1400
    ptr = ref_picture[1] + offset;
1401
    if(emu){
1402
        emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
1403
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1404
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1405
    }
1406
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1407

    
1408
    ptr = ref_picture[2] + offset;
1409
    if(emu){
1410
        emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
1411
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1412
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1413
    }
1414
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1415
}
1416

    
1417
static inline void qpel_motion(MpegEncContext *s,
1418
                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1419
                               int dest_offset,
1420
                               UINT8 **ref_picture, int src_offset,
1421
                               int field_based, op_pixels_func (*pix_op)[4],
1422
                               qpel_mc_func (*qpix_op)[16],
1423
                               int motion_x, int motion_y, int h)
1424
{
1425
    UINT8 *ptr;
1426
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1427
    int emu=0;
1428

    
1429
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1430
    src_x = s->mb_x * 16 + (motion_x >> 2);
1431
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
1432

    
1433
    height = s->height >> field_based;
1434
    v_edge_pos = s->v_edge_pos >> field_based;
1435
    src_x = clip(src_x, -16, s->width);
1436
    if (src_x == s->width)
1437
        dxy &= ~3;
1438
    src_y = clip(src_y, -16, height);
1439
    if (src_y == height)
1440
        dxy &= ~12;
1441
    linesize = s->linesize << field_based;
1442
    uvlinesize = s->uvlinesize << field_based;
1443
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1444
    dest_y += dest_offset;
1445
//printf("%d %d %d\n", src_x, src_y, dxy);
1446
    
1447
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1448
        if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 16 > s->h_edge_pos
1449
                              || src_y + (motion_y&3) + h  > v_edge_pos){
1450
            emulated_edge_mc(s, ptr - src_offset, s->linesize, 17, 17+field_based, 
1451
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1452
            ptr= s->edge_emu_buffer + src_offset;
1453
            emu=1;
1454
        }
1455
    }
1456
    if(!field_based)
1457
        qpix_op[0][dxy](dest_y, ptr, linesize);
1458
    else{
1459
        //damn interlaced mode
1460
        //FIXME boundary mirroring is not exactly correct here
1461
        qpix_op[1][dxy](dest_y  , ptr  , linesize);
1462
        qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
1463
    }
1464

    
1465
    if(s->flags&CODEC_FLAG_GRAY) return;
1466

    
1467
    if(field_based){
1468
        mx= motion_x/2;
1469
        my= motion_y>>1;
1470
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
1471
        mx= (motion_x>>1)|(motion_x&1);
1472
        my= (motion_y>>1)|(motion_y&1);
1473
    }else{
1474
        mx= motion_x/2;
1475
        my= motion_y/2;
1476
    }
1477
    mx= (mx>>1)|(mx&1);
1478
    my= (my>>1)|(my&1);
1479
    dxy= (mx&1) | ((my&1)<<1);
1480
    mx>>=1;
1481
    my>>=1;
1482

    
1483
    src_x = s->mb_x * 8 + mx;
1484
    src_y = s->mb_y * (8 >> field_based) + my;
1485
    src_x = clip(src_x, -8, s->width >> 1);
1486
    if (src_x == (s->width >> 1))
1487
        dxy &= ~1;
1488
    src_y = clip(src_y, -8, height >> 1);
1489
    if (src_y == (height >> 1))
1490
        dxy &= ~2;
1491

    
1492
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1493
    ptr = ref_picture[1] + offset;
1494
    if(emu){
1495
        emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
1496
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1497
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1498
    }
1499
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1500
    
1501
    ptr = ref_picture[2] + offset;
1502
    if(emu){
1503
        emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
1504
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1505
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1506
    }
1507
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1508
}
1509

    
1510

    
1511
static inline void MPV_motion(MpegEncContext *s, 
1512
                              UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1513
                              int dir, UINT8 **ref_picture, 
1514
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
1515
{
1516
    int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
1517
    int mb_x, mb_y, i;
1518
    UINT8 *ptr, *dest;
1519
    int emu=0;
1520

    
1521
    mb_x = s->mb_x;
1522
    mb_y = s->mb_y;
1523

    
1524
    switch(s->mv_type) {
1525
    case MV_TYPE_16X16:
1526
        if(s->mcsel){
1527
            if(s->real_sprite_warping_points==1){
1528
                gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
1529
                            ref_picture, 0);
1530
            }else{
1531
                gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
1532
                            ref_picture, 0);
1533
            }
1534
        }else if(s->quarter_sample){
1535
            qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1536
                        ref_picture, 0,
1537
                        0, pix_op, qpix_op,
1538
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1539
        }else{
1540
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1541
                        ref_picture, 0,
1542
                        0, pix_op,
1543
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1544
        }           
1545
        break;
1546
    case MV_TYPE_8X8:
1547
        mx = 0;
1548
        my = 0;
1549
        if(s->quarter_sample){
1550
            for(i=0;i<4;i++) {
1551
                motion_x = s->mv[dir][i][0];
1552
                motion_y = s->mv[dir][i][1];
1553

    
1554
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1555
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
1556
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
1557
                    
1558
                /* WARNING: do no forget half pels */
1559
                src_x = clip(src_x, -16, s->width);
1560
                if (src_x == s->width)
1561
                    dxy &= ~3;
1562
                src_y = clip(src_y, -16, s->height);
1563
                if (src_y == s->height)
1564
                    dxy &= ~12;
1565
                    
1566
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1567
                if(s->flags&CODEC_FLAG_EMU_EDGE){
1568
                    if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 8 > s->h_edge_pos
1569
                                          || src_y + (motion_y&3) + 8 > s->v_edge_pos){
1570
                        emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1571
                        ptr= s->edge_emu_buffer;
1572
                    }
1573
                }
1574
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1575
                qpix_op[1][dxy](dest, ptr, s->linesize);
1576

    
1577
                mx += s->mv[dir][i][0]/2;
1578
                my += s->mv[dir][i][1]/2;
1579
            }
1580
        }else{
1581
            for(i=0;i<4;i++) {
1582
                motion_x = s->mv[dir][i][0];
1583
                motion_y = s->mv[dir][i][1];
1584

    
1585
                dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1586
                src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;
1587
                src_y = mb_y * 16 + (motion_y >> 1) + (i >>1) * 8;
1588
                    
1589
                /* WARNING: do no forget half pels */
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, s->height);
1594
                if (src_y == s->height)
1595
                    dxy &= ~2;
1596
                    
1597
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1598
                if(s->flags&CODEC_FLAG_EMU_EDGE){
1599
                    if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 8 > s->h_edge_pos
1600
                                          || src_y + (motion_y&1) + 8 > s->v_edge_pos){
1601
                        emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1602
                        ptr= s->edge_emu_buffer;
1603
                    }
1604
                }
1605
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1606
                pix_op[1][dxy](dest, ptr, s->linesize, 8);
1607

    
1608
                mx += s->mv[dir][i][0];
1609
                my += s->mv[dir][i][1];
1610
            }
1611
        }
1612

    
1613
        if(s->flags&CODEC_FLAG_GRAY) break;
1614
        /* In case of 8X8, we construct a single chroma motion vector
1615
           with a special rounding */
1616
        for(i=0;i<4;i++) {
1617
        }
1618
        if (mx >= 0)
1619
            mx = (h263_chroma_roundtab[mx & 0xf] + ((mx >> 3) & ~1));
1620
        else {
1621
            mx = -mx;
1622
            mx = -(h263_chroma_roundtab[mx & 0xf] + ((mx >> 3) & ~1));
1623
        }
1624
        if (my >= 0)
1625
            my = (h263_chroma_roundtab[my & 0xf] + ((my >> 3) & ~1));
1626
        else {
1627
            my = -my;
1628
            my = -(h263_chroma_roundtab[my & 0xf] + ((my >> 3) & ~1));
1629
        }
1630
        dxy = ((my & 1) << 1) | (mx & 1);
1631
        mx >>= 1;
1632
        my >>= 1;
1633

    
1634
        src_x = mb_x * 8 + mx;
1635
        src_y = mb_y * 8 + my;
1636
        src_x = clip(src_x, -8, s->width/2);
1637
        if (src_x == s->width/2)
1638
            dxy &= ~1;
1639
        src_y = clip(src_y, -8, s->height/2);
1640
        if (src_y == s->height/2)
1641
            dxy &= ~2;
1642
        
1643
        offset = (src_y * (s->uvlinesize)) + src_x;
1644
        ptr = ref_picture[1] + offset;
1645
        if(s->flags&CODEC_FLAG_EMU_EDGE){
1646
                if(src_x<0 || src_y<0 || src_x + (dxy &1) + 8 > s->h_edge_pos>>1
1647
                                      || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
1648
                    emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1649
                    ptr= s->edge_emu_buffer;
1650
                    emu=1;
1651
                }
1652
            }
1653
        pix_op[1][dxy](dest_cb, ptr, s->uvlinesize, 8);
1654

    
1655
        ptr = ref_picture[2] + offset;
1656
        if(emu){
1657
            emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1658
            ptr= s->edge_emu_buffer;
1659
        }
1660
        pix_op[1][dxy](dest_cr, ptr, s->uvlinesize, 8);
1661
        break;
1662
    case MV_TYPE_FIELD:
1663
        if (s->picture_structure == PICT_FRAME) {
1664
            if(s->quarter_sample){
1665
                /* top field */
1666
                qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1667
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
1668
                            1, pix_op, qpix_op,
1669
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
1670
                /* bottom field */
1671
                qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
1672
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
1673
                            1, pix_op, qpix_op,
1674
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
1675
            }else{
1676
                /* top field */       
1677
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1678
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
1679
                            1, pix_op,
1680
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
1681
                /* bottom field */
1682
                mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
1683
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
1684
                            1, pix_op,
1685
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
1686
            }
1687
        } else {
1688
            
1689

    
1690
        }
1691
        break;
1692
    }
1693
}
1694

    
1695

    
1696
/* put block[] to dest[] */
1697
static inline void put_dct(MpegEncContext *s, 
1698
                           DCTELEM *block, int i, UINT8 *dest, int line_size)
1699
{
1700
    s->dct_unquantize(s, block, i, s->qscale);
1701
    s->idct_put (dest, line_size, block);
1702
}
1703

    
1704
/* add block[] to dest[] */
1705
static inline void add_dct(MpegEncContext *s, 
1706
                           DCTELEM *block, int i, UINT8 *dest, int line_size)
1707
{
1708
    if (s->block_last_index[i] >= 0) {
1709
        s->idct_add (dest, line_size, block);
1710
    }
1711
}
1712

    
1713
static inline void add_dequant_dct(MpegEncContext *s, 
1714
                           DCTELEM *block, int i, UINT8 *dest, int line_size)
1715
{
1716
    if (s->block_last_index[i] >= 0) {
1717
        s->dct_unquantize(s, block, i, s->qscale);
1718

    
1719
        s->idct_add (dest, line_size, block);
1720
    }
1721
}
1722

    
1723
/**
1724
 * cleans dc, ac, coded_block for the current non intra MB
1725
 */
1726
void ff_clean_intra_table_entries(MpegEncContext *s)
1727
{
1728
    int wrap = s->block_wrap[0];
1729
    int xy = s->block_index[0];
1730
    
1731
    s->dc_val[0][xy           ] = 
1732
    s->dc_val[0][xy + 1       ] = 
1733
    s->dc_val[0][xy     + wrap] =
1734
    s->dc_val[0][xy + 1 + wrap] = 1024;
1735
    /* ac pred */
1736
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(INT16));
1737
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(INT16));
1738
    if (s->msmpeg4_version>=3) {
1739
        s->coded_block[xy           ] =
1740
        s->coded_block[xy + 1       ] =
1741
        s->coded_block[xy     + wrap] =
1742
        s->coded_block[xy + 1 + wrap] = 0;
1743
    }
1744
    /* chroma */
1745
    wrap = s->block_wrap[4];
1746
    xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
1747
    s->dc_val[1][xy] =
1748
    s->dc_val[2][xy] = 1024;
1749
    /* ac pred */
1750
    memset(s->ac_val[1][xy], 0, 16 * sizeof(INT16));
1751
    memset(s->ac_val[2][xy], 0, 16 * sizeof(INT16));
1752
    
1753
    s->mbintra_table[s->mb_x + s->mb_y*s->mb_width]= 0;
1754
}
1755

    
1756
/* generic function called after a macroblock has been parsed by the
1757
   decoder or after it has been encoded by the encoder.
1758

1759
   Important variables used:
1760
   s->mb_intra : true if intra macroblock
1761
   s->mv_dir   : motion vector direction
1762
   s->mv_type  : motion vector type
1763
   s->mv       : motion vector
1764
   s->interlaced_dct : true if interlaced dct used (mpeg2)
1765
 */
1766
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1767
{
1768
    int mb_x, mb_y;
1769
    const int mb_xy = s->mb_y * s->mb_width + s->mb_x;
1770

    
1771
    mb_x = s->mb_x;
1772
    mb_y = s->mb_y;
1773

    
1774
    s->current_picture.qscale_table[mb_xy]= s->qscale;
1775

    
1776
    /* update DC predictors for P macroblocks */
1777
    if (!s->mb_intra) {
1778
        if (s->h263_pred || s->h263_aic) {
1779
            if(s->mbintra_table[mb_xy])
1780
                ff_clean_intra_table_entries(s);
1781
        } else {
1782
            s->last_dc[0] =
1783
            s->last_dc[1] =
1784
            s->last_dc[2] = 128 << s->intra_dc_precision;
1785
        }
1786
    }
1787
    else if (s->h263_pred || s->h263_aic)
1788
        s->mbintra_table[mb_xy]=1;
1789

    
1790
    /* update motion predictor, not for B-frames as they need the motion_val from the last P/S-Frame */
1791
    if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) { //FIXME move into h263.c if possible, format specific stuff shouldnt be here
1792
        
1793
        const int wrap = s->block_wrap[0];
1794
        const int xy = s->block_index[0];
1795
        const int mb_index= s->mb_x + s->mb_y*s->mb_width;
1796
        if(s->mv_type == MV_TYPE_8X8){
1797
            s->co_located_type_table[mb_index]= CO_LOCATED_TYPE_4MV;
1798
        } else {
1799
            int motion_x, motion_y;
1800
            if (s->mb_intra) {
1801
                motion_x = 0;
1802
                motion_y = 0;
1803
                if(s->co_located_type_table)
1804
                    s->co_located_type_table[mb_index]= 0;
1805
            } else if (s->mv_type == MV_TYPE_16X16) {
1806
                motion_x = s->mv[0][0][0];
1807
                motion_y = s->mv[0][0][1];
1808
                if(s->co_located_type_table)
1809
                    s->co_located_type_table[mb_index]= 0;
1810
            } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
1811
                int i;
1812
                motion_x = s->mv[0][0][0] + s->mv[0][1][0];
1813
                motion_y = s->mv[0][0][1] + s->mv[0][1][1];
1814
                motion_x = (motion_x>>1) | (motion_x&1);
1815
                for(i=0; i<2; i++){
1816
                    s->field_mv_table[mb_index][i][0]= s->mv[0][i][0];
1817
                    s->field_mv_table[mb_index][i][1]= s->mv[0][i][1];
1818
                    s->field_select_table[mb_index][i]= s->field_select[0][i];
1819
                }
1820
                s->co_located_type_table[mb_index]= CO_LOCATED_TYPE_FIELDMV;
1821
            }
1822
            /* no update if 8X8 because it has been done during parsing */
1823
            s->motion_val[xy][0] = motion_x;
1824
            s->motion_val[xy][1] = motion_y;
1825
            s->motion_val[xy + 1][0] = motion_x;
1826
            s->motion_val[xy + 1][1] = motion_y;
1827
            s->motion_val[xy + wrap][0] = motion_x;
1828
            s->motion_val[xy + wrap][1] = motion_y;
1829
            s->motion_val[xy + 1 + wrap][0] = motion_x;
1830
            s->motion_val[xy + 1 + wrap][1] = motion_y;
1831
        }
1832
    }
1833
    
1834
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
1835
        UINT8 *dest_y, *dest_cb, *dest_cr;
1836
        int dct_linesize, dct_offset;
1837
        op_pixels_func (*op_pix)[4];
1838
        qpel_mc_func (*op_qpix)[16];
1839

    
1840
        /* avoid copy if macroblock skipped in last frame too */
1841
        if (s->pict_type != B_TYPE) {
1842
            s->current_picture.mbskip_table[mb_xy]= s->mb_skiped;
1843
        }
1844

    
1845
        /* skip only during decoding as we might trash the buffers during encoding a bit */
1846
        if(!s->encoding){
1847
            UINT8 *mbskip_ptr = &s->mbskip_table[mb_xy];
1848
            const int age= s->current_picture.age;
1849

    
1850
            assert(age);
1851

    
1852
            if (s->mb_skiped) {
1853
                s->mb_skiped= 0;
1854
                assert(s->pict_type!=I_TYPE);
1855
 
1856
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
1857
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
1858

    
1859
                /* if previous was skipped too, then nothing to do !  */
1860
                if (*mbskip_ptr >= age){
1861
//if(s->pict_type!=B_TYPE && s->mb_x==0) printf("\n");
1862
//if(s->pict_type!=B_TYPE) printf("%d%d ", *mbskip_ptr, age);
1863
                    if(s->pict_type!=B_TYPE) return;
1864
                    if(s->avctx->draw_horiz_band==NULL && *mbskip_ptr > age) return; 
1865
                    /* we dont draw complete frames here so we cant skip */
1866
                }
1867
            } else {
1868
                *mbskip_ptr = 0; /* not skipped */
1869
            }
1870
        }else
1871
            s->mb_skiped= 0;
1872

    
1873
        if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band){
1874
            dest_y  = s->current_picture.data[0] + mb_x * 16;
1875
            dest_cb = s->current_picture.data[1] + mb_x * 8;
1876
            dest_cr = s->current_picture.data[2] + mb_x * 8;
1877
        }else{
1878
            dest_y  = s->current_picture.data[0] + (mb_y * 16* s->linesize  ) + mb_x * 16;
1879
            dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
1880
            dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
1881
        }
1882

    
1883
        if (s->interlaced_dct) {
1884
            dct_linesize = s->linesize * 2;
1885
            dct_offset = s->linesize;
1886
        } else {
1887
            dct_linesize = s->linesize;
1888
            dct_offset = s->linesize * 8;
1889
        }
1890

    
1891
        if (!s->mb_intra) {
1892
            /* motion handling */
1893
            /* decoding or more than one mb_type (MC was allready done otherwise) */
1894
            if((!s->encoding) || (s->mb_type[mb_xy]&(s->mb_type[mb_xy]-1))){
1895
                if ((!s->no_rounding) || s->pict_type==B_TYPE){                
1896
                    op_pix = s->dsp.put_pixels_tab;
1897
                    op_qpix= s->dsp.put_qpel_pixels_tab;
1898
                }else{
1899
                    op_pix = s->dsp.put_no_rnd_pixels_tab;
1900
                    op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
1901
                }
1902

    
1903
                if (s->mv_dir & MV_DIR_FORWARD) {
1904
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
1905
                    op_pix = s->dsp.avg_pixels_tab;
1906
                    op_qpix= s->dsp.avg_qpel_pixels_tab;
1907
                }
1908
                if (s->mv_dir & MV_DIR_BACKWARD) {
1909
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
1910
                }
1911
            }
1912

    
1913
            /* skip dequant / idct if we are really late ;) */
1914
            if(s->hurry_up>1) return;
1915

    
1916
            /* add dct residue */
1917
            if(s->encoding || !(   s->mpeg2 || s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO 
1918
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1919
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
1920
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
1921
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
1922
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
1923

    
1924
                if(!(s->flags&CODEC_FLAG_GRAY)){
1925
                    add_dequant_dct(s, block[4], 4, dest_cb, s->uvlinesize);
1926
                    add_dequant_dct(s, block[5], 5, dest_cr, s->uvlinesize);
1927
                }
1928
            } else {
1929
                add_dct(s, block[0], 0, dest_y, dct_linesize);
1930
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
1931
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
1932
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
1933

    
1934
                if(!(s->flags&CODEC_FLAG_GRAY)){
1935
                    add_dct(s, block[4], 4, dest_cb, s->uvlinesize);
1936
                    add_dct(s, block[5], 5, dest_cr, s->uvlinesize);
1937
                }
1938
            }
1939
        } else {
1940
            /* dct only in intra block */
1941
            if(s->encoding || !(s->mpeg2 || s->codec_id==CODEC_ID_MPEG1VIDEO)){
1942
                put_dct(s, block[0], 0, dest_y, dct_linesize);
1943
                put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
1944
                put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
1945
                put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
1946

    
1947
                if(!(s->flags&CODEC_FLAG_GRAY)){
1948
                    put_dct(s, block[4], 4, dest_cb, s->uvlinesize);
1949
                    put_dct(s, block[5], 5, dest_cr, s->uvlinesize);
1950
                }
1951
            }else{
1952
                s->idct_put(dest_y                 , dct_linesize, block[0]);
1953
                s->idct_put(dest_y              + 8, dct_linesize, block[1]);
1954
                s->idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
1955
                s->idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
1956

    
1957
                if(!(s->flags&CODEC_FLAG_GRAY)){
1958
                    s->idct_put(dest_cb, s->uvlinesize, block[4]);
1959
                    s->idct_put(dest_cr, s->uvlinesize, block[5]);
1960
                }
1961
            }
1962
        }
1963
    }
1964
}
1965

    
1966
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
1967
{
1968
    static const char tab[64]=
1969
        {3,2,2,1,1,1,1,1,
1970
         1,1,1,1,1,1,1,1,
1971
         1,1,1,1,1,1,1,1,
1972
         0,0,0,0,0,0,0,0,
1973
         0,0,0,0,0,0,0,0,
1974
         0,0,0,0,0,0,0,0,
1975
         0,0,0,0,0,0,0,0,
1976
         0,0,0,0,0,0,0,0};
1977
    int score=0;
1978
    int run=0;
1979
    int i;
1980
    DCTELEM *block= s->block[n];
1981
    const int last_index= s->block_last_index[n];
1982
    int skip_dc;
1983

    
1984
    if(threshold<0){
1985
        skip_dc=0;
1986
        threshold= -threshold;
1987
    }else
1988
        skip_dc=1;
1989

    
1990
    /* are all which we could set to zero are allready zero? */
1991
    if(last_index<=skip_dc - 1) return;
1992

    
1993
    for(i=0; i<=last_index; i++){
1994
        const int j = s->intra_scantable.permutated[i];
1995
        const int level = ABS(block[j]);
1996
        if(level==1){
1997
            if(skip_dc && i==0) continue;
1998
            score+= tab[run];
1999
            run=0;
2000
        }else if(level>1){
2001
            return;
2002
        }else{
2003
            run++;
2004
        }
2005
    }
2006
    if(score >= threshold) return;
2007
    for(i=skip_dc; i<=last_index; i++){
2008
        const int j = s->intra_scantable.permutated[i];
2009
        block[j]=0;
2010
    }
2011
    if(block[0]) s->block_last_index[n]= 0;
2012
    else         s->block_last_index[n]= -1;
2013
}
2014

    
2015
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
2016
{
2017
    int i;
2018
    const int maxlevel= s->max_qcoeff;
2019
    const int minlevel= s->min_qcoeff;
2020
    
2021
    if(s->mb_intra){
2022
        i=1; //skip clipping of intra dc
2023
    }else
2024
        i=0;
2025
    
2026
    for(;i<=last_index; i++){
2027
        const int j= s->intra_scantable.permutated[i];
2028
        int level = block[j];
2029
       
2030
        if     (level>maxlevel) level=maxlevel;
2031
        else if(level<minlevel) level=minlevel;
2032
        block[j]= level;
2033
    }
2034
}
2035

    
2036
static inline void requantize_coeffs(MpegEncContext *s, DCTELEM block[64], int oldq, int newq, int n)
2037
{
2038
    int i;
2039

    
2040
    if(s->mb_intra){
2041
        i=1; //skip clipping of intra dc
2042
         //FIXME requantize, note (mpeg1/h263/h263p-aic dont need it,...)
2043
    }else
2044
        i=0;
2045
    
2046
    for(;i<=s->block_last_index[n]; i++){
2047
        const int j = s->intra_scantable.permutated[i];
2048
        int level = block[j];
2049
        
2050
        block[j]= ROUNDED_DIV(level*oldq, newq);
2051
    }
2052

    
2053
    for(i=s->block_last_index[n]; i>=0; i--){
2054
        const int j = s->intra_scantable.permutated[i];
2055
        if(block[j]) break;
2056
    }
2057
    s->block_last_index[n]= i;
2058
}
2059

    
2060
static inline void auto_requantize_coeffs(MpegEncContext *s, DCTELEM block[6][64])
2061
{
2062
    int i,n, newq;
2063
    const int maxlevel= s->max_qcoeff;
2064
    const int minlevel= s->min_qcoeff;
2065
    int largest=0, smallest=0;
2066

    
2067
    assert(s->adaptive_quant);
2068
    
2069
    for(n=0; n<6; n++){
2070
        if(s->mb_intra){
2071
            i=1; //skip clipping of intra dc
2072
             //FIXME requantize, note (mpeg1/h263/h263p-aic dont need it,...)
2073
        }else
2074
            i=0;
2075

    
2076
        for(;i<=s->block_last_index[n]; i++){
2077
            const int j = s->intra_scantable.permutated[i];
2078
            int level = block[n][j];
2079
            if(largest  < level) largest = level;
2080
            if(smallest > level) smallest= level;
2081
        }
2082
    }
2083
    
2084
    for(newq=s->qscale+1; newq<32; newq++){
2085
        if(   ROUNDED_DIV(smallest*s->qscale, newq) >= minlevel
2086
           && ROUNDED_DIV(largest *s->qscale, newq) <= maxlevel) 
2087
            break;
2088
    }
2089
        
2090
    if(s->out_format==FMT_H263){
2091
        /* h263 like formats cannot change qscale by more than 2 easiely */
2092
        if(s->avctx->qmin + 2 < newq)
2093
            newq= s->avctx->qmin + 2;
2094
    }
2095

    
2096
    for(n=0; n<6; n++){
2097
        requantize_coeffs(s, block[n], s->qscale, newq, n);
2098
        clip_coeffs(s, block[n], s->block_last_index[n]);
2099
    }
2100
     
2101
    s->dquant+= newq - s->qscale;
2102
    s->qscale= newq;
2103
}
2104
#if 0
2105
static int pix_vcmp16x8(UINT8 *s, int stride){ //FIXME move to dsputil & optimize
2106
    int score=0;
2107
    int x,y;
2108
    
2109
    for(y=0; y<7; y++){
2110
        for(x=0; x<16; x+=4){
2111
            score+= ABS(s[x  ] - s[x  +stride]) + ABS(s[x+1] - s[x+1+stride]) 
2112
                   +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
2113
        }
2114
        s+= stride;
2115
    }
2116
    
2117
    return score;
2118
}
2119

2120
static int pix_diff_vcmp16x8(UINT8 *s1, UINT8*s2, int stride){ //FIXME move to dsputil & optimize
2121
    int score=0;
2122
    int x,y;
2123
    
2124
    for(y=0; y<7; y++){
2125
        for(x=0; x<16; x++){
2126
            score+= ABS(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2127
        }
2128
        s1+= stride;
2129
        s2+= stride;
2130
    }
2131
    
2132
    return score;
2133
}
2134
#else
2135
#define SQ(a) ((a)*(a))
2136

    
2137
static int pix_vcmp16x8(UINT8 *s, int stride){ //FIXME move to dsputil & optimize
2138
    int score=0;
2139
    int x,y;
2140
    
2141
    for(y=0; y<7; y++){
2142
        for(x=0; x<16; x+=4){
2143
            score+= SQ(s[x  ] - s[x  +stride]) + SQ(s[x+1] - s[x+1+stride]) 
2144
                   +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
2145
        }
2146
        s+= stride;
2147
    }
2148
    
2149
    return score;
2150
}
2151

    
2152
static int pix_diff_vcmp16x8(UINT8 *s1, UINT8*s2, int stride){ //FIXME move to dsputil & optimize
2153
    int score=0;
2154
    int x,y;
2155
    
2156
    for(y=0; y<7; y++){
2157
        for(x=0; x<16; x++){
2158
            score+= SQ(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2159
        }
2160
        s1+= stride;
2161
        s2+= stride;
2162
    }
2163
    
2164
    return score;
2165
}
2166

    
2167
#endif
2168

    
2169
void ff_draw_horiz_band(MpegEncContext *s){
2170
    if (    s->avctx->draw_horiz_band 
2171
        && (s->num_available_buffers>=1 || (!s->has_b_frames)) ) {
2172
        UINT8 *src_ptr[3];
2173
        int y, h, offset;
2174
        y = s->mb_y * 16;
2175
        h = s->height - y;
2176
        if (h > 16)
2177
            h = 16;
2178

    
2179
        if(s->pict_type==B_TYPE)
2180
            offset = 0;
2181
        else
2182
            offset = y * s->linesize;
2183

    
2184
        if(s->pict_type==B_TYPE || (!s->has_b_frames)){
2185
            src_ptr[0] = s->current_picture.data[0] + offset;
2186
            src_ptr[1] = s->current_picture.data[1] + (offset >> 2);
2187
            src_ptr[2] = s->current_picture.data[2] + (offset >> 2);
2188
        } else {
2189
            src_ptr[0] = s->last_picture.data[0] + offset;
2190
            src_ptr[1] = s->last_picture.data[1] + (offset >> 2);
2191
            src_ptr[2] = s->last_picture.data[2] + (offset >> 2);
2192
        }
2193
        emms_c();
2194

    
2195
        s->avctx->draw_horiz_band(s->avctx, src_ptr, s->linesize,
2196
                               y, s->width, h);
2197
    }
2198
}
2199

    
2200
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2201
{
2202
    const int mb_x= s->mb_x;
2203
    const int mb_y= s->mb_y;
2204
    int i;
2205
    int skip_dct[6];
2206
    int dct_offset   = s->linesize*8; //default for progressive frames
2207
    
2208
    for(i=0; i<6; i++) skip_dct[i]=0;
2209
    
2210
    if(s->adaptive_quant){
2211
        s->dquant= s->current_picture.qscale_table[mb_x + mb_y*s->mb_width] - s->qscale;
2212

    
2213
        if(s->out_format==FMT_H263){
2214
            if     (s->dquant> 2) s->dquant= 2;
2215
            else if(s->dquant<-2) s->dquant=-2;
2216
        }
2217
            
2218
        if(s->codec_id==CODEC_ID_MPEG4){        
2219
            if(!s->mb_intra){
2220
                assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
2221

    
2222
                if(s->mv_dir&MV_DIRECT)
2223
                    s->dquant=0;
2224
            }
2225
        }
2226
        s->qscale+= s->dquant;
2227
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2228
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2229
    }
2230

    
2231
    if (s->mb_intra) {
2232
        UINT8 *ptr;
2233
        int wrap_y;
2234
        int emu=0;
2235

    
2236
        wrap_y = s->linesize;
2237
        ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2238

    
2239
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2240
            emulated_edge_mc(s, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2241
            ptr= s->edge_emu_buffer;
2242
            emu=1;
2243
        }
2244
        
2245
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2246
            int progressive_score, interlaced_score;
2247
            
2248
            progressive_score= pix_vcmp16x8(ptr, wrap_y  ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
2249
            interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y  , wrap_y*2);
2250
            
2251
            if(progressive_score > interlaced_score + 100){
2252
                s->interlaced_dct=1;
2253
            
2254
                dct_offset= wrap_y;
2255
                wrap_y<<=1;
2256
            }else
2257
                s->interlaced_dct=0;
2258
        }
2259
        
2260
        s->dsp.get_pixels(s->block[0], ptr                 , wrap_y);
2261
        s->dsp.get_pixels(s->block[1], ptr              + 8, wrap_y);
2262
        s->dsp.get_pixels(s->block[2], ptr + dct_offset    , wrap_y);
2263
        s->dsp.get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
2264

    
2265
        if(s->flags&CODEC_FLAG_GRAY){
2266
            skip_dct[4]= 1;
2267
            skip_dct[5]= 1;
2268
        }else{
2269
            int wrap_c = s->uvlinesize;
2270
            ptr = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2271
            if(emu){
2272
                emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2273
                ptr= s->edge_emu_buffer;
2274
            }
2275
            s->dsp.get_pixels(s->block[4], ptr, wrap_c);
2276

    
2277
            ptr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2278
            if(emu){
2279
                emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2280
                ptr= s->edge_emu_buffer;
2281
            }
2282
            s->dsp.get_pixels(s->block[5], ptr, wrap_c);
2283
        }
2284
    }else{
2285
        op_pixels_func (*op_pix)[4];
2286
        qpel_mc_func (*op_qpix)[16];
2287
        UINT8 *dest_y, *dest_cb, *dest_cr;
2288
        UINT8 *ptr_y, *ptr_cb, *ptr_cr;
2289
        int wrap_y, wrap_c;
2290
        int emu=0;
2291

    
2292
        dest_y  = s->current_picture.data[0] + (mb_y * 16 * s->linesize    ) + mb_x * 16;
2293
        dest_cb = s->current_picture.data[1] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2294
        dest_cr = s->current_picture.data[2] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2295
        wrap_y = s->linesize;
2296
        wrap_c = s->uvlinesize;
2297
        ptr_y  = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2298
        ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2299
        ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2300

    
2301
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
2302
            op_pix = s->dsp.put_pixels_tab;
2303
            op_qpix= s->dsp.put_qpel_pixels_tab;
2304
        }else{
2305
            op_pix = s->dsp.put_no_rnd_pixels_tab;
2306
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2307
        }
2308

    
2309
        if (s->mv_dir & MV_DIR_FORWARD) {
2310
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2311
            op_pix = s->dsp.avg_pixels_tab;
2312
            op_qpix= s->dsp.avg_qpel_pixels_tab;
2313
        }
2314
        if (s->mv_dir & MV_DIR_BACKWARD) {
2315
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2316
        }
2317

    
2318
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2319
            emulated_edge_mc(s, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2320
            ptr_y= s->edge_emu_buffer;
2321
            emu=1;
2322
        }
2323
        
2324
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2325
            int progressive_score, interlaced_score;
2326
            
2327
            progressive_score= pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y  ) 
2328
                             + pix_diff_vcmp16x8(ptr_y + wrap_y*8, dest_y + wrap_y*8, wrap_y  );
2329
            interlaced_score = pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y*2)
2330
                             + pix_diff_vcmp16x8(ptr_y + wrap_y  , dest_y + wrap_y  , wrap_y*2);
2331
            
2332
            if(progressive_score > interlaced_score + 600){
2333
                s->interlaced_dct=1;
2334
            
2335
                dct_offset= wrap_y;
2336
                wrap_y<<=1;
2337
            }else
2338
                s->interlaced_dct=0;
2339
        }
2340
        
2341
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
2342
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
2343
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
2344
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
2345
        
2346
        if(s->flags&CODEC_FLAG_GRAY){
2347
            skip_dct[4]= 1;
2348
            skip_dct[5]= 1;
2349
        }else{
2350
            if(emu){
2351
                emulated_edge_mc(s, ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2352
                ptr_cb= s->edge_emu_buffer;
2353
            }
2354
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2355
            if(emu){
2356
                emulated_edge_mc(s, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2357
                ptr_cr= s->edge_emu_buffer;
2358
            }
2359
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2360
        }
2361
        /* pre quantization */         
2362
        if(s->current_picture.mc_mb_var[s->mb_width*mb_y+ mb_x]<2*s->qscale*s->qscale){
2363
            //FIXME optimize
2364
            if(s->dsp.pix_abs8x8(ptr_y               , dest_y               , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
2365
            if(s->dsp.pix_abs8x8(ptr_y            + 8, dest_y            + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
2366
            if(s->dsp.pix_abs8x8(ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
2367
            if(s->dsp.pix_abs8x8(ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
2368
            if(s->dsp.pix_abs8x8(ptr_cb              , dest_cb              , wrap_c) < 20*s->qscale) skip_dct[4]= 1;
2369
            if(s->dsp.pix_abs8x8(ptr_cr              , dest_cr              , wrap_c) < 20*s->qscale) skip_dct[5]= 1;
2370
#if 0
2371
{
2372
 static int stat[7];
2373
 int num=0;
2374
 for(i=0; i<6; i++)
2375
  if(skip_dct[i]) num++;
2376
 stat[num]++;
2377
 
2378
 if(s->mb_x==0 && s->mb_y==0){
2379
  for(i=0; i<7; i++){
2380
   printf("%6d %1d\n", stat[i], i);
2381
  }
2382
 }
2383
}
2384
#endif
2385
        }
2386

    
2387
    }
2388
            
2389
#if 0
2390
            {
2391
                float adap_parm;
2392
                
2393
                adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_width*mb_y+mb_x] + 1.0) /
2394
                            ((s->mb_var[s->mb_width*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);
2395
            
2396
                printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d", 
2397
                        (s->mb_type[s->mb_width*mb_y+mb_x] > 0) ? 'I' : 'P', 
2398
                        s->qscale, adap_parm, s->qscale*adap_parm,
2399
                        s->mb_var[s->mb_width*mb_y+mb_x], s->avg_mb_var);
2400
            }
2401
#endif
2402
    /* DCT & quantize */
2403
    if(s->out_format==FMT_MJPEG){
2404
        for(i=0;i<6;i++) {
2405
            int overflow;
2406
            s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
2407
            if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2408
        }
2409
    }else{
2410
        for(i=0;i<6;i++) {
2411
            if(!skip_dct[i]){
2412
                int overflow;
2413
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2414
            // FIXME we could decide to change to quantizer instead of clipping
2415
            // JS: I don't think that would be a good idea it could lower quality instead
2416
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
2417
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2418
            }else
2419
                s->block_last_index[i]= -1;
2420
        }
2421
        if(s->luma_elim_threshold && !s->mb_intra)
2422
            for(i=0; i<4; i++)
2423
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2424
        if(s->chroma_elim_threshold && !s->mb_intra)
2425
            for(i=4; i<6; i++)
2426
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2427
    }
2428

    
2429
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
2430
        s->block_last_index[4]=
2431
        s->block_last_index[5]= 0;
2432
        s->block[4][0]=
2433
        s->block[5][0]= 128;
2434
    }
2435

    
2436
#ifdef CONFIG_ENCODERS
2437
    /* huffman encode */
2438
    switch(s->out_format) {
2439
    case FMT_MPEG1:
2440
        mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2441
        break;
2442
    case FMT_H263:
2443
        if (s->h263_msmpeg4)
2444
            msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2445
        else if(s->h263_pred)
2446
            mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2447
        else
2448
            h263_encode_mb(s, s->block, motion_x, motion_y);
2449
        break;
2450
    case FMT_MJPEG:
2451
        mjpeg_encode_mb(s, s->block);
2452
        break;
2453
    }
2454
#endif
2455
}
2456

    
2457
void ff_copy_bits(PutBitContext *pb, UINT8 *src, int length)
2458
{
2459
    int bytes= length>>4;
2460
    int bits= length&15;
2461
    int i;
2462

    
2463
    if(length==0) return;
2464

    
2465
    for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
2466
    put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
2467
}
2468

    
2469
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2470
    int i;
2471

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

    
2474
    /* mpeg1 */
2475
    d->mb_incr= s->mb_incr;
2476
    for(i=0; i<3; i++)
2477
        d->last_dc[i]= s->last_dc[i];
2478
    
2479
    /* statistics */
2480
    d->mv_bits= s->mv_bits;
2481
    d->i_tex_bits= s->i_tex_bits;
2482
    d->p_tex_bits= s->p_tex_bits;
2483
    d->i_count= s->i_count;
2484
    d->f_count= s->f_count;
2485
    d->b_count= s->b_count;
2486
    d->skip_count= s->skip_count;
2487
    d->misc_bits= s->misc_bits;
2488
    d->last_bits= 0;
2489

    
2490
    d->mb_skiped= s->mb_skiped;
2491
}
2492

    
2493
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2494
    int i;
2495

    
2496
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
2497
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
2498
    
2499
    /* mpeg1 */
2500
    d->mb_incr= s->mb_incr;
2501
    for(i=0; i<3; i++)
2502
        d->last_dc[i]= s->last_dc[i];
2503
    
2504
    /* statistics */
2505
    d->mv_bits= s->mv_bits;
2506
    d->i_tex_bits= s->i_tex_bits;
2507
    d->p_tex_bits= s->p_tex_bits;
2508
    d->i_count= s->i_count;
2509
    d->f_count= s->f_count;
2510
    d->b_count= s->b_count;
2511
    d->skip_count= s->skip_count;
2512
    d->misc_bits= s->misc_bits;
2513

    
2514
    d->mb_intra= s->mb_intra;
2515
    d->mb_skiped= s->mb_skiped;
2516
    d->mv_type= s->mv_type;
2517
    d->mv_dir= s->mv_dir;
2518
    d->pb= s->pb;
2519
    if(s->data_partitioning){
2520
        d->pb2= s->pb2;
2521
        d->tex_pb= s->tex_pb;
2522
    }
2523
    d->block= s->block;
2524
    for(i=0; i<6; i++)
2525
        d->block_last_index[i]= s->block_last_index[i];
2526
    d->interlaced_dct= s->interlaced_dct;
2527
}
2528

    
2529
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
2530
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2531
                           int *dmin, int *next_block, int motion_x, int motion_y)
2532
{
2533
    int bits_count;
2534
    
2535
    copy_context_before_encode(s, backup, type);
2536

    
2537
    s->block= s->blocks[*next_block];
2538
    s->pb= pb[*next_block];
2539
    if(s->data_partitioning){
2540
        s->pb2   = pb2   [*next_block];
2541
        s->tex_pb= tex_pb[*next_block];
2542
    }
2543

    
2544
    encode_mb(s, motion_x, motion_y);
2545

    
2546
    bits_count= get_bit_count(&s->pb);
2547
    if(s->data_partitioning){
2548
        bits_count+= get_bit_count(&s->pb2);
2549
        bits_count+= get_bit_count(&s->tex_pb);
2550
    }
2551

    
2552
    if(bits_count<*dmin){
2553
        *dmin= bits_count;
2554
        *next_block^=1;
2555

    
2556
        copy_context_after_encode(best, s, type);
2557
    }
2558
}
2559
                
2560
static inline int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2561
    uint32_t *sq = squareTbl + 256;
2562
    int acc=0;
2563
    int x,y;
2564
    
2565
    if(w==16 && h==16) 
2566
        return s->dsp.pix_norm(src1, src2, stride);
2567
    
2568
    for(y=0; y<h; y++){
2569
        for(x=0; x<w; x++){
2570
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2571
        } 
2572
    }
2573
    return acc;
2574
}
2575

    
2576
static void encode_picture(MpegEncContext *s, int picture_number)
2577
{
2578
    int mb_x, mb_y, pdif = 0;
2579
    int i;
2580
    int bits;
2581
    MpegEncContext best_s, backup_s;
2582
    UINT8 bit_buf[2][3000];
2583
    UINT8 bit_buf2[2][3000];
2584
    UINT8 bit_buf_tex[2][3000];
2585
    PutBitContext pb[2], pb2[2], tex_pb[2];
2586

    
2587
    for(i=0; i<2; i++){
2588
        init_put_bits(&pb    [i], bit_buf    [i], 3000, NULL, NULL);
2589
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000, NULL, NULL);
2590
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
2591
    }
2592

    
2593
    s->picture_number = picture_number;
2594

    
2595
    s->block_wrap[0]=
2596
    s->block_wrap[1]=
2597
    s->block_wrap[2]=
2598
    s->block_wrap[3]= s->mb_width*2 + 2;
2599
    s->block_wrap[4]=
2600
    s->block_wrap[5]= s->mb_width + 2;
2601
    
2602
    /* Reset the average MB variance */
2603
    s->current_picture.mb_var_sum = 0;
2604
    s->current_picture.mc_mb_var_sum = 0;
2605

    
2606
    /* we need to initialize some time vars before we can encode b-frames */
2607
    if (s->h263_pred && !s->h263_msmpeg4)
2608
        ff_set_mpeg4_time(s, s->picture_number); 
2609

    
2610
    s->scene_change_score=0;
2611
    
2612
    s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
2613

    
2614
    /* Estimate motion for every MB */
2615
    if(s->pict_type != I_TYPE){
2616
        for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2617
            s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
2618
            s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
2619
            s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
2620
            s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
2621
            for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2622
                s->mb_x = mb_x;
2623
                s->mb_y = mb_y;
2624
                s->block_index[0]+=2;
2625
                s->block_index[1]+=2;
2626
                s->block_index[2]+=2;
2627
                s->block_index[3]+=2;
2628

    
2629
                /* compute motion vector & mb_type and store in context */
2630
                if(s->pict_type==B_TYPE)
2631
                    ff_estimate_b_frame_motion(s, mb_x, mb_y);
2632
                else
2633
                    ff_estimate_p_frame_motion(s, mb_x, mb_y);
2634
//                s->mb_type[mb_y*s->mb_width + mb_x]=MB_TYPE_INTER;
2635
            }
2636
        }
2637
    }else /* if(s->pict_type == I_TYPE) */{
2638
        /* I-Frame */
2639
        //FIXME do we need to zero them?
2640
        memset(s->motion_val[0], 0, sizeof(INT16)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
2641
        memset(s->p_mv_table   , 0, sizeof(INT16)*(s->mb_width+2)*(s->mb_height+2)*2);
2642
        memset(s->mb_type      , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
2643
        
2644
        if(!s->fixed_qscale){
2645
            /* finding spatial complexity for I-frame rate control */
2646
            for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2647
                for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2648
                    int xx = mb_x * 16;
2649
                    int yy = mb_y * 16;
2650
                    uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
2651
                    int varc;
2652
                    int sum = s->dsp.pix_sum(pix, s->linesize);
2653
    
2654
                    varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
2655

    
2656
                    s->current_picture.mb_var [s->mb_width * mb_y + mb_x] = varc;
2657
                    s->current_picture.mb_mean[s->mb_width * mb_y + mb_x] = (sum+128)>>8;
2658
                    s->current_picture.mb_var_sum    += varc;
2659
                }
2660
            }
2661
        }
2662
    }
2663
    emms_c();
2664

    
2665
    if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
2666
        s->pict_type= I_TYPE;
2667
        memset(s->mb_type   , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
2668
//printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
2669
    }
2670

    
2671
    if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) 
2672
        s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
2673
        ff_fix_long_p_mvs(s);
2674
    if(s->pict_type==B_TYPE){
2675
        s->f_code= ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
2676
        s->b_code= ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
2677

    
2678
        ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
2679
        ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
2680
        ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
2681
        ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
2682
    }
2683
    
2684
    if (s->fixed_qscale) 
2685
        s->frame_qscale = s->current_picture.quality;
2686
    else
2687
        s->frame_qscale = ff_rate_estimate_qscale(s);
2688

    
2689
    if(s->adaptive_quant){
2690
        switch(s->codec_id){
2691
        case CODEC_ID_MPEG4:
2692
            ff_clean_mpeg4_qscales(s);
2693
            break;
2694
        case CODEC_ID_H263:
2695
        case CODEC_ID_H263P:
2696
            ff_clean_h263_qscales(s);
2697
            break;
2698
        }
2699

    
2700
        s->qscale= s->current_picture.qscale_table[0];
2701
    }else
2702
        s->qscale= (int)(s->frame_qscale + 0.5);
2703
        
2704
    if (s->out_format == FMT_MJPEG) {
2705
        /* for mjpeg, we do include qscale in the matrix */
2706
        s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
2707
        for(i=1;i<64;i++){
2708
            int j= s->idct_permutation[i];
2709

    
2710
            s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
2711
        }
2712
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, 
2713
                       s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
2714
    }
2715
    
2716
    //FIXME var duplication
2717
    s->current_picture.key_frame= s->pict_type == I_TYPE;
2718
    s->current_picture.pict_type= s->pict_type;
2719

    
2720
    if(s->current_picture.key_frame)
2721
        s->picture_in_gop_number=0;
2722

    
2723
    s->last_bits= get_bit_count(&s->pb);
2724
    switch(s->out_format) {
2725
    case FMT_MJPEG:
2726
        mjpeg_picture_header(s);
2727
        break;
2728
    case FMT_H263:
2729
        if (s->h263_msmpeg4) 
2730
            msmpeg4_encode_picture_header(s, picture_number);
2731
        else if (s->h263_pred)
2732
            mpeg4_encode_picture_header(s, picture_number);
2733
        else if (s->h263_rv10) 
2734
            rv10_encode_picture_header(s, picture_number);
2735
        else
2736
            h263_encode_picture_header(s, picture_number);
2737
        break;
2738
    case FMT_MPEG1:
2739
        mpeg1_encode_picture_header(s, picture_number);
2740
        break;
2741
    }
2742
    bits= get_bit_count(&s->pb);
2743
    s->header_bits= bits - s->last_bits;
2744
    s->last_bits= bits;
2745
    s->mv_bits=0;
2746
    s->misc_bits=0;
2747
    s->i_tex_bits=0;
2748
    s->p_tex_bits=0;
2749
    s->i_count=0;
2750
    s->f_count=0;
2751
    s->b_count=0;
2752
    s->skip_count=0;
2753

    
2754
    for(i=0; i<3; i++){
2755
        /* init last dc values */
2756
        /* note: quant matrix value (8) is implied here */
2757
        s->last_dc[i] = 128;
2758
        
2759
        s->current_picture.error[i] = 0;
2760
    }
2761
    s->mb_incr = 1;
2762
    s->last_mv[0][0][0] = 0;
2763
    s->last_mv[0][0][1] = 0;
2764

    
2765
    if (s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P)
2766
        s->gob_index = ff_h263_get_gob_height(s);
2767

    
2768
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
2769
        ff_mpeg4_init_partitions(s);
2770

    
2771
    s->resync_mb_x=0;
2772
    s->resync_mb_y=0;
2773
    s->first_slice_line = 1;
2774
    s->ptr_lastgob = s->pb.buf;
2775
    s->ptr_last_mb_line = s->pb.buf;
2776
    for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2777
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2778
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2779
        
2780
        s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
2781
        s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
2782
        s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
2783
        s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
2784
        s->block_index[4]= s->block_wrap[4]*(mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2);
2785
        s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
2786
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2787
            const int mb_type= s->mb_type[mb_y * s->mb_width + mb_x];
2788
            const int xy= (mb_y+1) * (s->mb_width+2) + mb_x + 1;
2789
//            int d;
2790
            int dmin=10000000;
2791

    
2792
            s->mb_x = mb_x;
2793
            s->mb_y = mb_y;
2794
            s->block_index[0]+=2;
2795
            s->block_index[1]+=2;
2796
            s->block_index[2]+=2;
2797
            s->block_index[3]+=2;
2798
            s->block_index[4]++;
2799
            s->block_index[5]++;
2800

    
2801
            /* write gob / video packet header  */
2802
            if(s->rtp_mode){
2803
                int current_packet_size, is_gob_start;
2804
                
2805
                current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
2806
                is_gob_start=0;
2807
                
2808
                if(s->codec_id==CODEC_ID_MPEG4){
2809
                    if(current_packet_size + s->mb_line_avgsize/s->mb_width >= s->rtp_payload_size
2810
                       && s->mb_y + s->mb_x>0){
2811

    
2812
                        if(s->partitioned_frame){
2813
                            ff_mpeg4_merge_partitions(s);
2814
                            ff_mpeg4_init_partitions(s);
2815
                        }
2816
                        ff_mpeg4_encode_video_packet_header(s);
2817

    
2818
                        if(s->flags&CODEC_FLAG_PASS1){
2819
                            int bits= get_bit_count(&s->pb);
2820
                            s->misc_bits+= bits - s->last_bits;
2821
                            s->last_bits= bits;
2822
                        }
2823
                        ff_mpeg4_clean_buffers(s);
2824
                        is_gob_start=1;
2825
                    }
2826
                }else{
2827
                    if(current_packet_size + s->mb_line_avgsize*s->gob_index >= s->rtp_payload_size
2828
                       && s->mb_x==0 && s->mb_y>0 && s->mb_y%s->gob_index==0){
2829
                       
2830
                        h263_encode_gob_header(s, mb_y);                       
2831
                        is_gob_start=1;
2832
                    }
2833
                }
2834

    
2835
                if(is_gob_start){
2836
                    s->ptr_lastgob = pbBufPtr(&s->pb);
2837
                    s->first_slice_line=1;
2838
                    s->resync_mb_x=mb_x;
2839
                    s->resync_mb_y=mb_y;
2840
                }
2841
            }
2842

    
2843
            if(  (s->resync_mb_x   == s->mb_x)
2844
               && s->resync_mb_y+1 == s->mb_y){
2845
                s->first_slice_line=0; 
2846
            }
2847

    
2848
            if(mb_type & (mb_type-1)){ // more than 1 MB type possible
2849
                int next_block=0;
2850
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2851

    
2852
                copy_context_before_encode(&backup_s, s, -1);
2853
                backup_s.pb= s->pb;
2854
                best_s.data_partitioning= s->data_partitioning;
2855
                best_s.partitioned_frame= s->partitioned_frame;
2856
                if(s->data_partitioning){
2857
                    backup_s.pb2= s->pb2;
2858
                    backup_s.tex_pb= s->tex_pb;
2859
                }
2860

    
2861
                if(mb_type&MB_TYPE_INTER){
2862
                    s->mv_dir = MV_DIR_FORWARD;
2863
                    s->mv_type = MV_TYPE_16X16;
2864
                    s->mb_intra= 0;
2865
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
2866
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
2867
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb, 
2868
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2869
                }
2870
                if(mb_type&MB_TYPE_INTER4V){                 
2871
                    s->mv_dir = MV_DIR_FORWARD;
2872
                    s->mv_type = MV_TYPE_8X8;
2873
                    s->mb_intra= 0;
2874
                    for(i=0; i<4; i++){
2875
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
2876
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
2877
                    }
2878
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb, 
2879
                                 &dmin, &next_block, 0, 0);
2880
                }
2881
                if(mb_type&MB_TYPE_FORWARD){
2882
                    s->mv_dir = MV_DIR_FORWARD;
2883
                    s->mv_type = MV_TYPE_16X16;
2884
                    s->mb_intra= 0;
2885
                    s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2886
                    s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2887
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb, 
2888
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2889
                }
2890
                if(mb_type&MB_TYPE_BACKWARD){
2891
                    s->mv_dir = MV_DIR_BACKWARD;
2892
                    s->mv_type = MV_TYPE_16X16;
2893
                    s->mb_intra= 0;
2894
                    s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2895
                    s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2896
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb, 
2897
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2898
                }
2899
                if(mb_type&MB_TYPE_BIDIR){
2900
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2901
                    s->mv_type = MV_TYPE_16X16;
2902
                    s->mb_intra= 0;
2903
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2904
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2905
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2906
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2907
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb, 
2908
                                 &dmin, &next_block, 0, 0);
2909
                }
2910
                if(mb_type&MB_TYPE_DIRECT){
2911
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2912
                    s->mv_type = MV_TYPE_16X16; //FIXME
2913
                    s->mb_intra= 0;
2914
                    s->mv[0][0][0] = s->b_direct_forw_mv_table[xy][0];
2915
                    s->mv[0][0][1] = s->b_direct_forw_mv_table[xy][1];
2916
                    s->mv[1][0][0] = s->b_direct_back_mv_table[xy][0];
2917
                    s->mv[1][0][1] = s->b_direct_back_mv_table[xy][1];
2918
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb, 
2919
                                 &dmin, &next_block, s->b_direct_mv_table[xy][0], s->b_direct_mv_table[xy][1]);
2920
                }
2921
                if(mb_type&MB_TYPE_INTRA){
2922
                    s->mv_dir = MV_DIR_FORWARD;
2923
                    s->mv_type = MV_TYPE_16X16;
2924
                    s->mb_intra= 1;
2925
                    s->mv[0][0][0] = 0;
2926
                    s->mv[0][0][1] = 0;
2927
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb, 
2928
                                 &dmin, &next_block, 0, 0);
2929
                    /* force cleaning of ac/dc pred stuff if needed ... */
2930
                    if(s->h263_pred || s->h263_aic)
2931
                        s->mbintra_table[mb_x + mb_y*s->mb_width]=1;
2932
                }
2933
                copy_context_after_encode(s, &best_s, -1);
2934
                
2935
                pb_bits_count= get_bit_count(&s->pb);
2936
                flush_put_bits(&s->pb);
2937
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2938
                s->pb= backup_s.pb;
2939
                
2940
                if(s->data_partitioning){
2941
                    pb2_bits_count= get_bit_count(&s->pb2);
2942
                    flush_put_bits(&s->pb2);
2943
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2944
                    s->pb2= backup_s.pb2;
2945
                    
2946
                    tex_pb_bits_count= get_bit_count(&s->tex_pb);
2947
                    flush_put_bits(&s->tex_pb);
2948
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2949
                    s->tex_pb= backup_s.tex_pb;
2950
                }
2951
                s->last_bits= get_bit_count(&s->pb);
2952
            } else {
2953
                int motion_x, motion_y;
2954
                s->mv_type=MV_TYPE_16X16;
2955
                // only one MB-Type possible
2956
                switch(mb_type){
2957
                case MB_TYPE_INTRA:
2958
                    s->mv_dir = MV_DIR_FORWARD;
2959
                    s->mb_intra= 1;
2960
                    motion_x= s->mv[0][0][0] = 0;
2961
                    motion_y= s->mv[0][0][1] = 0;
2962
                    break;
2963
                case MB_TYPE_INTER:
2964
                    s->mv_dir = MV_DIR_FORWARD;
2965
                    s->mb_intra= 0;
2966
                    motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2967
                    motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2968
                    break;
2969
                case MB_TYPE_INTER4V:
2970
                    s->mv_dir = MV_DIR_FORWARD;
2971
                    s->mv_type = MV_TYPE_8X8;
2972
                    s->mb_intra= 0;
2973
                    for(i=0; i<4; i++){
2974
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
2975
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
2976
                    }
2977
                    motion_x= motion_y= 0;
2978
                    break;
2979
                case MB_TYPE_DIRECT:
2980
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2981
                    s->mb_intra= 0;
2982
                    motion_x=s->b_direct_mv_table[xy][0];
2983
                    motion_y=s->b_direct_mv_table[xy][1];
2984
                    s->mv[0][0][0] = s->b_direct_forw_mv_table[xy][0];
2985
                    s->mv[0][0][1] = s->b_direct_forw_mv_table[xy][1];
2986
                    s->mv[1][0][0] = s->b_direct_back_mv_table[xy][0];
2987
                    s->mv[1][0][1] = s->b_direct_back_mv_table[xy][1];
2988
                    break;
2989
                case MB_TYPE_BIDIR:
2990
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2991
                    s->mb_intra= 0;
2992
                    motion_x=0;
2993
                    motion_y=0;
2994
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2995
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2996
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2997
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2998
                    break;
2999
                case MB_TYPE_BACKWARD:
3000
                    s->mv_dir = MV_DIR_BACKWARD;
3001
                    s->mb_intra= 0;
3002
                    motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3003
                    motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3004
                    break;
3005
                case MB_TYPE_FORWARD:
3006
                    s->mv_dir = MV_DIR_FORWARD;
3007
                    s->mb_intra= 0;
3008
                    motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3009
                    motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3010
//                    printf(" %d %d ", motion_x, motion_y);
3011
                    break;
3012
                default:
3013
                    motion_x=motion_y=0; //gcc warning fix
3014
                    printf("illegal MB type\n");
3015
                }
3016
                encode_mb(s, motion_x, motion_y);
3017
            }
3018
            /* clean the MV table in IPS frames for direct mode in B frames */
3019
            if(s->mb_intra /* && I,P,S_TYPE */){
3020
                s->p_mv_table[xy][0]=0;
3021
                s->p_mv_table[xy][1]=0;
3022
            }
3023

    
3024
            MPV_decode_mb(s, s->block);
3025
            
3026
            if(s->flags&CODEC_FLAG_PSNR){
3027
                int w= 16;
3028
                int h= 16;
3029

    
3030
                if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3031
                if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3032
                
3033
                s->current_picture.error[0] += sse(
3034
                    s,
3035
                    s->new_picture    .data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3036
                    s->current_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3037
                    w, h, s->linesize);
3038
                s->current_picture.error[1] += sse(
3039
                    s,
3040
                    s->new_picture    .data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3041
                    s->current_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3042
                    w>>1, h>>1, s->uvlinesize);
3043
                s->current_picture.error[2] += sse(
3044
                    s,
3045
                    s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3046
                    s->current_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3047
                    w>>1, h>>1, s->uvlinesize);
3048
            }
3049
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_width, get_bit_count(&s->pb));
3050
        }
3051

    
3052

    
3053
        /* Obtain average mb_row size for RTP */
3054
        if (s->rtp_mode) {
3055
            if (mb_y==0)
3056
                s->mb_line_avgsize = pbBufPtr(&s->pb) - s->ptr_last_mb_line;
3057
            else {    
3058
                s->mb_line_avgsize = (s->mb_line_avgsize + pbBufPtr(&s->pb) - s->ptr_last_mb_line) >> 1;
3059
            }
3060
            s->ptr_last_mb_line = pbBufPtr(&s->pb);
3061
        }
3062
    }
3063
    emms_c();
3064

    
3065
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3066
        ff_mpeg4_merge_partitions(s);
3067

    
3068
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
3069
        msmpeg4_encode_ext_header(s);
3070

    
3071
    if(s->codec_id==CODEC_ID_MPEG4) 
3072
        ff_mpeg4_stuffing(&s->pb);
3073

    
3074
    //if (s->gob_number)
3075
    //    fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
3076
    
3077
    /* Send the last GOB if RTP */    
3078
    if (s->rtp_mode) {
3079
        flush_put_bits(&s->pb);
3080
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
3081
        /* Call the RTP callback to send the last GOB */
3082
        if (s->rtp_callback)
3083
            s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
3084
        s->ptr_lastgob = pbBufPtr(&s->pb);
3085
        //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
3086
    }
3087
}
3088

    
3089
static int dct_quantize_c(MpegEncContext *s, 
3090
                        DCTELEM *block, int n,
3091
                        int qscale, int *overflow)
3092
{
3093
    int i, j, level, last_non_zero, q;
3094
    const int *qmat;
3095
    const UINT8 *scantable= s->intra_scantable.scantable;
3096
    int bias;
3097
    int max=0;
3098
    unsigned int threshold1, threshold2;
3099

    
3100
    s->fdct (block);
3101

    
3102
    if (s->mb_intra) {
3103
        if (!s->h263_aic) {
3104
            if (n < 4)
3105
                q = s->y_dc_scale;
3106
            else
3107
                q = s->c_dc_scale;
3108
            q = q << 3;
3109
        } else
3110
            /* For AIC we skip quant/dequant of INTRADC */
3111
            q = 1 << 3;
3112
            
3113
        /* note: block[0] is assumed to be positive */
3114
        block[0] = (block[0] + (q >> 1)) / q;
3115
        i = 1;
3116
        last_non_zero = 0;
3117
        qmat = s->q_intra_matrix[qscale];
3118
        bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
3119
    } else {
3120
        i = 0;
3121
        last_non_zero = -1;
3122
        qmat = s->q_inter_matrix[qscale];
3123
        bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
3124
    }
3125
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
3126
    threshold2= (threshold1<<1);
3127

    
3128
    for(;i<64;i++) {
3129
        j = scantable[i];
3130
        level = block[j];
3131
        level = level * qmat[j];
3132

    
3133
//        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
3134
//           || bias-level >= (1<<(QMAT_SHIFT - 3))){
3135
        if(((unsigned)(level+threshold1))>threshold2){
3136
            if(level>0){
3137
                level= (bias + level)>>QMAT_SHIFT;
3138
                block[j]= level;
3139
            }else{
3140
                level= (bias - level)>>QMAT_SHIFT;
3141
                block[j]= -level;
3142
            }
3143
            max |=level;
3144
            last_non_zero = i;
3145
        }else{
3146
            block[j]=0;
3147
        }
3148
    }
3149
    *overflow= s->max_qcoeff < max; //overflow might have happend
3150
    
3151
    /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
3152
    if (s->idct_permutation_type != FF_NO_IDCT_PERM)
3153
        ff_block_permute(block, s->idct_permutation, scantable, last_non_zero);
3154

    
3155
    return last_non_zero;
3156
}
3157

    
3158
static void dct_unquantize_mpeg1_c(MpegEncContext *s, 
3159
                                   DCTELEM *block, int n, int qscale)
3160
{
3161
    int i, level, nCoeffs;
3162
    const UINT16 *quant_matrix;
3163

    
3164
    nCoeffs= s->block_last_index[n];
3165
    
3166
    if (s->mb_intra) {
3167
        if (n < 4) 
3168
            block[0] = block[0] * s->y_dc_scale;
3169
        else
3170
            block[0] = block[0] * s->c_dc_scale;
3171
        /* XXX: only mpeg1 */
3172
        quant_matrix = s->intra_matrix;
3173
        for(i=1;i<=nCoeffs;i++) {
3174
            int j= s->intra_scantable.permutated[i];
3175
            level = block[j];
3176
            if (level) {
3177
                if (level < 0) {
3178
                    level = -level;
3179
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3180
                    level = (level - 1) | 1;
3181
                    level = -level;
3182
                } else {
3183
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3184
                    level = (level - 1) | 1;
3185
                }
3186
#ifdef PARANOID
3187
                if (level < -2048 || level > 2047)
3188
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3189
#endif
3190
                block[j] = level;
3191
            }
3192
        }
3193
    } else {
3194
        i = 0;
3195
        quant_matrix = s->inter_matrix;
3196
        for(;i<=nCoeffs;i++) {
3197
            int j= s->intra_scantable.permutated[i];
3198
            level = block[j];
3199
            if (level) {
3200
                if (level < 0) {
3201
                    level = -level;
3202
                    level = (((level << 1) + 1) * qscale *
3203
                             ((int) (quant_matrix[j]))) >> 4;
3204
                    level = (level - 1) | 1;
3205
                    level = -level;
3206
                } else {
3207
                    level = (((level << 1) + 1) * qscale *
3208
                             ((int) (quant_matrix[j]))) >> 4;
3209
                    level = (level - 1) | 1;
3210
                }
3211
#ifdef PARANOID
3212
                if (level < -2048 || level > 2047)
3213
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3214
#endif
3215
                block[j] = level;
3216
            }
3217
        }
3218
    }
3219
}
3220

    
3221
static void dct_unquantize_mpeg2_c(MpegEncContext *s, 
3222
                                   DCTELEM *block, int n, int qscale)
3223
{
3224
    int i, level, nCoeffs;
3225
    const UINT16 *quant_matrix;
3226

    
3227
    if(s->alternate_scan) nCoeffs= 63;
3228
    else nCoeffs= s->block_last_index[n];
3229
    
3230
    if (s->mb_intra) {
3231
        if (n < 4) 
3232
            block[0] = block[0] * s->y_dc_scale;
3233
        else
3234
            block[0] = block[0] * s->c_dc_scale;
3235
        quant_matrix = s->intra_matrix;
3236
        for(i=1;i<=nCoeffs;i++) {
3237
            int j= s->intra_scantable.permutated[i];
3238
            level = block[j];
3239
            if (level) {
3240
                if (level < 0) {
3241
                    level = -level;
3242
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3243
                    level = -level;
3244
                } else {
3245
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3246
                }
3247
#ifdef PARANOID
3248
                if (level < -2048 || level > 2047)
3249
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3250
#endif
3251
                block[j] = level;
3252
            }
3253
        }
3254
    } else {
3255
        int sum=-1;
3256
        i = 0;
3257
        quant_matrix = s->inter_matrix;
3258
        for(;i<=nCoeffs;i++) {
3259
            int j= s->intra_scantable.permutated[i];
3260
            level = block[j];
3261
            if (level) {
3262
                if (level < 0) {
3263
                    level = -level;
3264
                    level = (((level << 1) + 1) * qscale *
3265
                             ((int) (quant_matrix[j]))) >> 4;
3266
                    level = -level;
3267
                } else {
3268
                    level = (((level << 1) + 1) * qscale *
3269
                             ((int) (quant_matrix[j]))) >> 4;
3270
                }
3271
#ifdef PARANOID
3272
                if (level < -2048 || level > 2047)
3273
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3274
#endif
3275
                block[j] = level;
3276
                sum+=level;
3277
            }
3278
        }
3279
        block[63]^=sum&1;
3280
    }
3281
}
3282

    
3283

    
3284
static void dct_unquantize_h263_c(MpegEncContext *s, 
3285
                                  DCTELEM *block, int n, int qscale)
3286
{
3287
    int i, level, qmul, qadd;
3288
    int nCoeffs;
3289
    
3290
    assert(s->block_last_index[n]>=0);
3291
    
3292
    qadd = (qscale - 1) | 1;
3293
    qmul = qscale << 1;
3294
    
3295
    if (s->mb_intra) {
3296
        if (!s->h263_aic) {
3297
            if (n < 4) 
3298
                block[0] = block[0] * s->y_dc_scale;
3299
            else
3300
                block[0] = block[0] * s->c_dc_scale;
3301
        }else
3302
            qadd = 0;
3303
        i = 1;
3304
        nCoeffs= 63; //does not allways use zigzag table 
3305
    } else {
3306
        i = 0;
3307
        nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ];
3308
    }
3309

    
3310
    for(;i<=nCoeffs;i++) {
3311
        level = block[i];
3312
        if (level) {
3313
            if (level < 0) {
3314
                level = level * qmul - qadd;
3315
            } else {
3316
                level = level * qmul + qadd;
3317
            }
3318
#ifdef PARANOID
3319
                if (level < -2048 || level > 2047)
3320
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3321
#endif
3322
            block[i] = level;
3323
        }
3324
    }
3325
}
3326

    
3327
AVCodec mpeg1video_encoder = {
3328
    "mpeg1video",
3329
    CODEC_TYPE_VIDEO,
3330
    CODEC_ID_MPEG1VIDEO,
3331
    sizeof(MpegEncContext),
3332
    MPV_encode_init,
3333
    MPV_encode_picture,
3334
    MPV_encode_end,
3335
};
3336

    
3337
AVCodec h263_encoder = {
3338
    "h263",
3339
    CODEC_TYPE_VIDEO,
3340
    CODEC_ID_H263,
3341
    sizeof(MpegEncContext),
3342
    MPV_encode_init,
3343
    MPV_encode_picture,
3344
    MPV_encode_end,
3345
};
3346

    
3347
AVCodec h263p_encoder = {
3348
    "h263p",
3349
    CODEC_TYPE_VIDEO,
3350
    CODEC_ID_H263P,
3351
    sizeof(MpegEncContext),
3352
    MPV_encode_init,
3353
    MPV_encode_picture,
3354
    MPV_encode_end,
3355
};
3356

    
3357
AVCodec rv10_encoder = {
3358
    "rv10",
3359
    CODEC_TYPE_VIDEO,
3360
    CODEC_ID_RV10,
3361
    sizeof(MpegEncContext),
3362
    MPV_encode_init,
3363
    MPV_encode_picture,
3364
    MPV_encode_end,
3365
};
3366

    
3367
AVCodec mjpeg_encoder = {
3368
    "mjpeg",
3369
    CODEC_TYPE_VIDEO,
3370
    CODEC_ID_MJPEG,
3371
    sizeof(MpegEncContext),
3372
    MPV_encode_init,
3373
    MPV_encode_picture,
3374
    MPV_encode_end,
3375
};
3376

    
3377
AVCodec mpeg4_encoder = {
3378
    "mpeg4",
3379
    CODEC_TYPE_VIDEO,
3380
    CODEC_ID_MPEG4,
3381
    sizeof(MpegEncContext),
3382
    MPV_encode_init,
3383
    MPV_encode_picture,
3384
    MPV_encode_end,
3385
};
3386

    
3387
AVCodec msmpeg4v1_encoder = {
3388
    "msmpeg4v1",
3389
    CODEC_TYPE_VIDEO,
3390
    CODEC_ID_MSMPEG4V1,
3391
    sizeof(MpegEncContext),
3392
    MPV_encode_init,
3393
    MPV_encode_picture,
3394
    MPV_encode_end,
3395
};
3396

    
3397
AVCodec msmpeg4v2_encoder = {
3398
    "msmpeg4v2",
3399
    CODEC_TYPE_VIDEO,
3400
    CODEC_ID_MSMPEG4V2,
3401
    sizeof(MpegEncContext),
3402
    MPV_encode_init,
3403
    MPV_encode_picture,
3404
    MPV_encode_end,
3405
};
3406

    
3407
AVCodec msmpeg4v3_encoder = {
3408
    "msmpeg4",
3409
    CODEC_TYPE_VIDEO,
3410
    CODEC_ID_MSMPEG4V3,
3411
    sizeof(MpegEncContext),
3412
    MPV_encode_init,
3413
    MPV_encode_picture,
3414
    MPV_encode_end,
3415
};
3416

    
3417
AVCodec wmv1_encoder = {
3418
    "wmv1",
3419
    CODEC_TYPE_VIDEO,
3420
    CODEC_ID_WMV1,
3421
    sizeof(MpegEncContext),
3422
    MPV_encode_init,
3423
    MPV_encode_picture,
3424
    MPV_encode_end,
3425
};
3426

    
3427
AVCodec wmv2_encoder = {
3428
    "wmv2",
3429
    CODEC_TYPE_VIDEO,
3430
    CODEC_ID_WMV2,
3431
    sizeof(MpegEncContext),
3432
    MPV_encode_init,
3433
    MPV_encode_picture,
3434
    MPV_encode_end,
3435
};