Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 369fe599

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
static void convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[64], uint16_t (*qmat16_bias)[64],
90
                           const UINT16 *quant_matrix, int bias, int qmin, int qmax)
91
{
92
    int qscale;
93

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

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

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

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

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

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

    
191
    ff_put_pixels_clamped = s->dsp.put_pixels_clamped;
192
    ff_add_pixels_clamped = s->dsp.add_pixels_clamped;
193

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

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

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

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

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

    
259

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

    
268
    return 0;
269
}
270

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

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

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

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

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

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

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

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

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

    
361
    dsputil_init(&s->dsp, s->avctx->dsp_mask);
362
    DCT_common_init(s);
363

    
364
    s->flags= s->avctx->flags;
365

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

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

    
373
    s->mb_num = s->mb_width * s->mb_height;
374

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

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

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

    
387
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
388

    
389
    if (s->encoding) {
390
        int mv_table_size= (s->mb_width+2)*(s->mb_height+2);
391

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

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

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

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

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

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

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

    
477
    s->parse_context.state= -1;
478

    
479
    s->context_initialized = 1;
480
    return 0;
481
 fail:
482
    MPV_common_end(s);
483
    return -1;
484
}
485

    
486

    
487
//extern int sads;
488

    
489
/* init common structure for both encoder and decoder */
490
void MPV_common_end(MpegEncContext *s)
491
{
492
    int i;
493

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

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

    
530
/* init video encoder */
531
int MPV_encode_init(AVCodecContext *avctx)
532
{
533
    MpegEncContext *s = avctx->priv_data;
534
    int i;
535

    
536
    avctx->pix_fmt = PIX_FMT_YUV420P;
537

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

    
569
    if (s->gop_size <= 1) {
570
        s->intra_only = 1;
571
        s->gop_size = 12;
572
    } else {
573
        s->intra_only = 0;
574
    }
575

    
576
    s->me_method = avctx->me_method;
577

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

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

    
700
            default_mv_penalty= av_mallocz( sizeof(UINT16)*(MAX_FCODE+1)*(2*MAX_MV+1) );
701
            memset(default_mv_penalty, 0, sizeof(UINT16)*(MAX_FCODE+1)*(2*MAX_MV+1));
702
            memset(default_fcode_tab , 0, sizeof(UINT8)*(2*MAX_MV+1));
703

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

    
718
    s->encoding = 1;
719

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

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

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

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

    
759
    if(ff_rate_control_init(s) < 0)
760
        return -1;
761

    
762
    s->picture_number = 0;
763
    s->picture_in_gop_number = 0;
764
    s->fake_picture_number = 0;
765
    /* motion detector init */
766
    s->f_code = 1;
767
    s->b_code = 1;
768

    
769
    return 0;
770
}
771

    
772
int MPV_encode_end(AVCodecContext *avctx)
773
{
774
    MpegEncContext *s = avctx->priv_data;
775

    
776
#ifdef STATS
777
    print_stats();
778
#endif
779

    
780
    ff_rate_control_uninit(s);
781

    
782
    MPV_common_end(s);
783
    if (s->out_format == FMT_MJPEG)
784
        mjpeg_close(s);
785
      
786
    return 0;
787
}
788

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

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

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

    
834
    assert(i<MAX_PICTURE_COUNT);
835
    return i;
836
}
837

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

    
844
    s->mb_skiped = 0;
845
    
846
    /* mark&release old frames */
847
    if (s->pict_type != B_TYPE && s->last_picture.data[0]) {
848
        for(i=0; i<MAX_PICTURE_COUNT; i++){
849
//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]);
850
            if(s->picture[i].data[0] == s->last_picture.data[0]){
851
//                s->picture[i].reference=0;
852
                avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
853
                break;
854
            }    
855
        }
856
        assert(i<MAX_PICTURE_COUNT);
857

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

    
879
        s->current_picture= s->picture[i];
880
    }
881

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

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

    
906
    return 0;
907
}
908

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

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

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

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

    
993

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

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

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

    
1021
        pic= (AVFrame*)&s->picture[i];
1022
        pic->reference= 1;
1023

    
1024
        alloc_picture(s, (Picture*)pic, 0);
1025

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

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

    
1070
    return 0;
1071
}
1072

    
1073
static void select_input_picture(MpegEncContext *s){
1074
    int i;
1075
    const int encoding_delay= s->max_b_frames;
1076
    int coded_pic_num=0;    
1077

    
1078
    if(s->reordered_input_picture[0])
1079
        coded_pic_num= s->reordered_input_picture[0]->coded_picture_number + 1;
1080

    
1081
    for(i=1; i<MAX_PICTURE_COUNT; i++)
1082
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1083
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1084

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

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

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

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

    
1167
            s->new_picture= *s->reordered_input_picture[0];
1168

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

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

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

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

    
1208
    init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
1209

    
1210
    s->picture_in_gop_number++;
1211

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

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

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

    
1240
        MPV_frame_end(s);
1241

    
1242
        if (s->out_format == FMT_MJPEG)
1243
            mjpeg_picture_trailer(s);
1244
        
1245
        if(s->flags&CODEC_FLAG_PASS1)
1246
            ff_write_pass1_stats(s);
1247
    }
1248

    
1249
    s->input_picture_number++;
1250

    
1251
    flush_put_bits(&s->pb);
1252
    s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1253
    
1254
    s->total_bits += s->frame_bits;
