Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ af27aea9

History | View | Annotate | Download (114 KB)

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

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

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

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

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

    
49
#define EDGE_WIDTH 16
50

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

    
54
//#define DEBUG
55

    
56

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

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

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

    
84
static UINT8 h263_chroma_roundtab[16] = {
85
    0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
86
};
87

    
88
static UINT16 default_mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
89
static UINT8 default_fcode_tab[MAX_MV*2+1];
90

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

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

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

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

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

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

    
171
/* XXX: those functions should be suppressed ASAP when all IDCTs are
172
   converted */
173
static void ff_jref_idct_put(UINT8 *dest, int line_size, DCTELEM *block)
174
{
175
    j_rev_dct (block);
176
    put_pixels_clamped(block, dest, line_size);
177
}
178
static void ff_jref_idct_add(UINT8 *dest, int line_size, DCTELEM *block)
179
{
180
    j_rev_dct (block);
181
    add_pixels_clamped(block, dest, line_size);
182
}
183

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

    
189
    s->dct_unquantize_h263 = dct_unquantize_h263_c;
190
    s->dct_unquantize_mpeg1 = dct_unquantize_mpeg1_c;
191
    s->dct_unquantize_mpeg2 = dct_unquantize_mpeg2_c;
192
    s->dct_quantize= dct_quantize_c;
193

    
194
    if(s->avctx->dct_algo==FF_DCT_FASTINT)
195
        s->fdct = fdct_ifast;
196
    else
197
        s->fdct = ff_jpeg_fdct_islow; //slow/accurate/default
198

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

    
225
    switch(s->idct_permutation_type){
226
    case FF_NO_IDCT_PERM:
227
        for(i=0; i<64; i++)
228
            s->idct_permutation[i]= i;
229
        break;
230
    case FF_LIBMPEG2_IDCT_PERM:
231
        for(i=0; i<64; i++)
232
            s->idct_permutation[i]= (i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2);
233
        break;
234
    case FF_SIMPLE_IDCT_PERM:
235
        for(i=0; i<64; i++)
236
            s->idct_permutation[i]= simple_mmx_permutation[i];
237
        break;
238
    case FF_TRANSPOSE_IDCT_PERM:
239
        for(i=0; i<64; i++)
240
            s->idct_permutation[i]= ((i&7)<<3) | (i>>3);
241
        break;
242
    default:
243
        fprintf(stderr, "Internal error, IDCT permutation not set\n");
244
        return -1;
245
    }
246

    
247

    
248
    /* load & permutate scantables
249
       note: only wmv uses differnt ones 
250
    */
251
    ff_init_scantable(s, &s->inter_scantable  , ff_zigzag_direct);
252
    ff_init_scantable(s, &s->intra_scantable  , ff_zigzag_direct);
253
    ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);
254
    ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
255

    
256
    return 0;
257
}
258

    
259
/* init common structure for both encoder and decoder */
260
int MPV_common_init(MpegEncContext *s)
261
{
262
    UINT8 *pict;
263
    int y_size, c_size, yc_size, i;
264

    
265
    DCT_common_init(s);
266
    
267
    s->flags= s->avctx->flags;
268

    
269
    s->mb_width = (s->width + 15) / 16;
270
    s->mb_height = (s->height + 15) / 16;
271
    
272
    y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
273
    c_size = (s->mb_width + 2) * (s->mb_height + 2);
274
    yc_size = y_size + 2 * c_size;
275
    
276
    /* set default edge pos, will be overriden in decode_header if needed */
277
    s->h_edge_pos= s->mb_width*16;
278
    s->v_edge_pos= s->mb_height*16;
279
    
280
    /* convert fourcc to upper case */
281
    s->avctx->fourcc=   toupper( s->avctx->fourcc     &0xFF)          
282
                     + (toupper((s->avctx->fourcc>>8 )&0xFF)<<8 )
283
                     + (toupper((s->avctx->fourcc>>16)&0xFF)<<16) 
284
                     + (toupper((s->avctx->fourcc>>24)&0xFF)<<24);
285

    
286
    s->mb_num = s->mb_width * s->mb_height;
287
    
288
    if(!(s->flags&CODEC_FLAG_DR1)){
289
      s->linesize   = s->mb_width * 16 + 2 * EDGE_WIDTH;
290
      s->uvlinesize = s->mb_width * 8  +     EDGE_WIDTH;
291

    
292
      for(i=0;i<3;i++) {
293
        int w, h, shift, pict_start, size;
294

    
295
        w = s->linesize;
296
        h = s->mb_height * 16 + 2 * EDGE_WIDTH;
297
        shift = (i == 0) ? 0 : 1;
298
        size = (s->linesize>>shift) * (h >> shift);
299
        pict_start = (s->linesize>>shift) * (EDGE_WIDTH >> shift) + (EDGE_WIDTH >> shift);
300

    
301
        CHECKED_ALLOCZ(pict, size)
302
        s->last_picture_base[i] = pict;
303
        s->last_picture[i] = pict + pict_start;
304
        if(i>0) memset(s->last_picture_base[i], 128, size);
305
    
306
        CHECKED_ALLOCZ(pict, size)
307
        s->next_picture_base[i] = pict;
308
        s->next_picture[i] = pict + pict_start;
309
        if(i>0) memset(s->next_picture_base[i], 128, size);
310
        
311
        if (s->has_b_frames || s->codec_id==CODEC_ID_MPEG4) {
312
        /* Note the MPEG4 stuff is here cuz of buggy encoders which dont set the low_delay flag but 
313
           do low-delay encoding, so we cant allways distinguish b-frame containing streams from low_delay streams */
314
            CHECKED_ALLOCZ(pict, size)
315
            s->aux_picture_base[i] = pict;
316
            s->aux_picture[i] = pict + pict_start;
317
            if(i>0) memset(s->aux_picture_base[i], 128, size);
318
        }
319
      }
320
      s->ip_buffer_count= 2;
321
    }
322
    
323
    CHECKED_ALLOCZ(s->edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
324
    
325
    if (s->encoding) {
326
        int j;
327
        int mv_table_size= (s->mb_width+2)*(s->mb_height+2);
328
        
329
        CHECKED_ALLOCZ(s->mb_var   , s->mb_num * sizeof(INT16))
330
        CHECKED_ALLOCZ(s->mc_mb_var, s->mb_num * sizeof(INT16))
331
        CHECKED_ALLOCZ(s->mb_mean  , s->mb_num * sizeof(INT8))
332

    
333
        /* Allocate MV tables */
334
        CHECKED_ALLOCZ(s->p_mv_table            , mv_table_size * 2 * sizeof(INT16))
335
        CHECKED_ALLOCZ(s->b_forw_mv_table       , mv_table_size * 2 * sizeof(INT16))
336
        CHECKED_ALLOCZ(s->b_back_mv_table       , mv_table_size * 2 * sizeof(INT16))
337
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table , mv_table_size * 2 * sizeof(INT16))
338
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table , mv_table_size * 2 * sizeof(INT16))
339
        CHECKED_ALLOCZ(s->b_direct_forw_mv_table, mv_table_size * 2 * sizeof(INT16))
340
        CHECKED_ALLOCZ(s->b_direct_back_mv_table, mv_table_size * 2 * sizeof(INT16))
341
        CHECKED_ALLOCZ(s->b_direct_mv_table     , mv_table_size * 2 * sizeof(INT16))
342

    
343
        CHECKED_ALLOCZ(s->me_scratchpad,  s->linesize*16*3*sizeof(uint8_t))
344
        
345
        CHECKED_ALLOCZ(s->me_map      , ME_MAP_SIZE*sizeof(uint32_t))
346
        CHECKED_ALLOCZ(s->me_score_map, ME_MAP_SIZE*sizeof(uint16_t))
347

    
348
        if(s->max_b_frames){
349
            for(j=0; j<REORDER_BUFFER_SIZE; j++){
350
                int i;
351
                for(i=0;i<3;i++) {
352
                    int w, h, shift, size;
353

    
354
                    w = s->linesize;
355
                    h = s->mb_height * 16;
356
                    shift = (i == 0) ? 0 : 1;
357
                    size = (w >> shift) * (h >> shift);
358

    
359
                    CHECKED_ALLOCZ(pict, size);
360
                    s->picture_buffer[j][i] = pict;
361
                }
362
            }
363
        }
364

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

    
383
        /* MV prediction */
384
        size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
385
        CHECKED_ALLOCZ(s->motion_val, size * 2 * sizeof(INT16));
386
    }
387

    
388
    if(s->codec_id==CODEC_ID_MPEG4){
389
        /* interlaced direct mode decoding tables */
390
        CHECKED_ALLOCZ(s->field_mv_table, s->mb_num*2*2 * sizeof(INT16))
391
        CHECKED_ALLOCZ(s->field_select_table, s->mb_num*2* sizeof(INT8))
392
    }
393
    /* 4mv b frame decoding table */
394
    //note this is needed for h263 without b frames too (segfault on damaged streams otherwise)
395
    CHECKED_ALLOCZ(s->co_located_type_table, s->mb_num * sizeof(UINT8))
396
    if (s->out_format == FMT_H263) {
397
        /* ac values */
398
        CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(INT16) * 16);
399
        s->ac_val[1] = s->ac_val[0] + y_size;
400
        s->ac_val[2] = s->ac_val[1] + c_size;
401
        
402
        /* cbp values */
403
        CHECKED_ALLOCZ(s->coded_block, y_size);
404
        
405
        /* divx501 bitstream reorder buffer */
406
        CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
407
        
408
        /* cbp, ac_pred, pred_dir */
409
        CHECKED_ALLOCZ(s->cbp_table  , s->mb_num * sizeof(UINT8))
410
        CHECKED_ALLOCZ(s->pred_dir_table, s->mb_num * sizeof(UINT8))
411
    }
412
    
413
    if (s->h263_pred || s->h263_plus || !s->encoding) {
414
        /* dc values */
415
        //MN: we need these for error resilience of intra-frames
416
        CHECKED_ALLOCZ(s->dc_val[0], yc_size * sizeof(INT16));
417
        s->dc_val[1] = s->dc_val[0] + y_size;
418
        s->dc_val[2] = s->dc_val[1] + c_size;
419
        for(i=0;i<yc_size;i++)
420
            s->dc_val[0][i] = 1024;
421
    }
422

    
423
    CHECKED_ALLOCZ(s->next_qscale_table  , s->mb_num * sizeof(UINT8))
424
    CHECKED_ALLOCZ(s->last_qscale_table  , s->mb_num * sizeof(UINT8))
425
    CHECKED_ALLOCZ(s->aux_qscale_table   , s->mb_num * sizeof(UINT8))
426
    s->qscale_table= s->next_qscale_table;
427
    s->avctx->qstride= s->mb_width;
428
    
429
    /* which mb is a intra block */
430
    CHECKED_ALLOCZ(s->mbintra_table, s->mb_num);
431
    memset(s->mbintra_table, 1, s->mb_num);
432
    
433
    /* default structure is frame */
434
    s->picture_structure = PICT_FRAME;
435
    
436
    /* init macroblock skip table */
437
    CHECKED_ALLOCZ(s->mbskip_table, s->mb_num+1);
438
    //Note the +1 is for a quicker mpeg4 slice_end detection
439
    
440
    s->block= s->blocks[0];
441

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

    
449

    
450
//extern int sads;
451

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

    
457
    av_freep(&s->mb_type);
458
    av_freep(&s->mb_var);
459
    av_freep(&s->mc_mb_var);
460
    av_freep(&s->mb_mean);
461
    av_freep(&s->p_mv_table);
462
    av_freep(&s->b_forw_mv_table);
463
    av_freep(&s->b_back_mv_table);
464
    av_freep(&s->b_bidir_forw_mv_table);
465
    av_freep(&s->b_bidir_back_mv_table);
466
    av_freep(&s->b_direct_forw_mv_table);
467
    av_freep(&s->b_direct_back_mv_table);
468
    av_freep(&s->b_direct_mv_table);
469
    av_freep(&s->motion_val);
470
    av_freep(&s->dc_val[0]);
471
    av_freep(&s->ac_val[0]);
472
    av_freep(&s->coded_block);
473
    av_freep(&s->mbintra_table);
474
    av_freep(&s->cbp_table);
475
    av_freep(&s->pred_dir_table);
476
    av_freep(&s->next_qscale_table);
477
    av_freep(&s->last_qscale_table);
478
    av_freep(&s->aux_qscale_table);
479
    av_freep(&s->me_scratchpad);
480
    av_freep(&s->me_map);
481
    av_freep(&s->me_score_map);
482
    
483
    av_freep(&s->mbskip_table);
484
    av_freep(&s->bitstream_buffer);
485
    av_freep(&s->tex_pb_buffer);
486
    av_freep(&s->pb2_buffer);
487
    av_freep(&s->edge_emu_buffer);
488
    av_freep(&s->co_located_type_table);
489
    av_freep(&s->field_mv_table);
490
    av_freep(&s->field_select_table);
491
    av_freep(&s->avctx->stats_out);
492
    av_freep(&s->ac_stats);
493
    av_freep(&s->error_status_table);
494
    
495
    for(i=0;i<3;i++) {
496
        int j;
497
        if(!(s->flags&CODEC_FLAG_DR1)){
498
            av_freep(&s->last_picture_base[i]);
499
            av_freep(&s->next_picture_base[i]);
500
            av_freep(&s->aux_picture_base[i]);
501
        }
502
        s->last_picture_base[i]=
503
        s->next_picture_base[i]=
504
        s->aux_picture_base [i] = NULL;
505
        s->last_picture[i]=
506
        s->next_picture[i]=
507
        s->aux_picture [i] = NULL;
508

    
509
        for(j=0; j<REORDER_BUFFER_SIZE; j++){
510
            av_freep(&s->picture_buffer[j][i]);
511
        }
512
    }
513
    s->context_initialized = 0;
