Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 741235eb

History | View | Annotate | Download (132 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
static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
45

    
46
void (*draw_edges)(UINT8 *buf, int wrap, int width, int height, int w)= draw_edges_c;
47

    
48

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

    
52
//#define DEBUG
53

    
54

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

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

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

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

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

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

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

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

    
132
                if(qmat16[qscale][i]==0 || qmat16[qscale][i]==128*256) qmat16[qscale][i]=128*256-1;
133
                qmat16_bias[qscale][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][i]);
134
            }
135
        }
136
    }
137
}
138
// move into common.c perhaps 
139
#define CHECKED_ALLOCZ(p, size)\
140
{\
141
    p= av_mallocz(size);\
142
    if(p==NULL){\
143
        perror("malloc");\
144
        goto fail;\
145
    }\
146
}
147

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

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

    
172
/* XXX: those functions should be suppressed ASAP when all IDCTs are
173
 converted */
174
// *FIXME* this is ugly hack using local static
175
static void (*ff_put_pixels_clamped)(const DCTELEM *block, UINT8 *pixels, int line_size);
176
static void (*ff_add_pixels_clamped)(const DCTELEM *block, UINT8 *pixels, int line_size);
177
static void ff_jref_idct_put(UINT8 *dest, int line_size, DCTELEM *block)
178
{
179
    j_rev_dct (block);
180
    ff_put_pixels_clamped(block, dest, line_size);
181
}
182
static void ff_jref_idct_add(UINT8 *dest, int line_size, DCTELEM *block)
183
{
184
    j_rev_dct (block);
185
    ff_add_pixels_clamped(block, dest, line_size);
186
}
187

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

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

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

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

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

    
235
    if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
236
        s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
237
    }
238

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

    
261

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

    
270
    return 0;
271
}
272

    
273
/**
274
 * allocates a Picture
275
 * The pixels are allocated/set by calling get_buffer() if shared=0
276
 */
277
static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
278
    
279
    if(shared){
280
        assert(pic->data[0]);
281
        assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
282
        pic->type= FF_BUFFER_TYPE_SHARED;
283
    }else{
284
        int r;
285
        
286
        assert(!pic->data[0]);
287
        
288
        r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
289
        
290
        if(r<0 || !pic->age || !pic->type || !pic->data[0]){
291
            fprintf(stderr, "get_buffer() failed (%d %d %d %X)\n", r, pic->age, pic->type, (int)pic->data[0]);
292
            return -1;
293
        }
294

    
295
        if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
296
            fprintf(stderr, "get_buffer() failed (stride changed)\n");
297
            return -1;
298
        }
299

    
300
        if(pic->linesize[1] != pic->linesize[2]){
301
            fprintf(stderr, "get_buffer() failed (uv stride missmatch)\n");
302
            return -1;
303
        }
304

    
305
        s->linesize  = pic->linesize[0];
306
        s->uvlinesize= pic->linesize[1];
307
    }
308
    
309
    if(pic->qscale_table==NULL){
310
        if (s->encoding) {        
311
            CHECKED_ALLOCZ(pic->mb_var   , s->mb_num * sizeof(INT16))
312
            CHECKED_ALLOCZ(pic->mc_mb_var, s->mb_num * sizeof(INT16))
313
            CHECKED_ALLOCZ(pic->mb_mean  , s->mb_num * sizeof(INT8))
314
        }
315

    
316
        CHECKED_ALLOCZ(pic->mbskip_table , s->mb_num * sizeof(UINT8)+1) //the +1 is for the slice end check
317
        CHECKED_ALLOCZ(pic->qscale_table , s->mb_num * sizeof(UINT8))
318
        pic->qstride= s->mb_width;
319
    }
320
    
321
    return 0;
322
fail: //for the CHECKED_ALLOCZ macro
323
    return -1;
324
}
325

    
326
/**
327
 * deallocates a picture
328
 */
329
static void free_picture(MpegEncContext *s, Picture *pic){
330
    int i;
331

    
332
    if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
333
        s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
334
    }
335

    
336
    av_freep(&pic->mb_var);
337
    av_freep(&pic->mc_mb_var);
338
    av_freep(&pic->mb_mean);
339
    av_freep(&pic->mbskip_table);
340
    av_freep(&pic->qscale_table);
341
    
342
    if(pic->type == FF_BUFFER_TYPE_INTERNAL){
343
        for(i=0; i<4; i++){
344
            av_freep(&pic->base[i]);
345
            pic->data[i]= NULL;
346
        }
347
        av_freep(&pic->opaque);
348
        pic->type= 0;
349
    }else if(pic->type == FF_BUFFER_TYPE_SHARED){
350
        for(i=0; i<4; i++){
351
            pic->base[i]=
352
            pic->data[i]= NULL;
353
        }
354
        pic->type= 0;        
355
    }
356
}
357

    
358
/* init common structure for both encoder and decoder */
359
int MPV_common_init(MpegEncContext *s)
360
{
361
    int y_size, c_size, yc_size, i;
362

    
363
    dsputil_init(&s->dsp, s->avctx->dsp_mask);
364
    DCT_common_init(s);
365

    
366
    s->flags= s->avctx->flags;
367

    
368
    s->mb_width  = (s->width  + 15) / 16;
369
    s->mb_height = (s->height + 15) / 16;
370

    
371
    /* set default edge pos, will be overriden in decode_header if needed */
372
    s->h_edge_pos= s->mb_width*16;
373
    s->v_edge_pos= s->mb_height*16;
374

    
375
    s->mb_num = s->mb_width * s->mb_height;
376

    
377
    y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
378
    c_size = (s->mb_width + 2) * (s->mb_height + 2);
379
    yc_size = y_size + 2 * c_size;
380

    
381
    /* convert fourcc to upper case */
382
    s->avctx->fourcc=   toupper( s->avctx->fourcc     &0xFF)          
383
                     + (toupper((s->avctx->fourcc>>8 )&0xFF)<<8 )
384
                     + (toupper((s->avctx->fourcc>>16)&0xFF)<<16) 
385
                     + (toupper((s->avctx->fourcc>>24)&0xFF)<<24);
386

    
387
    CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
388
    s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
389

    
390
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
391

    
392
    if (s->encoding) {
393
        int mv_table_size= (s->mb_width+2)*(s->mb_height+2);
394

    
395
        /* Allocate MV tables */
396
        CHECKED_ALLOCZ(s->p_mv_table            , mv_table_size * 2 * sizeof(INT16))
397
        CHECKED_ALLOCZ(s->b_forw_mv_table       , mv_table_size * 2 * sizeof(INT16))
398
        CHECKED_ALLOCZ(s->b_back_mv_table       , mv_table_size * 2 * sizeof(INT16))
399
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table , mv_table_size * 2 * sizeof(INT16))
400
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table , mv_table_size * 2 * sizeof(INT16))
401
        CHECKED_ALLOCZ(s->b_direct_mv_table     , mv_table_size * 2 * sizeof(INT16))
402

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

    
409
        if(s->codec_id==CODEC_ID_MPEG4){
410
            CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
411
            CHECKED_ALLOCZ(   s->pb2_buffer, PB_BUFFER_SIZE);
412
        }
413
        
414
        if(s->msmpeg4_version){
415
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
416
        }
417
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
418
    }
419
        
420
    CHECKED_ALLOCZ(s->error_status_table, s->mb_num*sizeof(UINT8))
421
    
422
    if (s->out_format == FMT_H263 || s->encoding) {
423
        int size;
424
        /* Allocate MB type table */
425
        CHECKED_ALLOCZ(s->mb_type  , s->mb_num * sizeof(UINT8))
426

    
427
        /* MV prediction */
428
        size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
429
        CHECKED_ALLOCZ(s->motion_val, size * 2 * sizeof(INT16));
430
    }
431

    
432
    if(s->codec_id==CODEC_ID_MPEG4){
433
        /* interlaced direct mode decoding tables */
434
        CHECKED_ALLOCZ(s->field_mv_table, s->mb_num*2*2 * sizeof(INT16))
435
        CHECKED_ALLOCZ(s->field_select_table, s->mb_num*2* sizeof(INT8))
436
    }
437
    /* 4mv b frame decoding table */
438
    //note this is needed for h263 without b frames too (segfault on damaged streams otherwise)
439
    CHECKED_ALLOCZ(s->co_located_type_table, s->mb_num * sizeof(UINT8))
440
    if (s->out_format == FMT_H263) {
441
        /* ac values */
442
        CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(INT16) * 16);
443
        s->ac_val[1] = s->ac_val[0] + y_size;
444
        s->ac_val[2] = s->ac_val[1] + c_size;
445
        
446
        /* cbp values */
447
        CHECKED_ALLOCZ(s->coded_block, y_size);
448
        
449
        /* divx501 bitstream reorder buffer */
450
        CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
451

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

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

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

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

    
489

    
490
//extern int sads;
491

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

    
497
    av_freep(&s->mb_type);
498
    av_freep(&s->p_mv_table);
499
    av_freep(&s->b_forw_mv_table);
500
    av_freep(&s->b_back_mv_table);
501
    av_freep(&s->b_bidir_forw_mv_table);
502
    av_freep(&s->b_bidir_back_mv_table);
503
    av_freep(&s->b_direct_mv_table);
504
    av_freep(&s->motion_val);
505
    av_freep(&s->dc_val[0]);
506
    av_freep(&s->ac_val[0]);
507
    av_freep(&s->coded_block);
508
    av_freep(&s->mbintra_table);
509
    av_freep(&s->cbp_table);
510
    av_freep(&s->pred_dir_table);
511
    av_freep(&s->me.scratchpad);
512
    av_freep(&s->me.map);
513
    av_freep(&s->me.score_map);
514
    
515
    av_freep(&s->mbskip_table);
516
    av_freep(&s->bitstream_buffer);
517
    av_freep(&s->tex_pb_buffer);
518
    av_freep(&s->pb2_buffer);
519
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
520
    av_freep(&s->co_located_type_table);
521
    av_freep(&s->field_mv_table);
522
    av_freep(&s->field_select_table);
523
    av_freep(&s->avctx->stats_out);
524
    av_freep(&s->ac_stats);
525
    av_freep(&s->error_status_table);
526

    
527
    for(i=0; i<MAX_PICTURE_COUNT; i++){
528
        free_picture(s, &s->picture[i]);
529
    }
530
    s->context_initialized = 0;
531
}
532

    
533
/* init video encoder */
534
int MPV_encode_init(AVCodecContext *avctx)
535
{
536
    MpegEncContext *s = avctx->priv_data;
537
    int i;
538

    
539
    avctx->pix_fmt = PIX_FMT_YUV420P;
540

    
541
    s->bit_rate = avctx->bit_rate;
542
    s->bit_rate_tolerance = avctx->bit_rate_tolerance;
543
    s->frame_rate = avctx->frame_rate;
544
    s->width = avctx->width;
545
    s->height = avctx->height;
546
    if(avctx->gop_size > 600){
547
        fprintf(stderr, "Warning keyframe interval too large! reducing it ...\n");
548
        avctx->gop_size=600;
549
    }
550
    s->gop_size = avctx->gop_size;
551
    s->rtp_mode = avctx->rtp_mode;
552
    s->rtp_payload_size = avctx->rtp_payload_size;
553
    if (avctx->rtp_callback)
554
        s->rtp_callback = avctx->rtp_callback;
555
    s->qmin= avctx->qmin;
556
    s->qmax= avctx->qmax;
557
    s->max_qdiff= avctx->max_qdiff;
558
    s->qcompress= avctx->qcompress;
559
    s->qblur= avctx->qblur;
560
    s->avctx = avctx;
561
    s->flags= avctx->flags;
562
    s->max_b_frames= avctx->max_b_frames;
563
    s->b_frame_strategy= avctx->b_frame_strategy;
564
    s->codec_id= avctx->codec->id;
565
    s->luma_elim_threshold  = avctx->luma_elim_threshold;
566
    s->chroma_elim_threshold= avctx->chroma_elim_threshold;
567
    s->strict_std_compliance= avctx->strict_std_compliance;
568
    s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
569
    s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
570
    s->mpeg_quant= avctx->mpeg_quant;
571

    
572
    if (s->gop_size <= 1) {
573
        s->intra_only = 1;
574
        s->gop_size = 12;
575
    } else {
576
        s->intra_only = 0;
577
    }
578

    
579
    s->me_method = avctx->me_method;
580

    
581
    /* Fixed QSCALE */
582
    s->fixed_qscale = (avctx->flags & CODEC_FLAG_QSCALE);
583
    
584
    s->adaptive_quant= (   s->avctx->lumi_masking
585
                        || s->avctx->dark_masking
586
                        || s->avctx->temporal_cplx_masking 
587
                        || s->avctx->spatial_cplx_masking
588
                        || s->avctx->p_masking)
589
                       && !s->fixed_qscale;
590
    
591
    s->progressive_sequence= !(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
592

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

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

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

    
721
    s->encoding = 1;
722

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

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

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

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

    
762
    if(ff_rate_control_init(s) < 0)
763
        return -1;
764

    
765
    s->picture_number = 0;
766
    s->picture_in_gop_number = 0;
767
    s->fake_picture_number = 0;
768
    /* motion detector init */
769
    s->f_code = 1;
770
    s->b_code = 1;
771

    
772
    return 0;
773
}
774

    
775
int MPV_encode_end(AVCodecContext *avctx)
776
{
777
    MpegEncContext *s = avctx->priv_data;
778

    
779
#ifdef STATS
780
    print_stats();
781
#endif
782

    
783
    ff_rate_control_uninit(s);
784

    
785
    MPV_common_end(s);
786
    if (s->out_format == FMT_MJPEG)
787
        mjpeg_close(s);
788
      
789
    return 0;
790
}
791

    
792
/* draw the edges of width 'w' of an image of size width, height */
793
//FIXME check that this is ok for mpeg4 interlaced
794
static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w)
795
{
796
    UINT8 *ptr, *last_line;
797
    int i;
798

    
799
    last_line = buf + (height - 1) * wrap;
800
    for(i=0;i<w;i++) {
801
        /* top and bottom */
802
        memcpy(buf - (i + 1) * wrap, buf, width);
803
        memcpy(last_line + (i + 1) * wrap, last_line, width);
804
    }
805
    /* left and right */
806
    ptr = buf;
807
    for(i=0;i<height;i++) {
808
        memset(ptr - w, ptr[0], w);
809
        memset(ptr + width, ptr[width-1], w);
810
        ptr += wrap;
811
    }
812
    /* corners */
813
    for(i=0;i<w;i++) {
814
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
815
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
816
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
817
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
818
    }
819
}
820

    
821
static int find_unused_picture(MpegEncContext *s, int shared){
822
    int i;
823
    
824
    if(shared){
825
        for(i=0; i<MAX_PICTURE_COUNT; i++){
826
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) break;
827
        }
828
    }else{
829
        for(i=0; i<MAX_PICTURE_COUNT; i++){
830
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) break;
831
        }
832
        for(i=0; i<MAX_PICTURE_COUNT; i++){
833
            if(s->picture[i].data[0]==NULL) break;
834
        }
835
    }
836

    
837
    assert(i<MAX_PICTURE_COUNT);
838
    return i;