1255
    avctx->frame_bits  = s->frame_bits;
1256

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

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

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

    
1287
    linesize = s->linesize;
1288
    uvlinesize = s->uvlinesize;
1289
    
1290
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1291

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

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

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

    
1349
static inline void gmc_motion(MpegEncContext *s,
1350
                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1351
                               int dest_offset,
1352
                               UINT8 **ref_picture, int src_offset)
1353
{
1354
    UINT8 *ptr;
1355
    int linesize, uvlinesize;
1356
    const int a= s->sprite_warping_accuracy;
1357
    int ox, oy;
1358

    
1359
    linesize = s->linesize;
1360
    uvlinesize = s->uvlinesize;
1361

    
1362
    ptr = ref_picture[0] + src_offset;
1363

    
1364
    dest_y+=dest_offset;
1365
    
1366
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
1367
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
1368

    
1369
    s->dsp.gmc(dest_y, ptr, linesize, 16,
1370
           ox, 
1371
           oy, 
1372
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1373
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1374
           a+1, (1<<(2*a+1)) - s->no_rounding,
1375
           s->h_edge_pos, s->v_edge_pos);
1376
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
1377
           ox + s->sprite_delta[0][0]*8, 
1378
           oy + s->sprite_delta[1][0]*8, 
1379
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1380
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1381
           a+1, (1<<(2*a+1)) - s->no_rounding,
1382
           s->h_edge_pos, s->v_edge_pos);
1383

    
1384
    if(s->flags&CODEC_FLAG_GRAY) return;
1385

    
1386

    
1387
    dest_cb+=dest_offset>>1;
1388
    dest_cr+=dest_offset>>1;
1389
    
1390
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
1391
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
1392

    
1393
    ptr = ref_picture[1] + (src_offset>>1);
1394
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
1395
           ox, 
1396
           oy, 
1397
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1398
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1399
           a+1, (1<<(2*a+1)) - s->no_rounding,
1400
           s->h_edge_pos>>1, s->v_edge_pos>>1);
1401
    
1402
    ptr = ref_picture[2] + (src_offset>>1);
1403
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
1404
           ox, 
1405
           oy, 
1406
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1407
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1408
           a+1, (1<<(2*a+1)) - s->no_rounding,
1409
           s->h_edge_pos>>1, s->v_edge_pos>>1);
1410
}
1411

    
1412

    
1413
void ff_emulated_edge_mc(MpegEncContext *s, UINT8 *src, int linesize, int block_w, int block_h, 
1414
                                    int src_x, int src_y, int w, int h){
1415
    int x, y;
1416
    int start_y, start_x, end_y, end_x;
1417
    UINT8 *buf= s->edge_emu_buffer;
1418

    
1419
    if(src_y>= h){
1420
        src+= (h-1-src_y)*linesize;
1421
        src_y=h-1;
1422
    }else if(src_y<=-block_h){
1423
        src+= (1-block_h-src_y)*linesize;
1424
        src_y=1-block_h;
1425
    }
1426
    if(src_x>= w){
1427
        src+= (w-1-src_x);
1428
        src_x=w-1;
1429
    }else if(src_x<=-block_w){
1430
        src+= (1-block_w-src_x);
1431
        src_x=1-block_w;
1432
    }
1433

    
1434
    start_y= FFMAX(0, -src_y);
1435
    start_x= FFMAX(0, -src_x);
1436
    end_y= FFMIN(block_h, h-src_y);
1437
    end_x= FFMIN(block_w, w-src_x);
1438

    
1439
    // copy existing part
1440
    for(y=start_y; y<end_y; y++){
1441
        for(x=start_x; x<end_x; x++){
1442
            buf[x + y*linesize]= src[x + y*linesize];
1443
        }
1444
    }
1445

    
1446
    //top
1447
    for(y=0; y<start_y; y++){
1448
        for(x=start_x; x<end_x; x++){
1449
            buf[x + y*linesize]= buf[x + start_y*linesize];
1450
        }
1451
    }
1452

    
1453
    //bottom
1454
    for(y=end_y; y<block_h; y++){
1455
        for(x=start_x; x<end_x; x++){
1456
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1457
        }
1458
    }
1459
                                    
1460
    for(y=0; y<block_h; y++){
1461
       //left
1462
        for(x=0; x<start_x; x++){
1463
            buf[x + y*linesize]= buf[start_x + y*linesize];
1464
        }
1465
       
1466
       //right
1467
        for(x=end_x; x<block_w; x++){
1468
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1469
        }
1470
    }
1471
}
1472

    
1473

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

    
1510
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1511
        if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 16 > s->h_edge_pos
1512
                              || src_y + (motion_y&1) + h  > v_edge_pos){
1513
            ff_emulated_edge_mc(s, ptr - src_offset, s->linesize, 17, 17+field_based, 
1514
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1515
            ptr= s->edge_emu_buffer + src_offset;
1516
            emu=1;
1517
        }
1518
    }
1519
    pix_op[0][dxy](dest_y, ptr, linesize, h);
1520

    
1521
    if(s->flags&CODEC_FLAG_GRAY) return;
1522

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

    
1556
    ptr = ref_picture[2] + offset;
1557
    if(emu){
1558
        ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
1559
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1560
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1561
    }
1562
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1563
}
1564

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

    
1577
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1578
    src_x = s->mb_x * 16 + (motion_x >> 2);