514
}
515

    
516
/* init video encoder */
517
int MPV_encode_init(AVCodecContext *avctx)
518
{
519
    MpegEncContext *s = avctx->priv_data;
520
    int i;
521

    
522
    avctx->pix_fmt = PIX_FMT_YUV420P;
523

    
524
    s->bit_rate = avctx->bit_rate;
525
    s->bit_rate_tolerance = avctx->bit_rate_tolerance;
526
    s->frame_rate = avctx->frame_rate;
527
    s->width = avctx->width;
528
    s->height = avctx->height;
529
    if(avctx->gop_size > 600){
530
        fprintf(stderr, "Warning keyframe interval too large! reducing it ...\n");
531
        avctx->gop_size=600;
532
    }
533
    s->gop_size = avctx->gop_size;
534
    s->rtp_mode = avctx->rtp_mode;
535
    s->rtp_payload_size = avctx->rtp_payload_size;
536
    if (avctx->rtp_callback)
537
        s->rtp_callback = avctx->rtp_callback;
538
    s->qmin= avctx->qmin;
539
    s->qmax= avctx->qmax;
540
    s->max_qdiff= avctx->max_qdiff;
541
    s->qcompress= avctx->qcompress;
542
    s->qblur= avctx->qblur;
543
    s->avctx = avctx;
544
    s->aspect_ratio_info= avctx->aspect_ratio_info;
545
    if (avctx->aspect_ratio_info == FF_ASPECT_EXTENDED)
546
    {
547
        s->aspected_width = avctx->aspected_width;
548
        s->aspected_height = avctx->aspected_height;
549
    }
550
    s->flags= avctx->flags;
551
    s->max_b_frames= avctx->max_b_frames;
552
    s->b_frame_strategy= avctx->b_frame_strategy;
553
    s->codec_id= avctx->codec->id;
554
    s->luma_elim_threshold  = avctx->luma_elim_threshold;
555
    s->chroma_elim_threshold= avctx->chroma_elim_threshold;
556
    s->strict_std_compliance= avctx->strict_std_compliance;
557
    s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
558
    s->mpeg_quant= avctx->mpeg_quant;
559

    
560
    if (s->gop_size <= 1) {
561
        s->intra_only = 1;
562
        s->gop_size = 12;
563
    } else {
564
        s->intra_only = 0;
565
    }
566

    
567
    /* ME algorithm */
568
    if (avctx->me_method == 0)
569
        /* For compatibility */
570
        s->me_method = motion_estimation_method;
571
    else
572
        s->me_method = avctx->me_method;
573

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

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

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

    
703
    s->encoding = 1;
704

    
705
    /* init */
706
    if (MPV_common_init(s) < 0)
707
        return -1;
708
    
709
    if (s->out_format == FMT_H263)
710
        h263_encode_init(s);
711
    else if (s->out_format == FMT_MPEG1)
712
        ff_mpeg1_encode_init(s);
713
    if(s->msmpeg4_version)
714
        ff_msmpeg4_encode_init(s);
715

    
716
    /* init default q matrix */
717
    for(i=0;i<64;i++) {
718
        int j= s->idct_permutation[i];
719
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
720
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
721
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
722
        }else if(s->out_format == FMT_H263){
723
            s->intra_matrix[j] =
724
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
725
        }else{ /* mpeg1 */
726
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
727
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
728
        }
729
    }
730

    
731
    /* precompute matrix */
732
    /* for mjpeg, we do include qscale in the matrix */
733
    if (s->out_format != FMT_MJPEG) {
734
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, s->q_intra_matrix16_bias, 
735
                       s->intra_matrix, s->intra_quant_bias, 1, 31);
736
        convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16, s->q_inter_matrix16_bias, 
737
                       s->inter_matrix, s->inter_quant_bias, 1, 31);
738
    }
739

    
740
    if(ff_rate_control_init(s) < 0)
741
        return -1;
742

    
743
    s->picture_number = 0;
744
    s->picture_in_gop_number = 0;
745
    s->fake_picture_number = 0;
746
    /* motion detector init */
747
    s->f_code = 1;
748
    s->b_code = 1;
749

    
750
    return 0;