839
}
840

    
841
/* generic function for encode/decode called before a frame is coded/decoded */
842
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
843
{
844
    int i;
845
    AVFrame *pic;
846

    
847
    s->mb_skiped = 0;
848
    
849
    /* mark&release old frames */
850
    if (s->pict_type != B_TYPE && s->last_picture.data[0]) {
851
        for(i=0; i<MAX_PICTURE_COUNT; i++){
852
//printf("%8X %d %d %X %X\n", s->picture[i].data[0], s->picture[i].type, i, s->next_picture.data[0], s->last_picture.data[0]);
853
            if(s->picture[i].data[0] == s->last_picture.data[0]){
854
//                s->picture[i].reference=0;
855
                avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
856
                break;
857
            }    
858
        }
859
        assert(i<MAX_PICTURE_COUNT);
860

    
861
        /* release forgotten pictures */
862
        /* if(mpeg124/h263) */
863
        if(!s->encoding){
864
            for(i=0; i<MAX_PICTURE_COUNT; i++){
865
                if(s->picture[i].data[0] && s->picture[i].data[0] != s->next_picture.data[0] && s->picture[i].reference){
866
                    fprintf(stderr, "releasing zombie picture\n");
867
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
868
                }
869
            }
870
        }
871
    }
872
alloc:
873
    if(!s->encoding){
874
        i= find_unused_picture(s, 0);
875
    
876
        pic= (AVFrame*)&s->picture[i];
877
        pic->reference= s->pict_type != B_TYPE;
878
        pic->coded_picture_number= s->current_picture.coded_picture_number+1;
879
        
880
        alloc_picture(s, (Picture*)pic, 0);
881

    
882
        s->current_picture= s->picture[i];
883
    }
884

    
885
    if (s->pict_type != B_TYPE) {
886
        s->last_picture= s->next_picture;
887
        s->next_picture= s->current_picture;
888
    }
889
    
890
    if(s->pict_type != I_TYPE && s->last_picture.data[0]==NULL){
891
        fprintf(stderr, "warning: first frame is no keyframe\n");
892
        assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
893
        goto alloc;
894
    }
895
   
896
    s->hurry_up= s->avctx->hurry_up;
897
    s->error_resilience= avctx->error_resilience;
898

    
899
    /* set dequantizer, we cant do it during init as it might change for mpeg4
900
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
901
    if(s->out_format == FMT_H263){
902
        if(s->mpeg_quant)
903
            s->dct_unquantize = s->dct_unquantize_mpeg2;
904
        else
905
            s->dct_unquantize = s->dct_unquantize_h263;
906
    }else 
907
        s->dct_unquantize = s->dct_unquantize_mpeg1;
908

    
909
    return 0;
910
}
911

    
912
/* generic function for encode/decode called after a frame has been coded/decoded */
913
void MPV_frame_end(MpegEncContext *s)
914
{
915
    int i;
916
    /* draw edge for correct motion prediction if outside */
917
    if(s->codec_id!=CODEC_ID_SVQ1){
918
        if (s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
919
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
920
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
921
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
922
        }
923
    }
924
    emms_c();
925
    
926
    s->last_pict_type    = s->pict_type;
927
    if(s->pict_type!=B_TYPE){
928
        s->last_non_b_pict_type= s->pict_type;
929
    }
930
    
931
    s->current_picture.quality= s->qscale; //FIXME get average of qscale_table
932
    s->current_picture.pict_type= s->pict_type;
933
    s->current_picture.key_frame= s->pict_type == I_TYPE;
934
    
935
    /* copy back current_picture variables */
936
    for(i=0; i<MAX_PICTURE_COUNT; i++){
937
        if(s->picture[i].data[0] == s->current_picture.data[0]){
938
            s->picture[i]= s->current_picture;
939
            break;
940
        }    
941
    }
942
    assert(i<MAX_PICTURE_COUNT);
943

    
944
    /* release non refernce frames */
945
    for(i=0; i<MAX_PICTURE_COUNT; i++){
946
        if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/)
947
            s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
948
    }
949
    if(s->avctx->debug&FF_DEBUG_SKIP){
950
        int x,y;        
951
        for(y=0; y<s->mb_height; y++){
952
            for(x=0; x<s->mb_width; x++){
953
                int count= s->mbskip_table[x + y*s->mb_width];
954
                if(count>9) count=9;
955
                printf(" %1d", count);
956
            }
957
            printf("\n");
958
        }
959
        printf("pict type: %d\n", s->pict_type);
960
    }
961
}
962

    
963
static int get_sae(uint8_t *src, int ref, int stride){
964
    int x,y;
965
    int acc=0;
966
    
967
    for(y=0; y<16; y++){
968
        for(x=0; x<16; x++){
969
            acc+= ABS(src[x+y*stride] - ref);
970
        }
971
    }
972
    
973
    return acc;
974
}
975

    
976
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
977
    int x, y, w, h;
978
    int acc=0;
979
    
980
    w= s->width &~15;
981
    h= s->height&~15;
982
    
983
    for(y=0; y<h; y+=16){
984
        for(x=0; x<w; x+=16){
985
            int offset= x + y*stride;
986
            int sad = s->dsp.pix_abs16x16(src + offset, ref + offset, stride);
987
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
988
            int sae = get_sae(src + offset, mean, stride);
989
            
990
            acc+= sae + 500 < sad;
991
        }
992
    }
993
    return acc;
994
}
995

    
996

    
997
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
998
    AVFrame *pic;
999
    int i;
1000
    const int encoding_delay= s->max_b_frames;
1001
    int direct=1;
1002

    
1003
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1004
    if(pic_arg->linesize[0] != s->linesize) direct=0;
1005
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1006
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1007
  
1008
//    printf("%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1009
    
1010
    if(direct){
1011
        i= find_unused_picture(s, 1);
1012

    
1013
        pic= (AVFrame*)&s->picture[i];
1014
        pic->reference= 1;
1015
    
1016
        for(i=0; i<4; i++){
1017
            pic->data[i]= pic_arg->data[i];
1018
            pic->linesize[i]= pic_arg->linesize[i];
1019
        }
1020
        alloc_picture(s, (Picture*)pic, 1);
1021
    }else{
1022
        i= find_unused_picture(s, 0);
1023

    
1024
        pic= (AVFrame*)&s->picture[i];
1025
        pic->reference= 1;
1026

    
1027
        alloc_picture(s, (Picture*)pic, 0);
1028

    
1029
        if(   pic->data[0] == pic_arg->data[0] 
1030
           && pic->data[1] == pic_arg->data[1]
1031
           && pic->data[2] == pic_arg->data[2]){
1032
       // empty
1033
        }else{
1034
            int h_chroma_shift, v_chroma_shift;
1035
        
1036
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1037
        
1038
            for(i=0; i<3; i++){
1039
                int src_stride= pic_arg->linesize[i];
1040
                int dst_stride= i ? s->uvlinesize : s->linesize;
1041
                int h_shift= i ? h_chroma_shift : 0;
1042
                int v_shift= i ? v_chroma_shift : 0;
1043
                int w= s->width >>h_shift;
1044
                int h= s->height>>v_shift;
1045
                uint8_t *src= pic_arg->data[i];
1046
                uint8_t *dst= pic->data[i];
1047
            
1048
                if(src_stride==dst_stride)
1049
                    memcpy(dst, src, src_stride*h);
1050
                else{
1051
                    while(h--){
1052
                        memcpy(dst, src, w);
1053
                        dst += dst_stride;
1054
                        src += src_stride;
1055
                    }
1056
                }
1057
            }
1058
        }
1059
    }
1060
    pic->quality= pic_arg->quality;
1061
    pic->pict_type= pic_arg->pict_type;
1062
    pic->pts = pic_arg->pts;
1063
    
1064
    if(s->input_picture[encoding_delay])
1065
        pic->display_picture_number= s->input_picture[encoding_delay]->display_picture_number + 1;
1066

    
1067
    /* shift buffer entries */
1068
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1069
        s->input_picture[i-1]= s->input_picture[i];
1070
        
1071
    s->input_picture[encoding_delay]= (Picture*)pic;
1072

    
1073
    return 0;
1074
}
1075

    
1076
static void select_input_picture(MpegEncContext *s){
1077
    int i;
1078
    const int encoding_delay= s->max_b_frames;
1079
    int coded_pic_num=0;    
1080

    
1081
    if(s->reordered_input_picture[0])
1082
        coded_pic_num= s->reordered_input_picture[0]->coded_picture_number + 1;
1083

    
1084
    for(i=1; i<MAX_PICTURE_COUNT; i++)
1085
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1086
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1087

    
1088
    /* set next picture types & ordering */
1089
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1090
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture.data[0]==NULL || s->intra_only){
1091
            s->reordered_input_picture[0]= s->input_picture[0];
1092
            s->reordered_input_picture[0]->pict_type= I_TYPE;
1093
            s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1094
        }else{
1095
            int b_frames;
1096
            
1097
            if(s->flags&CODEC_FLAG_PASS2){
1098
                for(i=0; i<s->max_b_frames+1; i++){
1099
                    int pict_num= s->input_picture[0]->display_picture_number + i;
1100
                    int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1101
                    s->input_picture[i]->pict_type= pict_type;
1102
                    
1103
                    if(i + 1 >= s->rc_context.num_entries) break;
1104
                }
1105
            }
1106

    
1107
            if(s->input_picture[0]->pict_type){
1108
                /* user selected pict_type */
1109
                for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
1110
                    if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
1111
                }
1112
            
1113
                if(b_frames > s->max_b_frames){
1114
                    fprintf(stderr, "warning, too many bframes in a row\n");
1115
                    b_frames = s->max_b_frames;
1116
                }
1117
            }else if(s->b_frame_strategy==0){
1118
                b_frames= s->max_b_frames;
1119
            }else if(s->b_frame_strategy==1){
1120
                for(i=1; i<s->max_b_frames+1; i++){
1121
                    if(s->input_picture[i]->b_frame_score==0){
1122
                        s->input_picture[i]->b_frame_score= 
1123
                            get_intra_count(s, s->input_picture[i  ]->data[0], 
1124
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
1125
                    }
1126
                }
1127
                for(i=0; i<s->max_b_frames; i++){
1128
                    if(s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
1129
                }
1130
                                
1131
                b_frames= FFMAX(0, i-1);
1132
                
1133
                /* reset scores */
1134
                for(i=0; i<b_frames+1; i++){
1135
                    s->input_picture[i]->b_frame_score=0;
1136
                }
1137
            }else{
1138
                fprintf(stderr, "illegal b frame strategy\n");
1139
                b_frames=0;
1140
            }
1141

    
1142
            emms_c();
1143
//static int b_count=0;
1144
//b_count+= b_frames;
1145
//printf("b_frames: %d\n", b_count);
1146
                        
1147
            s->reordered_input_picture[0]= s->input_picture[b_frames];
1148
            if(   s->picture_in_gop_number + b_frames >= s->gop_size 
1149
               || s->reordered_input_picture[0]->pict_type== I_TYPE)
1150
                s->reordered_input_picture[0]->pict_type= I_TYPE;
1151
            else
1152
                s->reordered_input_picture[0]->pict_type= P_TYPE;
1153
            s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1154
            for(i=0; i<b_frames; i++){
1155
                coded_pic_num++;
1156
                s->reordered_input_picture[i+1]= s->input_picture[i];
1157
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
1158
                s->reordered_input_picture[i+1]->coded_picture_number= coded_pic_num;
1159
            }
1160
        }
1161
    }
1162
    
1163
    if(s->reordered_input_picture[0]){
1164
       s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE;
1165

    
1166
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
1167
            int i= find_unused_picture(s, 0);
1168
            Picture *pic= &s->picture[i];
1169

    
1170
            s->new_picture= *s->reordered_input_picture[0];
1171

    
1172
            /* mark us unused / free shared pic */
1173
            for(i=0; i<4; i++)
1174
                s->reordered_input_picture[0]->data[i]= NULL;
1175
            s->reordered_input_picture[0]->type= 0;
1176
            
1177
            pic->pict_type = s->reordered_input_picture[0]->pict_type;
1178
            pic->quality   = s->reordered_input_picture[0]->quality;
1179
            pic->coded_picture_number = s->reordered_input_picture[0]->coded_picture_number;
1180
            pic->reference = s->reordered_input_picture[0]->reference;
1181
            
1182
            alloc_picture(s, pic, 0);
1183

    
1184
            s->current_picture= *pic;
1185
        }else{
1186
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
1187
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
1188
            
1189
            s->new_picture= *s->reordered_input_picture[0];
1190

    
1191
            for(i=0; i<4; i++){
1192
                s->reordered_input_picture[0]->data[i]-=16; //FIXME dirty
1193
            }
1194
            s->current_picture= *s->reordered_input_picture[0];
1195
        }
1196
    
1197
        s->picture_number= s->new_picture.display_picture_number;
1198
//printf("dpn:%d\n", s->picture_number);
1199
    }else{
1200
       memset(&s->new_picture, 0, sizeof(Picture));
1201
    }
1202
}
1203

    
1204
int MPV_encode_picture(AVCodecContext *avctx,
1205
                       unsigned char *buf, int buf_size, void *data)
1206
{
1207
    MpegEncContext *s = avctx->priv_data;
1208
    AVFrame *pic_arg = data;
1209
    int i;
1210

    
1211
    init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
1212

    
1213
    s->picture_in_gop_number++;
1214

    
1215
    load_input_picture(s, pic_arg);
1216
    
1217
    select_input_picture(s);
1218
    
1219
    /* output? */
1220
    if(s->new_picture.data[0]){
1221

    
1222
        s->pict_type= s->new_picture.pict_type;
1223
        if (s->fixed_qscale){ /* the ratecontrol needs the last qscale so we dont touch it for CBR */
1224
            s->qscale= (int)(s->new_picture.quality+0.5);
1225
            assert(s->qscale);
1226
        }
1227
//emms_c();
1228
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
1229
        MPV_frame_start(s, avctx);
1230

    
1231
        encode_picture(s, s->picture_number);
1232
        
1233
        avctx->real_pict_num  = s->picture_number;
1234
        avctx->header_bits = s->header_bits;
1235
        avctx->mv_bits     = s->mv_bits;
1236
        avctx->misc_bits   = s->misc_bits;
1237
        avctx->i_tex_bits  = s->i_tex_bits;
1238
        avctx->p_tex_bits  = s->p_tex_bits;
1239
        avctx->i_count     = s->i_count;
1240
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
1241
        avctx->skip_count  = s->skip_count;
1242

    
1243
        MPV_frame_end(s);
1244

    
1245
        if (s->out_format == FMT_MJPEG)
1246
            mjpeg_picture_trailer(s);
1247
        
1248
        if(s->flags&CODEC_FLAG_PASS1)
1249
            ff_write_pass1_stats(s);
1250
    }
1251

    
1252
    s->input_picture_number++;
1253

    
1254
    flush_put_bits(&s->pb);
1255
    s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1256
    
1257
    s->total_bits += s->frame_bits;
1258
    avctx->frame_bits  = s->frame_bits;
1259

    
1260
    for(i=0; i<4; i++){
1261
        avctx->error[i] += s->current_picture.error[i];
1262
    }
1263
    
1264
    return pbBufPtr(&s->pb) - s->pb.buf;
1265
}
1266

    
1267
static inline void gmc1_motion(MpegEncContext *s,
1268
                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1269
                               int dest_offset,
1270
                               UINT8 **ref_picture, int src_offset)