1579
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
1580

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

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

    
1615
    if(field_based){
1616
        mx= motion_x/2;
1617
        my= motion_y>>1;
1618
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
1619
        mx= (motion_x>>1)|(motion_x&1);
1620
        my= (motion_y>>1)|(motion_y&1);
1621
    }else{
1622
        mx= motion_x/2;
1623
        my= motion_y/2;
1624
    }
1625
    mx= (mx>>1)|(mx&1);
1626
    my= (my>>1)|(my&1);
1627
    dxy= (mx&1) | ((my&1)<<1);
1628
    mx>>=1;
1629
    my>>=1;
1630

    
1631
    src_x = s->mb_x * 8 + mx;
1632
    src_y = s->mb_y * (8 >> field_based) + my;
1633
    src_x = clip(src_x, -8, s->width >> 1);
1634
    if (src_x == (s->width >> 1))
1635
        dxy &= ~1;
1636
    src_y = clip(src_y, -8, height >> 1);
1637
    if (src_y == (height >> 1))
1638
        dxy &= ~2;
1639

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

    
1658

    
1659
static inline void MPV_motion(MpegEncContext *s, 
1660
                              UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1661
                              int dir, UINT8 **ref_picture, 
1662
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
1663
{
1664
    int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
1665
    int mb_x, mb_y, i;
1666
    UINT8 *ptr, *dest;
1667
    int emu=0;
1668

    
1669
    mb_x = s->mb_x;
1670
    mb_y = s->mb_y;
1671

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

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

    
1729
                mx += s->mv[dir][i][0]/2;
1730
                my += s->mv[dir][i][1]/2;
1731
            }
1732
        }else{
1733
            for(i=0;i<4;i++) {
1734
                motion_x = s->mv[dir][i][0];
1735
                motion_y = s->mv[dir][i][1];
1736

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

    
1760
                mx += s->mv[dir][i][0];
1761
                my += s->mv[dir][i][1];
1762
            }
1763
        }
1764

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

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

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

    
1842
        }
1843
        break;
1844
    }
1845
}
1846

    
1847

    
1848
/* put block[] to dest[] */
1849
static inline void put_dct(MpegEncContext *s, 
1850
                           DCTELEM *block, int i, UINT8 *dest, int line_size)
1851
{
1852
    s->dct_unquantize(s, block, i, s->qscale);
1853
    s->idct_put (dest, line_size, block);
1854
}
1855

    
1856
/* add block[] to dest[] */
1857
static inline void add_dct(MpegEncContext *s, 
1858
                           DCTELEM *block, int i, UINT8 *dest, int line_size)
1859
{
1860
    if (s->block_last_index[i] >= 0) {
1861
        s->idct_add (dest, line_size, block);
1862
    }
1863
}
1864

    
1865
static inline void add_dequant_dct(MpegEncContext *s, 
1866
                           DCTELEM *block, int i, UINT8 *dest, int line_size)
1867
{
1868
    if (s->block_last_index[i] >= 0) {
1869
        s->dct_unquantize(s, block, i, s->qscale);
1870

    
1871
        s->idct_add (dest, line_size, block);
1872
    }
1873
}
1874

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

    
1908
/* generic function called after a macroblock has been parsed by the
1909
   decoder or after it has been encoded by the encoder.
1910

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

    
1923
    mb_x = s->mb_x;
1924
    mb_y = s->mb_y;
1925

    
1926
    s->current_picture.qscale_table[mb_xy]= s->qscale;
1927

    
1928
    /* update DC predictors for P macroblocks */
1929
    if (!s->mb_intra) {
1930
        if (s->h263_pred || s->h263_aic) {
1931
            if(s->mbintra_table[mb_xy])
1932
                ff_clean_intra_table_entries(s);
1933
        } else {
1934
            s->last_dc[0] =
1935
            s->last_dc[1] =
1936
            s->last_dc[2] = 128 << s->intra_dc_precision;
1937
        }
1938
    }
1939
    else if (s->h263_pred || s->h263_aic)
1940
        s->mbintra_table[mb_xy]=1;
1941

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

    
1992
        /* avoid copy if macroblock skipped in last frame too */
1993
        if (s->pict_type != B_TYPE) {
1994
            s->current_picture.mbskip_table[mb_xy]= s->mb_skiped;
1995
        }
1996

    
1997
        /* skip only during decoding as we might trash the buffers during encoding a bit */
1998
        if(!s->encoding){
1999
            UINT8 *mbskip_ptr = &s->mbskip_table[mb_xy];
2000
            const int age= s->current_picture.age;
2001

    
2002
            assert(age);
2003

    
2004
            if (s->mb_skiped) {
2005
                s->mb_skiped= 0;
2006
                assert(s->pict_type!=I_TYPE);
2007
 
2008
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
2009
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2010

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

    
2025
        if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band){
2026
            dest_y  = s->current_picture.data[0] + mb_x * 16;
2027
            dest_cb = s->current_picture.data[1] + mb_x * 8;
2028
            dest_cr = s->current_picture.data[2] + mb_x * 8;
2029
        }else{
2030
            dest_y  = s->current_picture.data[0] + (mb_y * 16* s->linesize  ) + mb_x * 16;
2031
            dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
2032
            dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
2033
        }
2034

    
2035
        if (s->interlaced_dct) {
2036
            dct_linesize = s->linesize * 2;
2037
            dct_offset = s->linesize;
2038
        } else {
2039
            dct_linesize = s->linesize;
2040
            dct_offset = s->linesize * 8;
2041
        }
2042

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

    
2055
                if (s->mv_dir & MV_DIR_FORWARD) {
2056
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2057
                    op_pix = s->dsp.avg_pixels_tab;
2058
                    op_qpix= s->dsp.avg_qpel_pixels_tab;
2059
                }
2060
                if (s->mv_dir & MV_DIR_BACKWARD) {
2061
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2062
                }
2063
            }