751
}
752

    
753
int MPV_encode_end(AVCodecContext *avctx)
754
{
755
    MpegEncContext *s = avctx->priv_data;
756

    
757
#ifdef STATS
758
    print_stats();
759
#endif
760

    
761
    ff_rate_control_uninit(s);
762

    
763
    MPV_common_end(s);
764
    if (s->out_format == FMT_MJPEG)
765
        mjpeg_close(s);
766
      
767
    return 0;
768
}
769

    
770
/* draw the edges of width 'w' of an image of size width, height */
771
//FIXME check that this is ok for mpeg4 interlaced
772
static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w)
773
{
774
    UINT8 *ptr, *last_line;
775
    int i;
776

    
777
    last_line = buf + (height - 1) * wrap;
778
    for(i=0;i<w;i++) {
779
        /* top and bottom */
780
        memcpy(buf - (i + 1) * wrap, buf, width);
781
        memcpy(last_line + (i + 1) * wrap, last_line, width);
782
    }
783
    /* left and right */
784
    ptr = buf;
785
    for(i=0;i<height;i++) {
786
        memset(ptr - w, ptr[0], w);
787
        memset(ptr + width, ptr[width-1], w);
788
        ptr += wrap;
789
    }
790
    /* corners */
791
    for(i=0;i<w;i++) {
792
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
793
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
794
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
795
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
796
    }
797
}
798

    
799
/* generic function for encode/decode called before a frame is coded/decoded */
800
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
801
{
802
    int i;
803
    UINT8 *tmp;
804

    
805
    s->mb_skiped = 0;
806
    avctx->mbskip_table= s->mbskip_table;
807

    
808
    if(avctx->flags&CODEC_FLAG_DR1){
809
        if(avctx->get_buffer_callback(avctx, s->width, s->height, s->pict_type) < 0){
810
            fprintf(stderr, "get_buffer() failed\n");
811
            return -1;
812
        }
813

    
814
        s->linesize  = avctx->dr_stride;
815
        s->uvlinesize= avctx->dr_uvstride;
816
        s->ip_buffer_count= avctx->dr_ip_buffer_count;
817
    }
818
    avctx->dr_ip_buffer_count= s->ip_buffer_count;
819
    
820
    if (s->pict_type == B_TYPE) {
821
        for(i=0;i<3;i++) {
822
            if(avctx->flags&CODEC_FLAG_DR1)
823
                s->aux_picture[i]= avctx->dr_buffer[i];
824
            
825
            //FIXME the following should never be needed, the decoder should drop b frames if no reference is available
826
            if(s->next_picture[i]==NULL)
827
                s->next_picture[i]= s->aux_picture[i];
828
            if(s->last_picture[i]==NULL)
829
                s->last_picture[i]= s->next_picture[i];
830

    
831
            s->current_picture[i] = s->aux_picture[i];
832
        }
833
        s->avctx->display_qscale_table=
834
        s->avctx->current_qscale_table= 
835
        s->qscale_table= s->aux_qscale_table;
836
    } else {
837
        for(i=0;i<3;i++) {
838
            /* swap next and last */
839
            if(avctx->flags&CODEC_FLAG_DR1)
840
                tmp= avctx->dr_buffer[i];
841
            else
842
                tmp = s->last_picture[i];
843

    
844
            s->last_picture[i] = s->next_picture[i];
845
            s->next_picture[i] = tmp;
846
            s->current_picture[i] = tmp;
847

    
848
            if(s->last_picture[i]==NULL)
849
                s->last_picture[i]= s->next_picture[i];
850

    
851
            s->last_dr_opaque= s->next_dr_opaque;
852
            s->next_dr_opaque= avctx->dr_opaque_frame;
853

    
854
            if(s->has_b_frames && s->last_dr_opaque && s->codec_id!=CODEC_ID_SVQ1)
855
                avctx->dr_opaque_frame= s->last_dr_opaque;
856
            else
857
                avctx->dr_opaque_frame= s->next_dr_opaque;
858
        }
859
        s->avctx->current_qscale_table= s->qscale_table      = s->last_qscale_table;
860
        s->avctx->display_qscale_table= s->last_qscale_table = s->next_qscale_table;
861
        s->next_qscale_table= s->qscale_table;
862
    }
863
    /* set dequantizer, we cant do it during init as it might change for mpeg4
864
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
865
    if(s->out_format == FMT_H263){
866
        if(s->mpeg_quant)
867
            s->dct_unquantize = s->dct_unquantize_mpeg2;
868
        else
869
            s->dct_unquantize = s->dct_unquantize_h263;
870
    }else 
871
        s->dct_unquantize = s->dct_unquantize_mpeg1;
872

    
873
    return 0;
874
}
875

    
876
/* generic function for encode/decode called after a frame has been coded/decoded */
877
void MPV_frame_end(MpegEncContext *s)
878
{
879
    s->avctx->key_frame   = (s->pict_type == I_TYPE);
880
    s->avctx->pict_type   = s->pict_type;
881

    
882
    /* draw edge for correct motion prediction if outside */
883
    if (s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
884
        draw_edges(s->current_picture[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
885
        draw_edges(s->current_picture[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
886
        draw_edges(s->current_picture[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
887
    }
888
    emms_c();
889
    
890
    s->last_pict_type    = s->pict_type;
891
    if(s->pict_type!=B_TYPE){
892
        s->last_non_b_pict_type= s->pict_type;
893
        s->num_available_buffers++;
894
        if(s->num_available_buffers>2) s->num_available_buffers= 2;
895
    }
896
}
897

    
898
/* reorder input for encoding */
899
void reorder_input(MpegEncContext *s, AVPicture *pict)
900
{
901
    int i, j, index;
902
            
903
    if(s->max_b_frames > FF_MAX_B_FRAMES) s->max_b_frames= FF_MAX_B_FRAMES;
904

    
905
//        delay= s->max_b_frames+1; (or 0 if no b frames cuz decoder diff)
906

    
907
    for(j=0; j<REORDER_BUFFER_SIZE-1; j++){
908
        s->coded_order[j]= s->coded_order[j+1];
909
    }
910
    s->coded_order[j].picture[0]= s->coded_order[j].picture[1]= s->coded_order[j].picture[2]= NULL; //catch uninitalized buffers
911
    s->coded_order[j].pict_type=0;
912

    
913
    switch(s->input_pict_type){
914
    default: 
915
    case I_TYPE:
916
    case S_TYPE:
917
    case P_TYPE:
918
        index= s->max_b_frames - s->b_frames_since_non_b;
919
        s->b_frames_since_non_b=0;
920
        break;            
921
    case B_TYPE:
922
        index= s->max_b_frames + 1;
923
        s->b_frames_since_non_b++;
924
        break;          
925
    }
926
//printf("index:%d type:%d strides: %d %d\n", index, s->input_pict_type, pict->linesize[0], s->linesize);
927
    if(   (index==0 || (s->flags&CODEC_FLAG_INPUT_PRESERVED))
928
       && pict->linesize[0] == s->linesize
929
       && pict->linesize[1] == s->uvlinesize
930
       && pict->linesize[2] == s->uvlinesize){
931
//printf("ptr\n");
932
        for(i=0; i<3; i++){
933
            s->coded_order[index].picture[i]= pict->data[i];
934
        }
935
    }else{
936
//printf("copy\n");
937
        for(i=0; i<3; i++){
938
            uint8_t *src = pict->data[i];
939
            uint8_t *dest;
940
            int src_wrap = pict->linesize[i];
941
            int dest_wrap = s->linesize;
942
            int w = s->width;
943
            int h = s->height;
944

    
945
            if(index==0) dest= s->last_picture[i]+16; //is current_picture indeed but the switch hapens after reordering
946
            else         dest= s->picture_buffer[s->picture_buffer_index][i];
947

    
948
            if (i >= 1) {
949
                dest_wrap >>= 1;
950
                w >>= 1;
951
                h >>= 1;
952
            }
953

    
954
            s->coded_order[index].picture[i]= dest;
955
            for(j=0;j<h;j++) {
956
                memcpy(dest, src, w);
957
                dest += dest_wrap;
958
                src += src_wrap;
959
            }
960
        }
961
        if(index!=0){
962
            s->picture_buffer_index++;
963
            if(s->picture_buffer_index >= REORDER_BUFFER_SIZE) s->picture_buffer_index=0;
964
        }
965
    }
966
    s->coded_order[index].pict_type = s->input_pict_type;
967
    s->coded_order[index].qscale    = s->input_qscale;
968
    s->coded_order[index].force_type= s->force_input_type;
969
    s->coded_order[index].picture_in_gop_number= s->input_picture_in_gop_number;
970
    s->coded_order[index].picture_number= s->input_picture_number;
971

    
972
    for(i=0; i<3; i++){
973
        s->new_picture[i]= s->coded_order[0].picture[i];
974
    }
975
}
976

    
977
int MPV_encode_picture(AVCodecContext *avctx,
978
                       unsigned char *buf, int buf_size, void *data)
979
{
980
    MpegEncContext *s = avctx->priv_data;
981
    AVPicture *pict = data;
982

    
983
    s->input_qscale = avctx->quality;
984

    
985
    init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
986

    
987
    if(avctx->flags&CODEC_FLAG_TYPE){
988
        s->input_pict_type=
989
        s->force_input_type= avctx->key_frame ? I_TYPE : P_TYPE;
990
    }else if(s->flags&CODEC_FLAG_PASS2){
991
        s->input_pict_type=
992
        s->force_input_type= s->rc_context.entry[s->input_picture_number].new_pict_type;
993
    }else{
994
        s->force_input_type=0;
995
        if (!s->intra_only) {
996
            /* first picture of GOP is intra */
997
            if (s->input_picture_in_gop_number % s->gop_size==0){
998
                s->input_pict_type = I_TYPE;
999
            }else if(s->max_b_frames==0){
1000
                s->input_pict_type = P_TYPE;
1001
            }else{
1002
                if(s->b_frames_since_non_b < s->max_b_frames) //FIXME more IQ
1003
                    s->input_pict_type = B_TYPE;
1004
                else
1005
                    s->input_pict_type = P_TYPE;
1006
            }
1007
        } else {
1008
            s->input_pict_type = I_TYPE;
1009
        }
1010
    }
1011

    
1012
    if(s->input_pict_type==I_TYPE)
1013
        s->input_picture_in_gop_number=0;
1014
    
1015
    reorder_input(s, pict);
1016
    
1017
    /* output? */
1018
    if(s->coded_order[0].picture[0]){
1019

    
1020
        s->pict_type= s->coded_order[0].pict_type;
1021
        if (s->fixed_qscale) /* the ratecontrol needs the last qscale so we dont touch it for CBR */
1022
            s->qscale= s->coded_order[0].qscale;
1023
        s->force_type= s->coded_order[0].force_type;
1024
        s->picture_in_gop_number= s->coded_order[0].picture_in_gop_number;
1025
        s->picture_number= s->coded_order[0].picture_number;
1026

    
1027
        MPV_frame_start(s, avctx);
1028

    
1029
        encode_picture(s, s->picture_number);
1030
        
1031
        avctx->real_pict_num  = s->picture_number;
1032
        avctx->header_bits = s->header_bits;
1033
        avctx->mv_bits     = s->mv_bits;
1034
        avctx->misc_bits   = s->misc_bits;
1035
        avctx->i_tex_bits  = s->i_tex_bits;
1036
        avctx->p_tex_bits  = s->p_tex_bits;
1037
        avctx->i_count     = s->i_count;
1038
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
1039
        avctx->skip_count  = s->skip_count;
1040

    
1041
        MPV_frame_end(s);
1042

    
1043
        if (s->out_format == FMT_MJPEG)
1044
            mjpeg_picture_trailer(s);
1045

    
1046
        if(!s->fixed_qscale)
1047
            avctx->quality = s->qscale;
1048
        
1049
        if(s->flags&CODEC_FLAG_PASS1)
1050
            ff_write_pass1_stats(s);
1051
    
1052
    }
1053

    
1054
    s->input_picture_number++;
1055
    s->input_picture_in_gop_number++;
1056

    
1057
    flush_put_bits(&s->pb);
1058
    s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1059
    
1060
    s->total_bits += s->frame_bits;
1061
    avctx->frame_bits  = s->frame_bits;
1062
//printf("fcode: %d, type: %d, head: %d, mv: %d, misc: %d, frame: %d, itex: %d, ptex: %d\n", 
1063
//s->f_code, avctx->key_frame, s->header_bits, s->mv_bits, s->misc_bits, s->frame_bits, s->i_tex_bits, s->p_tex_bits);
1064
#if 0 //dump some stats to stats.txt for testing/debuging
1065
if(s->max_b_frames==0)
1066
{
1067
    static FILE *f=NULL;
1068
    if(!f) f= fopen("stats.txt", "wb");
1069
    get_psnr(pict->data, s->current_picture,
1070
             pict->linesize, s->linesize, avctx);
1071
    fprintf(f, "%7d, %7d, %2.4f\n", pbBufPtr(&s->pb) - s->pb.buf, s->qscale, avctx->psnr_y);
1072
}
1073
#endif
1074

    
1075
    if (avctx->get_psnr) {
1076
        /* At this point pict->data should have the original frame   */
1077
        /* an s->current_picture should have the coded/decoded frame */
1078
        get_psnr(pict->data, s->current_picture,
1079
                 pict->linesize, s->linesize, avctx);
1080
//        printf("%f\n", avctx->psnr_y);
1081
    }
1082
    return pbBufPtr(&s->pb) - s->pb.buf;
1083
}
1084

    
1085
static inline void gmc1_motion(MpegEncContext *s,
1086
                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1087
                               int dest_offset,
1088
                               UINT8 **ref_picture, int src_offset)
1089
{
1090
    UINT8 *ptr;
1091
    int offset, src_x, src_y, linesize, uvlinesize;
1092
    int motion_x, motion_y;
1093
    int emu=0;
1094

    
1095
    motion_x= s->sprite_offset[0][0];
1096
    motion_y= s->sprite_offset[0][1];
1097
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1098
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1099
    motion_x<<=(3-s->sprite_warping_accuracy);
1100
    motion_y<<=(3-s->sprite_warping_accuracy);
1101
    src_x = clip(src_x, -16, s->width);
1102
    if (src_x == s->width)
1103
        motion_x =0;
1104
    src_y = clip(src_y, -16, s->height);
1105
    if (src_y == s->height)
1106
        motion_y =0;
1107

    
1108
    linesize = s->linesize;
1109
    uvlinesize = s->uvlinesize;
1110
    
1111
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1112

    
1113
    dest_y+=dest_offset;
1114
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1115
        if(src_x<0 || src_y<0 || src_x + (motion_x&15) + 16 > s->h_edge_pos
1116
                              || src_y + (motion_y&15) + 16 > s->v_edge_pos){
1117
            emulated_edge_mc(s, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1118
            ptr= s->edge_emu_buffer;
1119
            emu=1;
1120
        }
1121
    }
1122
    
1123
    if((motion_x|motion_y)&7){
1124
        ff_gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1125
        ff_gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1126
    }else{
1127
        int dxy;
1128
        
1129
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
1130
        if (s->no_rounding){
1131
            put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
1132
        }else{
1133
            put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
1134
        }        
1135
    }
1136
    
1137
    if(s->flags&CODEC_FLAG_GRAY) return;
1138

    
1139
    motion_x= s->sprite_offset[1][0];
1140
    motion_y= s->sprite_offset[1][1];
1141
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
1142
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
1143
    motion_x<<=(3-s->sprite_warping_accuracy);
1144
    motion_y<<=(3-s->sprite_warping_accuracy);
1145
    src_x = clip(src_x, -8, s->width>>1);
1146
    if (src_x == s->width>>1)
1147
        motion_x =0;
1148
    src_y = clip(src_y, -8, s->height>>1);
1149
    if (src_y == s->height>>1)
1150
        motion_y =0;
1151

    
1152
    offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
1153
    ptr = ref_picture[1] + offset;
1154
    if(emu){
1155
        emulated_edge_mc(s, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1156
        ptr= s->edge_emu_buffer;
1157
    }
1158
    ff_gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1159
    
1160
    ptr = ref_picture[2] + offset;
1161
    if(emu){
1162
        emulated_edge_mc(s, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1163
        ptr= s->edge_emu_buffer;
1164
    }
1165
    ff_gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1166
    
1167
    return;
1168
}
1169

    
1170
static inline void gmc_motion(MpegEncContext *s,
1171
                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1172
                               int dest_offset,
1173
                               UINT8 **ref_picture, int src_offset)
1174
{
1175
    UINT8 *ptr;
1176
    int linesize, uvlinesize;
1177
    const int a= s->sprite_warping_accuracy;
1178
    int ox, oy;
1179

    
1180
    linesize = s->linesize;
1181
    uvlinesize = s->uvlinesize;
1182

    
1183
    ptr = ref_picture[0] + src_offset;
1184

    
1185
    dest_y+=dest_offset;
1186
    
1187
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
1188
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
1189

    
1190
    ff_gmc(dest_y, ptr, linesize, 16, 
1191
           ox, 
1192
           oy, 
1193
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1194
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1195
           a+1, (1<<(2*a+1)) - s->no_rounding,
1196
           s->h_edge_pos, s->v_edge_pos);
1197
    ff_gmc(dest_y+8, ptr, linesize, 16, 
1198
           ox + s->sprite_delta[0][0]*8, 
1199
           oy + s->sprite_delta[1][0]*8, 
1200
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1201
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1202
           a+1, (1<<(2*a+1)) - s->no_rounding,
1203
           s->h_edge_pos, s->v_edge_pos);
1204

    
1205
    if(s->flags&CODEC_FLAG_GRAY) return;
1206

    
1207

    
1208
    dest_cb+=dest_offset>>1;
1209
    dest_cr+=dest_offset>>1;
1210
    
1211
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
1212
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
1213

    
1214
    ptr = ref_picture[1] + (src_offset>>1);
1215
    ff_gmc(dest_cb, ptr, uvlinesize, 8, 
1216
           ox, 
1217
           oy, 
1218
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1219
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1220
           a+1, (1<<(2*a+1)) - s->no_rounding,
1221
           s->h_edge_pos>>1, s->v_edge_pos>>1);
1222
    
1223
    ptr = ref_picture[2] + (src_offset>>1);
1224
    ff_gmc(dest_cr, ptr, uvlinesize, 8, 
1225
           ox, 
1226
           oy, 
1227
           s->sprite_delta[0][0], s->sprite_delta[0][1],
1228
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
1229
           a+1, (1<<(2*a+1)) - s->no_rounding,
1230
           s->h_edge_pos>>1, s->v_edge_pos>>1);
1231
}
1232

    
1233

    
1234
static void emulated_edge_mc(MpegEncContext *s, UINT8 *src, int linesize, int block_w, int block_h, 
1235
                                    int src_x, int src_y, int w, int h){
1236
    int x, y;
1237
    int start_y, start_x, end_y, end_x;
1238
    UINT8 *buf= s->edge_emu_buffer;
1239
    
1240
    if(src_y>= h){
1241
        src+= (h-1-src_y)*linesize;
1242
        src_y=h-1;
1243
    }else if(src_y<=-block_h){
1244
        src+= (1-block_h-src_y)*linesize;
1245
        src_y=1-block_h;
1246
    }
1247
    if(src_x>= w){
1248
        src+= (w-1-src_x);
1249
        src_x=w-1;
1250
    }else if(src_x<=-block_w){
1251
        src+= (1-block_w-src_x);
1252
        src_x=1-block_w;
1253
    }
1254

    
1255
    start_y= MAX(0, -src_y);
1256
    start_x= MAX(0, -src_x);
1257
    end_y= MIN(block_h, h-src_y);
1258
    end_x= MIN(block_w, w-src_x);
1259

    
1260
    // copy existing part
1261
    for(y=start_y; y<end_y; y++){
1262
        for(x=start_x; x<end_x; x++){
1263
            buf[x + y*linesize]= src[x + y*linesize];
1264
        }
1265
    }
1266

    
1267
    //top
1268
    for(y=0; y<start_y; y++){
1269
        for(x=start_x; x<end_x; x++){
1270
            buf[x + y*linesize]= buf[x + start_y*linesize];
1271
        }
1272
    }
1273

    
1274
    //bottom
1275
    for(y=end_y; y<block_h; y++){
1276
        for(x=start_x; x<end_x; x++){
1277
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1278
        }
1279
    }
1280
                                    
1281
    for(y=0; y<block_h; y++){
1282
       //left
1283
        for(x=0; x<start_x; x++){
1284
            buf[x + y*linesize]= buf[start_x + y*linesize];
1285
        }
1286
       
1287
       //right
1288
        for(x=end_x; x<block_w; x++){
1289
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1290
        }
1291
    }
1292
}
1293

    
1294

    
1295
/* apply one mpeg motion vector to the three components */
1296
static inline void mpeg_motion(MpegEncContext *s,
1297
                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1298
                               int dest_offset,
1299
                               UINT8 **ref_picture, int src_offset,
1300
                               int field_based, op_pixels_func (*pix_op)[4],
1301
                               int motion_x, int motion_y, int h)
1302
{
1303
    UINT8 *ptr;
1304
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1305
    int emu=0;
1306
#if 0    
1307
if(s->quarter_sample)
1308
{
1309
    motion_x>>=1;
1310
    motion_y>>=1;
1311
}
1312
#endif
1313
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1314
    src_x = s->mb_x * 16 + (motion_x >> 1);
1315
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 1);
1316
                
1317
    /* WARNING: do no forget half pels */
1318
    height = s->height >> field_based;
1319
    v_edge_pos = s->v_edge_pos >> field_based;
1320
    src_x = clip(src_x, -16, s->width);
1321
    if (src_x == s->width)
1322
        dxy &= ~1;
1323
    src_y = clip(src_y, -16, height);
1324
    if (src_y == height)
1325
        dxy &= ~2;
1326
    linesize   = s->linesize << field_based;
1327
    uvlinesize = s->uvlinesize << field_based;
1328
    ptr = ref_picture[0] + (src_y * linesize) + (src_x) + src_offset;
1329
    dest_y += dest_offset;
1330

    
1331
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1332
        if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 16 > s->h_edge_pos
1333
                              || src_y + (motion_y&1) + h  > v_edge_pos){
1334
            emulated_edge_mc(s, ptr - src_offset, s->linesize, 17, 17+field_based, 
1335
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1336
            ptr= s->edge_emu_buffer + src_offset;
1337
            emu=1;
1338
        }
1339
    }
1340
    pix_op[0][dxy](dest_y, ptr, linesize, h);
1341

    
1342
    if(s->flags&CODEC_FLAG_GRAY) return;
1343

    
1344
    if (s->out_format == FMT_H263) {
1345
        dxy = 0;
1346
        if ((motion_x & 3) != 0)
1347
            dxy |= 1;
1348
        if ((motion_y & 3) != 0)
1349
            dxy |= 2;
1350
        mx = motion_x >> 2;
1351
        my = motion_y >> 2;
1352
    } else {
1353
        mx = motion_x / 2;
1354
        my = motion_y / 2;
1355
        dxy = ((my & 1) << 1) | (mx & 1);
1356
        mx >>= 1;
1357
        my >>= 1;
1358
    }
1359
    
1360
    src_x = s->mb_x * 8 + mx;
1361
    src_y = s->mb_y * (8 >> field_based) + my;
1362
    src_x = clip(src_x, -8, s->width >> 1);
1363
    if (src_x == (s->width >> 1))
1364
        dxy &= ~1;
1365
    src_y = clip(src_y, -8, height >> 1);
1366
    if (src_y == (height >> 1))
1367
        dxy &= ~2;
1368
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1369
    ptr = ref_picture[1] + offset;
1370
    if(emu){
1371
        emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
1372
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1373
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1374
    }
1375
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1376

    
1377
    ptr = ref_picture[2] + offset;
1378
    if(emu){
1379
        emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
1380
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1381
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1382
    }
1383
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1384
}
1385

    
1386
static inline void qpel_motion(MpegEncContext *s,
1387
                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1388
                               int dest_offset,
1389
                               UINT8 **ref_picture, int src_offset,
1390
                               int field_based, op_pixels_func (*pix_op)[4],
1391
                               qpel_mc_func (*qpix_op)[16],
1392
                               int motion_x, int motion_y, int h)
1393
{
1394
    UINT8 *ptr;
1395
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1396
    int emu=0;
1397

    
1398
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1399
    src_x = s->mb_x * 16 + (motion_x >> 2);
1400
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
1401

    
1402
    height = s->height >> field_based;
1403
    v_edge_pos = s->v_edge_pos >> field_based;
1404
    src_x = clip(src_x, -16, s->width);
1405
    if (src_x == s->width)
1406
        dxy &= ~3;
1407
    src_y = clip(src_y, -16, height);
1408
    if (src_y == height)
1409
        dxy &= ~12;
1410
    linesize = s->linesize << field_based;
1411
    uvlinesize = s->uvlinesize << field_based;
1412
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1413
    dest_y += dest_offset;
1414
//printf("%d %d %d\n", src_x, src_y, dxy);
1415
    
1416
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1417
        if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 16 > s->h_edge_pos
1418
                              || src_y + (motion_y&3) + h  > v_edge_pos){
1419
            emulated_edge_mc(s, ptr - src_offset, s->linesize, 17, 17+field_based, 
1420
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1421
            ptr= s->edge_emu_buffer + src_offset;
1422
            emu=1;
1423
        }
1424
    }
1425
    if(!field_based)
1426
        qpix_op[0][dxy](dest_y, ptr, linesize);
1427
    else{
1428
        //damn interlaced mode
1429
        //FIXME boundary mirroring is not exactly correct here
1430
        qpix_op[1][dxy](dest_y  , ptr  , linesize);
1431
        qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
1432
    }
1433

    
1434
    if(s->flags&CODEC_FLAG_GRAY) return;
1435

    
1436
    if(field_based){
1437
        mx= motion_x/2;
1438
        my= motion_y>>1;
1439
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
1440
        mx= (motion_x>>1)|(motion_x&1);
1441
        my= (motion_y>>1)|(motion_y&1);
1442
    }else{
1443
        mx= motion_x/2;
1444
        my= motion_y/2;
1445
    }
1446
    mx= (mx>>1)|(mx&1);
1447
    my= (my>>1)|(my&1);
1448
    dxy= (mx&1) | ((my&1)<<1);
1449
    mx>>=1;
1450
    my>>=1;
1451

    
1452
    src_x = s->mb_x * 8 + mx;
1453
    src_y = s->mb_y * (8 >> field_based) + my;
1454
    src_x = clip(src_x, -8, s->width >> 1);
1455
    if (src_x == (s->width >> 1))
1456
        dxy &= ~1;
1457
    src_y = clip(src_y, -8, height >> 1);
1458
    if (src_y == (height >> 1))
1459
        dxy &= ~2;
1460

    
1461
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1462
    ptr = ref_picture[1] + offset;
1463
    if(emu){
1464
        emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
1465
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1466
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1467
    }
1468
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1469
    
1470
    ptr = ref_picture[2] + offset;
1471
    if(emu){
1472
        emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
1473
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1474
        ptr= s->edge_emu_buffer + (src_offset >> 1);
1475
    }
1476
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1477
}
1478

    
1479

    
1480
static inline void MPV_motion(MpegEncContext *s, 
1481
                              UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1482
                              int dir, UINT8 **ref_picture, 
1483
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
1484
{
1485
    int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
1486
    int mb_x, mb_y, i;
1487
    UINT8 *ptr, *dest;
1488
    int emu=0;
1489

    
1490
    mb_x = s->mb_x;
1491
    mb_y = s->mb_y;
1492

    
1493
    switch(s->mv_type) {
1494
    case MV_TYPE_16X16:
1495
        if(s->mcsel){
1496
            if(s->real_sprite_warping_points==1){
1497
                gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
1498
                            ref_picture, 0);
1499
            }else{
1500
                gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
1501
                            ref_picture, 0);
1502
            }
1503
        }else if(s->quarter_sample){
1504
            qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1505
                        ref_picture, 0,
1506
                        0, pix_op, qpix_op,
1507
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1508
        }else{
1509
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1510
                        ref_picture, 0,
1511
                        0, pix_op,
1512
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1513
        }           
1514
        break;
1515
    case MV_TYPE_8X8:
1516
        mx = 0;
1517
        my = 0;
1518
        if(s->quarter_sample){
1519
            for(i=0;i<4;i++) {
1520
                motion_x = s->mv[dir][i][0];
1521
                motion_y = s->mv[dir][i][1];
1522

    
1523
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1524
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
1525
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
1526
                    
1527
                /* WARNING: do no forget half pels */
1528
                src_x = clip(src_x, -16, s->width);
1529
                if (src_x == s->width)
1530
                    dxy &= ~3;
1531
                src_y = clip(src_y, -16, s->height);
1532
                if (src_y == s->height)
1533
                    dxy &= ~12;
1534
                    
1535
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1536
                if(s->flags&CODEC_FLAG_EMU_EDGE){
1537
                    if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 8 > s->h_edge_pos
1538
                                          || src_y + (motion_y&3) + 8 > s->v_edge_pos){
1539
                        emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1540
                        ptr= s->edge_emu_buffer;
1541
                    }
1542
                }
1543
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1544
                qpix_op[1][dxy](dest, ptr, s->linesize);
1545

    
1546
                mx += s->mv[dir][i][0]/2;
1547
                my += s->mv[dir][i][1]/2;
1548
            }
1549
        }else{
1550
            for(i=0;i<4;i++) {
1551
                motion_x = s->mv[dir][i][0];
1552
                motion_y = s->mv[dir][i][1];
1553

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

    
1577
                mx += s->mv[dir][i][0];
1578
                my += s->mv[dir][i][1];
1579
            }
1580
        }
1581

    
1582
        if(s->flags&CODEC_FLAG_GRAY) break;
1583
        /* In case of 8X8, we construct a single chroma motion vector
1584
           with a special rounding */
1585
        for(i=0;i<4;i++) {
1586
        }
1587
        if (mx >= 0)
1588
            mx = (h263_chroma_roundtab[mx & 0xf] + ((mx >> 3) & ~1));
1589
        else {
1590
            mx = -mx;
1591
            mx = -(h263_chroma_roundtab[mx & 0xf] + ((mx >> 3) & ~1));
1592
        }
1593
        if (my >= 0)
1594
            my = (h263_chroma_roundtab[my & 0xf] + ((my >> 3) & ~1));
1595
        else {
1596
            my = -my;
1597
            my = -(h263_chroma_roundtab[my & 0xf] + ((my >> 3) & ~1));
1598
        }
1599
        dxy = ((my & 1) << 1) | (mx & 1);
1600
        mx >>= 1;
1601
        my >>= 1;
1602

    
1603
        src_x = mb_x * 8 + mx;
1604
        src_y = mb_y * 8 + my;
1605
        src_x = clip(src_x, -8, s->width/2);
1606
        if (src_x == s->width/2)
1607
            dxy &= ~1;
1608
        src_y = clip(src_y, -8, s->height/2);
1609
        if (src_y == s->height/2)
1610
            dxy &= ~2;
1611
        
1612
        offset = (src_y * (s->uvlinesize)) + src_x;
1613
        ptr = ref_picture[1] + offset;
1614
        if(s->flags&CODEC_FLAG_EMU_EDGE){
1615
                if(src_x<0 || src_y<0 || src_x + (dxy &1) + 8 > s->h_edge_pos>>1
1616
                                      || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
1617
                    emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1618
                    ptr= s->edge_emu_buffer;
1619
                    emu=1;
1620
                }
1621
            }
1622
        pix_op[1][dxy](dest_cb, ptr, s->uvlinesize, 8);
1623

    
1624
        ptr = ref_picture[2] + offset;
1625
        if(emu){
1626
            emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1627
            ptr= s->edge_emu_buffer;
1628
        }
1629
        pix_op[1][dxy](dest_cr, ptr, s->uvlinesize, 8);
1630
        break;
1631
    case MV_TYPE_FIELD:
1632
        if (s->picture_structure == PICT_FRAME) {
1633
            if(s->quarter_sample){
1634
                /* top field */
1635
                qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1636
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
1637
                            1, pix_op, qpix_op,
1638
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
1639
                /* bottom field */
1640
                qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
1641
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
1642
                            1, pix_op, qpix_op,
1643
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
1644
            }else{
1645
                /* top field */       
1646
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1647
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
1648
                            1, pix_op,
1649
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
1650
                /* bottom field */
1651
                mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
1652
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
1653
                            1, pix_op,
1654
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
1655
            }
1656
        } else {
1657
            
1658

    
1659
        }
1660
        break;
1661
    }
1662
}
1663

    
1664

    
1665
/* put block[] to dest[] */
1666
static inline void put_dct(MpegEncContext *s, 
1667
                           DCTELEM *block, int i, UINT8 *dest, int line_size)
1668
{
1669
    s->dct_unquantize(s, block, i, s->qscale);
1670
    s->idct_put (dest, line_size, block);
1671
}
1672

    
1673
/* add block[] to dest[] */
1674
static inline void add_dct(MpegEncContext *s, 
1675
                           DCTELEM *block, int i, UINT8 *dest, int line_size)
1676
{
1677
    if (s->block_last_index[i] >= 0) {
1678
        s->idct_add (dest, line_size, block);
1679
    }
1680
}
1681

    
1682
static inline void add_dequant_dct(MpegEncContext *s, 
1683
                           DCTELEM *block, int i, UINT8 *dest, int line_size)
1684
{
1685
    if (s->block_last_index[i] >= 0) {
1686
        s->dct_unquantize(s, block, i, s->qscale);
1687

    
1688
        s->idct_add (dest, line_size, block);
1689
    }
1690
}
1691

    
1692
/**
1693
 * cleans dc, ac, coded_block for the current non intra MB
1694
 */
1695
void ff_clean_intra_table_entries(MpegEncContext *s)
1696
{
1697
    int wrap = s->block_wrap[0];
1698
    int xy = s->block_index[0];
1699
    
1700
    s->dc_val[0][xy           ] = 
1701
    s->dc_val[0][xy + 1       ] = 
1702
    s->dc_val[0][xy     + wrap] =
1703
    s->dc_val[0][xy + 1 + wrap] = 1024;
1704
    /* ac pred */
1705
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(INT16));
1706
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(INT16));
1707
    if (s->msmpeg4_version>=3) {
1708
        s->coded_block[xy           ] =
1709
        s->coded_block[xy + 1       ] =
1710
        s->coded_block[xy     + wrap] =
1711
        s->coded_block[xy + 1 + wrap] = 0;
1712
    }
1713
    /* chroma */
1714
    wrap = s->block_wrap[4];
1715
    xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
1716
    s->dc_val[1][xy] =
1717
    s->dc_val[2][xy] = 1024;
1718
    /* ac pred */
1719
    memset(s->ac_val[1][xy], 0, 16 * sizeof(INT16));
1720
    memset(s->ac_val[2][xy], 0, 16 * sizeof(INT16));
1721
    
1722
    s->mbintra_table[s->mb_x + s->mb_y*s->mb_width]= 0;
1723
}
1724

    
1725
/* generic function called after a macroblock has been parsed by the
1726
   decoder or after it has been encoded by the encoder.
1727

1728
   Important variables used:
1729
   s->mb_intra : true if intra macroblock
1730
   s->mv_dir   : motion vector direction
1731
   s->mv_type  : motion vector type
1732
   s->mv       : motion vector
1733
   s->interlaced_dct : true if interlaced dct used (mpeg2)
1734
 */
1735
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1736
{
1737
    int mb_x, mb_y;
1738
    const int mb_xy = s->mb_y * s->mb_width + s->mb_x;
1739

    
1740
    mb_x = s->mb_x;
1741
    mb_y = s->mb_y;
1742

    
1743
    s->qscale_table[mb_xy]= s->qscale;
1744

    
1745
    /* update DC predictors for P macroblocks */
1746
    if (!s->mb_intra) {
1747
        if (s->h263_pred || s->h263_aic) {
1748
            if(s->mbintra_table[mb_xy])
1749
                ff_clean_intra_table_entries(s);
1750
        } else {
1751
            s->last_dc[0] =
1752
            s->last_dc[1] =
1753
            s->last_dc[2] = 128 << s->intra_dc_precision;
1754
        }
1755
    }
1756
    else if (s->h263_pred || s->h263_aic)
1757
        s->mbintra_table[mb_xy]=1;
1758

    
1759
    /* update motion predictor, not for B-frames as they need the motion_val from the last P/S-Frame */
1760
    if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) { //FIXME move into h263.c if possible, format specific stuff shouldnt be here
1761
        
1762
        const int wrap = s->block_wrap[0];
1763
        const int xy = s->block_index[0];
1764
        const int mb_index= s->mb_x + s->mb_y*s->mb_width;
1765
        if(s->mv_type == MV_TYPE_8X8){
1766
            s->co_located_type_table[mb_index]= CO_LOCATED_TYPE_4MV;
1767
        } else {
1768
            int motion_x, motion_y;
1769
            if (s->mb_intra) {
1770
                motion_x = 0;
1771
                motion_y = 0;
1772
                if(s->co_located_type_table)
1773
                    s->co_located_type_table[mb_index]= 0;
1774
            } else if (s->mv_type == MV_TYPE_16X16) {
1775
                motion_x = s->mv[0][0][0];
1776
                motion_y = s->mv[0][0][1];
1777
                if(s->co_located_type_table)
1778
                    s->co_located_type_table[mb_index]= 0;
1779
            } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
1780
                int i;
1781
                motion_x = s->mv[0][0][0] + s->mv[0][1][0];
1782
                motion_y = s->mv[0][0][1] + s->mv[0][1][1];
1783
                motion_x = (motion_x>>1) | (motion_x&1);
1784
                for(i=0; i<2; i++){
1785
                    s->field_mv_table[mb_index][i][0]= s->mv[0][i][0];
1786
                    s->field_mv_table[mb_index][i][1]= s->mv[0][i][1];
1787
                    s->field_select_table[mb_index][i]= s->field_select[0][i];
1788
                }
1789
                s->co_located_type_table[mb_index]= CO_LOCATED_TYPE_FIELDMV;
1790
            }
1791
            /* no update if 8X8 because it has been done during parsing */
1792
            s->motion_val[xy][0] = motion_x;
1793
            s->motion_val[xy][1] = motion_y;
1794
            s->motion_val[xy + 1][0] = motion_x;
1795
            s->motion_val[xy + 1][1] = motion_y;
1796
            s->motion_val[xy + wrap][0] = motion_x;
1797
            s->motion_val[xy + wrap][1] = motion_y;
1798
            s->motion_val[xy + 1 + wrap][0] = motion_x;
1799
            s->motion_val[xy + 1 + wrap][1] = motion_y;
1800
        }
1801
    }
1802
    
1803
    if (!(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) {
1804
        UINT8 *dest_y, *dest_cb, *dest_cr;
1805
        int dct_linesize, dct_offset;
1806
        op_pixels_func (*op_pix)[4];
1807
        qpel_mc_func (*op_qpix)[16];
1808

    
1809
        /* avoid copy if macroblock skipped in last frame too 
1810
           dont touch it for B-frames as they need the skip info from the next p-frame */
1811
        if (s->pict_type != B_TYPE) {
1812
            UINT8 *mbskip_ptr = &s->mbskip_table[mb_xy];
1813
            if (s->mb_skiped) {
1814
                s->mb_skiped = 0;
1815

    
1816
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
1817
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
1818

    
1819
                /* if previous was skipped too, then nothing to do ! 
1820
                   skip only during decoding as we might trash the buffers during encoding a bit */
1821
                if (*mbskip_ptr >= s->ip_buffer_count  && !s->encoding) 
1822
                    goto the_end;
1823
            } else {
1824
                *mbskip_ptr = 0; /* not skipped */
1825
            }
1826
        }
1827

    
1828
        if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band){
1829
            dest_y = s->current_picture [0] + mb_x * 16;
1830
            dest_cb = s->current_picture[1] + mb_x * 8;
1831
            dest_cr = s->current_picture[2] + mb_x * 8;
1832
        }else{
1833
            dest_y = s->current_picture [0] + (mb_y * 16* s->linesize  ) + mb_x * 16;
1834
            dest_cb = s->current_picture[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
1835
            dest_cr = s->current_picture[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
1836
        }
1837

    
1838
        if (s->interlaced_dct) {
1839
            dct_linesize = s->linesize * 2;
1840
            dct_offset = s->linesize;
1841
        } else {
1842
            dct_linesize = s->linesize;
1843
            dct_offset = s->linesize * 8;
1844
        }
1845

    
1846
        if (!s->mb_intra) {
1847
            /* motion handling */
1848
            /* decoding or more than one mb_type (MC was allready done otherwise) */
1849
            if((!s->encoding) || (s->mb_type[mb_xy]&(s->mb_type[mb_xy]-1))){
1850
                if ((!s->no_rounding) || s->pict_type==B_TYPE){                
1851
                    op_pix = put_pixels_tab;
1852
                    op_qpix= put_qpel_pixels_tab;
1853
                }else{
1854
                    op_pix = put_no_rnd_pixels_tab;
1855
                    op_qpix= put_no_rnd_qpel_pixels_tab;
1856
                }
1857

    
1858
                if (s->mv_dir & MV_DIR_FORWARD) {
1859
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture, op_pix, op_qpix);
1860
                    op_pix = avg_pixels_tab;
1861
                    op_qpix= avg_qpel_pixels_tab;
1862
                }
1863
                if (s->mv_dir & MV_DIR_BACKWARD) {
1864
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture, op_pix, op_qpix);
1865
                }
1866
            }
1867

    
1868
            /* skip dequant / idct if we are really late ;) */
1869
            if(s->hurry_up>1) goto the_end;
1870

    
1871
            /* add dct residue */
1872
            if(s->encoding || !(   s->mpeg2 || s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO 
1873
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1874
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
1875
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
1876
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
1877
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
1878

    
1879
                if(!(s->flags&CODEC_FLAG_GRAY)){
1880
                    add_dequant_dct(s, block[4], 4, dest_cb, s->uvlinesize);
1881
                    add_dequant_dct(s, block[5], 5, dest_cr, s->uvlinesize);
1882
                }
1883
            } else {
1884
                add_dct(s, block[0], 0, dest_y, dct_linesize);
1885
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
1886
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
1887
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
1888

    
1889
                if(!(s->flags&CODEC_FLAG_GRAY)){
1890
                    add_dct(s, block[4], 4, dest_cb, s->uvlinesize);
1891
                    add_dct(s, block[5], 5, dest_cr, s->uvlinesize);
1892
                }
1893
            }
1894
        } else {
1895
            /* dct only in intra block */
1896
            if(s->encoding || !(s->mpeg2 || s->codec_id==CODEC_ID_MPEG1VIDEO)){
1897
                put_dct(s, block[0], 0, dest_y, dct_linesize);
1898
                put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
1899
                put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
1900
                put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
1901

    
1902
                if(!(s->flags&CODEC_FLAG_GRAY)){
1903
                    put_dct(s, block[4], 4, dest_cb, s->uvlinesize);
1904
                    put_dct(s, block[5], 5, dest_cr, s->uvlinesize);
1905
                }
1906
            }else{
1907
                s->idct_put(dest_y                 , dct_linesize, block[0]);
1908
                s->idct_put(dest_y              + 8, dct_linesize, block[1]);
1909
                s->idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
1910
                s->idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
1911

    
1912
                if(!(s->flags&CODEC_FLAG_GRAY)){
1913
                    s->idct_put(dest_cb, s->uvlinesize, block[4]);
1914
                    s->idct_put(dest_cr, s->uvlinesize, block[5]);
1915
                }
1916
            }
1917
        }
1918
    }
1919
 the_end:
1920
    emms_c(); //FIXME remove
1921
}
1922

    
1923
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
1924
{
1925
    static const char tab[64]=
1926
        {3,2,2,1,1,1,1,1,
1927
         1,1,1,1,1,1,1,1,
1928
         1,1,1,1,1,1,1,1,
1929
         0,0,0,0,0,0,0,0,
1930
         0,0,0,0,0,0,0,0,
1931
         0,0,0,0,0,0,0,0,
1932
         0,0,0,0,0,0,0,0,
1933
         0,0,0,0,0,0,0,0};
1934
    int score=0;
1935
    int run=0;
1936
    int i;
1937
    DCTELEM *block= s->block[n];
1938
    const int last_index= s->block_last_index[n];
1939
    int skip_dc;
1940

    
1941
    if(threshold<0){
1942
        skip_dc=0;
1943
        threshold= -threshold;
1944
    }else
1945
        skip_dc=1;
1946

    
1947
    /* are all which we could set to zero are allready zero? */
1948
    if(last_index<=skip_dc - 1) return;
1949

    
1950
    for(i=0; i<=last_index; i++){
1951
        const int j = s->intra_scantable.permutated[i];
1952
        const int level = ABS(block[j]);
1953
        if(level==1){
1954
            if(skip_dc && i==0) continue;
1955
            score+= tab[run];
1956
            run=0;
1957
        }else if(level>1){
1958
            return;
1959
        }else{
1960
            run++;
1961
        }
1962
    }
1963
    if(score >= threshold) return;
1964
    for(i=skip_dc; i<=last_index; i++){
1965
        const int j = s->intra_scantable.permutated[i];
1966
        block[j]=0;
1967
    }
1968
    if(block[0]) s->block_last_index[n]= 0;
1969
    else         s->block_last_index[n]= -1;
1970
}
1971

    
1972
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
1973
{
1974
    int i;
1975
    const int maxlevel= s->max_qcoeff;
1976
    const int minlevel= s->min_qcoeff;
1977
    
1978
    if(s->mb_intra){
1979
        i=1; //skip clipping of intra dc
1980
    }else
1981
        i=0;
1982
    
1983
    for(;i<=last_index; i++){
1984
        const int j= s->intra_scantable.permutated[i];
1985
        int level = block[j];
1986
       
1987
        if     (level>maxlevel) level=maxlevel;
1988
        else if(level<minlevel) level=minlevel;
1989
        block[j]= level;
1990
    }
1991
}
1992

    
1993
static inline void requantize_coeffs(MpegEncContext *s, DCTELEM block[64], int oldq, int newq, int n)
1994
{
1995
    int i;
1996

    
1997
    if(s->mb_intra){
1998
        i=1; //skip clipping of intra dc
1999
         //FIXME requantize, note (mpeg1/h263/h263p-aic dont need it,...)
2000
    }else
2001
        i=0;
2002
    
2003
    for(;i<=s->block_last_index[n]; i++){
2004
        const int j = s->intra_scantable.permutated[i];
2005
        int level = block[j];
2006
        
2007
        block[j]= ROUNDED_DIV(level*oldq, newq);
2008
    }
2009

    
2010
    for(i=s->block_last_index[n]; i>=0; i--){
2011
        const int j = s->intra_scantable.permutated[i];
2012
        if(block[j]) break;
2013
    }
2014
    s->block_last_index[n]= i;
2015
}
2016

    
2017
static inline void auto_requantize_coeffs(MpegEncContext *s, DCTELEM block[6][64])
2018
{
2019
    int i,n, newq;
2020
    const int maxlevel= s->max_qcoeff;
2021
    const int minlevel= s->min_qcoeff;
2022
    int largest=0, smallest=0;
2023

    
2024
    assert(s->adaptive_quant);
2025
    
2026
    for(n=0; n<6; n++){
2027
        if(s->mb_intra){
2028
            i=1; //skip clipping of intra dc
2029
             //FIXME requantize, note (mpeg1/h263/h263p-aic dont need it,...)
2030
        }else
2031
            i=0;
2032

    
2033
        for(;i<=s->block_last_index[n]; i++){
2034
            const int j = s->intra_scantable.permutated[i];
2035
            int level = block[n][j];
2036
            if(largest  < level) largest = level;
2037
            if(smallest > level) smallest= level;
2038
        }
2039
    }
2040
    
2041
    for(newq=s->qscale+1; newq<32; newq++){
2042
        if(   ROUNDED_DIV(smallest*s->qscale, newq) >= minlevel
2043
           && ROUNDED_DIV(largest *s->qscale, newq) <= maxlevel) 
2044
            break;
2045
    }
2046
        
2047
    if(s->out_format==FMT_H263){
2048
        /* h263 like formats cannot change qscale by more than 2 easiely */
2049
        if(s->avctx->qmin + 2 < newq)
2050
            newq= s->avctx->qmin + 2;
2051
    }
2052

    
2053
    for(n=0; n<6; n++){
2054
        requantize_coeffs(s, block[n], s->qscale, newq, n);
2055
        clip_coeffs(s, block[n], s->block_last_index[n]);
2056
    }
2057
     
2058
    s->dquant+= newq - s->qscale;
2059
    s->qscale= newq;
2060
}
2061
#if 0
2062
static int pix_vcmp16x8(UINT8 *s, int stride){ //FIXME move to dsputil & optimize
2063
    int score=0;
2064
    int x,y;
2065
    
2066
    for(y=0; y<7; y++){
2067
        for(x=0; x<16; x+=4){
2068
            score+= ABS(s[x  ] - s[x  +stride]) + ABS(s[x+1] - s[x+1+stride]) 
2069
                   +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
2070
        }
2071
        s+= stride;
2072
    }
2073
    
2074
    return score;
2075
}
2076

2077
static int pix_diff_vcmp16x8(UINT8 *s1, UINT8*s2, int stride){ //FIXME move to dsputil & optimize
2078
    int score=0;
2079
    int x,y;
2080
    
2081
    for(y=0; y<7; y++){
2082
        for(x=0; x<16; x++){
2083
            score+= ABS(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2084
        }
2085
        s1+= stride;
2086
        s2+= stride;
2087
    }
2088
    
2089
    return score;
2090
}
2091
#else
2092
#define SQ(a) ((a)*(a))
2093

    
2094
static int pix_vcmp16x8(UINT8 *s, int stride){ //FIXME move to dsputil & optimize
2095
    int score=0;
2096
    int x,y;
2097
    
2098
    for(y=0; y<7; y++){
2099
        for(x=0; x<16; x+=4){
2100
            score+= SQ(s[x  ] - s[x  +stride]) + SQ(s[x+1] - s[x+1+stride]) 
2101
                   +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
2102
        }
2103
        s+= stride;
2104
    }
2105
    
2106
    return score;
2107
}
2108

    
2109
static int pix_diff_vcmp16x8(UINT8 *s1, UINT8*s2, int stride){ //FIXME move to dsputil & optimize
2110
    int score=0;
2111
    int x,y;
2112
    
2113
    for(y=0; y<7; y++){
2114
        for(x=0; x<16; x++){
2115
            score+= SQ(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2116
        }
2117
        s1+= stride;
2118
        s2+= stride;
2119
    }
2120
    
2121
    return score;
2122
}
2123

    
2124
#endif
2125

    
2126
void ff_draw_horiz_band(MpegEncContext *s){
2127
    if (    s->avctx->draw_horiz_band 
2128
        && (s->num_available_buffers>=1 || (!s->has_b_frames)) ) {
2129
        UINT8 *src_ptr[3];
2130
        int y, h, offset;
2131
        y = s->mb_y * 16;
2132
        h = s->height - y;
2133
        if (h > 16)
2134
            h = 16;
2135

    
2136
        if(s->pict_type==B_TYPE)
2137
            offset = 0;
2138
        else
2139
            offset = y * s->linesize;
2140

    
2141
        if(s->pict_type==B_TYPE || (!s->has_b_frames)){
2142
            src_ptr[0] = s->current_picture[0] + offset;
2143
            src_ptr[1] = s->current_picture[1] + (offset >> 2);
2144
            src_ptr[2] = s->current_picture[2] + (offset >> 2);
2145
        } else {
2146
            src_ptr[0] = s->last_picture[0] + offset;
2147
            src_ptr[1] = s->last_picture[1] + (offset >> 2);
2148
            src_ptr[2] = s->last_picture[2] + (offset >> 2);
2149
        }
2150
        s->avctx->draw_horiz_band(s->avctx, src_ptr, s->linesize,
2151
                               y, s->width, h);
2152
    }
2153
}
2154

    
2155
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2156
{
2157
    const int mb_x= s->mb_x;
2158
    const int mb_y= s->mb_y;
2159
    int i;
2160
    int skip_dct[6];
2161
    int dct_offset   = s->linesize*8; //default for progressive frames
2162
    
2163
    for(i=0; i<6; i++) skip_dct[i]=0;
2164
    
2165
    if(s->adaptive_quant){
2166
        s->dquant= s->qscale_table[mb_x + mb_y*s->mb_width] - s->qscale;
2167

    
2168
        if(s->out_format==FMT_H263){
2169
            if     (s->dquant> 2) s->dquant= 2;
2170
            else if(s->dquant<-2) s->dquant=-2;
2171
        }
2172
            
2173
        if(s->codec_id==CODEC_ID_MPEG4){        
2174
            if(!s->mb_intra){
2175
                assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
2176

    
2177
                if(s->mv_dir&MV_DIRECT)
2178
                    s->dquant=0;
2179
            }
2180
        }
2181
        s->qscale+= s->dquant;
2182
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2183
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2184
    }
2185

    
2186
    if (s->mb_intra) {
2187
        UINT8 *ptr;
2188
        int wrap_y;
2189
        int emu=0;
2190

    
2191
        wrap_y = s->linesize;
2192
        ptr = s->new_picture[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2193

    
2194
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2195
            emulated_edge_mc(s, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2196
            ptr= s->edge_emu_buffer;
2197
            emu=1;
2198
        }
2199
        
2200
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2201
            int progressive_score, interlaced_score;
2202
            
2203
            progressive_score= pix_vcmp16x8(ptr, wrap_y  ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
2204
            interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y  , wrap_y*2);
2205
            
2206
            if(progressive_score > interlaced_score + 100){
2207
                s->interlaced_dct=1;
2208
            
2209
                dct_offset= wrap_y;
2210
                wrap_y<<=1;
2211
            }else
2212
                s->interlaced_dct=0;
2213
        }
2214
        
2215
        get_pixels(s->block[0], ptr                 , wrap_y);
2216
        get_pixels(s->block[1], ptr              + 8, wrap_y);
2217
        get_pixels(s->block[2], ptr + dct_offset    , wrap_y);
2218
        get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
2219

    
2220
        if(s->flags&CODEC_FLAG_GRAY){
2221
            skip_dct[4]= 1;
2222
            skip_dct[5]= 1;
2223
        }else{
2224
            int wrap_c = s->uvlinesize;
2225
            ptr = s->new_picture[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2226
            if(emu){
2227
                emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2228
                ptr= s->edge_emu_buffer;
2229
            }
2230
            get_pixels(s->block[4], ptr, wrap_c);
2231

    
2232
            ptr = s->new_picture[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2233
            if(emu){
2234
                emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2235
                ptr= s->edge_emu_buffer;
2236
            }
2237
            get_pixels(s->block[5], ptr, wrap_c);
2238
        }
2239
    }else{
2240
        op_pixels_func (*op_pix)[4];
2241
        qpel_mc_func (*op_qpix)[16];
2242
        UINT8 *dest_y, *dest_cb, *dest_cr;
2243
        UINT8 *ptr_y, *ptr_cb, *ptr_cr;
2244
        int wrap_y, wrap_c;
2245
        int emu=0;
2246

    
2247
        dest_y  = s->current_picture[0] + (mb_y * 16 * s->linesize       ) + mb_x * 16;
2248
        dest_cb = s->current_picture[1] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2249
        dest_cr = s->current_picture[2] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2250
        wrap_y = s->linesize;
2251
        wrap_c = s->uvlinesize;
2252
        ptr_y  = s->new_picture[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2253
        ptr_cb = s->new_picture[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2254
        ptr_cr = s->new_picture[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2255

    
2256
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
2257
            op_pix = put_pixels_tab;
2258
            op_qpix= put_qpel_pixels_tab;
2259
        }else{
2260
            op_pix = put_no_rnd_pixels_tab;
2261
            op_qpix= put_no_rnd_qpel_pixels_tab;
2262
        }
2263

    
2264
        if (s->mv_dir & MV_DIR_FORWARD) {
2265
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture, op_pix, op_qpix);
2266
            op_pix = avg_pixels_tab;
2267
            op_qpix= avg_qpel_pixels_tab;
2268
        }
2269
        if (s->mv_dir & MV_DIR_BACKWARD) {
2270
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture, op_pix, op_qpix);
2271
        }
2272

    
2273
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2274
            emulated_edge_mc(s, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2275
            ptr_y= s->edge_emu_buffer;
2276
            emu=1;
2277
        }
2278
        
2279
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2280
            int progressive_score, interlaced_score;
2281
            
2282
            progressive_score= pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y  ) 
2283
                             + pix_diff_vcmp16x8(ptr_y + wrap_y*8, dest_y + wrap_y*8, wrap_y  );
2284
            interlaced_score = pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y*2)
2285
                             + pix_diff_vcmp16x8(ptr_y + wrap_y  , dest_y + wrap_y  , wrap_y*2);
2286
            
2287
            if(progressive_score > interlaced_score + 600){
2288
                s->interlaced_dct=1;
2289
            
2290
                dct_offset= wrap_y;
2291
                wrap_y<<=1;
2292
            }else
2293
                s->interlaced_dct=0;
2294
        }
2295
        
2296
        diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
2297
        diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
2298
        diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
2299
        diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
2300
        
2301
        if(s->flags&CODEC_FLAG_GRAY){
2302
            skip_dct[4]= 1;
2303
            skip_dct[5]= 1;
2304
        }else{
2305
            if(emu){
2306
                emulated_edge_mc(s, ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2307
                ptr_cb= s->edge_emu_buffer;
2308
            }
2309
            diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2310
            if(emu){
2311
                emulated_edge_mc(s, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2312
                ptr_cr= s->edge_emu_buffer;
2313
            }
2314
            diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2315
        }
2316

    
2317
        /* pre quantization */         
2318
        if(s->mc_mb_var[s->mb_width*mb_y+ mb_x]<2*s->qscale*s->qscale){
2319
            //FIXME optimize
2320
            if(pix_abs8x8(ptr_y               , dest_y               , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
2321
            if(pix_abs8x8(ptr_y            + 8, dest_y            + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
2322
            if(pix_abs8x8(ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
2323
            if(pix_abs8x8(ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
2324
            if(pix_abs8x8(ptr_cb              , dest_cb              , wrap_y) < 20*s->qscale) skip_dct[4]= 1;
2325
            if(pix_abs8x8(ptr_cr              , dest_cr              , wrap_y) < 20*s->qscale) skip_dct[5]= 1;
2326
#if 0
2327
{
2328
 static int stat[7];
2329
 int num=0;
2330
 for(i=0; i<6; i++)
2331
  if(skip_dct[i]) num++;
2332
 stat[num]++;
2333
 
2334
 if(s->mb_x==0 && s->mb_y==0){
2335
  for(i=0; i<7; i++){
2336
   printf("%6d %1d\n", stat[i], i);
2337
  }
2338
 }
2339
}
2340
#endif
2341
        }
2342

    
2343
    }
2344
            
2345
#if 0
2346
            {
2347
                float adap_parm;
2348
                
2349
                adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_width*mb_y+mb_x] + 1.0) /
2350
                            ((s->mb_var[s->mb_width*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);
2351
            
2352
                printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d", 
2353
                        (s->mb_type[s->mb_width*mb_y+mb_x] > 0) ? 'I' : 'P', 
2354
                        s->qscale, adap_parm, s->qscale*adap_parm,
2355
                        s->mb_var[s->mb_width*mb_y+mb_x], s->avg_mb_var);
2356
            }
2357
#endif
2358
    /* DCT & quantize */
2359
    if(s->out_format==FMT_MJPEG){
2360
        for(i=0;i<6;i++) {
2361
            int overflow;
2362
            s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
2363
            if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2364
        }
2365
    }else{
2366
        for(i=0;i<6;i++) {
2367
            if(!skip_dct[i]){
2368
                int overflow;
2369
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2370
            // FIXME we could decide to change to quantizer instead of clipping
2371
            // JS: I don't think that would be a good idea it could lower quality instead
2372
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
2373
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2374
            }else
2375
                s->block_last_index[i]= -1;
2376
        }
2377
        if(s->luma_elim_threshold && !s->mb_intra)
2378
            for(i=0; i<4; i++)
2379
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2380
        if(s->chroma_elim_threshold && !s->mb_intra)
2381
            for(i=4; i<6; i++)
2382
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2383
    }
2384

    
2385
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
2386
        s->block_last_index[4]=
2387
        s->block_last_index[5]= 0;
2388
        s->block[4][0]=
2389
        s->block[5][0]= 128;
2390
    }
2391

    
2392
    /* huffman encode */
2393
    switch(s->out_format) {
2394
    case FMT_MPEG1:
2395
        mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2396
        break;
2397
    case FMT_H263:
2398
        if (s->h263_msmpeg4)
2399
            msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2400
        else if(s->h263_pred)
2401
            mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2402
        else
2403
            h263_encode_mb(s, s->block, motion_x, motion_y);
2404
        break;
2405
    case FMT_MJPEG:
2406
        mjpeg_encode_mb(s, s->block);
2407
        break;
2408
    }
2409
}
2410

    
2411
void ff_copy_bits(PutBitContext *pb, UINT8 *src, int length)
2412
{
2413
    int bytes= length>>4;
2414
    int bits= length&15;
2415
    int i;
2416

    
2417
    if(length==0) return;
2418

    
2419
    for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
2420
    put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
2421
}
2422

    
2423
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2424
    int i;
2425

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

    
2428
    /* mpeg1 */
2429
    d->mb_incr= s->mb_incr;
2430
    for(i=0; i<3; i++)
2431
        d->last_dc[i]= s->last_dc[i];
2432
    
2433
    /* statistics */
2434
    d->mv_bits= s->mv_bits;
2435
    d->i_tex_bits= s->i_tex_bits;
2436
    d->p_tex_bits= s->p_tex_bits;
2437
    d->i_count= s->i_count;
2438
    d->f_count= s->f_count;
2439
    d->b_count= s->b_count;
2440
    d->skip_count= s->skip_count;
2441
    d->misc_bits= s->misc_bits;
2442
    d->last_bits= 0;
2443

    
2444
    d->mb_skiped= s->mb_skiped;
2445
}
2446

    
2447
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2448
    int i;
2449

    
2450
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
2451
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
2452
    
2453
    /* mpeg1 */
2454
    d->mb_incr= s->mb_incr;
2455
    for(i=0; i<3; i++)
2456
        d->last_dc[i]= s->last_dc[i];
2457
    
2458
    /* statistics */
2459
    d->mv_bits= s->mv_bits;
2460
    d->i_tex_bits= s->i_tex_bits;
2461
    d->p_tex_bits= s->p_tex_bits;
2462
    d->i_count= s->i_count;
2463
    d->f_count= s->f_count;
2464
    d->b_count= s->b_count;
2465
    d->skip_count= s->skip_count;
2466
    d->misc_bits= s->misc_bits;
2467

    
2468
    d->mb_intra= s->mb_intra;
2469
    d->mb_skiped= s->mb_skiped;
2470
    d->mv_type= s->mv_type;
2471
    d->mv_dir= s->mv_dir;
2472
    d->pb= s->pb;
2473
    if(s->data_partitioning){
2474
        d->pb2= s->pb2;
2475
        d->tex_pb= s->tex_pb;
2476
    }
2477
    d->block= s->block;
2478
    for(i=0; i<6; i++)
2479
        d->block_last_index[i]= s->block_last_index[i];
2480
    d->interlaced_dct= s->interlaced_dct;
2481
}
2482

    
2483
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
2484
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2485
                           int *dmin, int *next_block, int motion_x, int motion_y)
2486
{
2487
    int bits_count;
2488
    
2489
    copy_context_before_encode(s, backup, type);
2490

    
2491
    s->block= s->blocks[*next_block];
2492
    s->pb= pb[*next_block];
2493
    if(s->data_partitioning){
2494
        s->pb2   = pb2   [*next_block];
2495
        s->tex_pb= tex_pb[*next_block];
2496
    }
2497

    
2498
    encode_mb(s, motion_x, motion_y);
2499

    
2500
    bits_count= get_bit_count(&s->pb);
2501
    if(s->data_partitioning){
2502
        bits_count+= get_bit_count(&s->pb2);
2503
        bits_count+= get_bit_count(&s->tex_pb);
2504
    }
2505

    
2506
    if(bits_count<*dmin){
2507
        *dmin= bits_count;
2508
        *next_block^=1;
2509

    
2510
        copy_context_after_encode(best, s, type);
2511
    }
2512
}
2513

    
2514
static void encode_picture(MpegEncContext *s, int picture_number)
2515
{
2516
    int mb_x, mb_y, pdif = 0;
2517
    int i;
2518
    int bits;
2519
    MpegEncContext best_s, backup_s;
2520
    UINT8 bit_buf[2][3000];
2521
    UINT8 bit_buf2[2][3000];
2522
    UINT8 bit_buf_tex[2][3000];
2523
    PutBitContext pb[2], pb2[2], tex_pb[2];
2524

    
2525
    for(i=0; i<2; i++){
2526
        init_put_bits(&pb    [i], bit_buf    [i], 3000, NULL, NULL);
2527
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000, NULL, NULL);
2528
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
2529
    }
2530

    
2531
    s->picture_number = picture_number;
2532

    
2533
    s->block_wrap[0]=
2534
    s->block_wrap[1]=
2535
    s->block_wrap[2]=
2536
    s->block_wrap[3]= s->mb_width*2 + 2;
2537
    s->block_wrap[4]=
2538
    s->block_wrap[5]= s->mb_width + 2;
2539
    
2540
    /* Reset the average MB variance */
2541
    s->mb_var_sum = 0;
2542
    s->mc_mb_var_sum = 0;
2543

    
2544
    /* we need to initialize some time vars before we can encode b-frames */
2545
    if (s->h263_pred && !s->h263_msmpeg4)
2546
        ff_set_mpeg4_time(s, s->picture_number); 
2547

    
2548
    s->scene_change_score=0;
2549
    
2550
    s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
2551

    
2552
    /* Estimate motion for every MB */
2553
    if(s->pict_type != I_TYPE){
2554
        for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2555
            s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
2556
            s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
2557
            s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
2558
            s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
2559
            for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2560
                s->mb_x = mb_x;
2561
                s->mb_y = mb_y;
2562
                s->block_index[0]+=2;
2563
                s->block_index[1]+=2;
2564
                s->block_index[2]+=2;
2565
                s->block_index[3]+=2;
2566

    
2567
                /* compute motion vector & mb_type and store in context */
2568
                if(s->pict_type==B_TYPE)
2569
                    ff_estimate_b_frame_motion(s, mb_x, mb_y);
2570
                else
2571
                    ff_estimate_p_frame_motion(s, mb_x, mb_y);
2572
//                s->mb_type[mb_y*s->mb_width + mb_x]=MB_TYPE_INTER;
2573
            }
2574
        }
2575
        emms_c();
2576
    }else /* if(s->pict_type == I_TYPE) */{
2577
        /* I-Frame */
2578
        //FIXME do we need to zero them?
2579
        memset(s->motion_val[0], 0, sizeof(INT16)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
2580
        memset(s->p_mv_table   , 0, sizeof(INT16)*(s->mb_width+2)*(s->mb_height+2)*2);
2581
        memset(s->mb_type      , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
2582
        
2583
        if(!s->fixed_qscale){
2584
            /* finding spatial complexity for I-frame rate control */
2585
            for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2586
                for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2587
                    int xx = mb_x * 16;
2588
                    int yy = mb_y * 16;
2589
                    uint8_t *pix = s->new_picture[0] + (yy * s->linesize) + xx;
2590
                    int varc;
2591
                    int sum = pix_sum(pix, s->linesize);
2592
    
2593
                    varc = (pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
2594

    
2595
                    s->mb_var [s->mb_width * mb_y + mb_x] = varc;
2596
                    s->mb_mean[s->mb_width * mb_y + mb_x] = (sum+128)>>8;
2597
                    s->mb_var_sum    += varc;
2598
                }
2599
            }
2600
        }
2601
    }
2602
    if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
2603
        s->pict_type= I_TYPE;
2604
        memset(s->mb_type   , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
2605
        if(s->max_b_frames==0){
2606
            s->input_pict_type= I_TYPE;
2607
            s->input_picture_in_gop_number=0;
2608
        }
2609
//printf("Scene change detected, encoding as I Frame %d %d\n", s->mb_var_sum, s->mc_mb_var_sum);
2610
    }
2611
    
2612
    if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) 
2613
        s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
2614
        ff_fix_long_p_mvs(s);
2615
    if(s->pict_type==B_TYPE){
2616
        s->f_code= ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
2617
        s->b_code= ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
2618

    
2619
        ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
2620
        ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
2621
        ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
2622
        ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
2623
    }
2624
    
2625
    if (s->fixed_qscale) 
2626
        s->frame_qscale = s->avctx->quality;
2627
    else
2628
        s->frame_qscale = ff_rate_estimate_qscale(s);
2629

    
2630
    if(s->adaptive_quant){
2631
        switch(s->codec_id){
2632
        case CODEC_ID_MPEG4:
2633
            ff_clean_mpeg4_qscales(s);
2634
            break;
2635
        case CODEC_ID_H263:
2636
        case CODEC_ID_H263P:
2637
            ff_clean_h263_qscales(s);
2638
            break;
2639
        }
2640

    
2641
        s->qscale= s->qscale_table[0];
2642
    }else
2643
        s->qscale= (int)(s->frame_qscale + 0.5);
2644
        
2645
    if (s->out_format == FMT_MJPEG) {
2646
        /* for mjpeg, we do include qscale in the matrix */
2647
        s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
2648
        for(i=1;i<64;i++){
2649
            int j= s->idct_permutation[i];
2650

    
2651
            s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
2652
        }
2653
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, 
2654
                       s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
2655
    }
2656

    
2657
    s->last_bits= get_bit_count(&s->pb);
2658
    switch(s->out_format) {
2659
    case FMT_MJPEG:
2660
        mjpeg_picture_header(s);
2661
        break;
2662
    case FMT_H263:
2663
        if (s->h263_msmpeg4) 
2664
            msmpeg4_encode_picture_header(s, picture_number);
2665
        else if (s->h263_pred)
2666
            mpeg4_encode_picture_header(s, picture_number);
2667
        else if (s->h263_rv10) 
2668
            rv10_encode_picture_header(s, picture_number);
2669
        else
2670
            h263_encode_picture_header(s, picture_number);
2671
        break;
2672
    case FMT_MPEG1:
2673
        mpeg1_encode_picture_header(s, picture_number);
2674
        break;
2675
    }
2676
    bits= get_bit_count(&s->pb);
2677
    s->header_bits= bits - s->last_bits;
2678
    s->last_bits= bits;
2679
    s->mv_bits=0;
2680
    s->misc_bits=0;
2681
    s->i_tex_bits=0;
2682
    s->p_tex_bits=0;
2683
    s->i_count=0;
2684
    s->f_count=0;
2685
    s->b_count=0;
2686
    s->skip_count=0;
2687

    
2688
    /* init last dc values */
2689
    /* note: quant matrix value (8) is implied here */
2690
    s->last_dc[0] = 128;
2691
    s->last_dc[1] = 128;
2692
    s->last_dc[2] = 128;
2693
    s->mb_incr = 1;
2694
    s->last_mv[0][0][0] = 0;
2695
    s->last_mv[0][0][1] = 0;
2696

    
2697
    if (s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P)
2698
        s->gob_index = ff_h263_get_gob_height(s);
2699

    
2700
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
2701
        ff_mpeg4_init_partitions(s);
2702

    
2703
    s->resync_mb_x=0;
2704
    s->resync_mb_y=0;
2705
    s->first_slice_line = 1;
2706
    s->ptr_lastgob = s->pb.buf;
2707
    s->ptr_last_mb_line = s->pb.buf;
2708
    for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2709
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2710
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2711
        
2712
        s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
2713
        s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
2714
        s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
2715
        s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
2716
        s->block_index[4]= s->block_wrap[4]*(mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2);
2717
        s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
2718
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2719
            const int mb_type= s->mb_type[mb_y * s->mb_width + mb_x];
2720
            const int xy= (mb_y+1) * (s->mb_width+2) + mb_x + 1;
2721
//            int d;
2722
            int dmin=10000000;
2723

    
2724
            s->mb_x = mb_x;
2725
            s->mb_y = mb_y;
2726
            s->block_index[0]+=2;
2727
            s->block_index[1]+=2;
2728
            s->block_index[2]+=2;
2729
            s->block_index[3]+=2;
2730
            s->block_index[4]++;
2731
            s->block_index[5]++;
2732

    
2733
            /* write gob / video packet header  */
2734
            if(s->rtp_mode){
2735
                int current_packet_size, is_gob_start;
2736
                
2737
                current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
2738
                is_gob_start=0;
2739
                
2740
                if(s->codec_id==CODEC_ID_MPEG4){
2741
                    if(current_packet_size + s->mb_line_avgsize/s->mb_width >= s->rtp_payload_size
2742
                       && s->mb_y + s->mb_x>0){
2743

    
2744
                        if(s->partitioned_frame){
2745
                            ff_mpeg4_merge_partitions(s);
2746
                            ff_mpeg4_init_partitions(s);
2747
                        }
2748
                        ff_mpeg4_encode_video_packet_header(s);
2749

    
2750
                        if(s->flags&CODEC_FLAG_PASS1){
2751
                            int bits= get_bit_count(&s->pb);
2752
                            s->misc_bits+= bits - s->last_bits;
2753
                            s->last_bits= bits;
2754
                        }
2755
                        ff_mpeg4_clean_buffers(s);
2756
                        is_gob_start=1;
2757
                    }
2758
                }else{
2759
                    if(current_packet_size + s->mb_line_avgsize*s->gob_index >= s->rtp_payload_size
2760
                       && s->mb_x==0 && s->mb_y>0 && s->mb_y%s->gob_index==0){
2761
                       
2762
                        h263_encode_gob_header(s, mb_y);                       
2763
                        is_gob_start=1;
2764
                    }
2765
                }
2766

    
2767
                if(is_gob_start){
2768
                    s->ptr_lastgob = pbBufPtr(&s->pb);
2769
                    s->first_slice_line=1;
2770
                    s->resync_mb_x=mb_x;
2771
                    s->resync_mb_y=mb_y;
2772
                }
2773
            }
2774

    
2775
            if(  (s->resync_mb_x   == s->mb_x)
2776
               && s->resync_mb_y+1 == s->mb_y){
2777
                s->first_slice_line=0; 
2778
            }
2779

    
2780
            if(mb_type & (mb_type-1)){ // more than 1 MB type possible
2781
                int next_block=0;
2782
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2783

    
2784
                copy_context_before_encode(&backup_s, s, -1);
2785
                backup_s.pb= s->pb;
2786
                best_s.data_partitioning= s->data_partitioning;
2787
                best_s.partitioned_frame= s->partitioned_frame;
2788
                if(s->data_partitioning){
2789
                    backup_s.pb2= s->pb2;
2790
                    backup_s.tex_pb= s->tex_pb;
2791
                }
2792

    
2793
                if(mb_type&MB_TYPE_INTER){
2794
                    s->mv_dir = MV_DIR_FORWARD;
2795
                    s->mv_type = MV_TYPE_16X16;
2796
                    s->mb_intra= 0;
2797
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
2798
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
2799
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb, 
2800
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2801
                }
2802
                if(mb_type&MB_TYPE_INTER4V){                 
2803
                    s->mv_dir = MV_DIR_FORWARD;
2804
                    s->mv_type = MV_TYPE_8X8;
2805
                    s->mb_intra= 0;
2806
                    for(i=0; i<4; i++){
2807
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
2808
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
2809
                    }
2810
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb, 
2811
                                 &dmin, &next_block, 0, 0);
2812
                }
2813
                if(mb_type&MB_TYPE_FORWARD){
2814
                    s->mv_dir = MV_DIR_FORWARD;
2815
                    s->mv_type = MV_TYPE_16X16;
2816
                    s->mb_intra= 0;
2817
                    s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2818
                    s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2819
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb, 
2820
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2821
                }
2822
                if(mb_type&MB_TYPE_BACKWARD){
2823
                    s->mv_dir = MV_DIR_BACKWARD;
2824
                    s->mv_type = MV_TYPE_16X16;
2825
                    s->mb_intra= 0;
2826
                    s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2827
                    s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2828
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb, 
2829
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2830
                }
2831
                if(mb_type&MB_TYPE_BIDIR){
2832
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2833
                    s->mv_type = MV_TYPE_16X16;
2834
                    s->mb_intra= 0;
2835
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2836
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2837
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2838
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2839
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb, 
2840
                                 &dmin, &next_block, 0, 0);
2841
                }
2842
                if(mb_type&MB_TYPE_DIRECT){
2843
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2844
                    s->mv_type = MV_TYPE_16X16; //FIXME
2845
                    s->mb_intra= 0;
2846
                    s->mv[0][0][0] = s->b_direct_forw_mv_table[xy][0];
2847
                    s->mv[0][0][1] = s->b_direct_forw_mv_table[xy][1];
2848
                    s->mv[1][0][0] = s->b_direct_back_mv_table[xy][0];
2849
                    s->mv[1][0][1] = s->b_direct_back_mv_table[xy][1];
2850
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb, 
2851
                                 &dmin, &next_block, s->b_direct_mv_table[xy][0], s->b_direct_mv_table[xy][1]);
2852
                }
2853
                if(mb_type&MB_TYPE_INTRA){
2854
                    s->mv_dir = MV_DIR_FORWARD;
2855
                    s->mv_type = MV_TYPE_16X16;
2856
                    s->mb_intra= 1;
2857
                    s->mv[0][0][0] = 0;
2858
                    s->mv[0][0][1] = 0;
2859
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb, 
2860
                                 &dmin, &next_block, 0, 0);
2861
                    /* force cleaning of ac/dc pred stuff if needed ... */
2862
                    if(s->h263_pred || s->h263_aic)
2863
                        s->mbintra_table[mb_x + mb_y*s->mb_width]=1;
2864
                }
2865
                copy_context_after_encode(s, &best_s, -1);
2866
                
2867
                pb_bits_count= get_bit_count(&s->pb);
2868
                flush_put_bits(&s->pb);
2869
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2870
                s->pb= backup_s.pb;
2871
                
2872
                if(s->data_partitioning){
2873
                    pb2_bits_count= get_bit_count(&s->pb2);
2874
                    flush_put_bits(&s->pb2);
2875
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2876
                    s->pb2= backup_s.pb2;
2877
                    
2878
                    tex_pb_bits_count= get_bit_count(&s->tex_pb);
2879
                    flush_put_bits(&s->tex_pb);
2880
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2881
                    s->tex_pb= backup_s.tex_pb;
2882
                }
2883
                s->last_bits= get_bit_count(&s->pb);
2884
            } else {
2885
                int motion_x, motion_y;
2886
                s->mv_type=MV_TYPE_16X16;
2887
                // only one MB-Type possible
2888
                switch(mb_type){
2889
                case MB_TYPE_INTRA:
2890
                    s->mv_dir = MV_DIR_FORWARD;
2891
                    s->mb_intra= 1;
2892
                    motion_x= s->mv[0][0][0] = 0;
2893
                    motion_y= s->mv[0][0][1] = 0;
2894
                    break;
2895
                case MB_TYPE_INTER:
2896
                    s->mv_dir = MV_DIR_FORWARD;
2897
                    s->mb_intra= 0;
2898
                    motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2899
                    motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2900
                    break;
2901
                case MB_TYPE_INTER4V:
2902
                    s->mv_dir = MV_DIR_FORWARD;
2903
                    s->mv_type = MV_TYPE_8X8;
2904
                    s->mb_intra= 0;
2905
                    for(i=0; i<4; i++){
2906
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
2907
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
2908
                    }
2909
                    motion_x= motion_y= 0;
2910
                    break;
2911
                case MB_TYPE_DIRECT:
2912
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2913
                    s->mb_intra= 0;
2914
                    motion_x=s->b_direct_mv_table[xy][0];
2915
                    motion_y=s->b_direct_mv_table[xy][1];
2916
                    s->mv[0][0][0] = s->b_direct_forw_mv_table[xy][0];
2917
                    s->mv[0][0][1] = s->b_direct_forw_mv_table[xy][1];
2918
                    s->mv[1][0][0] = s->b_direct_back_mv_table[xy][0];
2919
                    s->mv[1][0][1] = s->b_direct_back_mv_table[xy][1];
2920
                    break;
2921
                case MB_TYPE_BIDIR:
2922
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2923
                    s->mb_intra= 0;
2924
                    motion_x=0;
2925
                    motion_y=0;
2926
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2927
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2928
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2929
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2930
                    break;
2931
                case MB_TYPE_BACKWARD:
2932
                    s->mv_dir = MV_DIR_BACKWARD;
2933
                    s->mb_intra= 0;
2934
                    motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2935
                    motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2936
                    break;
2937
                case MB_TYPE_FORWARD:
2938
                    s->mv_dir = MV_DIR_FORWARD;
2939
                    s->mb_intra= 0;
2940
                    motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2941
                    motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2942
//                    printf(" %d %d ", motion_x, motion_y);
2943
                    break;
2944
                default:
2945
                    motion_x=motion_y=0; //gcc warning fix
2946
                    printf("illegal MB type\n");
2947
                }
2948
                encode_mb(s, motion_x, motion_y);
2949
            }
2950
            /* clean the MV table in IPS frames for direct mode in B frames */
2951
            if(s->mb_intra /* && I,P,S_TYPE */){
2952
                s->p_mv_table[xy][0]=0;
2953
                s->p_mv_table[xy][1]=0;
2954
            }
2955

    
2956
            MPV_decode_mb(s, s->block);
2957
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_width, get_bit_count(&s->pb));
2958
        }