1271
{
1272
    UINT8 *ptr;
1273
    int offset, src_x, src_y, linesize, uvlinesize;
1274
    int motion_x, motion_y;
1275
    int emu=0;
1276

    
1277
    motion_x= s->sprite_offset[0][0];
1278
    motion_y= s->sprite_offset[0][1];
1279
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1280
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1281
    motion_x<<=(3-s->sprite_warping_accuracy);
1282
    motion_y<<=(3-s->sprite_warping_accuracy);
1283
    src_x = clip(src_x, -16, s->width);
1284
    if (src_x == s->width)
1285
        motion_x =0;
1286
    src_y = clip(src_y, -16, s->height);
1287
    if (src_y == s->height)
1288
        motion_y =0;
1289

    
1290
    linesize = s->linesize;
1291
    uvlinesize = s->uvlinesize;
1292
    
1293
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1294

    
1295
    dest_y+=dest_offset;
1296
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1297
        if(src_x<0 || src_y<0 || src_x + 17 >= s->h_edge_pos
1298
                              || src_y + 17 >= s->v_edge_pos){
1299
            ff_emulated_edge_mc(s, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1300
            ptr= s->edge_emu_buffer;
1301
        }
1302
    }
1303
    
1304
    if((motion_x|motion_y)&7){
1305
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1306
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1307
    }else{
1308
        int dxy;
1309
        
1310
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
1311
        if (s->no_rounding){
1312
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
1313
        }else{
1314
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
1315
        }
1316
    }
1317
    
1318
    if(s->flags&CODEC_FLAG_GRAY) return;
1319

    
1320
    motion_x= s->sprite_offset[1][0];
1321
    motion_y= s->sprite_offset[1][1];
1322
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
1323
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
1324
    motion_x<<=(3-s->sprite_warping_accuracy);
1325
    motion_y<<=(3-s->sprite_warping_accuracy);
1326
    src_x = clip(src_x, -8, s->width>>1);
1327
    if (src_x == s->width>>1)
1328
        motion_x =0;
1329
    src_y = clip(src_y, -8, s->height>>1);
1330
    if (src_y == s->height>>1)
1331
        motion_y =0;
1332

    
1333
    offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
1334
    ptr = ref_picture[1] + offset;
1335
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1336
        if(src_x<0 || src_y<0 || src_x + 9 >= s->h_edge_pos>>1
1337
                              || src_y + 9 >= s->v_edge_pos>>1){
1338
            ff_emulated_edge_mc(s, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1339
            ptr= s->edge_emu_buffer;
1340
            emu=1;
1341
        }
1342
    }
1343
    s->dsp.gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1344
    
1345
    ptr = ref_picture[2] + offset;
1346
    if(emu){
1347
        ff_emulated_edge_mc(s, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1348
        ptr= s->edge_emu_buffer;
1349
    }
1350
    s->dsp.gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1351
    
1352
    return;
1353
}
1354

    
1355
static inline void gmc_motion(MpegEncContext *s,
1356
                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1357
                               int dest_offset,
1358
                               UINT8 **ref_picture, int src_offset)
1359
{
1360
    UINT8 *ptr;
1361
    int linesize, uvlinesize;
1362
    const int a= s->sprite_warping_accuracy;
1363
    int ox, oy;
1364

    
1365
    linesize = s->linesize;
1366
    uvlinesize = s->uvlinesize;
1367

    
1368
    ptr = ref_picture[0] + src_offset;
1369

    
1370
    dest_y+=dest_offset;
1371
    
1372
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
1373
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
1374

    
1375
    s->dsp.gmc(dest_y, ptr, linesize, 16,
1376
           ox, 
1377
           oy, 
1378
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1379
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1380
           a+1, (1<<(2*a+1)) - s->no_rounding,
1381
           s->h_edge_pos, s->v_edge_pos);
1382
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
1383
           ox + s->sprite_delta[0][0]*8, 
1384
           oy + s->sprite_delta[1][0]*8, 
1385
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1386
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1387
           a+1, (1<<(2*a+1)) - s->no_rounding,
1388
           s->h_edge_pos, s->v_edge_pos);
1389

    
1390
    if(s->flags&CODEC_FLAG_GRAY) return;
1391

    
1392

    
1393
    dest_cb+=dest_offset>>1;
1394
    dest_cr+=dest_offset>>1;
1395
    
1396
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
1397
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
1398

    
1399
    ptr = ref_picture[1] + (src_offset>>1);
1400
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
1401
           ox, 
1402
           oy, 
1403
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1404
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1405
           a+1, (1<<(2*a+1)) - s->no_rounding,
1406
           s->h_edge_pos>>1, s->v_edge_pos>>1);
1407
    
1408
    ptr = ref_picture[2] + (src_offset>>1);
1409
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
1410
           ox, 
1411
           oy, 
1412
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1413
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1414
           a+1, (1<<(2*a+1)) - s->no_rounding,
1415
           s->h_edge_pos>>1, s->v_edge_pos>>1);
1416
}
1417

    
1418

    
1419
void ff_emulated_edge_mc(MpegEncContext *s, UINT8 *src, int linesize, int block_w, int block_h, 
1420
                                    int src_x, int src_y, int w, int h){
1421
    int x, y;
1422
    int start_y, start_x, end_y, end_x;
1423
    UINT8 *buf= s->edge_emu_buffer;
1424

    
1425
    if(src_y>= h){
1426
        src+= (h-1-src_y)*linesize;
1427
        src_y=h-1;
1428
    }else if(src_y<=-block_h){
1429
        src+= (1-block_h-src_y)*linesize;
1430
        src_y=1-block_h;
1431
    }
1432
    if(src_x>= w){
1433
        src+= (w-1-src_x);
1434
        src_x=w-1;
1435
    }else if(src_x<=-block_w){
1436
        src+= (1-block_w-src_x);
1437
        src_x=1-block_w;
1438
    }
1439

    
1440
    start_y= FFMAX(0, -src_y);
1441
    start_x= FFMAX(0, -src_x);
1442
    end_y= FFMIN(block_h, h-src_y);
1443
    end_x= FFMIN(block_w, w-src_x);
1444

    
1445
    // copy existing part
1446
    for(y=start_y; y<end_y; y++){
1447
        for(x=start_x; x<end_x; x++){
1448
            buf[x + y*linesize]= src[x + y*linesize];
1449
        }
1450
    }
1451

    
1452
    //top
1453
    for(y=0; y<start_y; y++){
1454
        for(x=start_x; x<end_x; x++){
1455
            buf[x + y*linesize]= buf[x + start_y*linesize];
1456
        }
1457
    }
1458

    
1459
    //bottom
1460
    for(y=end_y; y<block_h; y++){
1461
        for(x=start_x; x<end_x; x++){
1462
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1463
        }
1464
    }
1465
                                    
1466
    for(y=0; y<block_h; y++){
1467
       //left
1468
        for(x=0; x<start_x; x++){
1469
            buf[x + y*linesize]= buf[start_x + y*linesize];
1470
        }
1471
       
1472
       //right
1473
        for(x=end_x; x<block_w; x++){
1474
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1475
        }
1476
    }
1477
}
1478

    
1479

    
1480
/* apply one mpeg motion vector to the three components */
1481
static inline void mpeg_motion(MpegEncContext *s,
1482
                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1483
                               int dest_offset,
1484
                               UINT8 **ref_picture, int src_offset,
1485
                               int field_based, op_pixels_func (*pix_op)[4],
1486
                               int motion_x, int motion_y, int h)
1487
{
1488
    UINT8 *ptr;
1489
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1490
    int emu=0;
1491
#if 0    
1492
if(s->quarter_sample)
1493
{
1494
    motion_x>>=1;
1495
    motion_y>>=1;
1496
}
1497
#endif
1498
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1499
    src_x = s->mb_x * 16 + (motion_x >> 1);
1500
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 1);
1501
                
1502
    /* WARNING: do no forget half pels */
1503
    height = s->height >> field_based;
1504
    v_edge_pos = s->v_edge_pos >> field_based;
1505
    src_x = clip(src_x, -16, s->width);
1506
    if (src_x == s->width)
1507
        dxy &= ~1;
1508
    src_y = clip(src_y, -16, height);
1509
    if (src_y == height)
1510
        dxy &= ~2;
1511
    linesize   = s->linesize << field_based;
1512
    uvlinesize = s->uvlinesize << field_based;
1513
    ptr = ref_picture[0] + (src_y * linesize) + (src_x) + src_offset;
1514
    dest_y += dest_offset;
1515

    
1516
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1517
        if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 16 > s->h_edge_pos
1518
                              || src_y + (motion_y&1) + h  > v_edge_pos){
1519
            ff_emulated_edge_mc(s, ptr - src_offset, s->linesize, 17, 17+field_based, 
1520
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1521
            ptr= s->edge_emu_buffer + src_offset;
1522
            emu=1;
1523
        }
1524
    }
1525
    pix_op[0][dxy](dest_y, ptr, linesize, h);
1526

    
1527
    if(s->flags&CODEC_FLAG_GRAY) return;
1528

    
1529
    if (s->out_format == FMT_H263) {
1530
        dxy = 0;
1531
        if ((motion_x & 3) != 0)
1532
            dxy |= 1;
1533
        if ((motion_y & 3) != 0)
1534
            dxy |= 2;
1535
        mx = motion_x >> 2;
1536
        my = motion_y >> 2;
1537
    } else {
1538
        mx = motion_x / 2;
1539
        my = motion_y / 2;
1540
        dxy = ((my & 1) << 1) | (mx & 1);
1541
        mx >>= 1;
1542
        my >>= 1;
1543
    }
1544
    
1545
    src_x = s->mb_x * 8 + mx;
1546
    src_y = s->mb_y * (8 >> field_based) + my;
1547
    src_x = clip(src_x, -8, s->width >> 1);
1548
    if (src_x == (s->width >> 1))
1549
        dxy &= ~1;
1550
    src_y = clip(src_y, -8, height >> 1);
1551
    if (src_y == (height >> 1))
1552
        dxy &= ~2;
1553
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1554
    ptr = ref_picture[1] + offset;
1555
    if(emu){
1556
        ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
1557
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1558
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1559
    }
1560
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1561

    
1562
    ptr = ref_picture[2] + offset;
1563
    if(emu){
1564
        ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
1565
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1566
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1567
    }
1568
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1569
}
1570

    
1571
static inline void qpel_motion(MpegEncContext *s,
1572
                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1573
                               int dest_offset,
1574
                               UINT8 **ref_picture, int src_offset,
1575
                               int field_based, op_pixels_func (*pix_op)[4],
1576
                               qpel_mc_func (*qpix_op)[16],
1577
                               int motion_x, int motion_y, int h)
1578
{
1579
    UINT8 *ptr;
1580
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1581
    int emu=0;
1582

    
1583
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1584
    src_x = s->mb_x * 16 + (motion_x >> 2);
1585
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
1586

    
1587
    height = s->height >> field_based;
1588
    v_edge_pos = s->v_edge_pos >> field_based;
1589
    src_x = clip(src_x, -16, s->width);
1590
    if (src_x == s->width)
1591
        dxy &= ~3;
1592
    src_y = clip(src_y, -16, height);
1593
    if (src_y == height)
1594
        dxy &= ~12;
1595
    linesize = s->linesize << field_based;
1596
    uvlinesize = s->uvlinesize << field_based;
1597
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1598
    dest_y += dest_offset;
1599
//printf("%d %d %d\n", src_x, src_y, dxy);
1600
    
1601
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1602
        if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 16 > s->h_edge_pos
1603
                              || src_y + (motion_y&3) + h  > v_edge_pos){
1604
            ff_emulated_edge_mc(s, ptr - src_offset, s->linesize, 17, 17+field_based, 
1605
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1606
            ptr= s->edge_emu_buffer + src_offset;
1607
            emu=1;
1608
        }
1609
    }
1610
    if(!field_based)
1611
        qpix_op[0][dxy](dest_y, ptr, linesize);
1612
    else{
1613
        //damn interlaced mode
1614
        //FIXME boundary mirroring is not exactly correct here
1615
        qpix_op[1][dxy](dest_y  , ptr  , linesize);
1616
        qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
1617
    }
1618

    
1619
    if(s->flags&CODEC_FLAG_GRAY) return;
1620

    
1621
    if(field_based){
1622
        mx= motion_x/2;
1623
        my= motion_y>>1;
1624
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
1625
        mx= (motion_x>>1)|(motion_x&1);
1626
        my= (motion_y>>1)|(motion_y&1);
1627
    }else{
1628
        mx= motion_x/2;
1629
        my= motion_y/2;
1630
    }
1631
    mx= (mx>>1)|(mx&1);
1632
    my= (my>>1)|(my&1);
1633
    dxy= (mx&1) | ((my&1)<<1);
1634
    mx>>=1;
1635
    my>>=1;
1636

    
1637
    src_x = s->mb_x * 8 + mx;
1638
    src_y = s->mb_y * (8 >> field_based) + my;
1639
    src_x = clip(src_x, -8, s->width >> 1);
1640
    if (src_x == (s->width >> 1))
1641
        dxy &= ~1;
1642
    src_y = clip(src_y, -8, height >> 1);
1643
    if (src_y == (height >> 1))
1644
        dxy &= ~2;
1645

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

    
1664

    
1665
static inline void MPV_motion(MpegEncContext *s, 
1666
                              UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1667
                              int dir, UINT8 **ref_picture, 
1668
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
1669
{
1670
    int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
1671
    int mb_x, mb_y, i;
1672
    UINT8 *ptr, *dest;
1673
    int emu=0;
1674

    
1675
    mb_x = s->mb_x;
1676
    mb_y = s->mb_y;
1677

    
1678
    switch(s->mv_type) {
1679
    case MV_TYPE_16X16:
1680
        if(s->mcsel){
1681
            if(s->real_sprite_warping_points==1){
1682
                gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
1683
                            ref_picture, 0);
1684
            }else{
1685
                gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
1686
                            ref_picture, 0);
1687
            }
1688
        }else if(s->quarter_sample){
1689
            qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1690
                        ref_picture, 0,
1691
                        0, pix_op, qpix_op,
1692
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1693
        }else if(s->mspel){
1694
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
1695
                        ref_picture, pix_op,
1696
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1697
        }else{
1698
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1699
                        ref_picture, 0,
1700
                        0, pix_op,
1701
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1702
        }           
1703
        break;
1704
    case MV_TYPE_8X8:
1705
        mx = 0;
1706
        my = 0;
1707
        if(s->quarter_sample){
1708
            for(i=0;i<4;i++) {
1709
                motion_x = s->mv[dir][i][0];
1710
                motion_y = s->mv[dir][i][1];
1711

    
1712
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1713
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
1714
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
1715
                    
1716
                /* WARNING: do no forget half pels */
1717
                src_x = clip(src_x, -16, s->width);
1718
                if (src_x == s->width)
1719
                    dxy &= ~3;
1720
                src_y = clip(src_y, -16, s->height);
1721
                if (src_y == s->height)
1722
                    dxy &= ~12;
1723
                    
1724
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1725
                if(s->flags&CODEC_FLAG_EMU_EDGE){
1726
                    if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 8 > s->h_edge_pos
1727
                                          || src_y + (motion_y&3) + 8 > s->v_edge_pos){
1728
                        ff_emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1729
                        ptr= s->edge_emu_buffer;
1730
                    }
1731
                }
1732
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1733
                qpix_op[1][dxy](dest, ptr, s->linesize);
1734

    
1735
                mx += s->mv[dir][i][0]/2;
1736
                my += s->mv[dir][i][1]/2;
1737
            }
1738
        }else{
1739
            for(i=0;i<4;i++) {
1740
                motion_x = s->mv[dir][i][0];
1741
                motion_y = s->mv[dir][i][1];
1742

    
1743
                dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1744
                src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;
1745
                src_y = mb_y * 16 + (motion_y >> 1) + (i >>1) * 8;
1746
                    
1747
                /* WARNING: do no forget half pels */
1748
                src_x = clip(src_x, -16, s->width);
1749
                if (src_x == s->width)
1750
                    dxy &= ~1;
1751
                src_y = clip(src_y, -16, s->height);
1752
                if (src_y == s->height)
1753
                    dxy &= ~2;
1754
                    
1755
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1756
                if(s->flags&CODEC_FLAG_EMU_EDGE){
1757
                    if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 8 > s->h_edge_pos
1758
                                          || src_y + (motion_y&1) + 8 > s->v_edge_pos){
1759
                        ff_emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1760
                        ptr= s->edge_emu_buffer;
1761
                    }
1762
                }
1763
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1764
                pix_op[1][dxy](dest, ptr, s->linesize, 8);
1765

    
1766
                mx += s->mv[dir][i][0];
1767
                my += s->mv[dir][i][1];
1768
            }