2064

    
2065
            /* skip dequant / idct if we are really late ;) */
2066
            if(s->hurry_up>1) return;
2067

    
2068
            /* add dct residue */
2069
            if(s->encoding || !(   s->mpeg2 || s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO 
2070
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2071
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
2072
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2073
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2074
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2075

    
2076
                if(!(s->flags&CODEC_FLAG_GRAY)){
2077
                    add_dequant_dct(s, block[4], 4, dest_cb, s->uvlinesize);
2078
                    add_dequant_dct(s, block[5], 5, dest_cr, s->uvlinesize);
2079
                }
2080
            } else if(s->codec_id != CODEC_ID_WMV2){
2081
                add_dct(s, block[0], 0, dest_y, dct_linesize);
2082
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2083
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2084
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2085

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

    
2101
                if(!(s->flags&CODEC_FLAG_GRAY)){
2102
                    put_dct(s, block[4], 4, dest_cb, s->uvlinesize);
2103
                    put_dct(s, block[5], 5, dest_cr, s->uvlinesize);
2104
                }
2105
            }else{
2106
                s->idct_put(dest_y                 , dct_linesize, block[0]);
2107
                s->idct_put(dest_y              + 8, dct_linesize, block[1]);
2108
                s->idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
2109
                s->idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
2110

    
2111
                if(!(s->flags&CODEC_FLAG_GRAY)){
2112
                    s->idct_put(dest_cb, s->uvlinesize, block[4]);
2113
                    s->idct_put(dest_cr, s->uvlinesize, block[5]);
2114
                }
2115
            }
2116
        }
2117
    }
2118
}
2119

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

    
2138
    if(threshold<0){
2139
        skip_dc=0;
2140
        threshold= -threshold;
2141
    }else
2142
        skip_dc=1;
2143

    
2144
    /* are all which we could set to zero are allready zero? */
2145
    if(last_index<=skip_dc - 1) return;