2959

    
2960

    
2961
        /* Obtain average mb_row size for RTP */
2962
        if (s->rtp_mode) {
2963
            if (mb_y==0)
2964
                s->mb_line_avgsize = pbBufPtr(&s->pb) - s->ptr_last_mb_line;
2965
            else {    
2966
                s->mb_line_avgsize = (s->mb_line_avgsize + pbBufPtr(&s->pb) - s->ptr_last_mb_line) >> 1;
2967
            }
2968
            s->ptr_last_mb_line = pbBufPtr(&s->pb);
2969
        }
2970
    }
2971
    emms_c();
2972

    
2973
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
2974
        ff_mpeg4_merge_partitions(s);
2975

    
2976
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
2977
        msmpeg4_encode_ext_header(s);
2978

    
2979
    if(s->codec_id==CODEC_ID_MPEG4) 
2980
        ff_mpeg4_stuffing(&s->pb);
2981

    
2982
    //if (s->gob_number)
2983
    //    fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
2984
    
2985
    /* Send the last GOB if RTP */    
2986
    if (s->rtp_mode) {
2987
        flush_put_bits(&s->pb);
2988
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
2989
        /* Call the RTP callback to send the last GOB */
2990
        if (s->rtp_callback)
2991
            s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
2992
        s->ptr_lastgob = pbBufPtr(&s->pb);
2993
        //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
2994
    }