1769
        }
1770

    
1771
        if(s->flags&CODEC_FLAG_GRAY) break;
1772
        /* In case of 8X8, we construct a single chroma motion vector
1773
           with a special rounding */
1774
        for(i=0;i<4;i++) {
1775
        }
1776
        if (mx >= 0)
1777
            mx = (h263_chroma_roundtab[mx & 0xf] + ((mx >> 3) & ~1));
1778
        else {
1779
            mx = -mx;
1780
            mx = -(h263_chroma_roundtab[mx & 0xf] + ((mx >> 3) & ~1));
1781
        }
1782
        if (my >= 0)
1783
            my = (h263_chroma_roundtab[my & 0xf] + ((my >> 3) & ~1));
1784
        else {
1785
            my = -my;
1786
            my = -(h263_chroma_roundtab[my & 0xf] + ((my >> 3) & ~1));
1787
        }
1788
        dxy = ((my & 1) << 1) | (mx & 1);
1789
        mx >>= 1;
1790
        my >>= 1;
1791

    
1792
        src_x = mb_x * 8 + mx;
1793
        src_y = mb_y * 8 + my;
1794
        src_x = clip(src_x, -8, s->width/2);
1795
        if (src_x == s->width/2)
1796
            dxy &= ~1;
1797
        src_y = clip(src_y, -8, s->height/2);
1798
        if (src_y == s->height/2)
1799
            dxy &= ~2;
1800
        
1801
        offset = (src_y * (s->uvlinesize)) + src_x;
1802
        ptr = ref_picture[1] + offset;
1803
        if(s->flags&CODEC_FLAG_EMU_EDGE){
1804
                if(src_x<0 || src_y<0 || src_x + (dxy &1) + 8 > s->h_edge_pos>>1
1805
                                      || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
1806
                    ff_emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1807
                    ptr= s->edge_emu_buffer;
1808
                    emu=1;
1809
                }
1810
            }
1811
        pix_op[1][dxy](dest_cb, ptr, s->uvlinesize, 8);
1812

    
1813
        ptr = ref_picture[2] + offset;
1814
        if(emu){
1815
            ff_emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1816
            ptr= s->edge_emu_buffer;
1817
        }
1818
        pix_op[1][dxy](dest_cr, ptr, s->uvlinesize, 8);
1819
        break;
1820
    case MV_TYPE_FIELD:
1821
        if (s->picture_structure == PICT_FRAME) {
1822
            if(s->quarter_sample){
1823
                /* top field */
1824
                qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1825
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
1826
                            1, pix_op, qpix_op,
1827
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
1828
                /* bottom field */
1829
                qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
1830
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
1831
                            1, pix_op, qpix_op,
1832
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
1833
            }else{
1834
                /* top field */       
1835
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1836
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
1837
                            1, pix_op,
1838
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
1839
                /* bottom field */
1840
                mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
1841
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
1842
                            1, pix_op,
1843
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
1844
            }
1845
        } else {
1846
            
1847

    
1848
        }
1849
        break;
1850
    }
1851
}
1852

    
1853

    
1854
/* put block[] to dest[] */
1855
static inline void put_dct(MpegEncContext *s, 
1856
                           DCTELEM *block, int i, UINT8 *dest, int line_size)
1857
{
1858
    s->dct_unquantize(s, block, i, s->qscale);
1859
    s->idct_put (dest, line_size, block);
1860
}
1861

    
1862
/* add block[] to dest[] */
1863
static inline void add_dct(MpegEncContext *s, 
1864
                           DCTELEM *block, int i, UINT8 *dest, int line_size)
1865
{
1866
    if (s->block_last_index[i] >= 0) {
1867
        s->idct_add (dest, line_size, block);
1868
    }
1869
}
1870

    
1871
static inline void add_dequant_dct(MpegEncContext *s, 
1872
                           DCTELEM *block, int i, UINT8 *dest, int line_size)
1873
{
1874
    if (s->block_last_index[i] >= 0) {
1875
        s->dct_unquantize(s, block, i, s->qscale);
1876

    
1877
        s->idct_add (dest, line_size, block);
1878
    }
1879
}
1880

    
1881
/**
1882
 * cleans dc, ac, coded_block for the current non intra MB
1883
 */
1884
void ff_clean_intra_table_entries(MpegEncContext *s)
1885
{
1886
    int wrap = s->block_wrap[0];
1887
    int xy = s->block_index[0];
1888
    
1889
    s->dc_val[0][xy           ] = 
1890
    s->dc_val[0][xy + 1       ] = 
1891
    s->dc_val[0][xy     + wrap] =
1892
    s->dc_val[0][xy + 1 + wrap] = 1024;
1893
    /* ac pred */
1894
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(INT16));
1895
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(INT16));
1896
    if (s->msmpeg4_version>=3) {
1897
        s->coded_block[xy           ] =
1898
        s->coded_block[xy + 1       ] =
1899
        s->coded_block[xy     + wrap] =
1900
        s->coded_block[xy + 1 + wrap] = 0;
1901
    }
1902
    /* chroma */
1903
    wrap = s->block_wrap[4];
1904
    xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
1905
    s->dc_val[1][xy] =
1906
    s->dc_val[2][xy] = 1024;
1907
    /* ac pred */
1908
    memset(s->ac_val[1][xy], 0, 16 * sizeof(INT16));
1909
    memset(s->ac_val[2][xy], 0, 16 * sizeof(INT16));
1910
    
1911
    s->mbintra_table[s->mb_x + s->mb_y*s->mb_width]= 0;
1912
}
1913

    
1914
/* generic function called after a macroblock has been parsed by the
1915
   decoder or after it has been encoded by the encoder.
1916

1917
   Important variables used:
1918
   s->mb_intra : true if intra macroblock
1919
   s->mv_dir   : motion vector direction
1920
   s->mv_type  : motion vector type
1921
   s->mv       : motion vector
1922
   s->interlaced_dct : true if interlaced dct used (mpeg2)
1923
 */
1924
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1925
{
1926
    int mb_x, mb_y;
1927
    const int mb_xy = s->mb_y * s->mb_width + s->mb_x;
1928

    
1929
    mb_x = s->mb_x;
1930
    mb_y = s->mb_y;
1931

    
1932
    s->current_picture.qscale_table[mb_xy]= s->qscale;
1933

    
1934
    /* update DC predictors for P macroblocks */
1935
    if (!s->mb_intra) {
1936
        if (s->h263_pred || s->h263_aic) {
1937
            if(s->mbintra_table[mb_xy])
1938
                ff_clean_intra_table_entries(s);
1939
        } else {
1940
            s->last_dc[0] =
1941
            s->last_dc[1] =
1942
            s->last_dc[2] = 128 << s->intra_dc_precision;
1943
        }
1944
    }
1945
    else if (s->h263_pred || s->h263_aic)
1946
        s->mbintra_table[mb_xy]=1;
1947

    
1948
    /* update motion predictor, not for B-frames as they need the motion_val from the last P/S-Frame */
1949
    if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) { //FIXME move into h263.c if possible, format specific stuff shouldnt be here
1950
        //FIXME a lot of thet is only needed for !low_delay
1951
        const int wrap = s->block_wrap[0];
1952
        const int xy = s->block_index[0];
1953
        const int mb_index= s->mb_x + s->mb_y*s->mb_width;
1954
        if(s->mv_type == MV_TYPE_8X8){
1955
            s->co_located_type_table[mb_index]= CO_LOCATED_TYPE_4MV;
1956
        } else {
1957
            int motion_x, motion_y;
1958
            if (s->mb_intra) {
1959
                motion_x = 0;
1960
                motion_y = 0;
1961
                if(s->co_located_type_table)
1962
                    s->co_located_type_table[mb_index]= 0;
1963
            } else if (s->mv_type == MV_TYPE_16X16) {
1964
                motion_x = s->mv[0][0][0];
1965
                motion_y = s->mv[0][0][1];
1966
                if(s->co_located_type_table)
1967
                    s->co_located_type_table[mb_index]= 0;
1968
            } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
1969
                int i;
1970
                motion_x = s->mv[0][0][0] + s->mv[0][1][0];
1971
                motion_y = s->mv[0][0][1] + s->mv[0][1][1];
1972
                motion_x = (motion_x>>1) | (motion_x&1);
1973
                for(i=0; i<2; i++){
1974
                    s->field_mv_table[mb_index][i][0]= s->mv[0][i][0];
1975
                    s->field_mv_table[mb_index][i][1]= s->mv[0][i][1];
1976
                    s->field_select_table[mb_index][i]= s->field_select[0][i];
1977
                }
1978
                s->co_located_type_table[mb_index]= CO_LOCATED_TYPE_FIELDMV;
1979
            }
1980
            /* no update if 8X8 because it has been done during parsing */
1981
            s->motion_val[xy][0] = motion_x;
1982
            s->motion_val[xy][1] = motion_y;
1983
            s->motion_val[xy + 1][0] = motion_x;
1984
            s->motion_val[xy + 1][1] = motion_y;
1985
            s->motion_val[xy + wrap][0] = motion_x;
1986
            s->motion_val[xy + wrap][1] = motion_y;
1987
            s->motion_val[xy + 1 + wrap][0] = motion_x;
1988
            s->motion_val[xy + 1 + wrap][1] = motion_y;
1989
        }
1990
    }
1991
    
1992
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
1993
        UINT8 *dest_y, *dest_cb, *dest_cr;
1994
        int dct_linesize, dct_offset;
1995
        op_pixels_func (*op_pix)[4];
1996
        qpel_mc_func (*op_qpix)[16];
1997

    
1998
        /* avoid copy if macroblock skipped in last frame too */
1999
        if (s->pict_type != B_TYPE) {
2000
            s->current_picture.mbskip_table[mb_xy]= s->mb_skiped;
2001
        }
2002

    
2003
        /* skip only during decoding as we might trash the buffers during encoding a bit */
2004
        if(!s->encoding){
2005
            UINT8 *mbskip_ptr = &s->mbskip_table[mb_xy];
2006
            const int age= s->current_picture.age;
2007

    
2008
            assert(age);
2009

    
2010
            if (s->mb_skiped) {
2011
                s->mb_skiped= 0;
2012
                assert(s->pict_type!=I_TYPE);
2013
 
2014
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
2015
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2016

    
2017
                /* if previous was skipped too, then nothing to do !  */
2018
                if (*mbskip_ptr >= age){
2019
//if(s->pict_type!=B_TYPE && s->mb_x==0) printf("\n");
2020
//if(s->pict_type!=B_TYPE) printf("%d%d ", *mbskip_ptr, age);
2021
                    if(s->pict_type!=B_TYPE) return;
2022
                    if(s->avctx->draw_horiz_band==NULL && *mbskip_ptr > age) return; 
2023
                    /* we dont draw complete frames here so we cant skip */
2024
                }
2025
            } else {
2026
                *mbskip_ptr = 0; /* not skipped */
2027
            }
2028
        }else
2029
            s->mb_skiped= 0;
2030

    
2031
        if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band){
2032
            dest_y  = s->current_picture.data[0] + mb_x * 16;
2033
            dest_cb = s->current_picture.data[1] + mb_x * 8;
2034
            dest_cr = s->current_picture.data[2] + mb_x * 8;
2035
        }else{
2036
            dest_y  = s->current_picture.data[0] + (mb_y * 16* s->linesize  ) + mb_x * 16;
2037
            dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
2038
            dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
2039
        }
2040

    
2041
        if (s->interlaced_dct) {
2042
            dct_linesize = s->linesize * 2;
2043
            dct_offset = s->linesize;
2044
        } else {
2045
            dct_linesize = s->linesize;
2046
            dct_offset = s->linesize * 8;
2047
        }
2048

    
2049
        if (!s->mb_intra) {
2050
            /* motion handling */
2051
            /* decoding or more than one mb_type (MC was allready done otherwise) */
2052
            if((!s->encoding) || (s->mb_type[mb_xy]&(s->mb_type[mb_xy]-1))){
2053
                if ((!s->no_rounding) || s->pict_type==B_TYPE){                
2054
                    op_pix = s->dsp.put_pixels_tab;
2055
                    op_qpix= s->dsp.put_qpel_pixels_tab;
2056
                }else{
2057
                    op_pix = s->dsp.put_no_rnd_pixels_tab;
2058
                    op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2059
                }
2060

    
2061
                if (s->mv_dir & MV_DIR_FORWARD) {
2062
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2063
                    op_pix = s->dsp.avg_pixels_tab;
2064
                    op_qpix= s->dsp.avg_qpel_pixels_tab;
2065
                }
2066
                if (s->mv_dir & MV_DIR_BACKWARD) {
2067
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2068
                }
2069
            }
2070

    
2071
            /* skip dequant / idct if we are really late ;) */
2072
            if(s->hurry_up>1) return;
2073

    
2074
            /* add dct residue */
2075
            if(s->encoding || !(   s->mpeg2 || s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO 
2076
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2077
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
2078
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2079
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2080
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2081

    
2082
                if(!(s->flags&CODEC_FLAG_GRAY)){
2083
                    add_dequant_dct(s, block[4], 4, dest_cb, s->uvlinesize);
2084
                    add_dequant_dct(s, block[5], 5, dest_cr, s->uvlinesize);
2085
                }
2086
            } else if(s->codec_id != CODEC_ID_WMV2){
2087
                add_dct(s, block[0], 0, dest_y, dct_linesize);
2088
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2089
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2090
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2091

    
2092
                if(!(s->flags&CODEC_FLAG_GRAY)){
2093
                    add_dct(s, block[4], 4, dest_cb, s->uvlinesize);
2094
                    add_dct(s, block[5], 5, dest_cr, s->uvlinesize);
2095
                }
2096
            } else{
2097
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2098
            }
2099
        } else {
2100
            /* dct only in intra block */
2101
            if(s->encoding || !(s->mpeg2 || s->codec_id==CODEC_ID_MPEG1VIDEO)){
2102
                put_dct(s, block[0], 0, dest_y, dct_linesize);
2103
                put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2104
                put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2105
                put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2106

    
2107
                if(!(s->flags&CODEC_FLAG_GRAY)){
2108
                    put_dct(s, block[4], 4, dest_cb, s->uvlinesize);
2109
                    put_dct(s, block[5], 5, dest_cr, s->uvlinesize);
2110
                }
2111
            }else{
2112
                s->idct_put(dest_y                 , dct_linesize, block[0]);
2113
                s->idct_put(dest_y              + 8, dct_linesize, block[1]);
2114
                s->idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
2115
                s->idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
2116

    
2117
                if(!(s->flags&CODEC_FLAG_GRAY)){
2118
                    s->idct_put(dest_cb, s->uvlinesize, block[4]);
2119
                    s->idct_put(dest_cr, s->uvlinesize, block[5]);
2120
                }
2121
            }
2122
        }
2123
    }