2146

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

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

    
2190
static inline void requantize_coeffs(MpegEncContext *s, DCTELEM block[64], int oldq, int newq, int n)
2191
{
2192
    int i;
2193

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

    
2207
    for(i=s->block_last_index[n]; i>=0; i--){
2208
        const int j = s->intra_scantable.permutated[i];
2209
        if(block[j]) break;
2210
    }
2211
    s->block_last_index[n]= i;
2212
}
2213

    
2214
static inline void auto_requantize_coeffs(MpegEncContext *s, DCTELEM block[6][64])
2215
{
2216
    int i,n, newq;
2217
    const int maxlevel= s->max_qcoeff;
2218
    const int minlevel= s->min_qcoeff;
2219
    int largest=0, smallest=0;
2220

    
2221
    assert(s->adaptive_quant);
2222
    
2223
    for(n=0; n<6; n++){
2224
        if(s->mb_intra){
2225
            i=1; //skip clipping of intra dc
2226
             //FIXME requantize, note (mpeg1/h263/h263p-aic dont need it,...)
2227
        }else
2228
            i=0;
2229

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

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

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

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

    
2306
static int pix_diff_vcmp16x8(UINT8 *s1, UINT8*s2, int stride){ //FIXME move to dsputil & optimize
2307
    int score=0;
2308
    int x,y;
2309
    
2310
    for(y=0; y<7; y++){
2311
        for(x=0; x<16; x++){
2312
            score+= SQ(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2313
        }
2314
        s1+= stride;
2315
        s2+= stride;
2316
    }
2317
    
2318
    return score;
2319
}
2320

    
2321
#endif
2322

    
2323
void ff_draw_horiz_band(MpegEncContext *s){
2324
    if (    s->avctx->draw_horiz_band 
2325
        && (s->last_picture.data[0] || s->low_delay) ) {
2326
        UINT8 *src_ptr[3];
2327
        int y, h, offset;
2328
        y = s->mb_y * 16;
2329
        h = s->height - y;
2330
        if (h > 16)
2331
            h = 16;
2332

    
2333
        if(s->pict_type==B_TYPE)
2334
            offset = 0;
2335
        else
2336
            offset = y * s->linesize;
2337

    
2338
        if(s->pict_type==B_TYPE || s->low_delay){
2339
            src_ptr[0] = s->current_picture.data[0] + offset;
2340
            src_ptr[1] = s->current_picture.data[1] + (offset >> 2);
2341
            src_ptr[2] = s->current_picture.data[2] + (offset >> 2);
2342
        } else {
2343
            src_ptr[0] = s->last_picture.data[0] + offset;
2344
            src_ptr[1] = s->last_picture.data[1] + (offset >> 2);
2345
            src_ptr[2] = s->last_picture.data[2] + (offset >> 2);
2346
        }
2347
        emms_c();
2348

    
2349
        s->avctx->draw_horiz_band(s->avctx, src_ptr, s->linesize,
2350
                               y, s->width, h);
2351
    }
2352
}
2353

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

    
2367
        if(s->out_format==FMT_H263){
2368
            if     (s->dquant> 2) s->dquant= 2;
2369
            else if(s->dquant<-2) s->dquant=-2;
2370
        }
2371
            
2372
        if(s->codec_id==CODEC_ID_MPEG4){        
2373
            if(!s->mb_intra){
2374
                assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
2375

    
2376
                if(s->mv_dir&MV_DIRECT)
2377
                    s->dquant=0;
2378
            }
2379
        }
2380
        s->qscale+= s->dquant;
2381
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2382
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2383
    }
2384

    
2385
    if (s->mb_intra) {
2386
        UINT8 *ptr;
2387
        int wrap_y;
2388
        int emu=0;
2389

    
2390
        wrap_y = s->linesize;
2391
        ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2392

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

    
2419
        if(s->flags&CODEC_FLAG_GRAY){
2420
            skip_dct[4]= 1;
2421
            skip_dct[5]= 1;
2422
        }else{
2423
            int wrap_c = s->uvlinesize;
2424
            ptr = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2425
            if(emu){
2426
                ff_emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2427
                ptr= s->edge_emu_buffer;
2428
            }
2429
            s->dsp.get_pixels(s->block[4], ptr, wrap_c);
2430

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

    
2446
        dest_y  = s->current_picture.data[0] + (mb_y * 16 * s->linesize    ) + mb_x * 16;
2447
        dest_cb = s->current_picture.data[1] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2448
        dest_cr = s->current_picture.data[2] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2449
        wrap_y = s->linesize;
2450
        wrap_c = s->uvlinesize;
2451
        ptr_y  = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2452
        ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2453
        ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2454

    
2455
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
2456
            op_pix = s->dsp.put_pixels_tab;
2457
            op_qpix= s->dsp.put_qpel_pixels_tab;
2458
        }else{
2459
            op_pix = s->dsp.put_no_rnd_pixels_tab;
2460
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2461
        }
2462

    
2463
        if (s->mv_dir & MV_DIR_FORWARD) {
2464
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2465
            op_pix = s->dsp.avg_pixels_tab;
2466
            op_qpix= s->dsp.avg_qpel_pixels_tab;
2467
        }
2468
        if (s->mv_dir & MV_DIR_BACKWARD) {
2469
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2470
        }
2471

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

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

    
2583
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
2584
        s->block_last_index[4]=
2585
        s->block_last_index[5]= 0;
2586
        s->block[4][0]=
2587
        s->block[5][0]= 128;
2588
    }
2589

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

    
2615
void ff_copy_bits(PutBitContext *pb, UINT8 *src, int length)
2616
{
2617
    int bytes= length>>4;
2618
    int bits= length&15;
2619
    int i;
2620

    
2621
    if(length==0) return;
2622

    
2623
    for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
2624
    put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
2625
}
2626

    
2627
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2628
    int i;
2629

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

    
2632
    /* mpeg1 */
2633
    d->mb_incr= s->mb_incr;
2634
    for(i=0; i<3; i++)
2635
        d->last_dc[i]= s->last_dc[i];
2636
    
2637
    /* statistics */
2638
    d->mv_bits= s->mv_bits;
2639
    d->i_tex_bits= s->i_tex_bits;
2640
    d->p_tex_bits= s->p_tex_bits;
2641
    d->i_count= s->i_count;
2642
    d->f_count= s->f_count;
2643
    d->b_count= s->b_count;
2644
    d->skip_count= s->skip_count;
2645
    d->misc_bits= s->misc_bits;
2646
    d->last_bits= 0;
2647

    
2648
    d->mb_skiped= s->mb_skiped;
2649
    d->qscale= s->qscale;
2650
}
2651

    
2652
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2653
    int i;
2654

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

    
2673
    d->mb_intra= s->mb_intra;
2674
    d->mb_skiped= s->mb_skiped;
2675
    d->mv_type= s->mv_type;
2676
    d->mv_dir= s->mv_dir;
2677
    d->pb= s->pb;
2678
    if(s->data_partitioning){
2679
        d->pb2= s->pb2;
2680
        d->tex_pb= s->tex_pb;
2681
    }
2682
    d->block= s->block;
2683
    for(i=0; i<6; i++)
2684
        d->block_last_index[i]= s->block_last_index[i];
2685
    d->interlaced_dct= s->interlaced_dct;
2686
    d->qscale= s->qscale;
2687
}
2688

    
2689
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
2690
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2691
                           int *dmin, int *next_block, int motion_x, int motion_y)