2995
}
2996

    
2997
static int dct_quantize_c(MpegEncContext *s, 
2998
                        DCTELEM *block, int n,
2999
                        int qscale, int *overflow)
3000
{
3001
    int i, j, level, last_non_zero, q;
3002
    const int *qmat;
3003
    const UINT8 *scantable= s->intra_scantable.scantable;
3004
    int bias;
3005
    int max=0;
3006
    unsigned int threshold1, threshold2;
3007
    
3008
    s->fdct (block);
3009

    
3010
    if (s->mb_intra) {
3011
        if (!s->h263_aic) {
3012
            if (n < 4)
3013
                q = s->y_dc_scale;
3014
            else
3015
                q = s->c_dc_scale;
3016
            q = q << 3;
3017
        } else
3018
            /* For AIC we skip quant/dequant of INTRADC */
3019
            q = 1 << 3;
3020
            
3021
        /* note: block[0] is assumed to be positive */
3022
        block[0] = (block[0] + (q >> 1)) / q;
3023
        i = 1;
3024
        last_non_zero = 0;
3025
        qmat = s->q_intra_matrix[qscale];
3026
        bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
3027
    } else {
3028
        i = 0;
3029
        last_non_zero = -1;
3030
        qmat = s->q_inter_matrix[qscale];
3031
        bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
3032
    }
3033
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
3034
    threshold2= (threshold1<<1);
3035

    
3036
    for(;i<64;i++) {
3037
        j = scantable[i];
3038
        level = block[j];
3039
        level = level * qmat[j];
3040

    
3041
//        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
3042
//           || bias-level >= (1<<(QMAT_SHIFT - 3))){
3043
        if(((unsigned)(level+threshold1))>threshold2){
3044
            if(level>0){
3045
                level= (bias + level)>>QMAT_SHIFT;
3046
                block[j]= level;
3047
            }else{
3048
                level= (bias - level)>>QMAT_SHIFT;
3049
                block[j]= -level;
3050
            }
3051
            max |=level;
3052
            last_non_zero = i;
3053
        }else{
3054
            block[j]=0;
3055
        }
3056
    }
3057
    *overflow= s->max_qcoeff < max; //overflow might have happend
3058
    
3059
    /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
3060
    ff_block_permute(block, s->idct_permutation, scantable, last_non_zero);
3061

    
3062
    return last_non_zero;
3063
}
3064

    
3065
static void dct_unquantize_mpeg1_c(MpegEncContext *s, 
3066
                                   DCTELEM *block, int n, int qscale)