2124
}
2125

    
2126
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
2127
{
2128
    static const char tab[64]=
2129
        {3,2,2,1,1,1,1,1,
2130
         1,1,1,1,1,1,1,1,
2131
         1,1,1,1,1,1,1,1,
2132
         0,0,0,0,0,0,0,0,
2133
         0,0,0,0,0,0,0,0,
2134
         0,0,0,0,0,0,0,0,
2135
         0,0,0,0,0,0,0,0,
2136
         0,0,0,0,0,0,0,0};
2137
    int score=0;
2138
    int run=0;
2139
    int i;
2140
    DCTELEM *block= s->block[n];
2141
    const int last_index= s->block_last_index[n];
2142
    int skip_dc;
2143

    
2144
    if(threshold<0){
2145
        skip_dc=0;
2146
        threshold= -threshold;
2147
    }else
2148
        skip_dc=1;
2149

    
2150
    /* are all which we could set to zero are allready zero? */
2151
    if(last_index<=skip_dc - 1) return;
2152

    
2153
    for(i=0; i<=last_index; i++){
2154
        const int j = s->intra_scantable.permutated[i];
2155
        const int level = ABS(block[j]);
2156
        if(level==1){
2157
            if(skip_dc && i==0) continue;
2158
            score+= tab[run];
2159
            run=0;
2160
        }else if(level>1){
2161
            return;
2162
        }else{
2163
            run++;
2164
        }
2165
    }
2166
    if(score >= threshold) return;
2167
    for(i=skip_dc; i<=last_index; i++){
2168
        const int j = s->intra_scantable.permutated[i];
2169
        block[j]=0;
2170
    }
2171
    if(block[0]) s->block_last_index[n]= 0;
2172
    else         s->block_last_index[n]= -1;
2173
}
2174

    
2175
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
2176
{
2177
    int i;
2178
    const int maxlevel= s->max_qcoeff;
2179
    const int minlevel= s->min_qcoeff;
2180
    
2181
    if(s->mb_intra){
2182
        i=1; //skip clipping of intra dc
2183
    }else
2184
        i=0;
2185
    
2186
    for(;i<=last_index; i++){
2187
        const int j= s->intra_scantable.permutated[i];
2188
        int level = block[j];
2189
       
2190
        if     (level>maxlevel) level=maxlevel;
2191
        else if(level<minlevel) level=minlevel;
2192
        block[j]= level;
2193
    }
2194
}
2195

    
2196
static inline void requantize_coeffs(MpegEncContext *s, DCTELEM block[64], int oldq, int newq, int n)
2197
{
2198
    int i;
2199

    
2200
    if(s->mb_intra){
2201
        i=1; //skip clipping of intra dc
2202
         //FIXME requantize, note (mpeg1/h263/h263p-aic dont need it,...)
2203
    }else
2204
        i=0;
2205
    
2206
    for(;i<=s->block_last_index[n]; i++){
2207
        const int j = s->intra_scantable.permutated[i];
2208
        int level = block[j];
2209
        
2210
        block[j]= ROUNDED_DIV(level*oldq, newq);
2211
    }
2212

    
2213
    for(i=s->block_last_index[n]; i>=0; i--){
2214
        const int j = s->intra_scantable.permutated[i];
2215
        if(block[j]) break;
2216
    }
2217
    s->block_last_index[n]= i;
2218
}
2219

    
2220
static inline void auto_requantize_coeffs(MpegEncContext *s, DCTELEM block[6][64])
2221
{
2222
    int i,n, newq;
2223
    const int maxlevel= s->max_qcoeff;
2224
    const int minlevel= s->min_qcoeff;
2225
    int largest=0, smallest=0;
2226

    
2227
    assert(s->adaptive_quant);
2228
    
2229
    for(n=0; n<6; n++){
2230
        if(s->mb_intra){
2231
            i=1; //skip clipping of intra dc
2232
             //FIXME requantize, note (mpeg1/h263/h263p-aic dont need it,...)
2233
        }else
2234
            i=0;
2235

    
2236
        for(;i<=s->block_last_index[n]; i++){
2237
            const int j = s->intra_scantable.permutated[i];
2238
            int level = block[n][j];
2239
            if(largest  < level) largest = level;
2240
            if(smallest > level) smallest= level;
2241
        }
2242
    }
2243
    
2244
    for(newq=s->qscale+1; newq<32; newq++){
2245
        if(   ROUNDED_DIV(smallest*s->qscale, newq) >= minlevel
2246
           && ROUNDED_DIV(largest *s->qscale, newq) <= maxlevel) 
2247
            break;
2248
    }
2249
        
2250
    if(s->out_format==FMT_H263){
2251
        /* h263 like formats cannot change qscale by more than 2 easiely */
2252
        if(s->avctx->qmin + 2 < newq)
2253
            newq= s->avctx->qmin + 2;
2254
    }
2255

    
2256
    for(n=0; n<6; n++){
2257
        requantize_coeffs(s, block[n], s->qscale, newq, n);
2258
        clip_coeffs(s, block[n], s->block_last_index[n]);
2259
    }
2260
     
2261
    s->dquant+= newq - s->qscale;
2262
    s->qscale= newq;
2263
}
2264
#if 0
2265
static int pix_vcmp16x8(UINT8 *s, int stride){ //FIXME move to dsputil & optimize
2266
    int score=0;
2267
    int x,y;
2268
    
2269
    for(y=0; y<7; y++){
2270
        for(x=0; x<16; x+=4){
2271
            score+= ABS(s[x  ] - s[x  +stride]) + ABS(s[x+1] - s[x+1+stride]) 
2272
                   +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
2273
        }
2274
        s+= stride;
2275
    }
2276
    
2277
    return score;
2278
}
2279

2280
static int pix_diff_vcmp16x8(UINT8 *s1, UINT8*s2, int stride){ //FIXME move to dsputil & optimize
2281
    int score=0;
2282
    int x,y;
2283
    
2284
    for(y=0; y<7; y++){
2285
        for(x=0; x<16; x++){
2286
            score+= ABS(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2287
        }
2288
        s1+= stride;
2289
        s2+= stride;
2290
    }
2291
    
2292
    return score;
2293
}
2294
#else
2295
#define SQ(a) ((a)*(a))
2296

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

    
2312
static int pix_diff_vcmp16x8(UINT8 *s1, UINT8*s2, int stride){ //FIXME move to dsputil & optimize
2313
    int score=0;
2314
    int x,y;
2315
    
2316
    for(y=0; y<7; y++){
2317
        for(x=0; x<16; x++){
2318
            score+= SQ(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2319
        }
2320
        s1+= stride;
2321
        s2+= stride;
2322
    }
2323
    
2324
    return score;
2325
}
2326

    
2327
#endif
2328

    
2329
void ff_draw_horiz_band(MpegEncContext *s){
2330
    if (    s->avctx->draw_horiz_band 
2331
        && (s->last_picture.data[0] || s->low_delay) ) {
2332
        UINT8 *src_ptr[3];
2333
        int y, h, offset;
2334
        y = s->mb_y * 16;
2335
        h = s->height - y;
2336
        if (h > 16)
2337
            h = 16;
2338

    
2339
        if(s->pict_type==B_TYPE)
2340
            offset = 0;
2341
        else
2342
            offset = y * s->linesize;
2343

    
2344
        if(s->pict_type==B_TYPE || s->low_delay){
2345
            src_ptr[0] = s->current_picture.data[0] + offset;
2346
            src_ptr[1] = s->current_picture.data[1] + (offset >> 2);
2347
            src_ptr[2] = s->current_picture.data[2] + (offset >> 2);
2348
        } else {
2349
            src_ptr[0] = s->last_picture.data[0] + offset;
2350
            src_ptr[1] = s->last_picture.data[1] + (offset >> 2);
2351
            src_ptr[2] = s->last_picture.data[2] + (offset >> 2);
2352
        }
2353
        emms_c();
2354

    
2355
        s->avctx->draw_horiz_band(s->avctx, src_ptr, s->linesize,
2356
                               y, s->width, h);
2357
    }
2358
}
2359

    
2360
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2361
{
2362
    const int mb_x= s->mb_x;
2363
    const int mb_y= s->mb_y;
2364
    int i;
2365
    int skip_dct[6];
2366
    int dct_offset   = s->linesize*8; //default for progressive frames
2367
    
2368
    for(i=0; i<6; i++) skip_dct[i]=0;
2369
    
2370
    if(s->adaptive_quant){
2371
        s->dquant= s->current_picture.qscale_table[mb_x + mb_y*s->mb_width] - s->qscale;
2372

    
2373
        if(s->out_format==FMT_H263){
2374
            if     (s->dquant> 2) s->dquant= 2;
2375
            else if(s->dquant<-2) s->dquant=-2;
2376
        }
2377
            
2378
        if(s->codec_id==CODEC_ID_MPEG4){        
2379
            if(!s->mb_intra){
2380
                assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
2381

    
2382
                if(s->mv_dir&MV_DIRECT)
2383
                    s->dquant=0;
2384
            }
2385
        }
2386
        s->qscale+= s->dquant;
2387
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2388
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2389
    }
2390

    
2391
    if (s->mb_intra) {
2392
        UINT8 *ptr;
2393
        int wrap_y;
2394
        int emu=0;
2395

    
2396
        wrap_y = s->linesize;
2397
        ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2398

    
2399
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2400
            ff_emulated_edge_mc(s, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2401
            ptr= s->edge_emu_buffer;
2402
            emu=1;
2403
        }
2404
        
2405
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2406
            int progressive_score, interlaced_score;
2407
            
2408
            progressive_score= pix_vcmp16x8(ptr, wrap_y  ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
2409
            interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y  , wrap_y*2);
2410
            
2411
            if(progressive_score > interlaced_score + 100){
2412
                s->interlaced_dct=1;
2413
            
2414
                dct_offset= wrap_y;
2415
                wrap_y<<=1;
2416
            }else
2417
                s->interlaced_dct=0;
2418
        }
2419
        
2420
        s->dsp.get_pixels(s->block[0], ptr                 , wrap_y);
2421
        s->dsp.get_pixels(s->block[1], ptr              + 8, wrap_y);
2422
        s->dsp.get_pixels(s->block[2], ptr + dct_offset    , wrap_y);
2423
        s->dsp.get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
2424

    
2425
        if(s->flags&CODEC_FLAG_GRAY){
2426
            skip_dct[4]= 1;
2427
            skip_dct[5]= 1;
2428
        }else{
2429
            int wrap_c = s->uvlinesize;
2430
            ptr = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2431
            if(emu){
2432
                ff_emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2433
                ptr= s->edge_emu_buffer;
2434
            }
2435
            s->dsp.get_pixels(s->block[4], ptr, wrap_c);
2436

    
2437
            ptr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2438
            if(emu){
2439
                ff_emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2440
                ptr= s->edge_emu_buffer;
2441
            }
2442
            s->dsp.get_pixels(s->block[5], ptr, wrap_c);
2443
        }
2444
    }else{
2445
        op_pixels_func (*op_pix)[4];
2446
        qpel_mc_func (*op_qpix)[16];
2447
        UINT8 *dest_y, *dest_cb, *dest_cr;
2448
        UINT8 *ptr_y, *ptr_cb, *ptr_cr;
2449
        int wrap_y, wrap_c;
2450
        int emu=0;
2451

    
2452
        dest_y  = s->current_picture.data[0] + (mb_y * 16 * s->linesize    ) + mb_x * 16;
2453
        dest_cb = s->current_picture.data[1] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2454
        dest_cr = s->current_picture.data[2] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2455
        wrap_y = s->linesize;
2456
        wrap_c = s->uvlinesize;
2457
        ptr_y  = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2458
        ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2459
        ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2460

    
2461
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
2462
            op_pix = s->dsp.put_pixels_tab;
2463
            op_qpix= s->dsp.put_qpel_pixels_tab;
2464
        }else{
2465
            op_pix = s->dsp.put_no_rnd_pixels_tab;
2466
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2467
        }
2468

    
2469
        if (s->mv_dir & MV_DIR_FORWARD) {
2470
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2471
            op_pix = s->dsp.avg_pixels_tab;
2472
            op_qpix= s->dsp.avg_qpel_pixels_tab;
2473
        }
2474
        if (s->mv_dir & MV_DIR_BACKWARD) {
2475
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2476
        }
2477

    
2478
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2479
            ff_emulated_edge_mc(s, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2480
            ptr_y= s->edge_emu_buffer;
2481
            emu=1;
2482
        }
2483
        
2484
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2485
            int progressive_score, interlaced_score;
2486
            
2487
            progressive_score= pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y  ) 
2488
                             + pix_diff_vcmp16x8(ptr_y + wrap_y*8, dest_y + wrap_y*8, wrap_y  );
2489
            interlaced_score = pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y*2)
2490
                             + pix_diff_vcmp16x8(ptr_y + wrap_y  , dest_y + wrap_y  , wrap_y*2);
2491
            
2492
            if(progressive_score > interlaced_score + 600){
2493
                s->interlaced_dct=1;
2494
            
2495
                dct_offset= wrap_y;
2496
                wrap_y<<=1;
2497
            }else
2498
                s->interlaced_dct=0;
2499
        }
2500
        
2501
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
2502
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
2503
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
2504
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
2505
        