2692
{
2693
    int bits_count;
2694
    
2695
    copy_context_before_encode(s, backup, type);
2696

    
2697
    s->block= s->blocks[*next_block];
2698
    s->pb= pb[*next_block];
2699
    if(s->data_partitioning){
2700
        s->pb2   = pb2   [*next_block];
2701
        s->tex_pb= tex_pb[*next_block];
2702
    }
2703

    
2704
    encode_mb(s, motion_x, motion_y);
2705

    
2706
    bits_count= get_bit_count(&s->pb);
2707
    if(s->data_partitioning){
2708
        bits_count+= get_bit_count(&s->pb2);
2709
        bits_count+= get_bit_count(&s->tex_pb);
2710
    }
2711

    
2712
    if(bits_count<*dmin){
2713
        *dmin= bits_count;
2714
        *next_block^=1;
2715

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

    
2741
static void encode_picture(MpegEncContext *s, int picture_number)
2742
{
2743
    int mb_x, mb_y, pdif = 0;
2744
    int i;
2745
    int bits;
2746
    MpegEncContext best_s, backup_s;
2747
    UINT8 bit_buf[2][3000];
2748
    UINT8 bit_buf2[2][3000];
2749
    UINT8 bit_buf_tex[2][3000];
2750
    PutBitContext pb[2], pb2[2], tex_pb[2];
2751

    
2752
    for(i=0; i<2; i++){
2753
        init_put_bits(&pb    [i], bit_buf    [i], 3000, NULL, NULL);
2754
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000, NULL, NULL);
2755
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
2756
    }
2757

    
2758
    s->picture_number = picture_number;
2759

    
2760
    s->block_wrap[0]=
2761
    s->block_wrap[1]=
2762
    s->block_wrap[2]=
2763
    s->block_wrap[3]= s->mb_width*2 + 2;
2764
    s->block_wrap[4]=
2765
    s->block_wrap[5]= s->mb_width + 2;
2766
    
2767
    /* Reset the average MB variance */
2768
    s->current_picture.mb_var_sum = 0;
2769
    s->current_picture.mc_mb_var_sum = 0;
2770

    
2771
    /* we need to initialize some time vars before we can encode b-frames */
2772
    if (s->h263_pred && !s->h263_msmpeg4)
2773
        ff_set_mpeg4_time(s, s->picture_number); 
2774

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

    
2797
                for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) {
2798
                    for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) {
2799
                        s->mb_x = mb_x;
2800
                        s->mb_y = mb_y;
2801
                        ff_pre_estimate_p_frame_motion(s, mb_x, mb_y);
2802
                    }
2803
                }
2804
                s->me.pre_pass=0;
2805
            }
2806
        }
2807

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

    
2848
                    s->current_picture.mb_var [s->mb_width * mb_y + mb_x] = varc;
2849
                    s->current_picture.mb_mean[s->mb_width * mb_y + mb_x] = (sum+128)>>8;
2850
                    s->current_picture.mb_var_sum    += varc;
2851
                }
2852
            }
2853
        }
2854
    }
2855
    emms_c();
2856

    
2857
    if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
2858
        s->pict_type= I_TYPE;
2859
        memset(s->mb_type   , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
2860
//printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
2861
    }
2862

    
2863
    if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) 
2864
        s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
2865
        ff_fix_long_p_mvs(s);
2866
    if(s->pict_type==B_TYPE){
2867
        s->f_code= ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
2868
        s->b_code= ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
2869

    
2870
        ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
2871
        ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
2872
        ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
2873
        ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
2874
    }
2875
    
2876
    if (s->fixed_qscale) 
2877
        s->frame_qscale = s->current_picture.quality;
2878
    else
2879
        s->frame_qscale = ff_rate_estimate_qscale(s);
2880

    
2881
    if(s->adaptive_quant){
2882
        switch(s->codec_id){
2883
        case CODEC_ID_MPEG4:
2884
            ff_clean_mpeg4_qscales(s);
2885
            break;
2886
        case CODEC_ID_H263:
2887
        case CODEC_ID_H263P:
2888
            ff_clean_h263_qscales(s);
2889
            break;
2890
        }
2891

    
2892
        s->qscale= s->current_picture.qscale_table[0];
2893
    }else
2894
        s->qscale= (int)(s->frame_qscale + 0.5);
2895
        
2896
    if (s->out_format == FMT_MJPEG) {
2897
        /* for mjpeg, we do include qscale in the matrix */
2898
        s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
2899
        for(i=1;i<64;i++){
2900
            int j= s->idct_permutation[i];
2901

    
2902
            s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
2903
        }
2904
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, 
2905
                       s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
2906
    }
2907
    
2908
    //FIXME var duplication
2909
    s->current_picture.key_frame= s->pict_type == I_TYPE;
2910
    s->current_picture.pict_type= s->pict_type;
2911

    
2912
    if(s->current_picture.key_frame)
2913
        s->picture_in_gop_number=0;
2914

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

    
2948
    for(i=0; i<3; i++){
2949
        /* init last dc values */
2950
        /* note: quant matrix value (8) is implied here */
2951
        s->last_dc[i] = 128;
2952
        
2953
        s->current_picture.error[i] = 0;
2954
    }
2955
    s->mb_incr = 1;
2956
    s->last_mv[0][0][0] = 0;
2957
    s->last_mv[0][0][1] = 0;
2958

    
2959
    if (s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P)
2960
        s->gob_index = ff_h263_get_gob_height(s);
2961

    
2962
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
2963
        ff_mpeg4_init_partitions(s);
2964

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

    
2986
            s->mb_x = mb_x;
2987
            s->mb_y = mb_y;
2988
            s->block_index[0]+=2;
2989
            s->block_index[1]+=2;
2990
            s->block_index[2]+=2;
2991
            s->block_index[3]+=2;
2992
            s->block_index[4]++;
2993
            s->block_index[5]++;
2994

    
2995
            /* write gob / video packet header  */