3067
{
3068
    int i, level, nCoeffs;
3069
    const UINT16 *quant_matrix;
3070

    
3071
    nCoeffs= s->block_last_index[n];
3072
    
3073
    if (s->mb_intra) {
3074
        if (n < 4) 
3075
            block[0] = block[0] * s->y_dc_scale;
3076
        else
3077
            block[0] = block[0] * s->c_dc_scale;
3078
        /* XXX: only mpeg1 */
3079
        quant_matrix = s->intra_matrix;
3080
        for(i=1;i<=nCoeffs;i++) {
3081
            int j= s->intra_scantable.permutated[i];
3082
            level = block[j];
3083
            if (level) {
3084
                if (level < 0) {
3085
                    level = -level;
3086
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3087
                    level = (level - 1) | 1;
3088
                    level = -level;
3089
                } else {
3090
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3091
                    level = (level - 1) | 1;
3092
                }
3093
#ifdef PARANOID
3094
                if (level < -2048 || level > 2047)
3095
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3096
#endif
3097
                block[j] = level;
3098
            }
3099
        }
3100
    } else {
3101
        i = 0;
3102
        quant_matrix = s->inter_matrix;
3103
        for(;i<=nCoeffs;i++) {
3104
            int j= s->intra_scantable.permutated[i];
3105
            level = block[j];
3106
            if (level) {
3107
                if (level < 0) {
3108
                    level = -level;
3109
                    level = (((level << 1) + 1) * qscale *
3110
                             ((int) (quant_matrix[j]))) >> 4;
3111
                    level = (level - 1) | 1;
3112
                    level = -level;
3113
                } else {
3114
                    level = (((level << 1) + 1) * qscale *
3115
                             ((int) (quant_matrix[j]))) >> 4;
3116
                    level = (level - 1) | 1;
3117
                }
3118
#ifdef PARANOID
3119
                if (level < -2048 || level > 2047)
3120
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3121
#endif
3122
                block[j] = level;
3123
            }
3124
        }
3125
    }
3126
}
3127

    
3128
static void dct_unquantize_mpeg2_c(MpegEncContext *s, 
3129
                                   DCTELEM *block, int n, int qscale)