2506
        if(s->flags&CODEC_FLAG_GRAY){
2507
            skip_dct[4]= 1;
2508
            skip_dct[5]= 1;
2509
        }else{
2510
            if(emu){
2511
                ff_emulated_edge_mc(s, ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2512
                ptr_cb= s->edge_emu_buffer;
2513
            }
2514
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2515
            if(emu){
2516
                ff_emulated_edge_mc(s, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2517
                ptr_cr= s->edge_emu_buffer;
2518
            }
2519
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2520
        }
2521
        /* pre quantization */         
2522
        if(s->current_picture.mc_mb_var[s->mb_width*mb_y+ mb_x]<2*s->qscale*s->qscale){
2523
            //FIXME optimize
2524
            if(s->dsp.pix_abs8x8(ptr_y               , dest_y               , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
2525
            if(s->dsp.pix_abs8x8(ptr_y            + 8, dest_y            + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
2526
            if(s->dsp.pix_abs8x8(ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
2527
            if(s->dsp.pix_abs8x8(ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
2528
            if(s->dsp.pix_abs8x8(ptr_cb              , dest_cb              , wrap_c) < 20*s->qscale) skip_dct[4]= 1;
2529
            if(s->dsp.pix_abs8x8(ptr_cr              , dest_cr              , wrap_c) < 20*s->qscale) skip_dct[5]= 1;
2530
#if 0
2531
{
2532
 static int stat[7];
2533
 int num=0;
2534
 for(i=0; i<6; i++)
2535
  if(skip_dct[i]) num++;
2536
 stat[num]++;
2537
 
2538
 if(s->mb_x==0 && s->mb_y==0){
2539
  for(i=0; i<7; i++){
2540
   printf("%6d %1d\n", stat[i], i);
2541
  }
2542
 }
2543
}
2544
#endif
2545
        }
2546

    
2547
    }
2548
            
2549
#if 0
2550
            {
2551
                float adap_parm;
2552
                
2553
                adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_width*mb_y+mb_x] + 1.0) /
2554
                            ((s->mb_var[s->mb_width*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);
2555
            
2556
                printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d", 
2557
                        (s->mb_type[s->mb_width*mb_y+mb_x] > 0) ? 'I' : 'P', 
2558
                        s->qscale, adap_parm, s->qscale*adap_parm,
2559
                        s->mb_var[s->mb_width*mb_y+mb_x], s->avg_mb_var);
2560
            }
2561
#endif
2562
    /* DCT & quantize */
2563
    if(s->out_format==FMT_MJPEG){
2564
        for(i=0;i<6;i++) {
2565
            int overflow;
2566
            s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
2567
            if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2568
        }
2569
    }else{
2570
        for(i=0;i<6;i++) {
2571
            if(!skip_dct[i]){
2572
                int overflow;
2573
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2574
            // FIXME we could decide to change to quantizer instead of clipping
2575
            // JS: I don't think that would be a good idea it could lower quality instead
2576
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
2577
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2578
            }else
2579
                s->block_last_index[i]= -1;
2580
        }
2581
        if(s->luma_elim_threshold && !s->mb_intra)
2582
            for(i=0; i<4; i++)
2583
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2584
        if(s->chroma_elim_threshold && !s->mb_intra)
2585
            for(i=4; i<6; i++)
2586
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2587
    }
2588

    
2589
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
2590
        s->block_last_index[4]=
2591
        s->block_last_index[5]= 0;
2592
        s->block[4][0]=
2593
        s->block[5][0]= 128;
2594
    }
2595

    
2596
#ifdef CONFIG_ENCODERS
2597
    /* huffman encode */
2598
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2599
    case CODEC_ID_MPEG1VIDEO:
2600
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
2601
    case CODEC_ID_MPEG4:
2602
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
2603
    case CODEC_ID_MSMPEG4V2:
2604
    case CODEC_ID_MSMPEG4V3:
2605
    case CODEC_ID_WMV1:
2606
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
2607
    case CODEC_ID_WMV2:
2608
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
2609
    case CODEC_ID_MJPEG:
2610
        mjpeg_encode_mb(s, s->block); break;
2611
    case CODEC_ID_H263:
2612
    case CODEC_ID_H263P:
2613
    case CODEC_ID_RV10:
2614
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
2615
    default:
2616
        assert(0);
2617
    }
2618
#endif
2619
}
2620

    
2621
void ff_copy_bits(PutBitContext *pb, UINT8 *src, int length)
2622
{
2623
    int bytes= length>>4;
2624
    int bits= length&15;
2625
    int i;
2626

    
2627
    if(length==0) return;
2628

    
2629
    for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
2630
    put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
2631
}
2632

    
2633
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2634
    int i;
2635

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

    
2638
    /* mpeg1 */
2639
    d->mb_incr= s->mb_incr;
2640
    for(i=0; i<3; i++)
2641
        d->last_dc[i]= s->last_dc[i];
2642
    
2643
    /* statistics */
2644
    d->mv_bits= s->mv_bits;
2645
    d->i_tex_bits= s->i_tex_bits;
2646
    d->p_tex_bits= s->p_tex_bits;
2647
    d->i_count= s->i_count;
2648
    d->f_count= s->f_count;
2649
    d->b_count= s->b_count;
2650
    d->skip_count= s->skip_count;
2651
    d->misc_bits= s->misc_bits;
2652
    d->last_bits= 0;
2653

    
2654
    d->mb_skiped= s->mb_skiped;
2655
    d->qscale= s->qscale;
2656
}
2657

    
2658
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2659
    int i;
2660

    
2661
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
2662
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
2663
    
2664
    /* mpeg1 */
2665
    d->mb_incr= s->mb_incr;
2666
    for(i=0; i<3; i++)
2667
        d->last_dc[i]= s->last_dc[i];
2668
    
2669
    /* statistics */
2670
    d->mv_bits= s->mv_bits;
2671
    d->i_tex_bits= s->i_tex_bits;
2672
    d->p_tex_bits= s->p_tex_bits;
2673
    d->i_count= s->i_count;
2674
    d->f_count= s->f_count;
2675
    d->b_count= s->b_count;
2676
    d->skip_count= s->skip_count;
2677
    d->misc_bits= s->misc_bits;
2678

    
2679
    d->mb_intra= s->mb_intra;
2680
    d->mb_skiped= s->mb_skiped;
2681
    d->mv_type= s->mv_type;
2682
    d->mv_dir= s->mv_dir;
2683
    d->pb= s->pb;
2684
    if(s->data_partitioning){
2685
        d->pb2= s->pb2;
2686
        d->tex_pb= s->tex_pb;
2687
    }
2688
    d->block= s->block;
2689
    for(i=0; i<6; i++)
2690
        d->block_last_index[i]= s->block_last_index[i];
2691
    d->interlaced_dct= s->interlaced_dct;
2692
    d->qscale= s->qscale;
2693
}
2694

    
2695
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
2696
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2697
                           int *dmin, int *next_block, int motion_x, int motion_y)
2698
{
2699
    int bits_count;
2700
    
2701
    copy_context_before_encode(s, backup, type);
2702

    
2703
    s->block= s->blocks[*next_block];
2704
    s->pb= pb[*next_block];
2705
    if(s->data_partitioning){
2706
        s->pb2   = pb2   [*next_block];
2707
        s->tex_pb= tex_pb[*next_block];
2708
    }
2709

    
2710
    encode_mb(s, motion_x, motion_y);
2711

    
2712
    bits_count= get_bit_count(&s->pb);
2713
    if(s->data_partitioning){
2714
        bits_count+= get_bit_count(&s->pb2);
2715
        bits_count+= get_bit_count(&s->tex_pb);
2716
    }
2717

    
2718
    if(bits_count<*dmin){
2719
        *dmin= bits_count;
2720
        *next_block^=1;
2721

    
2722
        copy_context_after_encode(best, s, type);
2723
    }
2724
}
2725
                
2726
static inline int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2727
    uint32_t *sq = squareTbl + 256;
2728
    int acc=0;
2729
    int x,y;
2730
    
2731
    if(w==16 && h==16) 
2732
        return s->dsp.sse[0](NULL, src1, src2, stride);
2733
    else if(w==8 && h==8)
2734
        return s->dsp.sse[1](NULL, src1, src2, stride);
2735
    
2736
    for(y=0; y<h; y++){
2737
        for(x=0; x<w; x++){
2738
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2739
        } 
2740
    }
2741
    
2742
    assert(acc>=0);
2743
    
2744
    return acc;
2745
}
2746

    
2747
static void encode_picture(MpegEncContext *s, int picture_number)
2748
{
2749
    int mb_x, mb_y, pdif = 0;
2750
    int i;
2751
    int bits;
2752
    MpegEncContext best_s, backup_s;
2753
    UINT8 bit_buf[2][3000];
2754
    UINT8 bit_buf2[2][3000];
2755
    UINT8 bit_buf_tex[2][3000];
2756
    PutBitContext pb[2], pb2[2], tex_pb[2];
2757

    
2758
    for(i=0; i<2; i++){
2759
        init_put_bits(&pb    [i], bit_buf    [i], 3000, NULL, NULL);
2760
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000, NULL, NULL);
2761
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
2762
    }
2763

    
2764
    s->picture_number = picture_number;
2765

    
2766
    s->block_wrap[0]=
2767
    s->block_wrap[1]=
2768
    s->block_wrap[2]=
2769
    s->block_wrap[3]= s->mb_width*2 + 2;
2770
    s->block_wrap[4]=
2771
    s->block_wrap[5]= s->mb_width + 2;
2772
    
2773
    /* Reset the average MB variance */
2774
    s->current_picture.mb_var_sum = 0;
2775
    s->current_picture.mc_mb_var_sum = 0;
2776

    
2777
    /* we need to initialize some time vars before we can encode b-frames */
2778
    if (s->h263_pred && !s->h263_msmpeg4)
2779
        ff_set_mpeg4_time(s, s->picture_number); 
2780

    
2781
    s->scene_change_score=0;
2782
    
2783
    s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
2784
    
2785
    if(s->msmpeg4_version){
2786
        if(s->pict_type==I_TYPE)
2787
            s->no_rounding=1;
2788
        else if(s->flipflop_rounding)
2789
            s->no_rounding ^= 1;          
2790
    }else if(s->out_format == FMT_H263){
2791
        if(s->pict_type==I_TYPE)
2792
            s->no_rounding=0;
2793
        else if(s->pict_type!=B_TYPE)
2794
            s->no_rounding ^= 1;          
2795
    }
2796
    /* Estimate motion for every MB */
2797
    if(s->pict_type != I_TYPE){
2798
        if(s->pict_type != B_TYPE){
2799
            if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
2800
                s->me.pre_pass=1;
2801
                s->me.dia_size= s->avctx->pre_dia_size;
2802

    
2803
                for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) {
2804
                    for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) {
2805
                        s->mb_x = mb_x;
2806
                        s->mb_y = mb_y;
2807
                        ff_pre_estimate_p_frame_motion(s, mb_x, mb_y);
2808
                    }
2809
                }
2810
                s->me.pre_pass=0;
2811
            }
2812
        }
2813

    
2814
        s->me.dia_size= s->avctx->dia_size;
2815
        for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2816
            s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
2817
            s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
2818
            s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
2819
            s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
2820
            for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2821
                s->mb_x = mb_x;
2822
                s->mb_y = mb_y;
2823
                s->block_index[0]+=2;
2824
                s->block_index[1]+=2;
2825
                s->block_index[2]+=2;
2826
                s->block_index[3]+=2;
2827
                
2828
                /* compute motion vector & mb_type and store in context */
2829
                if(s->pict_type==B_TYPE)
2830
                    ff_estimate_b_frame_motion(s, mb_x, mb_y);
2831
                else
2832
                    ff_estimate_p_frame_motion(s, mb_x, mb_y);
2833
            }
2834
        }
2835
    }else /* if(s->pict_type == I_TYPE) */{
2836
        /* I-Frame */
2837
        //FIXME do we need to zero them?
2838
        memset(s->motion_val[0], 0, sizeof(INT16)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
2839
        memset(s->p_mv_table   , 0, sizeof(INT16)*(s->mb_width+2)*(s->mb_height+2)*2);
2840
        memset(s->mb_type      , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
2841
        
2842
        if(!s->fixed_qscale){
2843
            /* finding spatial complexity for I-frame rate control */
2844
            for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2845
                for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2846
                    int xx = mb_x * 16;
2847
                    int yy = mb_y * 16;
2848
                    uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
2849
                    int varc;
2850
                    int sum = s->dsp.pix_sum(pix, s->linesize);
2851
    
2852
                    varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
2853

    
2854
                    s->current_picture.mb_var [s->mb_width * mb_y + mb_x] = varc;
2855
                    s->current_picture.mb_mean[s->mb_width * mb_y + mb_x] = (sum+128)>>8;
2856
                    s->current_picture.mb_var_sum    += varc;
2857
                }
2858
            }
2859
        }
2860
    }
2861
    emms_c();
2862

    
2863
    if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
2864
        s->pict_type= I_TYPE;
2865
        memset(s->mb_type   , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
2866
//printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
2867
    }
2868

    
2869
    if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) 
2870
        s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
2871
        ff_fix_long_p_mvs(s);
2872
    if(s->pict_type==B_TYPE){
2873
        s->f_code= ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
2874
        s->b_code= ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
2875

    
2876
        ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
2877
        ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
2878
        ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
2879
        ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
2880
    }
2881
    
2882
    if (s->fixed_qscale) 
2883
        s->frame_qscale = s->current_picture.quality;
2884
    else
2885
        s->frame_qscale = ff_rate_estimate_qscale(s);
2886

    
2887
    if(s->adaptive_quant){
2888
        switch(s->codec_id){
2889
        case CODEC_ID_MPEG4:
2890
            ff_clean_mpeg4_qscales(s);
2891
            break;
2892
        case CODEC_ID_H263:
2893
        case CODEC_ID_H263P:
2894
            ff_clean_h263_qscales(s);
2895
            break;
2896
        }
2897

    
2898
        s->qscale= s->current_picture.qscale_table[0];
2899
    }else
2900
        s->qscale= (int)(s->frame_qscale + 0.5);
2901
        
2902
    if (s->out_format == FMT_MJPEG) {
2903
        /* for mjpeg, we do include qscale in the matrix */
2904
        s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
2905
        for(i=1;i<64;i++){
2906
            int j= s->idct_permutation[i];
2907

    
2908
            s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
2909
        }
2910
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, 
2911
                       s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
2912
    }
2913
    
2914
    //FIXME var duplication
2915
    s->current_picture.key_frame= s->pict_type == I_TYPE;
2916
    s->current_picture.pict_type= s->pict_type;
2917

    
2918
    if(s->current_picture.key_frame)
2919
        s->picture_in_gop_number=0;
2920

    
2921
    s->last_bits= get_bit_count(&s->pb);
2922
    switch(s->out_format) {
2923
    case FMT_MJPEG:
2924
        mjpeg_picture_header(s);
2925
        break;
2926
    case FMT_H263:
2927
        if (s->codec_id == CODEC_ID_WMV2) 
2928
            ff_wmv2_encode_picture_header(s, picture_number);
2929
        else if (s->h263_msmpeg4) 
2930
            msmpeg4_encode_picture_header(s, picture_number);
2931
        else if (s->h263_pred)
2932
            mpeg4_encode_picture_header(s, picture_number);
2933
        else if (s->h263_rv10) 
2934
            rv10_encode_picture_header(s, picture_number);
2935
        else
2936
            h263_encode_picture_header(s, picture_number);
2937
        break;
2938
    case FMT_MPEG1:
2939
        mpeg1_encode_picture_header(s, picture_number);
2940
        break;
2941
    }
2942
    bits= get_bit_count(&s->pb);
2943
    s->header_bits= bits - s->last_bits;
2944
    s->last_bits= bits;
2945
    s->mv_bits=0;
2946
    s->misc_bits=0;
2947
    s->i_tex_bits=0;
2948
    s->p_tex_bits=0;
2949
    s->i_count=0;
2950
    s->f_count=0;
2951
    s->b_count=0;
2952
    s->skip_count=0;
2953

    
2954
    for(i=0; i<3; i++){
2955
        /* init last dc values */
2956
        /* note: quant matrix value (8) is implied here */
2957
        s->last_dc[i] = 128;
2958
        
2959
        s->current_picture.error[i] = 0;
2960
    }
2961
    s->mb_incr = 1;
2962
    s->last_mv[0][0][0] = 0;
2963
    s->last_mv[0][0][1] = 0;
2964

    
2965
    if (s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P)
2966
        s->gob_index = ff_h263_get_gob_height(s);
2967

    
2968
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
2969
        ff_mpeg4_init_partitions(s);
2970

    
2971
    s->resync_mb_x=0;
2972
    s->resync_mb_y=0;
2973
    s->first_slice_line = 1;
2974
    s->ptr_lastgob = s->pb.buf;
2975
    s->ptr_last_mb_line = s->pb.buf;
2976
    for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2977
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2978
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2979
        
2980
        s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
2981
        s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
2982
        s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
2983
        s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
2984
        s->block_index[4]= s->block_wrap[4]*(mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2);
2985
        s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
2986
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2987
            const int mb_type= s->mb_type[mb_y * s->mb_width + mb_x];
2988
            const int xy= (mb_y+1) * (s->mb_width+2) + mb_x + 1;
2989
//            int d;
2990
            int dmin=10000000;
2991

    
2992
            s->mb_x = mb_x;
2993
            s->mb_y = mb_y;
2994
            s->block_index[0]+=2;
2995
            s->block_index[1]+=2;
2996
            s->block_index[2]+=2;
2997
            s->block_index[3]+=2;
2998
            s->block_index[4]++;
2999
            s->block_index[5]++;
3000

    
3001
            /* write gob / video packet header  */