2996
            if(s->rtp_mode){
2997
                int current_packet_size, is_gob_start;
2998
                
2999
                current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
3000
                is_gob_start=0;
3001
                
3002
                if(s->codec_id==CODEC_ID_MPEG4){
3003
                    if(current_packet_size + s->mb_line_avgsize/s->mb_width >= s->rtp_payload_size
3004
                       && s->mb_y + s->mb_x>0){
3005

    
3006
                        if(s->partitioned_frame){
3007
                            ff_mpeg4_merge_partitions(s);
3008
                            ff_mpeg4_init_partitions(s);
3009
                        }
3010
                        ff_mpeg4_encode_video_packet_header(s);
3011

    
3012
                        if(s->flags&CODEC_FLAG_PASS1){
3013
                            int bits= get_bit_count(&s->pb);
3014
                            s->misc_bits+= bits - s->last_bits;
3015
                            s->last_bits= bits;
3016
                        }
3017
                        ff_mpeg4_clean_buffers(s);
3018
                        is_gob_start=1;
3019
                    }
3020
                }else{
3021
                    if(current_packet_size + s->mb_line_avgsize*s->gob_index >= s->rtp_payload_size
3022
                       && s->mb_x==0 && s->mb_y>0 && s->mb_y%s->gob_index==0){
3023
                       
3024
                        h263_encode_gob_header(s, mb_y);                       
3025
                        is_gob_start=1;
3026
                    }
3027
                }
3028

    
3029
                if(is_gob_start){
3030
                    s->ptr_lastgob = pbBufPtr(&s->pb);
3031
                    s->first_slice_line=1;
3032
                    s->resync_mb_x=mb_x;
3033
                    s->resync_mb_y=mb_y;
3034
                }
3035
            }
3036

    
3037
            if(  (s->resync_mb_x   == s->mb_x)
3038
               && s->resync_mb_y+1 == s->mb_y){
3039
                s->first_slice_line=0; 
3040
            }