3130
{
3131
    int i, level, nCoeffs;
3132
    const UINT16 *quant_matrix;
3133

    
3134
    if(s->alternate_scan) nCoeffs= 63;
3135
    else nCoeffs= s->block_last_index[n];
3136
    
3137
    if (s->mb_intra) {
3138
        if (n < 4) 
3139
            block[0] = block[0] * s->y_dc_scale;
3140
        else
3141
            block[0] = block[0] * s->c_dc_scale;
3142
        quant_matrix = s->intra_matrix;
3143
        for(i=1;i<=nCoeffs;i++) {
3144
            int j= s->intra_scantable.permutated[i];
3145
            level = block[j];
3146
            if (level) {
3147
                if (level < 0) {
3148
                    level = -level;
3149
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3150
                    level = -level;
3151
                } else {
3152
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
3153
                }
3154
#ifdef PARANOID
3155
                if (level < -2048 || level > 2047)
3156
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3157
#endif
3158
                block[j] = level;
3159
            }
3160
        }
3161
    } else {
3162
        int sum=-1;
3163
        i = 0;
3164
        quant_matrix = s->inter_matrix;
3165
        for(;i<=nCoeffs;i++) {
3166
            int j= s->intra_scantable.permutated[i];
3167
            level = block[j];
3168
            if (level) {
3169
                if (level < 0) {
3170
                    level = -level;
3171
                    level = (((level << 1) + 1) * qscale *
3172
                             ((int) (quant_matrix[j]))) >> 4;
3173
                    level = -level;
3174
                } else {
3175
                    level = (((level << 1) + 1) * qscale *
3176
                             ((int) (quant_matrix[j]))) >> 4;
3177
                }
3178
#ifdef PARANOID
3179
                if (level < -2048 || level > 2047)
3180
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3181
#endif
3182
                block[j] = level;
3183
                sum+=level;
3184
            }
3185
        }
3186
        block[63]^=sum&1;
3187
    }
3188
}
3189

    
3190

    
3191
static void dct_unquantize_h263_c(MpegEncContext *s, 
3192
                                  DCTELEM *block, int n, int qscale)