3002
            if(s->rtp_mode){
3003
                int current_packet_size, is_gob_start;
3004
                
3005
                current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
3006
                is_gob_start=0;
3007
                
3008
                if(s->codec_id==CODEC_ID_MPEG4){
3009
                    if(current_packet_size + s->mb_line_avgsize/s->mb_width >= s->rtp_payload_size
3010
                       && s->mb_y + s->mb_x>0){
3011

    
3012
                        if(s->partitioned_frame){
3013
                            ff_mpeg4_merge_partitions(s);
3014
                            ff_mpeg4_init_partitions(s);
3015
                        }
3016
                        ff_mpeg4_encode_video_packet_header(s);
3017

    
3018
                        if(s->flags&CODEC_FLAG_PASS1){
3019
                            int bits= get_bit_count(&s->pb);
3020
                            s->misc_bits+= bits - s->last_bits;
3021
                            s->last_bits= bits;
3022
                        }
3023
                        ff_mpeg4_clean_buffers(s);
3024
                        is_gob_start=1;
3025
                    }
3026
                }else{
3027
                    if(current_packet_size + s->mb_line_avgsize*s->gob_index >= s->rtp_payload_size
3028
                       && s->mb_x==0 && s->mb_y>0 && s->mb_y%s->gob_index==0){
3029
                       
3030
                        h263_encode_gob_header(s, mb_y);                       
3031
                        is_gob_start=1;
3032
                    }
3033
                }
3034

    
3035
                if(is_gob_start){
3036
                    s->ptr_lastgob = pbBufPtr(&s->pb);
3037
                    s->first_slice_line=1;
3038
                    s->resync_mb_x=mb_x;
3039
                    s->resync_mb_y=mb_y;
3040
                }
3041
            }
3042

    
3043
            if(  (s->resync_mb_x   == s->mb_x)
3044
               && s->resync_mb_y+1 == s->mb_y){
3045
                s->first_slice_line=0; 
3046
            }
3047

    
3048
            if(mb_type & (mb_type-1)){ // more than 1 MB type possible
3049
                int next_block=0;
3050
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3051

    
3052
                copy_context_before_encode(&backup_s, s, -1);
3053
                backup_s.pb= s->pb;
3054
                best_s.data_partitioning= s->data_partitioning;
3055
                best_s.partitioned_frame= s->partitioned_frame;
3056
                if(s->data_partitioning){
3057
                    backup_s.pb2= s->pb2;
3058
                    backup_s.tex_pb= s->tex_pb;
3059
                }
3060

    
3061
                if(mb_type&MB_TYPE_INTER){
3062
                    s->mv_dir = MV_DIR_FORWARD;
3063
                    s->mv_type = MV_TYPE_16X16;
3064
                    s->mb_intra= 0;
3065
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
3066
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
3067
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb, 
3068
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3069
                }
3070
                if(mb_type&MB_TYPE_INTER4V){                 
3071
                    s->mv_dir = MV_DIR_FORWARD;
3072
                    s->mv_type = MV_TYPE_8X8;
3073
                    s->mb_intra= 0;
3074
                    for(i=0; i<4; i++){
3075
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3076
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3077
                    }
3078
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb, 
3079
                                 &dmin, &next_block, 0, 0);
3080
                }
3081
                if(mb_type&MB_TYPE_FORWARD){
3082
                    s->mv_dir = MV_DIR_FORWARD;
3083
                    s->mv_type = MV_TYPE_16X16;
3084
                    s->mb_intra= 0;
3085
                    s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3086
                    s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3087
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb, 
3088
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3089
                }
3090
                if(mb_type&MB_TYPE_BACKWARD){
3091
                    s->mv_dir = MV_DIR_BACKWARD;
3092
                    s->mv_type = MV_TYPE_16X16;
3093
                    s->mb_intra= 0;
3094
                    s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3095
                    s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3096
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb, 
3097
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3098
                }
3099
                if(mb_type&MB_TYPE_BIDIR){
3100
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3101
                    s->mv_type = MV_TYPE_16X16;
3102
                    s->mb_intra= 0;
3103
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3104
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3105
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3106
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3107
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb, 
3108
                                 &dmin, &next_block, 0, 0);
3109
                }
3110
                if(mb_type&MB_TYPE_DIRECT){
3111
                    int mx= s->b_direct_mv_table[xy][0];
3112
                    int my= s->b_direct_mv_table[xy][1];
3113
                    
3114
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3115
                    s->mb_intra= 0;
3116
                    ff_mpeg4_set_direct_mv(s, mx, my);
3117
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb, 
3118
                                 &dmin, &next_block, mx, my);
3119
                }
3120
                if(mb_type&MB_TYPE_INTRA){
3121
                    s->mv_dir = MV_DIR_FORWARD;
3122
                    s->mv_type = MV_TYPE_16X16;
3123
                    s->mb_intra= 1;
3124
                    s->mv[0][0][0] = 0;
3125
                    s->mv[0][0][1] = 0;
3126
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb, 
3127
                                 &dmin, &next_block, 0, 0);
3128
                    /* force cleaning of ac/dc pred stuff if needed ... */
3129
                    if(s->h263_pred || s->h263_aic)
3130
                        s->mbintra_table[mb_x + mb_y*s->mb_width]=1;
3131
                }
3132
                copy_context_after_encode(s, &best_s, -1);
3133
                
3134
                pb_bits_count= get_bit_count(&s->pb);
3135
                flush_put_bits(&s->pb);
3136
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3137
                s->pb= backup_s.pb;
3138
                
3139
                if(s->data_partitioning){
3140
                    pb2_bits_count= get_bit_count(&s->pb2);
3141
                    flush_put_bits(&s->pb2);
3142
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3143
                    s->pb2= backup_s.pb2;
3144
                    
3145
                    tex_pb_bits_count= get_bit_count(&s->tex_pb);
3146
                    flush_put_bits(&s->tex_pb);
3147
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3148
                    s->tex_pb= backup_s.tex_pb;
3149
                }
3150
                s->last_bits= get_bit_count(&s->pb);
3151
            } else {
3152
                int motion_x, motion_y;
3153
                s->mv_type=MV_TYPE_16X16;
3154
                // only one MB-Type possible
3155
                switch(mb_type){
3156
                case MB_TYPE_INTRA:
3157
                    s->mv_dir = MV_DIR_FORWARD;
3158
                    s->mb_intra= 1;
3159
                    motion_x= s->mv[0][0][0] = 0;
3160
                    motion_y= s->mv[0][0][1] = 0;
3161
                    break;
3162
                case MB_TYPE_INTER:
3163
                    s->mv_dir = MV_DIR_FORWARD;
3164
                    s->mb_intra= 0;
3165
                    motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3166
                    motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3167
                    break;
3168
                case MB_TYPE_INTER4V:
3169
                    s->mv_dir = MV_DIR_FORWARD;
3170
                    s->mv_type = MV_TYPE_8X8;
3171
                    s->mb_intra= 0;
3172
                    for(i=0; i<4; i++){
3173
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3174
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3175
                    }
3176
                    motion_x= motion_y= 0;
3177
                    break;
3178
                case MB_TYPE_DIRECT:
3179
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3180
                    s->mb_intra= 0;
3181
                    motion_x=s->b_direct_mv_table[xy][0];
3182
                    motion_y=s->b_direct_mv_table[xy][1];
3183
                    ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3184
                    break;
3185
                case MB_TYPE_BIDIR:
3186
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3187
                    s->mb_intra= 0;
3188
                    motion_x=0;
3189
                    motion_y=0;
3190
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3191
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3192
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3193
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3194
                    break;
3195
                case MB_TYPE_BACKWARD:
3196
                    s->mv_dir = MV_DIR_BACKWARD;
3197
                    s->mb_intra= 0;
3198
                    motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3199
                    motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3200
                    break;
3201
                case MB_TYPE_FORWARD:
3202
                    s->mv_dir = MV_DIR_FORWARD;
3203
                    s->mb_intra= 0;
3204
                    motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3205
                    motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3206
//                    printf(" %d %d ", motion_x, motion_y);
3207
                    break;
3208
                default:
3209
                    motion_x=motion_y=0; //gcc warning fix
3210
                    printf("illegal MB type\n");
3211
                }
3212
                encode_mb(s, motion_x, motion_y);
3213
            }
3214
            /* clean the MV table in IPS frames for direct mode in B frames */
3215
            if(s->mb_intra /* && I,P,S_TYPE */){
3216
                s->p_mv_table[xy][0]=0;
3217
                s->p_mv_table[xy][1]=0;
3218
            }
3219

    
3220
            MPV_decode_mb(s, s->block);
3221
            
3222
            if(s->flags&CODEC_FLAG_PSNR){
3223
                int w= 16;
3224
                int h= 16;
3225

    
3226
                if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3227
                if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3228

    
3229
                s->current_picture.error[0] += sse(
3230
                    s,
3231
                    s->new_picture    .data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3232
                    s->current_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3233
                    w, h, s->linesize);
3234
                s->current_picture.error[1] += sse(
3235
                    s,
3236
                    s->new_picture    .data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3237
                    s->current_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3238
                    w>>1, h>>1, s->uvlinesize);
3239
                s->current_picture.error[2] += sse(
3240
                    s,
3241
                    s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3242
                    s->current_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3243
                    w>>1, h>>1, s->uvlinesize);
3244
            }
3245
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_width, get_bit_count(&s->pb));
3246
        }
3247

    
3248

    
3249
        /* Obtain average mb_row size for RTP */
3250
        if (s->rtp_mode) {
3251
            if (mb_y==0)
3252
                s->mb_line_avgsize = pbBufPtr(&s->pb) - s->ptr_last_mb_line;
3253
            else {    
3254
                s->mb_line_avgsize = (s->mb_line_avgsize + pbBufPtr(&s->pb) - s->ptr_last_mb_line) >> 1;
3255
            }
3256
            s->ptr_last_mb_line = pbBufPtr(&s->pb);
3257
        }
3258
    }
3259
    emms_c();
3260

    
3261
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3262
        ff_mpeg4_merge_partitions(s);
3263

    
3264
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
3265
        msmpeg4_encode_ext_header(s);
3266

    
3267
    if(s->codec_id==CODEC_ID_MPEG4) 
3268
        ff_mpeg4_stuffing(&s->pb);
3269

    
3270
    //if (s->gob_number)
3271
    //    fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
3272
    
3273
    /* Send the last GOB if RTP */    
3274
    if (s->rtp_mode) {
3275
        flush_put_bits(&s->pb);
3276
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
3277
        /* Call the RTP callback to send the last GOB */
3278
        if (s->rtp_callback)
3279
            s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
3280
        s->ptr_lastgob = pbBufPtr(&s->pb);
3281
        //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
3282
    }