3041

    
3042
            if(mb_type & (mb_type-1)){ // more than 1 MB type possible
3043
                int next_block=0;
3044
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3045

    
3046
                copy_context_before_encode(&backup_s, s, -1);
3047
                backup_s.pb= s->pb;
3048
                best_s.data_partitioning= s->data_partitioning;
3049
                best_s.partitioned_frame= s->partitioned_frame;
3050
                if(s->data_partitioning){
3051
                    backup_s.pb2= s->pb2;
3052
                    backup_s.tex_pb= s->tex_pb;
3053
                }
3054

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

    
3214
            MPV_decode_mb(s, s->block);
3215
            
3216
            if(s->flags&CODEC_FLAG_PSNR){
3217
                int w= 16;
3218
                int h= 16;
3219

    
3220
                if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3221
                if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3222

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

    
3242

    
3243
        /* Obtain average mb_row size for RTP */
3244
        if (s->rtp_mode) {
3245
            if (mb_y==0)
3246
                s->mb_line_avgsize = pbBufPtr(&s->pb) - s->ptr_last_mb_line;
3247
            else {    
3248
                s->mb_line_avgsize = (s->mb_line_avgsize + pbBufPtr(&s->pb) - s->ptr_last_mb_line) >> 1;
3249
            }
3250
            s->ptr_last_mb_line = pbBufPtr(&s->pb);
3251
        }
3252
    }
3253
    emms_c();
3254

    
3255
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3256
        ff_mpeg4_merge_partitions(s);
3257

    
3258
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
3259
        msmpeg4_encode_ext_header(s);
3260

    
3261
    if(s->codec_id==CODEC_ID_MPEG4) 
3262
        ff_mpeg4_stuffing(&s->pb);
3263

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

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

    
3305
    qmul= qscale*16;
3306
    qadd= ((qscale-1)|1)*8;
3307

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

    
3339
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
3340
    threshold2= (threshold1<<1);
3341

    
3342
    for(i=start_i; i<64; i++) {
3343
        const int j = scantable[i];
3344
        const int k= i-start_i;
3345
        int level = block[j];
3346
        level = level * qmat[j];
3347

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

    
3378
    lambda= (qscale*qscale*64*82 + 50)/100; //FIXME finetune
3379
        
3380
    score_tab[0]= 0;
3381
    for(i=0; i<=last_non_zero - start_i; i++){
3382
        int level_index, run, j;
3383
        const int dct_coeff= block[ scantable[i + start_i] ];
3384
        const int zero_distoration= dct_coeff*dct_coeff;
3385
        int best_score=256*256*256*120;
3386

    
3387
        last_score += zero_distoration;
3388
        for(level_index=0; level_index < coeff_count[i]; level_index++){
3389
            int distoration;
3390
            int level= coeff[level_index][i];
3391
            int unquant_coeff;
3392
            
3393
            assert(level);
3394

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

    
3423
            distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff);
3424
            level+=64;
3425
            if((level&(~127)) == 0){
3426
                for(run=0; run<=i - left_limit; run++){
3427
                    int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3428
                    score += score_tab[i-run];
3429
                    
3430
                    if(score < best_score){
3431
                        best_score= 
3432
                        score_tab[i+1]= score;
3433
                        run_tab[i+1]= run;
3434
                        level_tab[i+1]= level-64;
3435
                    }
3436
                }
3437

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

    
3463
                if(s->out_format == FMT_H263){
3464
                    for(run=0; run<=i - left_limit; run++){
3465
                        int score= distoration + score_tab[i-run];
3466
                        if(score < last_score){
3467
                            last_score= score;
3468
                            last_run= run;
3469
                            last_level= level-64;
3470
                            last_i= i+1;
3471
                        }
3472
                    }
3473
                }
3474
            }
3475
        }
3476

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

    
3488
        //FIXME add some cbp penalty
3489

    
3490
    if(s->out_format != FMT_H263){
3491
        last_score= 256*256*256*120;
3492
        for(i= left_limit; i<=last_non_zero - start_i + 1; i++){
3493
            int score= score_tab[i];
3494
            if(i) score += lambda*2; //FIXME exacter?
3495

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

    
3524
    return last_non_zero;
3525
}
3526

    
3527
static int dct_quantize_c(MpegEncContext *s, 
3528
                        DCTELEM *block, int n,
3529
                        int qscale, int *overflow)
3530
{
3531
    int i, j, level, last_non_zero, q;
3532
    const int *qmat;
3533
    const UINT8 *scantable= s->intra_scantable.scantable;
3534
    int bias;
3535
    int max=0;
3536
    unsigned int threshold1, threshold2;
3537

    
3538
    s->fdct (block);
3539

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

    
3566
    for(;i<64;i++) {
3567
        j = scantable[i];
3568
        level = block[j];
3569
        level = level * qmat[j];
3570

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

    
3593
    return last_non_zero;
3594
}
3595

    
3596
static void dct_unquantize_mpeg1_c(MpegEncContext *s, 
3597
                                   DCTELEM *block, int n, int qscale)
3598
{
3599
    int i, level, nCoeffs;
3600
    const UINT16 *quant_matrix;
3601

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

    
3659
static void dct_unquantize_mpeg2_c(MpegEncContext *s, 
3660
                                   DCTELEM *block, int n, int qscale)
3661
{
3662
    int i, level, nCoeffs;
3663
    const UINT16 *quant_matrix;
3664

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

    
3721

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

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

    
3765
char ff_get_pict_type_char(int pict_type){
3766
    switch(pict_type){
3767
    case I_TYPE: return 'I'; 
3768
    case P_TYPE: return 'P'; 
3769
    case B_TYPE: return 'B'; 
3770
    case S_TYPE: return 'S'; 
3771
    default:     return '?';
3772
    }
3773
}
3774

    
3775
AVCodec mpeg1video_encoder = {
3776
    "mpeg1video",
3777
    CODEC_TYPE_VIDEO,
3778
    CODEC_ID_MPEG1VIDEO,
3779
    sizeof(MpegEncContext),
3780
    MPV_encode_init,
3781
    MPV_encode_picture,
3782
    MPV_encode_end,
3783
};
3784

    
3785
AVCodec h263_encoder = {
3786
    "h263",
3787
    CODEC_TYPE_VIDEO,
3788
    CODEC_ID_H263,
3789
    sizeof(MpegEncContext),
3790
    MPV_encode_init,
3791
    MPV_encode_picture,
3792
    MPV_encode_end,
3793
};
3794

    
3795
AVCodec h263p_encoder = {
3796
    "h263p",
3797
    CODEC_TYPE_VIDEO,
3798
    CODEC_ID_H263P,
3799
    sizeof(MpegEncContext),
3800
    MPV_encode_init,
3801
    MPV_encode_picture,
3802
    MPV_encode_end,
3803
};
3804

    
3805
AVCodec rv10_encoder = {
3806
    "rv10",
3807
    CODEC_TYPE_VIDEO,
3808
    CODEC_ID_RV10,
3809
    sizeof(MpegEncContext),
3810
    MPV_encode_init,
3811
    MPV_encode_picture,
3812
    MPV_encode_end,
3813
};
3814

    
3815
AVCodec mjpeg_encoder = {
3816
    "mjpeg",
3817
    CODEC_TYPE_VIDEO,
3818
    CODEC_ID_MJPEG,
3819
    sizeof(MpegEncContext),
3820
    MPV_encode_init,
3821
    MPV_encode_picture,
3822
    MPV_encode_end,
3823
};
3824

    
3825
AVCodec mpeg4_encoder = {
3826
    "mpeg4",
3827
    CODEC_TYPE_VIDEO,
3828
    CODEC_ID_MPEG4,
3829
    sizeof(MpegEncContext),
3830
    MPV_encode_init,
3831
    MPV_encode_picture,
3832
    MPV_encode_end,
3833
};
3834

    
3835
AVCodec msmpeg4v1_encoder = {
3836
    "msmpeg4v1",
3837
    CODEC_TYPE_VIDEO,
3838
    CODEC_ID_MSMPEG4V1,
3839
    sizeof(MpegEncContext),
3840
    MPV_encode_init,
3841
    MPV_encode_picture,
3842
    MPV_encode_end,
3843
};
3844

    
3845
AVCodec msmpeg4v2_encoder = {
3846
    "msmpeg4v2",
3847
    CODEC_TYPE_VIDEO,
3848
    CODEC_ID_MSMPEG4V2,
3849
    sizeof(MpegEncContext),
3850
    MPV_encode_init,
3851
    MPV_encode_picture,
3852
    MPV_encode_end,
3853
};
3854

    
3855
AVCodec msmpeg4v3_encoder = {
3856
    "msmpeg4",
3857
    CODEC_TYPE_VIDEO,
3858
    CODEC_ID_MSMPEG4V3,
3859
    sizeof(MpegEncContext),
3860
    MPV_encode_init,
3861
    MPV_encode_picture,
3862
    MPV_encode_end,
3863
};
3864

    
3865
AVCodec wmv1_encoder = {
3866
    "wmv1",
3867
    CODEC_TYPE_VIDEO,
3868
    CODEC_ID_WMV1,
3869
    sizeof(MpegEncContext),
3870
    MPV_encode_init,
3871
    MPV_encode_picture,
3872
    MPV_encode_end,
3873
};
3874