3193
{
3194
    int i, level, qmul, qadd;
3195
    int nCoeffs;
3196
    
3197
    assert(s->block_last_index[n]>=0);
3198
    
3199
    qadd = (qscale - 1) | 1;
3200
    qmul = qscale << 1;
3201
    
3202
    if (s->mb_intra) {
3203
        if (!s->h263_aic) {
3204
            if (n < 4) 
3205
                block[0] = block[0] * s->y_dc_scale;
3206
            else
3207
                block[0] = block[0] * s->c_dc_scale;
3208
        }else
3209
            qadd = 0;
3210
        i = 1;
3211
        nCoeffs= 63; //does not allways use zigzag table 
3212
    } else {
3213
        i = 0;
3214
        nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ];
3215
    }
3216

    
3217
    for(;i<=nCoeffs;i++) {
3218
        level = block[i];
3219
        if (level) {
3220
            if (level < 0) {
3221
                level = level * qmul - qadd;
3222
            } else {
3223
                level = level * qmul + qadd;
3224
            }
3225
#ifdef PARANOID
3226
                if (level < -2048 || level > 2047)
3227
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3228
#endif
3229
            block[i] = level;
3230
        }
3231
    }
3232
}
3233

    
3234
AVCodec mpeg1video_encoder = {
3235
    "mpeg1video",
3236
    CODEC_TYPE_VIDEO,
3237
    CODEC_ID_MPEG1VIDEO,
3238
    sizeof(MpegEncContext),
3239
    MPV_encode_init,
3240
    MPV_encode_picture,
3241
    MPV_encode_end,
3242
};
3243

    
3244
AVCodec h263_encoder = {
3245
    "h263",
3246
    CODEC_TYPE_VIDEO,
3247
    CODEC_ID_H263,
3248
    sizeof(MpegEncContext),
3249
    MPV_encode_init,
3250
    MPV_encode_picture,
3251
    MPV_encode_end,
3252
};
3253

    
3254
AVCodec h263p_encoder = {
3255
    "h263p",
3256
    CODEC_TYPE_VIDEO,
3257
    CODEC_ID_H263P,
3258
    sizeof(MpegEncContext),
3259
    MPV_encode_init,
3260
    MPV_encode_picture,
3261
    MPV_encode_end,
3262
};
3263

    
3264
AVCodec rv10_encoder = {
3265
    "rv10",
3266
    CODEC_TYPE_VIDEO,
3267
    CODEC_ID_RV10,
3268
    sizeof(MpegEncContext),
3269
    MPV_encode_init,
3270
    MPV_encode_picture,
3271
    MPV_encode_end,
3272
};
3273

    
3274
AVCodec mjpeg_encoder = {
3275
    "mjpeg",
3276
    CODEC_TYPE_VIDEO,
3277
    CODEC_ID_MJPEG,
3278
    sizeof(MpegEncContext),
3279
    MPV_encode_init,
3280
    MPV_encode_picture,
3281
    MPV_encode_end,
3282
};
3283

    
3284
AVCodec mpeg4_encoder = {
3285
    "mpeg4",
3286
    CODEC_TYPE_VIDEO,
3287
    CODEC_ID_MPEG4,
3288
    sizeof(MpegEncContext),
3289
    MPV_encode_init,
3290
    MPV_encode_picture,
3291
    MPV_encode_end,
3292
};
3293

    
3294
AVCodec msmpeg4v1_encoder = {
3295
    "msmpeg4v1",
3296
    CODEC_TYPE_VIDEO,
3297
    CODEC_ID_MSMPEG4V1,
3298
    sizeof(MpegEncContext),
3299
    MPV_encode_init,
3300
    MPV_encode_picture,
3301
    MPV_encode_end,
3302
};
3303

    
3304
AVCodec msmpeg4v2_encoder = {
3305
    "msmpeg4v2",
3306
    CODEC_TYPE_VIDEO,
3307
    CODEC_ID_MSMPEG4V2,
3308
    sizeof(MpegEncContext),
3309
    MPV_encode_init,
3310
    MPV_encode_picture,
3311
    MPV_encode_end,
3312
};
3313

    
3314
AVCodec msmpeg4v3_encoder = {
3315
    "msmpeg4",
3316
    CODEC_TYPE_VIDEO,
3317
    CODEC_ID_MSMPEG4V3,
3318
    sizeof(MpegEncContext),
3319
    MPV_encode_init,
3320
    MPV_encode_picture,
3321
    MPV_encode_end,
3322
};
3323

    
3324
AVCodec wmv1_encoder = {
3325
    "wmv1",
3326
    CODEC_TYPE_VIDEO,
3327
    CODEC_ID_WMV1,
3328
    sizeof(MpegEncContext),
3329
    MPV_encode_init,
3330
    MPV_encode_picture,
3331
    MPV_encode_end,
3332
};
3333

    
3334
AVCodec wmv2_encoder = {
3335
    "wmv2",
3336
    CODEC_TYPE_VIDEO,
3337
    CODEC_ID_WMV2,
3338
    sizeof(MpegEncContext),
3339
    MPV_encode_init,
3340
    MPV_encode_picture,
3341
    MPV_encode_end,
3342
};