3283
}
3284

    
3285
static int dct_quantize_trellis_c(MpegEncContext *s, 
3286
                        DCTELEM *block, int n,
3287
                        int qscale, int *overflow){
3288
    const int *qmat;
3289
    const UINT8 *scantable= s->intra_scantable.scantable;
3290
    int max=0;
3291
    unsigned int threshold1, threshold2;
3292
    int bias=0;
3293
    int run_tab[65];
3294
    int level_tab[65];
3295
    int score_tab[65];
3296
    int last_run=0;
3297
    int last_level=0;
3298
    int last_score= 0;
3299
    int last_i= 0;
3300
    int coeff[3][64];
3301
    int coeff_count[64];
3302
    int lambda, qmul, qadd, start_i, last_non_zero, i;
3303
    const int esc_length= s->ac_esc_length;
3304
    uint8_t * length;
3305
    uint8_t * last_length;
3306
    int score_limit=0;
3307
    int left_limit= 0;
3308
        
3309
    s->fdct (block);
3310

    
3311
    qmul= qscale*16;
3312
    qadd= ((qscale-1)|1)*8;
3313

    
3314
    if (s->mb_intra) {
3315
        int q;
3316
        if (!s->h263_aic) {
3317
            if (n < 4)
3318
                q = s->y_dc_scale;
3319
            else
3320
                q = s->c_dc_scale;
3321
            q = q << 3;
3322
        } else{
3323
            /* For AIC we skip quant/dequant of INTRADC */
3324
            q = 1 << 3;
3325
            qadd=0;
3326
        }
3327
            
3328
        /* note: block[0] is assumed to be positive */
3329
        block[0] = (block[0] + (q >> 1)) / q;
3330
        start_i = 1;
3331
        last_non_zero = 0;
3332
        qmat = s->q_intra_matrix[qscale];
3333
        if(s->mpeg_quant || s->codec_id== CODEC_ID_MPEG1VIDEO)
3334
            bias= 1<<(QMAT_SHIFT-1);
3335
        length     = s->intra_ac_vlc_length;
3336
        last_length= s->intra_ac_vlc_last_length;
3337
    } else {
3338
        start_i = 0;
3339
        last_non_zero = -1;
3340
        qmat = s->q_inter_matrix[qscale];
3341
        length     = s->inter_ac_vlc_length;
3342
        last_length= s->inter_ac_vlc_last_length;
3343
    }
3344

    
3345
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
3346
    threshold2= (threshold1<<1);
3347

    
3348
    for(i=start_i; i<64; i++) {
3349
        const int j = scantable[i];
3350
        const int k= i-start_i;
3351
        int level = block[j];
3352
        level = level * qmat[j];
3353

    
3354
//        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
3355
//           || bias-level >= (1<<(QMAT_SHIFT - 3))){
3356
        if(((unsigned)(level+threshold1))>threshold2){
3357
            if(level>0){
3358
                level= (bias + level)>>QMAT_SHIFT;
3359
                coeff[0][k]= level;
3360
                coeff[1][k]= level-1;
3361
//                coeff[2][k]= level-2;
3362
            }else{
3363
                level= (bias - level)>>QMAT_SHIFT;
3364
                coeff[0][k]= -level;
3365
                coeff[1][k]= -level+1;
3366
//                coeff[2][k]= -level+2;
3367
            }
3368
            coeff_count[k]= FFMIN(level, 2);
3369
            max |=level;
3370
            last_non_zero = i;
3371
        }else{
3372
            coeff[0][k]= (level>>31)|1;
3373
            coeff_count[k]= 1;
3374
        }
3375
    }
3376
    
3377
    *overflow= s->max_qcoeff < max; //overflow might have happend
3378
    
3379
    if(last_non_zero < start_i){
3380
        memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3381
        return last_non_zero;
3382
    }
3383

    
3384
    lambda= (qscale*qscale*64*82 + 50)/100; //FIXME finetune
3385
        
3386
    score_tab[0]= 0;
3387
    for(i=0; i<=last_non_zero - start_i; i++){
3388
        int level_index, run, j;
3389
        const int dct_coeff= block[ scantable[i + start_i] ];
3390
        const int zero_distoration= dct_coeff*dct_coeff;
3391
        int best_score=256*256*256*120;
3392

    
3393
        last_score += zero_distoration;
3394
        for(level_index=0; level_index < coeff_count[i]; level_index++){
3395
            int distoration;
3396
            int level= coeff[level_index][i];
3397
            int unquant_coeff;
3398
            
3399
            assert(level);
3400

    
3401
            if(s->out_format == FMT_H263){
3402
                if(level>0){
3403
                    unquant_coeff= level*qmul + qadd;
3404
                }else{
3405
                    unquant_coeff= level*qmul - qadd;
3406
                }
3407
            }else{ //MPEG1
3408
                j= s->idct_permutation[ scantable[i + start_i] ]; //FIXME optimize
3409
                if(s->mb_intra){
3410
                    if (level < 0) {
3411
                        unquant_coeff = (int)((-level) * qscale * s->intra_matrix[j]) >> 3;
3412
                        unquant_coeff = -((unquant_coeff - 1) | 1);
3413
                    } else {
3414
                        unquant_coeff = (int)(  level  * qscale * s->intra_matrix[j]) >> 3;
3415
                        unquant_coeff =   (unquant_coeff - 1) | 1;
3416
                    }
3417
                }else{
3418
                    if (level < 0) {
3419
                        unquant_coeff = ((((-level) << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3420
                        unquant_coeff = -((unquant_coeff - 1) | 1);
3421
                    } else {
3422
                        unquant_coeff = (((  level  << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3423
                        unquant_coeff =   (unquant_coeff - 1) | 1;
3424
                    }
3425
                }
3426
                unquant_coeff<<= 3;
3427
            }
3428

    
3429
            distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff);
3430
            level+=64;
3431
            if((level&(~127)) == 0){
3432
                for(run=0; run<=i - left_limit; run++){
3433
                    int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3434
                    score += score_tab[i-run];
3435
                    
3436
                    if(score < best_score){
3437
                        best_score= 
3438
                        score_tab[i+1]= score;
3439
                        run_tab[i+1]= run;
3440
                        level_tab[i+1]= level-64;
3441
                    }
3442
                }
3443

    
3444
                if(s->out_format == FMT_H263){
3445
                    for(run=0; run<=i - left_limit; run++){
3446
                        int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3447
                        score += score_tab[i-run];
3448
                        if(score < last_score){
3449
                            last_score= score;
3450
                            last_run= run;
3451
                            last_level= level-64;
3452
                            last_i= i+1;
3453
                        }
3454
                    }
3455
                }
3456
            }else{
3457
                distoration += esc_length*lambda;
3458
                for(run=0; run<=i - left_limit; run++){
3459
                    int score= distoration + score_tab[i-run];
3460
                    
3461
                    if(score < best_score){
3462
                        best_score= 
3463
                        score_tab[i+1]= score;
3464
                        run_tab[i+1]= run;
3465
                        level_tab[i+1]= level-64;
3466
                    }
3467
                }
3468

    
3469
                if(s->out_format == FMT_H263){
3470
                    for(run=0; run<=i - left_limit; run++){
3471
                        int score= distoration + score_tab[i-run];
3472
                        if(score < last_score){
3473
                            last_score= score;
3474
                            last_run= run;
3475
                            last_level= level-64;
3476
                            last_i= i+1;
3477
                        }
3478
                    }
3479
                }
3480
            }
3481
        }
3482

    
3483
        for(j=left_limit; j<=i; j++){
3484
            score_tab[j] += zero_distoration;
3485
        }
3486
        score_limit+= zero_distoration;
3487
        if(score_tab[i+1] < score_limit)
3488
            score_limit= score_tab[i+1];
3489
        
3490
        //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3491
        while(score_tab[ left_limit ] > score_limit + lambda) left_limit++;
3492
    }
3493

    
3494
        //FIXME add some cbp penalty
3495

    
3496
    if(s->out_format != FMT_H263){
3497
        last_score= 256*256*256*120;
3498
        for(i= left_limit; i<=last_non_zero - start_i + 1; i++){
3499
            int score= score_tab[i];
3500
            if(i) score += lambda*2; //FIXME exacter?
3501

    
3502
            if(score < last_score){
3503
                last_score= score;
3504
                last_i= i;
3505
                last_level= level_tab[i];
3506
                last_run= run_tab[i];
3507
            }
3508
        }
3509
    }
3510
    
3511
    last_non_zero= last_i - 1 + start_i;
3512
    memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3513
    
3514
    if(last_non_zero < start_i)
3515
        return last_non_zero;
3516
    
3517
    i= last_i;
3518
    assert(last_level);
3519
//FIXME use permutated scantable
3520
    block[ s->idct_permutation[ scantable[last_non_zero] ] ]= last_level;
3521
    i -= last_run + 1;
3522
    
3523
    for(;i>0 ; i -= run_tab[i] + 1){
3524
        const int j= s->idct_permutation[ scantable[i - 1 + start_i] ];
3525
    
3526
        block[j]= level_tab[i];
3527
        assert(block[j]);
3528
    }
3529

    
3530
    return last_non_zero;
3531
}
3532

    
3533
static int dct_quantize_c(MpegEncContext *s, 
3534
                        DCTELEM *block, int n,
3535
                        int qscale, int *overflow)
3536
{
3537
    int i, j, level, last_non_zero, q;
3538
    const int *qmat;
3539
    const UINT8 *scantable= s->intra_scantable.scantable;
3540
    int bias;
3541
    int max=0;
3542
    unsigned int threshold1, threshold2;
3543

    
3544
    s->fdct (block);
3545

    
3546
    if (s->mb_intra) {
3547
        if (!s->h263_aic) {
3548
            if (n < 4)
3549
                q = s->y_dc_scale;
3550
            else
3551
                q = s->c_dc_scale;
3552
            q = q << 3;
3553
        } else
3554
            /* For AIC we skip quant/dequant of INTRADC */
3555
            q = 1 << 3;
3556
            
3557
        /* note: block[0] is assumed to be positive */
3558
        block[0] = (block[0] + (q >> 1)) / q;
3559
        i = 1;
3560
        last_non_zero = 0;
3561
        qmat = s->q_intra_matrix[qscale];
3562
        bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
3563
    } else {
3564
        i = 0;
3565
        last_non_zero = -1;
3566
        qmat = s->q_inter_matrix[qscale];
3567
        bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
3568
    }
3569
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
3570
    threshold2= (threshold1<<1);
3571

    
3572
    for(;i<64;i++) {
3573
        j = scantable[i];
3574
        level = block[j];
3575
        level = level * qmat[j];
3576

    
3577
//        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
3578
//           || bias-level >= (1<<(QMAT_SHIFT - 3))){
3579
        if(((unsigned)(level+threshold1))>threshold2){
3580
            if(level>0){
3581
                level= (bias + level)>>QMAT_SHIFT;
3582
                block[j]= level;
3583
            }else{
3584
                level= (bias - level)>>QMAT_SHIFT;
3585
                block[j]= -level;
3586
            }
3587
            max |=level;
3588
            last_non_zero = i;
3589
        }else{
3590
            block[j]=0;
3591
        }
3592
    }
3593
    *overflow= s->max_qcoeff < max; //overflow might have happend
3594
    
3595
    /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
3596
    if (s->idct_permutation_type != FF_NO_IDCT_PERM)
3597
        ff_block_permute(block, s->idct_permutation, scantable, last_non_zero);
3598

    
3599
    return last_non_zero;
3600
}
3601

    
3602
static void dct_unquantize_mpeg1_c(MpegEncContext *s, 
3603
                                   DCTELEM *block, int n, int qscale)
3604
{
3605
    int i, level, nCoeffs;
3606
    const UINT16 *quant_matrix;
3607

    
3608
    nCoeffs= s->block_last_index[n];
3609
    
3610
    if (s->mb_intra) {
3611
        if (n < 4) 
3612
            block[0] = block[0] * s->y_dc_scale;
3613
        else
3614
            block[0] = block[0] * s->c_dc_scale;
3615
        /* XXX: only mpeg1 */
3616
        quant_matrix = s->intra_matrix;
3617
        for(i=1;i<=nCoeffs;i++) {
3618
            int j= s->intra_scantable.permutated[i];
3619
            level = block[j];
3620
            if (level) {
3621
                if (level < 0) {
3622
                    level = -level;
3623
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3624
                    level = (level - 1) | 1;
3625
                    level = -level;
3626
                } else {
3627
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3628
                    level = (level - 1) | 1;
3629
                }
3630
#ifdef PARANOID
3631
                if (level < -2048 || level > 2047)
3632
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3633
#endif
3634
                block[j] = level;
3635
            }
3636
        }
3637
    } else {
3638
        i = 0;
3639
        quant_matrix = s->inter_matrix;
3640
        for(;i<=nCoeffs;i++) {
3641
            int j= s->intra_scantable.permutated[i];
3642
            level = block[j];
3643
            if (level) {
3644
                if (level < 0) {
3645
                    level = -level;
3646
                    level = (((level << 1) + 1) * qscale *
3647
                             ((int) (quant_matrix[j]))) >> 4;
3648
                    level = (level - 1) | 1;
3649
                    level = -level;
3650
                } else {
3651
                    level = (((level << 1) + 1) * qscale *
3652
                             ((int) (quant_matrix[j]))) >> 4;
3653
                    level = (level - 1) | 1;
3654
                }
3655
#ifdef PARANOID
3656
                if (level < -2048 || level > 2047)
3657
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3658
#endif
3659
                block[j] = level;
3660
            }
3661
        }
3662
    }
3663
}
3664

    
3665
static void dct_unquantize_mpeg2_c(MpegEncContext *s, 
3666
                                   DCTELEM *block, int n, int qscale)
3667
{
3668
    int i, level, nCoeffs;
3669
    const UINT16 *quant_matrix;
3670

    
3671
    if(s->alternate_scan) nCoeffs= 63;
3672
    else nCoeffs= s->block_last_index[n];
3673
    
3674
    if (s->mb_intra) {
3675
        if (n < 4) 
3676
            block[0] = block[0] * s->y_dc_scale;
3677
        else
3678
            block[0] = block[0] * s->c_dc_scale;
3679
        quant_matrix = s->intra_matrix;
3680
        for(i=1;i<=nCoeffs;i++) {
3681
            int j= s->intra_scantable.permutated[i];
3682
            level = block[j];
3683
            if (level) {
3684
                if (level < 0) {
3685
                    level = -level;
3686
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3687
                    level = -level;
3688
                } else {
3689
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3690
                }
3691
#ifdef PARANOID
3692
                if (level < -2048 || level > 2047)
3693
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3694
#endif
3695
                block[j] = level;
3696
            }
3697
        }
3698
    } else {
3699
        int sum=-1;
3700
        i = 0;
3701
        quant_matrix = s->inter_matrix;
3702
        for(;i<=nCoeffs;i++) {
3703
            int j= s->intra_scantable.permutated[i];
3704
            level = block[j];
3705
            if (level) {
3706
                if (level < 0) {
3707
                    level = -level;
3708
                    level = (((level << 1) + 1) * qscale *
3709
                             ((int) (quant_matrix[j]))) >> 4;
3710
                    level = -level;
3711
                } else {
3712
                    level = (((level << 1) + 1) * qscale *
3713
                             ((int) (quant_matrix[j]))) >> 4;
3714
                }
3715
#ifdef PARANOID
3716
                if (level < -2048 || level > 2047)
3717
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3718
#endif
3719
                block[j] = level;
3720
                sum+=level;
3721
            }
3722
        }
3723
        block[63]^=sum&1;
3724
    }
3725
}
3726

    
3727

    
3728
static void dct_unquantize_h263_c(MpegEncContext *s, 
3729
                                  DCTELEM *block, int n, int qscale)
3730
{
3731
    int i, level, qmul, qadd;
3732
    int nCoeffs;
3733
    
3734
    assert(s->block_last_index[n]>=0);
3735
    
3736
    qadd = (qscale - 1) | 1;
3737
    qmul = qscale << 1;
3738
    
3739
    if (s->mb_intra) {
3740
        if (!s->h263_aic) {
3741
            if (n < 4) 
3742
                block[0] = block[0] * s->y_dc_scale;
3743
            else
3744
                block[0] = block[0] * s->c_dc_scale;
3745
        }else
3746
            qadd = 0;
3747
        i = 1;
3748
        nCoeffs= 63; //does not allways use zigzag table 
3749
    } else {
3750
        i = 0;
3751
        nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ];
3752
    }
3753

    
3754
    for(;i<=nCoeffs;i++) {
3755
        level = block[i];
3756
        if (level) {
3757
            if (level < 0) {
3758
                level = level * qmul - qadd;
3759
            } else {
3760
                level = level * qmul + qadd;
3761
            }
3762
#ifdef PARANOID
3763
                if (level < -2048 || level > 2047)
3764
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3765
#endif
3766
            block[i] = level;
3767
        }
3768
    }
3769
}
3770

    
3771
char ff_get_pict_type_char(int pict_type){
3772
    switch(pict_type){
3773
    case I_TYPE: return 'I'; 
3774
    case P_TYPE: return 'P'; 
3775
    case B_TYPE: return 'B'; 
3776
    case S_TYPE: return 'S'; 
3777
    default:     return '?';
3778
    }
3779
}
3780

    
3781
AVCodec mpeg1video_encoder = {
3782
    "mpeg1video",
3783
    CODEC_TYPE_VIDEO,
3784
    CODEC_ID_MPEG1VIDEO,
3785
    sizeof(MpegEncContext),
3786
    MPV_encode_init,
3787
    MPV_encode_picture,
3788
    MPV_encode_end,
3789
};
3790

    
3791
AVCodec h263_encoder = {
3792
    "h263",
3793
    CODEC_TYPE_VIDEO,
3794
    CODEC_ID_H263,
3795
    sizeof(MpegEncContext),
3796
    MPV_encode_init,
3797
    MPV_encode_picture,
3798
    MPV_encode_end,
3799
};
3800

    
3801
AVCodec h263p_encoder = {
3802
    "h263p",
3803
    CODEC_TYPE_VIDEO,
3804
    CODEC_ID_H263P,
3805
    sizeof(MpegEncContext),
3806
    MPV_encode_init,
3807
    MPV_encode_picture,
3808
    MPV_encode_end,
3809
};
3810

    
3811
AVCodec rv10_encoder = {
3812
    "rv10",
3813
    CODEC_TYPE_VIDEO,
3814
    CODEC_ID_RV10,
3815
    sizeof(MpegEncContext),
3816
    MPV_encode_init,
3817
    MPV_encode_picture,
3818
    MPV_encode_end,
3819
};
3820

    
3821
AVCodec mjpeg_encoder = {
3822
    "mjpeg",
3823
    CODEC_TYPE_VIDEO,
3824
    CODEC_ID_MJPEG,
3825
    sizeof(MpegEncContext),
3826
    MPV_encode_init,
3827
    MPV_encode_picture,
3828
    MPV_encode_end,
3829
};
3830

    
3831
AVCodec mpeg4_encoder = {
3832
    "mpeg4",
3833
    CODEC_TYPE_VIDEO,
3834
    CODEC_ID_MPEG4,
3835
    sizeof(MpegEncContext),
3836
    MPV_encode_init,
3837
    MPV_encode_picture,
3838
    MPV_encode_end,
3839
};
3840

    
3841
AVCodec msmpeg4v1_encoder = {
3842
    "msmpeg4v1",
3843
    CODEC_TYPE_VIDEO,
3844
    CODEC_ID_MSMPEG4V1,
3845
    sizeof(MpegEncContext),
3846
    MPV_encode_init,
3847
    MPV_encode_picture,
3848
    MPV_encode_end,
3849
};
3850

    
3851
AVCodec msmpeg4v2_encoder = {
3852
    "msmpeg4v2",
3853
    CODEC_TYPE_VIDEO,
3854
    CODEC_ID_MSMPEG4V2,
3855
    sizeof(MpegEncContext),
3856
    MPV_encode_init,
3857
    MPV_encode_picture,
3858
    MPV_encode_end,
3859
};
3860

    
3861
AVCodec msmpeg4v3_encoder = {
3862
    "msmpeg4",
3863
    CODEC_TYPE_VIDEO,
3864
    CODEC_ID_MSMPEG4V3,
3865
    sizeof(MpegEncContext),
3866
    MPV_encode_init,
3867
    MPV_encode_picture,
3868
    MPV_encode_end,
3869
};
3870

    
3871
AVCodec wmv1_encoder = {
3872
    "wmv1",
3873
    CODEC_TYPE_VIDEO,
3874
    CODEC_ID_WMV1,
3875
    sizeof(MpegEncContext),
3876
    MPV_encode_init,
3877
    MPV_encode_picture,
3878
    MPV_encode_end,
3879
};
3880