Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ b846b231

History | View | Annotate | Download (185 KB)

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

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

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

    
40
#ifdef CONFIG_ENCODERS
41
static void encode_picture(MpegEncContext *s, int picture_number);
42
#endif //CONFIG_ENCODERS
43
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s, 
44
                                   DCTELEM *block, int n, int qscale);
45
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, 
46
                                   DCTELEM *block, int n, int qscale);
47
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
48
                                   DCTELEM *block, int n, int qscale);
49
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
50
                                   DCTELEM *block, int n, int qscale);
51
static void dct_unquantize_h263_intra_c(MpegEncContext *s, 
52
                                  DCTELEM *block, int n, int qscale);
53
static void dct_unquantize_h263_inter_c(MpegEncContext *s, 
54
                                  DCTELEM *block, int n, int qscale);
55
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
56
#ifdef CONFIG_ENCODERS
57
static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
58
static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
59
static int sse_mb(MpegEncContext *s);
60
#endif //CONFIG_ENCODERS
61

    
62
#ifdef HAVE_XVMC
63
extern int  XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
64
extern void XVMC_field_end(MpegEncContext *s);
65
extern void XVMC_decode_mb(MpegEncContext *s);
66
#endif
67

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

    
70

    
71
/* enable all paranoid tests for rounding, overflows, etc... */
72
//#define PARANOID
73

    
74
//#define DEBUG
75

    
76

    
77
/* for jpeg fast DCT */
78
#define CONST_BITS 14
79

    
80
static const uint16_t aanscales[64] = {
81
    /* precomputed values scaled up by 14 bits */
82
    16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
83
    22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
84
    21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
85
    19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
86
    16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
87
    12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
88
    8867 , 12299, 11585, 10426,  8867,  6967,  4799,  2446,
89
    4520 ,  6270,  5906,  5315,  4520,  3552,  2446,  1247
90
};
91

    
92
static const uint8_t h263_chroma_roundtab[16] = {
93
//  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
94
    0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
95
};
96

    
97
static const uint8_t ff_default_chroma_qscale_table[32]={
98
//  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
99
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
100
};
101

    
102
#ifdef CONFIG_ENCODERS
103
static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
104
static uint8_t default_fcode_tab[MAX_MV*2+1];
105

    
106
enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
107

    
108
static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
109
                           const uint16_t *quant_matrix, int bias, int qmin, int qmax)
110
{
111
    int qscale;
112

    
113
    for(qscale=qmin; qscale<=qmax; qscale++){
114
        int i;
115
        if (dsp->fdct == ff_jpeg_fdct_islow 
116
#ifdef FAAN_POSTSCALE
117
            || dsp->fdct == ff_faandct
118
#endif
119
            ) {
120
            for(i=0;i<64;i++) {
121
                const int j= dsp->idct_permutation[i];
122
                /* 16 <= qscale * quant_matrix[i] <= 7905 */
123
                /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
124
                /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
125
                /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
126
                
127
                qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / 
128
                                (qscale * quant_matrix[j]));
129
            }
130
        } else if (dsp->fdct == fdct_ifast
131
#ifndef FAAN_POSTSCALE
132
                   || dsp->fdct == ff_faandct
133
#endif
134
                   ) {
135
            for(i=0;i<64;i++) {
136
                const int j= dsp->idct_permutation[i];
137
                /* 16 <= qscale * quant_matrix[i] <= 7905 */
138
                /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
139
                /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
140
                /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
141
                
142
                qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) / 
143
                                (aanscales[i] * qscale * quant_matrix[j]));
144
            }
145
        } else {
146
            for(i=0;i<64;i++) {
147
                const int j= dsp->idct_permutation[i];
148
                /* We can safely suppose that 16 <= quant_matrix[i] <= 255
149
                   So 16           <= qscale * quant_matrix[i]             <= 7905
150
                   so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
151
                   so 32768        >= (1<<19) / (qscale * quant_matrix[i]) >= 67
152
                */
153
                qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
154
//                qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
155
                qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
156

    
157
                if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
158
                qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
159
            }
160
        }
161
    }
162
}
163

    
164
static inline void update_qscale(MpegEncContext *s){
165
    s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
166
    s->qscale= clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
167
    
168
    s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
169
}
170
#endif //CONFIG_ENCODERS
171

    
172
void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
173
    int i;
174
    int end;
175
    
176
    st->scantable= src_scantable;
177

    
178
    for(i=0; i<64; i++){
179
        int j;
180
        j = src_scantable[i];
181
        st->permutated[i] = permutation[j];
182
#ifdef ARCH_POWERPC
183
        st->inverse[j] = i;
184
#endif
185
    }
186
    
187
    end=-1;
188
    for(i=0; i<64; i++){
189
        int j;
190
        j = st->permutated[i];
191
        if(j>end) end=j;
192
        st->raster_end[i]= end;
193
    }
194
}
195

    
196
#ifdef CONFIG_ENCODERS
197
void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
198
    int i;
199

    
200
    if(matrix){
201
        put_bits(pb, 1, 1);
202
        for(i=0;i<64;i++) {
203
            put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
204
        }
205
    }else
206
        put_bits(pb, 1, 0);
207
}
208
#endif //CONFIG_ENCODERS
209

    
210
/* init common dct for both encoder and decoder */
211
int DCT_common_init(MpegEncContext *s)
212
{
213
    s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
214
    s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
215
    s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
216
    s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
217
    s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
218
    s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
219

    
220
#ifdef CONFIG_ENCODERS
221
    s->dct_quantize= dct_quantize_c;
222
#endif
223
        
224
#ifdef HAVE_MMX
225
    MPV_common_init_mmx(s);
226
#endif
227
#ifdef ARCH_ALPHA
228
    MPV_common_init_axp(s);
229
#endif
230
#ifdef HAVE_MLIB
231
    MPV_common_init_mlib(s);
232
#endif
233
#ifdef HAVE_MMI
234
    MPV_common_init_mmi(s);
235
#endif
236
#ifdef ARCH_ARMV4L
237
    MPV_common_init_armv4l(s);
238
#endif
239
#ifdef ARCH_POWERPC
240
    MPV_common_init_ppc(s);
241
#endif
242

    
243
#ifdef CONFIG_ENCODERS
244
    s->fast_dct_quantize= s->dct_quantize;
245

    
246
    if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
247
        s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
248
    }
249

    
250
#endif //CONFIG_ENCODERS
251

    
252
    /* load & permutate scantables
253
       note: only wmv uses differnt ones 
254
    */
255
    ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
256
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
257
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
258
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
259

    
260
    s->picture_structure= PICT_FRAME;
261
    
262
    return 0;
263
}
264

    
265
static void copy_picture(Picture *dst, Picture *src){
266
    *dst = *src;
267
    dst->type= FF_BUFFER_TYPE_COPY;
268
}
269

    
270
static void copy_picture_attributes(AVFrame *dst, AVFrame *src){
271
    dst->pict_type              = src->pict_type;
272
    dst->quality                = src->quality;
273
    dst->coded_picture_number   = src->coded_picture_number;
274
    dst->display_picture_number = src->display_picture_number;
275
//    dst->reference              = src->reference;
276
    dst->pts                    = src->pts;
277
    dst->interlaced_frame       = src->interlaced_frame;
278
    dst->top_field_first        = src->top_field_first;
279
}
280

    
281
/**
282
 * allocates a Picture
283
 * The pixels are allocated/set by calling get_buffer() if shared=0
284
 */
285
static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
286
    const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
287
    const int mb_array_size= s->mb_stride*s->mb_height;
288
    const int b8_array_size= s->b8_stride*s->mb_height*2;
289
    const int b4_array_size= s->b4_stride*s->mb_height*4;
290
    int i;
291
    
292
    if(shared){
293
        assert(pic->data[0]);
294
        assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
295
        pic->type= FF_BUFFER_TYPE_SHARED;
296
    }else{
297
        int r;
298
        
299
        assert(!pic->data[0]);
300
        
301
        r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
302
        
303
        if(r<0 || !pic->age || !pic->type || !pic->data[0]){
304
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
305
            return -1;
306
        }
307

    
308
        if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
309
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
310
            return -1;
311
        }
312

    
313
        if(pic->linesize[1] != pic->linesize[2]){
314
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride missmatch)\n");
315
            return -1;
316
        }
317

    
318
        s->linesize  = pic->linesize[0];
319
        s->uvlinesize= pic->linesize[1];
320
    }
321
    
322
    if(pic->qscale_table==NULL){
323
        if (s->encoding) {        
324
            CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
325
            CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
326
            CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
327
        }
328

    
329
        CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
330
        CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
331
        CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num    * sizeof(int))
332
        pic->mb_type= pic->mb_type_base + s->mb_stride+1;
333
        if(s->out_format == FMT_H264){
334
            for(i=0; i<2; i++){
335
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+1)  * sizeof(uint16_t))
336
                pic->motion_val[i]= pic->motion_val_base[i]+1;
337
                CHECKED_ALLOCZ(pic->ref_index[i] , b8_array_size * sizeof(uint8_t))
338
            }
339
            pic->motion_subsample_log2= 2;
340
        }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
341
            for(i=0; i<2; i++){
342
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+1) * sizeof(uint16_t)*2) //FIXME
343
                pic->motion_val[i]= pic->motion_val_base[i]+1;
344
            }
345
            pic->motion_subsample_log2= 3;
346
        }
347
        pic->qstride= s->mb_stride;
348
        CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
349
    }
350

    
351
    //it might be nicer if the application would keep track of these but it would require a API change
352
    memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
353
    s->prev_pict_types[0]= s->pict_type;
354
    if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
355
        pic->age= INT_MAX; // skiped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
356
    
357
    return 0;
358
fail: //for the CHECKED_ALLOCZ macro
359
    return -1;
360
}
361

    
362
/**
363
 * deallocates a picture
364
 */
365
static void free_picture(MpegEncContext *s, Picture *pic){
366
    int i;
367

    
368
    if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
369
        s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
370
    }
371

    
372
    av_freep(&pic->mb_var);
373
    av_freep(&pic->mc_mb_var);
374
    av_freep(&pic->mb_mean);
375
    av_freep(&pic->mbskip_table);
376
    av_freep(&pic->qscale_table);
377
    av_freep(&pic->mb_type_base);
378
    av_freep(&pic->pan_scan);
379
    pic->mb_type= NULL;
380
    for(i=0; i<2; i++){
381
        av_freep(&pic->motion_val_base[i]);
382
        av_freep(&pic->ref_index[i]);
383
    }
384
    
385
    if(pic->type == FF_BUFFER_TYPE_SHARED){
386
        for(i=0; i<4; i++){
387
            pic->base[i]=
388
            pic->data[i]= NULL;
389
        }
390
        pic->type= 0;        
391
    }
392
}
393

    
394
/* init common structure for both encoder and decoder */
395
int MPV_common_init(MpegEncContext *s)
396
{
397
    int y_size, c_size, yc_size, i, mb_array_size, x, y;
398

    
399
    dsputil_init(&s->dsp, s->avctx);
400
    DCT_common_init(s);
401

    
402
    s->flags= s->avctx->flags;
403

    
404
    s->mb_width  = (s->width  + 15) / 16;
405
    s->mb_height = (s->height + 15) / 16;
406
    s->mb_stride = s->mb_width + 1;
407
    s->b8_stride = s->mb_width*2 + 1;
408
    s->b4_stride = s->mb_width*4 + 1;
409
    mb_array_size= s->mb_height * s->mb_stride;
410

    
411
    /* set default edge pos, will be overriden in decode_header if needed */
412
    s->h_edge_pos= s->mb_width*16;
413
    s->v_edge_pos= s->mb_height*16;
414

    
415
    s->mb_num = s->mb_width * s->mb_height;
416
    
417
    s->block_wrap[0]=
418
    s->block_wrap[1]=
419
    s->block_wrap[2]=
420
    s->block_wrap[3]= s->mb_width*2 + 2;
421
    s->block_wrap[4]=
422
    s->block_wrap[5]= s->mb_width + 2;
423

    
424
    s->y_dc_scale_table=
425
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
426
    s->chroma_qscale_table= ff_default_chroma_qscale_table;
427
    if (!s->encoding)
428
        s->progressive_sequence= 1;
429
    s->progressive_frame= 1;
430
    s->coded_picture_number = 0;
431

    
432
    y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
433
    c_size = (s->mb_width + 2) * (s->mb_height + 2);
434
    yc_size = y_size + 2 * c_size;
435

    
436
    /* convert fourcc to upper case */
437
    s->avctx->codec_tag=   toupper( s->avctx->codec_tag     &0xFF)          
438
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
439
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16) 
440
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
441

    
442
    s->avctx->stream_codec_tag=   toupper( s->avctx->stream_codec_tag     &0xFF)          
443
                               + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
444
                               + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16) 
445
                               + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
446

    
447
    CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
448
    s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
449

    
450
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
451

    
452
    CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
453
    for(y=0; y<s->mb_height; y++){
454
        for(x=0; x<s->mb_width; x++){
455
            s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
456
        }
457
    }
458
    s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
459
    
460
    if (s->encoding) {
461
        int mv_table_size= s->mb_stride * (s->mb_height+2) + 1;
462

    
463
        /* Allocate MV tables */
464
        CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
465
        CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
466
        CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
467
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
468
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
469
        CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
470
        s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
471
        s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
472
        s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
473
        s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
474
        s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
475
        s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
476

    
477
        //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
478
        CHECKED_ALLOCZ(s->me.scratchpad,  s->width*2*16*3*sizeof(uint8_t)) 
479
        
480
        CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
481
        CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
482

    
483
        if(s->codec_id==CODEC_ID_MPEG4){
484
            CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
485
            CHECKED_ALLOCZ(   s->pb2_buffer, PB_BUFFER_SIZE);
486
        }
487
        
488
        if(s->msmpeg4_version){
489
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
490
        }
491
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
492

    
493
        /* Allocate MB type table */
494
        CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint8_t)) //needed for encoding
495
        
496
        CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
497
        
498
        CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
499
        CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
500
        CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
501
        CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
502
        CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
503
        CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
504
        
505
        if(s->avctx->noise_reduction){
506
            CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
507
            CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
508
        }
509
    }
510
    CHECKED_ALLOCZ(s->blocks, 64*6*2 * sizeof(DCTELEM))
511
        
512
    CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
513

    
514
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
515
    
516
    if(s->codec_id==CODEC_ID_MPEG4){
517
        /* interlaced direct mode decoding tables */
518
        CHECKED_ALLOCZ(s->field_mv_table, mb_array_size*2*2 * sizeof(int16_t))
519
        CHECKED_ALLOCZ(s->field_select_table, mb_array_size*2* sizeof(int8_t))
520
    }
521
    if (s->out_format == FMT_H263) {
522
        /* ac values */
523
        CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(int16_t) * 16);
524
        s->ac_val[1] = s->ac_val[0] + y_size;
525
        s->ac_val[2] = s->ac_val[1] + c_size;
526
        
527
        /* cbp values */
528
        CHECKED_ALLOCZ(s->coded_block, y_size);
529
        
530
        /* divx501 bitstream reorder buffer */
531
        CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
532

    
533
        /* cbp, ac_pred, pred_dir */
534
        CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
535
        CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
536
    }
537
    
538
    if (s->h263_pred || s->h263_plus || !s->encoding) {
539
        /* dc values */
540
        //MN: we need these for error resilience of intra-frames
541
        CHECKED_ALLOCZ(s->dc_val[0], yc_size * sizeof(int16_t));
542
        s->dc_val[1] = s->dc_val[0] + y_size;
543
        s->dc_val[2] = s->dc_val[1] + c_size;
544
        for(i=0;i<yc_size;i++)
545
            s->dc_val[0][i] = 1024;
546
    }
547

    
548
    /* which mb is a intra block */
549
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
550
    memset(s->mbintra_table, 1, mb_array_size);
551
    
552
    /* default structure is frame */
553
    s->picture_structure = PICT_FRAME;
554
    
555
    /* init macroblock skip table */
556
    CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
557
    //Note the +1 is for a quicker mpeg4 slice_end detection
558
    CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
559
    
560
    s->block= s->blocks[0];
561

    
562
    for(i=0;i<12;i++){
563
        s->pblocks[i] = (short *)(&s->block[i]);
564
    }
565

    
566
    s->parse_context.state= -1;
567
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
568
       s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
569
       s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
570
       s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
571
    }
572

    
573
    s->context_initialized = 1;
574
    return 0;
575
 fail:
576
    MPV_common_end(s);
577
    return -1;
578
}
579

    
580

    
581
//extern int sads;
582

    
583
/* init common structure for both encoder and decoder */
584
void MPV_common_end(MpegEncContext *s)
585
{
586
    int i;
587

    
588
    av_freep(&s->parse_context.buffer);
589
    s->parse_context.buffer_size=0;
590

    
591
    av_freep(&s->mb_type);
592
    av_freep(&s->p_mv_table_base);
593
    av_freep(&s->b_forw_mv_table_base);
594
    av_freep(&s->b_back_mv_table_base);
595
    av_freep(&s->b_bidir_forw_mv_table_base);
596
    av_freep(&s->b_bidir_back_mv_table_base);
597
    av_freep(&s->b_direct_mv_table_base);
598
    s->p_mv_table= NULL;
599
    s->b_forw_mv_table= NULL;
600
    s->b_back_mv_table= NULL;
601
    s->b_bidir_forw_mv_table= NULL;
602
    s->b_bidir_back_mv_table= NULL;
603
    s->b_direct_mv_table= NULL;
604
    
605
    av_freep(&s->dc_val[0]);
606
    av_freep(&s->ac_val[0]);
607
    av_freep(&s->coded_block);
608
    av_freep(&s->mbintra_table);
609
    av_freep(&s->cbp_table);
610
    av_freep(&s->pred_dir_table);
611
    av_freep(&s->me.scratchpad);
612
    av_freep(&s->me.map);
613
    av_freep(&s->me.score_map);
614
    
615
    av_freep(&s->mbskip_table);
616
    av_freep(&s->prev_pict_types);
617
    av_freep(&s->bitstream_buffer);
618
    av_freep(&s->tex_pb_buffer);
619
    av_freep(&s->pb2_buffer);
620
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
621
    av_freep(&s->field_mv_table);
622
    av_freep(&s->field_select_table);
623
    av_freep(&s->avctx->stats_out);
624
    av_freep(&s->ac_stats);
625
    av_freep(&s->error_status_table);
626
    av_freep(&s->mb_index2xy);
627
    av_freep(&s->lambda_table);
628
    av_freep(&s->q_intra_matrix);
629
    av_freep(&s->q_inter_matrix);
630
    av_freep(&s->q_intra_matrix16);
631
    av_freep(&s->q_inter_matrix16);
632
    av_freep(&s->blocks);
633
    av_freep(&s->input_picture);
634
    av_freep(&s->reordered_input_picture);
635
    av_freep(&s->dct_error_sum);
636
    av_freep(&s->dct_offset);
637

    
638
    if(s->picture){
639
        for(i=0; i<MAX_PICTURE_COUNT; i++){
640
            free_picture(s, &s->picture[i]);
641
        }
642
    }
643
    av_freep(&s->picture);
644
    avcodec_default_free_buffers(s->avctx);
645
    s->context_initialized = 0;
646
    s->last_picture_ptr=
647
    s->next_picture_ptr=
648
    s->current_picture_ptr= NULL;
649
    for(i=0; i<3; i++)
650
        if (s->visualization_buffer[i])
651
            av_free(s->visualization_buffer[i]);
652
}
653

    
654
#ifdef CONFIG_ENCODERS
655

    
656
/* init video encoder */
657
int MPV_encode_init(AVCodecContext *avctx)
658
{
659
    MpegEncContext *s = avctx->priv_data;
660
    int i, dummy;
661
    int chroma_h_shift, chroma_v_shift;
662

    
663
    avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME
664

    
665
    s->bit_rate = avctx->bit_rate;
666
    s->width = avctx->width;
667
    s->height = avctx->height;
668
    if(avctx->gop_size > 600){
669
        av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
670
        avctx->gop_size=600;
671
    }
672
    s->gop_size = avctx->gop_size;
673
    s->avctx = avctx;
674
    s->flags= avctx->flags;
675
    s->max_b_frames= avctx->max_b_frames;
676
    s->codec_id= avctx->codec->id;
677
    s->luma_elim_threshold  = avctx->luma_elim_threshold;
678
    s->chroma_elim_threshold= avctx->chroma_elim_threshold;
679
    s->strict_std_compliance= avctx->strict_std_compliance;
680
    s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
681
    s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
682
    s->mpeg_quant= avctx->mpeg_quant;
683
    s->rtp_mode= !!avctx->rtp_payload_size;
684

    
685
    if (s->gop_size <= 1) {
686
        s->intra_only = 1;
687
        s->gop_size = 12;
688
    } else {
689
        s->intra_only = 0;
690
    }
691

    
692
    s->me_method = avctx->me_method;
693

    
694
    /* Fixed QSCALE */
695
    s->fixed_qscale = (avctx->flags & CODEC_FLAG_QSCALE);
696
    
697
    s->adaptive_quant= (   s->avctx->lumi_masking
698
                        || s->avctx->dark_masking
699
                        || s->avctx->temporal_cplx_masking 
700
                        || s->avctx->spatial_cplx_masking
701
                        || s->avctx->p_masking
702
                        || (s->flags&CODEC_FLAG_QP_RD))
703
                       && !s->fixed_qscale;
704
    
705
    s->obmc= (s->flags & CODEC_FLAG_OBMC);
706
    s->loop_filter= (s->flags & CODEC_FLAG_LOOP_FILTER);
707

    
708
    if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 
709
       && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
710
        av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
711
        return -1;
712
    }
713
    
714
    if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
715
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decission\n");
716
        return -1;
717
    }
718
    
719
    if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
720
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
721
        return -1;
722
    }
723
    
724
    if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
725
        av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
726
        return -1;
727
    }
728

    
729
    if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
730
        av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
731
        return -1;
732
    }
733
    
734
    if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
735
        av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
736
        return -1;
737
    }
738
    
739
    if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
740
        av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n");
741
        return -1;
742
    }
743
        
744
    if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
745
        av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
746
        return -1;
747
    }
748

    
749
    if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
750
        av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
751
        return -1;
752
    }
753
    
754
    if(s->codec_id==CODEC_ID_MJPEG){
755
        s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
756
        s->inter_quant_bias= 0;
757
    }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
758
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
759
        s->inter_quant_bias= 0;
760
    }else{
761
        s->intra_quant_bias=0;
762
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
763
    }
764
    
765
    if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
766
        s->intra_quant_bias= avctx->intra_quant_bias;
767
    if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
768
        s->inter_quant_bias= avctx->inter_quant_bias;
769
        
770
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
771

    
772
    av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
773
    s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
774

    
775
    switch(avctx->codec->id) {
776
    case CODEC_ID_MPEG1VIDEO:
777
        s->out_format = FMT_MPEG1;
778
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
779
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
780
        break;
781
    case CODEC_ID_MPEG2VIDEO:
782
        s->out_format = FMT_MPEG1;
783
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
784
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
785
        s->rtp_mode= 1;
786
        break;
787
    case CODEC_ID_LJPEG:
788
    case CODEC_ID_MJPEG:
789
        s->out_format = FMT_MJPEG;
790
        s->intra_only = 1; /* force intra only for jpeg */
791
        s->mjpeg_write_tables = 1; /* write all tables */
792
        s->mjpeg_data_only_frames = 0; /* write all the needed headers */
793
        s->mjpeg_vsample[0] = 1<<chroma_v_shift;
794
        s->mjpeg_vsample[1] = 1;
795
        s->mjpeg_vsample[2] = 1; 
796
        s->mjpeg_hsample[0] = 1<<chroma_h_shift;
797
        s->mjpeg_hsample[1] = 1; 
798
        s->mjpeg_hsample[2] = 1; 
799
        if (mjpeg_init(s) < 0)
800
            return -1;
801
        avctx->delay=0;
802
        s->low_delay=1;
803
        break;
804
#ifdef CONFIG_RISKY
805
    case CODEC_ID_H263:
806
        if (h263_get_picture_format(s->width, s->height) == 7) {
807
            av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
808
            return -1;
809
        }
810
        s->out_format = FMT_H263;
811
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
812
        avctx->delay=0;
813
        s->low_delay=1;
814
        break;
815
    case CODEC_ID_H263P:
816
        s->out_format = FMT_H263;
817
        s->h263_plus = 1;
818
        /* Fx */
819
        s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
820
        s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
821
        s->modified_quant= s->h263_aic;
822
        s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
823
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
824
        s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
825
        s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
826
        s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
827

    
828
        /* /Fx */
829
        /* These are just to be sure */
830
        avctx->delay=0;
831
        s->low_delay=1;
832
        break;
833
    case CODEC_ID_FLV1:
834
        s->out_format = FMT_H263;
835
        s->h263_flv = 2; /* format = 1; 11-bit codes */
836
        s->unrestricted_mv = 1;
837
        s->rtp_mode=0; /* don't allow GOB */
838
        avctx->delay=0;
839
        s->low_delay=1;
840
        break;
841
    case CODEC_ID_RV10:
842
        s->out_format = FMT_H263;
843
        avctx->delay=0;
844
        s->low_delay=1;
845
        break;
846
    case CODEC_ID_MPEG4:
847
        s->out_format = FMT_H263;
848
        s->h263_pred = 1;
849
        s->unrestricted_mv = 1;
850
        s->low_delay= s->max_b_frames ? 0 : 1;
851
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
852
        break;
853
    case CODEC_ID_MSMPEG4V1:
854
        s->out_format = FMT_H263;
855
        s->h263_msmpeg4 = 1;
856
        s->h263_pred = 1;
857
        s->unrestricted_mv = 1;
858
        s->msmpeg4_version= 1;
859
        avctx->delay=0;
860
        s->low_delay=1;
861
        break;
862
    case CODEC_ID_MSMPEG4V2:
863
        s->out_format = FMT_H263;
864
        s->h263_msmpeg4 = 1;
865
        s->h263_pred = 1;
866
        s->unrestricted_mv = 1;
867
        s->msmpeg4_version= 2;
868
        avctx->delay=0;
869
        s->low_delay=1;
870
        break;
871
    case CODEC_ID_MSMPEG4V3:
872
        s->out_format = FMT_H263;
873
        s->h263_msmpeg4 = 1;
874
        s->h263_pred = 1;
875
        s->unrestricted_mv = 1;
876
        s->msmpeg4_version= 3;
877
        s->flipflop_rounding=1;
878
        avctx->delay=0;
879
        s->low_delay=1;
880
        break;
881
    case CODEC_ID_WMV1:
882
        s->out_format = FMT_H263;
883
        s->h263_msmpeg4 = 1;
884
        s->h263_pred = 1;
885
        s->unrestricted_mv = 1;
886
        s->msmpeg4_version= 4;
887
        s->flipflop_rounding=1;
888
        avctx->delay=0;
889
        s->low_delay=1;
890
        break;
891
    case CODEC_ID_WMV2:
892
        s->out_format = FMT_H263;
893
        s->h263_msmpeg4 = 1;
894
        s->h263_pred = 1;
895
        s->unrestricted_mv = 1;
896
        s->msmpeg4_version= 5;
897
        s->flipflop_rounding=1;
898
        avctx->delay=0;
899
        s->low_delay=1;
900
        break;
901
#endif
902
    default:
903
        return -1;
904
    }
905
    
906
    { /* set up some save defaults, some codecs might override them later */
907
        static int done=0;
908
        if(!done){
909
            int i;
910
            done=1;
911

    
912
            default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
913
            memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
914
            memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
915

    
916
            for(i=-16; i<16; i++){
917
                default_fcode_tab[i + MAX_MV]= 1;
918
            }
919
        }
920
    }
921
    s->me.mv_penalty= default_mv_penalty;
922
    s->fcode_tab= default_fcode_tab;
923
 
924
    /* dont use mv_penalty table for crap MV as it would be confused */
925
    //FIXME remove after fixing / removing old ME
926
    if (s->me_method < ME_EPZS) s->me.mv_penalty = default_mv_penalty;
927

    
928
    s->encoding = 1;
929

    
930
    /* init */
931
    if (MPV_common_init(s) < 0)
932
        return -1;
933

    
934
    if(s->modified_quant)
935
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
936
    s->progressive_frame= 
937
    s->progressive_sequence= !(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
938
    
939
    ff_init_me(s);
940

    
941
#ifdef CONFIG_ENCODERS
942
#ifdef CONFIG_RISKY
943
    if (s->out_format == FMT_H263)
944
        h263_encode_init(s);
945
    if(s->msmpeg4_version)
946
        ff_msmpeg4_encode_init(s);
947
#endif
948
    if (s->out_format == FMT_MPEG1)
949
        ff_mpeg1_encode_init(s);
950
#endif
951

    
952
    /* init default q matrix */
953
    for(i=0;i<64;i++) {
954
        int j= s->dsp.idct_permutation[i];
955
#ifdef CONFIG_RISKY
956
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
957
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
958
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
959
        }else if(s->out_format == FMT_H263){
960
            s->intra_matrix[j] =
961
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
962
        }else
963
#endif
964
        { /* mpeg1/2 */
965
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
966
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
967
        }
968
        if(s->avctx->intra_matrix)
969
            s->intra_matrix[j] = s->avctx->intra_matrix[i];
970
        if(s->avctx->inter_matrix)
971
            s->inter_matrix[j] = s->avctx->inter_matrix[i];
972
    }
973

    
974
    /* precompute matrix */
975
    /* for mjpeg, we do include qscale in the matrix */
976
    if (s->out_format != FMT_MJPEG) {
977
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 
978
                       s->intra_matrix, s->intra_quant_bias, 1, 31);
979
        convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, 
980
                       s->inter_matrix, s->inter_quant_bias, 1, 31);
981
    }
982

    
983
    if(ff_rate_control_init(s) < 0)
984
        return -1;
985

    
986
    s->picture_number = 0;
987
    s->input_picture_number = 0;
988
    s->picture_in_gop_number = 0;
989
    s->fake_picture_number = 0;
990
    /* motion detector init */
991
    s->f_code = 1;
992
    s->b_code = 1;
993

    
994
    return 0;
995
}
996

    
997
int MPV_encode_end(AVCodecContext *avctx)
998
{
999
    MpegEncContext *s = avctx->priv_data;
1000

    
1001
#ifdef STATS
1002
    print_stats();
1003
#endif
1004

    
1005
    ff_rate_control_uninit(s);
1006

    
1007
    MPV_common_end(s);
1008
    if (s->out_format == FMT_MJPEG)
1009
        mjpeg_close(s);
1010

    
1011
    av_freep(&avctx->extradata);
1012
      
1013
    return 0;
1014
}
1015

    
1016
#endif //CONFIG_ENCODERS
1017

    
1018
void init_rl(RLTable *rl)
1019
{
1020
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1021
    uint8_t index_run[MAX_RUN+1];
1022
    int last, run, level, start, end, i;
1023

    
1024
    /* compute max_level[], max_run[] and index_run[] */
1025
    for(last=0;last<2;last++) {
1026
        if (last == 0) {
1027
            start = 0;
1028
            end = rl->last;
1029
        } else {
1030
            start = rl->last;
1031
            end = rl->n;
1032
        }
1033

    
1034
        memset(max_level, 0, MAX_RUN + 1);
1035
        memset(max_run, 0, MAX_LEVEL + 1);
1036
        memset(index_run, rl->n, MAX_RUN + 1);
1037
        for(i=start;i<end;i++) {
1038
            run = rl->table_run[i];
1039
            level = rl->table_level[i];
1040
            if (index_run[run] == rl->n)
1041
                index_run[run] = i;
1042
            if (level > max_level[run])
1043
                max_level[run] = level;
1044
            if (run > max_run[level])
1045
                max_run[level] = run;
1046
        }
1047
        rl->max_level[last] = av_malloc(MAX_RUN + 1);
1048
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1049
        rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1050
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1051
        rl->index_run[last] = av_malloc(MAX_RUN + 1);
1052
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1053
    }
1054
}
1055

    
1056
/* draw the edges of width 'w' of an image of size width, height */
1057
//FIXME check that this is ok for mpeg4 interlaced
1058
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1059
{
1060
    uint8_t *ptr, *last_line;
1061
    int i;
1062

    
1063
    last_line = buf + (height - 1) * wrap;
1064
    for(i=0;i<w;i++) {
1065
        /* top and bottom */
1066
        memcpy(buf - (i + 1) * wrap, buf, width);
1067
        memcpy(last_line + (i + 1) * wrap, last_line, width);
1068
    }
1069
    /* left and right */
1070
    ptr = buf;
1071
    for(i=0;i<height;i++) {
1072
        memset(ptr - w, ptr[0], w);
1073
        memset(ptr + width, ptr[width-1], w);
1074
        ptr += wrap;
1075
    }
1076
    /* corners */
1077
    for(i=0;i<w;i++) {
1078
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1079
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1080
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1081
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1082
    }
1083
}
1084

    
1085
int ff_find_unused_picture(MpegEncContext *s, int shared){
1086
    int i;
1087
    
1088
    if(shared){
1089
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1090
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1091
        }
1092
    }else{
1093
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1094
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1095
        }
1096
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1097
            if(s->picture[i].data[0]==NULL) return i;
1098
        }
1099
    }
1100

    
1101
    assert(0);
1102
    return -1;
1103
}
1104

    
1105
static void update_noise_reduction(MpegEncContext *s){
1106
    int intra, i;
1107

    
1108
    for(intra=0; intra<2; intra++){
1109
        if(s->dct_count[intra] > (1<<16)){
1110
            for(i=0; i<64; i++){
1111
                s->dct_error_sum[intra][i] >>=1;
1112
            }
1113
            s->dct_count[intra] >>= 1;
1114
        }
1115
        
1116
        for(i=0; i<64; i++){
1117
            s->dct_offset[intra][i]= (s->avctx->noise_reduction * s->dct_count[intra] + s->dct_error_sum[intra][i]/2) / (s->dct_error_sum[intra][i]+1);
1118
        }
1119
    }
1120
}
1121

    
1122
/**
1123
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1124
 */
1125
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1126
{
1127
    int i;
1128
    AVFrame *pic;
1129
    s->mb_skiped = 0;
1130

    
1131
    assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1132

    
1133
    /* mark&release old frames */
1134
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr->data[0]) {
1135
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1136

    
1137
        /* release forgotten pictures */
1138
        /* if(mpeg124/h263) */
1139
        if(!s->encoding){
1140
            for(i=0; i<MAX_PICTURE_COUNT; i++){
1141
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1142
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1143
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
1144
                }
1145
            }
1146
        }
1147
    }
1148
alloc:
1149
    if(!s->encoding){
1150
        /* release non refernce frames */
1151
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1152
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1153
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1154
            }
1155
        }
1156

    
1157
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1158
            pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1159
        else{
1160
            i= ff_find_unused_picture(s, 0);
1161
            pic= (AVFrame*)&s->picture[i];
1162
        }
1163

    
1164
        pic->reference= s->pict_type != B_TYPE ? 3 : 0;
1165

    
1166
        pic->coded_picture_number= s->coded_picture_number++;
1167
        
1168
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1169
            return -1;
1170

    
1171
        s->current_picture_ptr= (Picture*)pic;
1172
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1173
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1174
    }
1175

    
1176
    s->current_picture_ptr->pict_type= s->pict_type;
1177
//    if(s->flags && CODEC_FLAG_QSCALE) 
1178
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1179
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1180

    
1181
    copy_picture(&s->current_picture, s->current_picture_ptr);
1182
  
1183
  if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1184
    if (s->pict_type != B_TYPE) {
1185
        s->last_picture_ptr= s->next_picture_ptr;
1186
        s->next_picture_ptr= s->current_picture_ptr;
1187
    }
1188
    
1189
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1190
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1191
    
1192
    if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1193
        av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1194
        assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1195
        goto alloc;
1196
    }
1197

    
1198
    assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1199

    
1200
    if(s->picture_structure!=PICT_FRAME){
1201
        int i;
1202
        for(i=0; i<4; i++){
1203
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1204
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1205
            } 
1206
            s->current_picture.linesize[i] *= 2;
1207
            s->last_picture.linesize[i] *=2;
1208
            s->next_picture.linesize[i] *=2;
1209
        }
1210
    }
1211
  }
1212
   
1213
    s->hurry_up= s->avctx->hurry_up;
1214
    s->error_resilience= avctx->error_resilience;
1215

    
1216
    /* set dequantizer, we cant do it during init as it might change for mpeg4
1217
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1218
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1219
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1220
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1221
    }else if(s->out_format == FMT_H263){
1222
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1223
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1224
    }else{
1225
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1226
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1227
    }
1228

    
1229
    if(s->dct_error_sum){
1230
        assert(s->avctx->noise_reduction && s->encoding);
1231

    
1232
        update_noise_reduction(s);
1233
    }
1234
        
1235
#ifdef HAVE_XVMC
1236
    if(s->avctx->xvmc_acceleration)
1237
        return XVMC_field_start(s, avctx);
1238
#endif
1239
    return 0;
1240
}
1241

    
1242
/* generic function for encode/decode called after a frame has been coded/decoded */
1243
void MPV_frame_end(MpegEncContext *s)
1244
{
1245
    int i;
1246
    /* draw edge for correct motion prediction if outside */
1247
#ifdef HAVE_XVMC
1248
//just to make sure that all data is rendered.
1249
    if(s->avctx->xvmc_acceleration){
1250
        XVMC_field_end(s);
1251
    }else
1252
#endif
1253
    if(s->unrestricted_mv && s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1254
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1255
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1256
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1257
    }
1258
    emms_c();
1259
    
1260
    s->last_pict_type    = s->pict_type;
1261
    if(s->pict_type!=B_TYPE){
1262
        s->last_non_b_pict_type= s->pict_type;
1263
    }
1264
#if 0
1265
        /* copy back current_picture variables */
1266
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1267
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1268
            s->picture[i]= s->current_picture;
1269
            break;
1270
        }    
1271
    }
1272
    assert(i<MAX_PICTURE_COUNT);
1273
#endif    
1274

    
1275
    if(s->encoding){
1276
        /* release non refernce frames */
1277
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1278
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1279
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1280
            }
1281
        }
1282
    }
1283
    // clear copies, to avoid confusion
1284
#if 0
1285
    memset(&s->last_picture, 0, sizeof(Picture));
1286
    memset(&s->next_picture, 0, sizeof(Picture));
1287
    memset(&s->current_picture, 0, sizeof(Picture));
1288
#endif
1289
}
1290

    
1291
/**
1292
 * draws an line from (ex, ey) -> (sx, sy).
1293
 * @param w width of the image
1294
 * @param h height of the image
1295
 * @param stride stride/linesize of the image
1296
 * @param color color of the arrow
1297
 */
1298
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1299
    int t, x, y, f;
1300
    
1301
    sx= clip(sx, 0, w-1);
1302
    sy= clip(sy, 0, h-1);
1303
    ex= clip(ex, 0, w-1);
1304
    ey= clip(ey, 0, h-1);
1305
    
1306
    buf[sy*stride + sx]+= color;
1307
    
1308
    if(ABS(ex - sx) > ABS(ey - sy)){
1309
        if(sx > ex){
1310
            t=sx; sx=ex; ex=t;
1311
            t=sy; sy=ey; ey=t;
1312
        }
1313
        buf+= sx + sy*stride;
1314
        ex-= sx;
1315
        f= ((ey-sy)<<16)/ex;
1316
        for(x= 0; x <= ex; x++){
1317
            y= ((x*f) + (1<<15))>>16;
1318
            buf[y*stride + x]+= color;
1319
        }
1320
    }else{
1321
        if(sy > ey){
1322
            t=sx; sx=ex; ex=t;
1323
            t=sy; sy=ey; ey=t;
1324
        }
1325
        buf+= sx + sy*stride;
1326
        ey-= sy;
1327
        if(ey) f= ((ex-sx)<<16)/ey;
1328
        else   f= 0;
1329
        for(y= 0; y <= ey; y++){
1330
            x= ((y*f) + (1<<15))>>16;
1331
            buf[y*stride + x]+= color;
1332
        }
1333
    }
1334
}
1335

    
1336
/**
1337
 * draws an arrow from (ex, ey) -> (sx, sy).
1338
 * @param w width of the image
1339
 * @param h height of the image
1340
 * @param stride stride/linesize of the image
1341
 * @param color color of the arrow
1342
 */
1343
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1344
    int dx,dy;
1345

    
1346
    sx= clip(sx, -100, w+100);
1347
    sy= clip(sy, -100, h+100);
1348
    ex= clip(ex, -100, w+100);
1349
    ey= clip(ey, -100, h+100);
1350
    
1351
    dx= ex - sx;
1352
    dy= ey - sy;
1353
    
1354
    if(dx*dx + dy*dy > 3*3){
1355
        int rx=  dx + dy;
1356
        int ry= -dx + dy;
1357
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1358
        
1359
        //FIXME subpixel accuracy
1360
        rx= ROUNDED_DIV(rx*3<<4, length);
1361
        ry= ROUNDED_DIV(ry*3<<4, length);
1362
        
1363
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1364
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1365
    }
1366
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1367
}
1368

    
1369
/**
1370
 * prints debuging info for the given picture.
1371
 */
1372
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1373

    
1374
    if(!pict || !pict->mb_type) return;
1375

    
1376
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1377
        int x,y;
1378
        
1379
        av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1380
        switch (pict->pict_type) {
1381
            case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1382
            case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1383
            case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1384
            case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1385
            case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1386
            case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;            
1387
        }
1388
        for(y=0; y<s->mb_height; y++){
1389
            for(x=0; x<s->mb_width; x++){
1390
                if(s->avctx->debug&FF_DEBUG_SKIP){
1391
                    int count= s->mbskip_table[x + y*s->mb_stride];
1392
                    if(count>9) count=9;
1393
                    av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1394
                }
1395
                if(s->avctx->debug&FF_DEBUG_QP){
1396
                    av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1397
                }
1398
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1399
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
1400
                    //Type & MV direction
1401
                    if(IS_PCM(mb_type))
1402
                        av_log(s->avctx, AV_LOG_DEBUG, "P");
1403
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1404
                        av_log(s->avctx, AV_LOG_DEBUG, "A");
1405
                    else if(IS_INTRA4x4(mb_type))
1406
                        av_log(s->avctx, AV_LOG_DEBUG, "i");
1407
                    else if(IS_INTRA16x16(mb_type))
1408
                        av_log(s->avctx, AV_LOG_DEBUG, "I");
1409
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1410
                        av_log(s->avctx, AV_LOG_DEBUG, "d");
1411
                    else if(IS_DIRECT(mb_type))
1412
                        av_log(s->avctx, AV_LOG_DEBUG, "D");
1413
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1414
                        av_log(s->avctx, AV_LOG_DEBUG, "g");
1415
                    else if(IS_GMC(mb_type))
1416
                        av_log(s->avctx, AV_LOG_DEBUG, "G");
1417
                    else if(IS_SKIP(mb_type))
1418
                        av_log(s->avctx, AV_LOG_DEBUG, "S");
1419
                    else if(!USES_LIST(mb_type, 1))
1420
                        av_log(s->avctx, AV_LOG_DEBUG, ">");
1421
                    else if(!USES_LIST(mb_type, 0))
1422
                        av_log(s->avctx, AV_LOG_DEBUG, "<");
1423
                    else{
1424
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1425
                        av_log(s->avctx, AV_LOG_DEBUG, "X");
1426
                    }
1427
                    
1428
                    //segmentation
1429
                    if(IS_8X8(mb_type))
1430
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1431
                    else if(IS_16X8(mb_type))
1432
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1433
                    else if(IS_8X16(mb_type))
1434
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1435
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1436
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1437
                    else
1438
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1439
                    
1440
                        
1441
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1442
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1443
                    else
1444
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1445
                }
1446
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1447
            }
1448
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1449
        }
1450
    }
1451

    
1452
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1453
        const int shift= 1 + s->quarter_sample;
1454
        int mb_y;
1455
        uint8_t *ptr;
1456
        int i;
1457
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1458

    
1459
        for(i=0; i<3; i++){
1460
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*s->height:pict->linesize[i]*s->height/2);
1461
            pict->data[i]= s->visualization_buffer[i];
1462
        }
1463
        pict->type= FF_BUFFER_TYPE_COPY;
1464
        ptr= pict->data[0];
1465

    
1466
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1467
            int mb_x;
1468
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1469
                const int mb_index= mb_x + mb_y*s->mb_stride;
1470
                if((s->avctx->debug_mv) && pict->motion_val){
1471
                  int type;
1472
                  for(type=0; type<3; type++){
1473
                    int direction;
1474
                    switch (type) {
1475
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1476
                                continue;
1477
                              direction = 0;
1478
                              break;
1479
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1480
                                continue;
1481
                              direction = 0;
1482
                              break;
1483
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1484
                                continue;
1485
                              direction = 1;
1486
                              break;
1487
                    }
1488
                    if(IS_8X8(pict->mb_type[mb_index])){
1489
                      int i;
1490
                      for(i=0; i<4; i++){
1491
                        int sx= mb_x*16 + 4 + 8*(i&1);
1492
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1493
                        int xy= 1 + mb_x*2 + (i&1) + (mb_y*2 + 1 + (i>>1))*(s->mb_width*2 + 2);
1494
                        int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1495
                        int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1496
                        draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1497
                      }
1498
                    }else if(IS_16X8(pict->mb_type[mb_index])){
1499
                      int i;
1500
                      for(i=0; i<2; i++){
1501
                        int sx=mb_x*16 + 8;
1502
                        int sy=mb_y*16 + 4 + 8*i;
1503
                        int xy=1 + mb_x*2 + (mb_y*2 + 1 + i)*(s->mb_width*2 + 2);
1504
                        int mx=(pict->motion_val[direction][xy][0]>>shift) + sx;
1505
                        int my=(pict->motion_val[direction][xy][1]>>shift) + sy;
1506
                        draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1507
                      }
1508
                    }else{
1509
                      int sx= mb_x*16 + 8;
1510
                      int sy= mb_y*16 + 8;
1511
                      int xy= 1 + mb_x*2 + (mb_y*2 + 1)*(s->mb_width*2 + 2);
1512
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1513
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1514
                      draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1515
                    }
1516
                  }                  
1517
                }
1518
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1519
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1520
                    int y;
1521
                    for(y=0; y<8; y++){
1522
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1523
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1524
                    }
1525
                }
1526
                if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1527
                    int mb_type= pict->mb_type[mb_index];
1528
                    uint64_t u,v;
1529
                    int y;
1530
#define COLOR(theta, r)\
1531
u= (int)(128 + r*cos(theta*3.141592/180));\
1532
v= (int)(128 + r*sin(theta*3.141592/180));
1533

    
1534
                    
1535
                    u=v=128;
1536
                    if(IS_PCM(mb_type)){
1537
                        COLOR(120,48)
1538
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1539
                        COLOR(30,48)
1540
                    }else if(IS_INTRA4x4(mb_type)){
1541
                        COLOR(90,48)
1542
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1543
//                        COLOR(120,48)
1544
                    }else if(IS_DIRECT(mb_type)){
1545
                        COLOR(150,48)
1546
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1547
                        COLOR(170,48)
1548
                    }else if(IS_GMC(mb_type)){
1549
                        COLOR(190,48)
1550
                    }else if(IS_SKIP(mb_type)){
1551
//                        COLOR(180,48)
1552
                    }else if(!USES_LIST(mb_type, 1)){
1553
                        COLOR(240,48)
1554
                    }else if(!USES_LIST(mb_type, 0)){
1555
                        COLOR(0,48)
1556
                    }else{
1557
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1558
                        COLOR(300,48)
1559
                    }
1560

    
1561
                    u*= 0x0101010101010101ULL;
1562
                    v*= 0x0101010101010101ULL;
1563
                    for(y=0; y<8; y++){
1564
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1565
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1566
                    }
1567

    
1568
                    //segmentation
1569
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1570
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1571
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1572
                    }
1573
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1574
                        for(y=0; y<16; y++)
1575
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1576
                    }
1577
                        
1578
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1579
                        // hmm
1580
                    }
1581
                }
1582
                s->mbskip_table[mb_index]=0;
1583
            }
1584
        }
1585
    }
1586
}
1587

    
1588
#ifdef CONFIG_ENCODERS
1589

    
1590
static int get_sae(uint8_t *src, int ref, int stride){
1591
    int x,y;
1592
    int acc=0;
1593
    
1594
    for(y=0; y<16; y++){
1595
        for(x=0; x<16; x++){
1596
            acc+= ABS(src[x+y*stride] - ref);
1597
        }
1598
    }
1599
    
1600
    return acc;
1601
}
1602

    
1603
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1604
    int x, y, w, h;
1605
    int acc=0;
1606
    
1607
    w= s->width &~15;
1608
    h= s->height&~15;
1609
    
1610
    for(y=0; y<h; y+=16){
1611
        for(x=0; x<w; x+=16){
1612
            int offset= x + y*stride;
1613
            int sad = s->dsp.pix_abs16x16(src + offset, ref + offset, stride);
1614
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1615
            int sae = get_sae(src + offset, mean, stride);
1616
            
1617
            acc+= sae + 500 < sad;
1618
        }
1619
    }
1620
    return acc;
1621
}
1622

    
1623

    
1624
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1625
    AVFrame *pic=NULL;
1626
    int i;
1627
    const int encoding_delay= s->max_b_frames;
1628
    int direct=1;
1629
    
1630
  if(pic_arg){
1631
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1632
    if(pic_arg->linesize[0] != s->linesize) direct=0;
1633
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1634
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1635
  
1636
//    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1637
    
1638
    if(direct){
1639
        i= ff_find_unused_picture(s, 1);
1640

    
1641
        pic= (AVFrame*)&s->picture[i];
1642
        pic->reference= 3;
1643
    
1644
        for(i=0; i<4; i++){
1645
            pic->data[i]= pic_arg->data[i];
1646
            pic->linesize[i]= pic_arg->linesize[i];
1647
        }
1648
        alloc_picture(s, (Picture*)pic, 1);
1649
    }else{
1650
        int offset= 16;
1651
        i= ff_find_unused_picture(s, 0);
1652

    
1653
        pic= (AVFrame*)&s->picture[i];
1654
        pic->reference= 3;
1655

    
1656
        alloc_picture(s, (Picture*)pic, 0);
1657

    
1658
        if(   pic->data[0] + offset == pic_arg->data[0] 
1659
           && pic->data[1] + offset == pic_arg->data[1]
1660
           && pic->data[2] + offset == pic_arg->data[2]){
1661
       // empty
1662
        }else{
1663
            int h_chroma_shift, v_chroma_shift;
1664
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1665
        
1666
            for(i=0; i<3; i++){
1667
                int src_stride= pic_arg->linesize[i];
1668
                int dst_stride= i ? s->uvlinesize : s->linesize;
1669
                int h_shift= i ? h_chroma_shift : 0;
1670
                int v_shift= i ? v_chroma_shift : 0;
1671
                int w= s->width >>h_shift;
1672
                int h= s->height>>v_shift;
1673
                uint8_t *src= pic_arg->data[i];
1674
                uint8_t *dst= pic->data[i] + offset;
1675
            
1676
                if(src_stride==dst_stride)
1677
                    memcpy(dst, src, src_stride*h);
1678
                else{
1679
                    while(h--){
1680
                        memcpy(dst, src, w);
1681
                        dst += dst_stride;
1682
                        src += src_stride;
1683
                    }
1684
                }
1685
            }
1686
        }
1687
    }
1688
    copy_picture_attributes(pic, pic_arg);
1689
    
1690
    pic->display_picture_number= s->input_picture_number++;
1691
  }
1692

    
1693
    /* shift buffer entries */
1694
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1695
        s->input_picture[i-1]= s->input_picture[i];
1696
        
1697
    s->input_picture[encoding_delay]= (Picture*)pic;
1698

    
1699
    return 0;
1700
}
1701

    
1702
static void select_input_picture(MpegEncContext *s){
1703
    int i;
1704

    
1705
    for(i=1; i<MAX_PICTURE_COUNT; i++)
1706
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1707
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1708

    
1709
    /* set next picture types & ordering */
1710
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1711
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
1712
            s->reordered_input_picture[0]= s->input_picture[0];
1713
            s->reordered_input_picture[0]->pict_type= I_TYPE;
1714
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
1715
        }else{
1716
            int b_frames;
1717
            
1718
            if(s->flags&CODEC_FLAG_PASS2){
1719
                for(i=0; i<s->max_b_frames+1; i++){
1720
                    int pict_num= s->input_picture[0]->display_picture_number + i;
1721
                    int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1722
                    s->input_picture[i]->pict_type= pict_type;
1723
                    
1724
                    if(i + 1 >= s->rc_context.num_entries) break;
1725
                }
1726
            }
1727

    
1728
            if(s->input_picture[0]->pict_type){
1729
                /* user selected pict_type */
1730
                for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
1731
                    if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
1732
                }
1733
            
1734
                if(b_frames > s->max_b_frames){
1735
                    av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
1736
                    b_frames = s->max_b_frames;
1737
                }
1738
            }else if(s->avctx->b_frame_strategy==0){
1739
                b_frames= s->max_b_frames;
1740
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
1741
            }else if(s->avctx->b_frame_strategy==1){
1742
                for(i=1; i<s->max_b_frames+1; i++){
1743
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
1744
                        s->input_picture[i]->b_frame_score= 
1745
                            get_intra_count(s, s->input_picture[i  ]->data[0], 
1746
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
1747
                    }
1748
                }
1749
                for(i=0; i<s->max_b_frames; i++){
1750
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
1751
                }
1752
                                
1753
                b_frames= FFMAX(0, i-1);
1754
                
1755
                /* reset scores */
1756
                for(i=0; i<b_frames+1; i++){
1757
                    s->input_picture[i]->b_frame_score=0;
1758
                }
1759
            }else{
1760
                av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1761
                b_frames=0;
1762
            }
1763

    
1764
            emms_c();
1765
//static int b_count=0;
1766
//b_count+= b_frames;
1767
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
1768
                        
1769
            s->reordered_input_picture[0]= s->input_picture[b_frames];
1770
            if(   s->picture_in_gop_number + b_frames >= s->gop_size 
1771
               || s->reordered_input_picture[0]->pict_type== I_TYPE)
1772
                s->reordered_input_picture[0]->pict_type= I_TYPE;
1773
            else
1774
                s->reordered_input_picture[0]->pict_type= P_TYPE;
1775
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
1776
            for(i=0; i<b_frames; i++){
1777
                s->reordered_input_picture[i+1]= s->input_picture[i];
1778
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
1779
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
1780
            }
1781
        }
1782
    }
1783
    
1784
    if(s->reordered_input_picture[0]){
1785
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
1786

    
1787
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
1788

    
1789
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
1790
            // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
1791
        
1792
            int i= ff_find_unused_picture(s, 0);
1793
            Picture *pic= &s->picture[i];
1794

    
1795
            /* mark us unused / free shared pic */
1796
            for(i=0; i<4; i++)
1797
                s->reordered_input_picture[0]->data[i]= NULL;
1798
            s->reordered_input_picture[0]->type= 0;
1799
            
1800
            copy_picture_attributes((AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
1801
            pic->reference              = s->reordered_input_picture[0]->reference;
1802
            
1803
            alloc_picture(s, pic, 0);
1804

    
1805
            s->current_picture_ptr= pic;
1806
        }else{
1807
            // input is not a shared pix -> reuse buffer for current_pix
1808

    
1809
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
1810
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
1811
            
1812
            s->current_picture_ptr= s->reordered_input_picture[0];
1813
            for(i=0; i<4; i++){
1814
                s->new_picture.data[i]+=16;
1815
            }
1816
        }
1817
        copy_picture(&s->current_picture, s->current_picture_ptr);
1818
    
1819
        s->picture_number= s->new_picture.display_picture_number;
1820
//printf("dpn:%d\n", s->picture_number);
1821
    }else{
1822
       memset(&s->new_picture, 0, sizeof(Picture));
1823
    }
1824
}
1825

    
1826
int MPV_encode_picture(AVCodecContext *avctx,
1827
                       unsigned char *buf, int buf_size, void *data)
1828
{
1829
    MpegEncContext *s = avctx->priv_data;
1830
    AVFrame *pic_arg = data;
1831
    int i, stuffing_count;
1832

    
1833
    if(avctx->pix_fmt != PIX_FMT_YUV420P){
1834
        av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
1835
        return -1;
1836
    }
1837
    
1838
    init_put_bits(&s->pb, buf, buf_size);
1839

    
1840
    s->picture_in_gop_number++;
1841

    
1842
    load_input_picture(s, pic_arg);
1843
    
1844
    select_input_picture(s);
1845
    
1846
    /* output? */
1847
    if(s->new_picture.data[0]){
1848
        s->pict_type= s->new_picture.pict_type;
1849
//emms_c();
1850
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
1851
        MPV_frame_start(s, avctx);
1852

    
1853
        encode_picture(s, s->picture_number);
1854
        
1855
        avctx->real_pict_num  = s->picture_number;
1856
        avctx->header_bits = s->header_bits;
1857
        avctx->mv_bits     = s->mv_bits;
1858
        avctx->misc_bits   = s->misc_bits;
1859
        avctx->i_tex_bits  = s->i_tex_bits;
1860
        avctx->p_tex_bits  = s->p_tex_bits;
1861
        avctx->i_count     = s->i_count;
1862
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
1863
        avctx->skip_count  = s->skip_count;
1864

    
1865
        MPV_frame_end(s);
1866

    
1867
        if (s->out_format == FMT_MJPEG)
1868
            mjpeg_picture_trailer(s);
1869
        
1870
        if(s->flags&CODEC_FLAG_PASS1)
1871
            ff_write_pass1_stats(s);
1872

    
1873
        for(i=0; i<4; i++){
1874
            avctx->error[i] += s->current_picture_ptr->error[i];
1875
        }
1876
    }
1877

    
1878
    flush_put_bits(&s->pb);
1879
    s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1880

    
1881
    stuffing_count= ff_vbv_update(s, s->frame_bits);
1882
    if(stuffing_count){
1883
        switch(s->codec_id){
1884
        case CODEC_ID_MPEG1VIDEO:
1885
        case CODEC_ID_MPEG2VIDEO:
1886
            while(stuffing_count--){
1887
                put_bits(&s->pb, 8, 0);
1888
            }
1889
        break;
1890
        case CODEC_ID_MPEG4:
1891
            put_bits(&s->pb, 16, 0);
1892
            put_bits(&s->pb, 16, 0x1C3);
1893
            stuffing_count -= 4;
1894
            while(stuffing_count--){
1895
                put_bits(&s->pb, 8, 0xFF);
1896
            }
1897
        break;
1898
        default:
1899
            av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1900
        }
1901
        flush_put_bits(&s->pb);
1902
        s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1903
    }
1904

    
1905
    /* update mpeg1/2 vbv_delay for CBR */    
1906
    if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate){
1907
        int vbv_delay;
1908

    
1909
        assert(s->repeat_first_field==0 && s->avctx->repeat_pic==0);
1910
        
1911
        vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
1912
        assert(vbv_delay < 0xFFFF);
1913

    
1914
        s->vbv_delay_ptr[0] &= 0xF8;
1915
        s->vbv_delay_ptr[0] |= vbv_delay>>13;
1916
        s->vbv_delay_ptr[1]  = vbv_delay>>5;
1917
        s->vbv_delay_ptr[2] &= 0x07;
1918
        s->vbv_delay_ptr[2] |= vbv_delay<<3;
1919
    }
1920

    
1921
    s->total_bits += s->frame_bits;
1922
    avctx->frame_bits  = s->frame_bits;
1923
    
1924
    return s->frame_bits/8;
1925
}
1926

    
1927
#endif //CONFIG_ENCODERS
1928

    
1929
static inline void gmc1_motion(MpegEncContext *s,
1930
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1931
                               int dest_offset,
1932
                               uint8_t **ref_picture, int src_offset)
1933
{
1934
    uint8_t *ptr;
1935
    int offset, src_x, src_y, linesize, uvlinesize;
1936
    int motion_x, motion_y;
1937
    int emu=0;
1938

    
1939
    motion_x= s->sprite_offset[0][0];
1940
    motion_y= s->sprite_offset[0][1];
1941
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1942
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1943
    motion_x<<=(3-s->sprite_warping_accuracy);
1944
    motion_y<<=(3-s->sprite_warping_accuracy);
1945
    src_x = clip(src_x, -16, s->width);
1946
    if (src_x == s->width)
1947
        motion_x =0;
1948
    src_y = clip(src_y, -16, s->height);
1949
    if (src_y == s->height)
1950
        motion_y =0;
1951

    
1952
    linesize = s->linesize;
1953
    uvlinesize = s->uvlinesize;
1954
    
1955
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1956

    
1957
    dest_y+=dest_offset;
1958
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1959
        if(   (unsigned)src_x >= s->h_edge_pos - 17
1960
           || (unsigned)src_y >= s->v_edge_pos - 17){
1961
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1962
            ptr= s->edge_emu_buffer;
1963
        }
1964
    }
1965
    
1966
    if((motion_x|motion_y)&7){
1967
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1968
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1969
    }else{
1970
        int dxy;
1971
        
1972
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
1973
        if (s->no_rounding){
1974
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
1975
        }else{
1976
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
1977
        }
1978
    }
1979
    
1980
    if(s->flags&CODEC_FLAG_GRAY) return;
1981

    
1982
    motion_x= s->sprite_offset[1][0];
1983
    motion_y= s->sprite_offset[1][1];
1984
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
1985
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
1986
    motion_x<<=(3-s->sprite_warping_accuracy);
1987
    motion_y<<=(3-s->sprite_warping_accuracy);
1988
    src_x = clip(src_x, -8, s->width>>1);
1989
    if (src_x == s->width>>1)
1990
        motion_x =0;
1991
    src_y = clip(src_y, -8, s->height>>1);
1992
    if (src_y == s->height>>1)
1993
        motion_y =0;
1994

    
1995
    offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
1996
    ptr = ref_picture[1] + offset;
1997
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1998
        if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
1999
           || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2000
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2001
            ptr= s->edge_emu_buffer;
2002
            emu=1;
2003
        }
2004
    }
2005
    s->dsp.gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2006
    
2007
    ptr = ref_picture[2] + offset;
2008
    if(emu){
2009
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2010
        ptr= s->edge_emu_buffer;
2011
    }
2012
    s->dsp.gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2013
    
2014
    return;
2015
}
2016

    
2017
static inline void gmc_motion(MpegEncContext *s,
2018
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2019
                               int dest_offset,
2020
                               uint8_t **ref_picture, int src_offset)
2021
{
2022
    uint8_t *ptr;
2023
    int linesize, uvlinesize;
2024
    const int a= s->sprite_warping_accuracy;
2025
    int ox, oy;
2026

    
2027
    linesize = s->linesize;
2028
    uvlinesize = s->uvlinesize;
2029

    
2030
    ptr = ref_picture[0] + src_offset;
2031

    
2032
    dest_y+=dest_offset;
2033
    
2034
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2035
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2036

    
2037
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2038
           ox, 
2039
           oy, 
2040
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2041
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2042
           a+1, (1<<(2*a+1)) - s->no_rounding,
2043
           s->h_edge_pos, s->v_edge_pos);
2044
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2045
           ox + s->sprite_delta[0][0]*8, 
2046
           oy + s->sprite_delta[1][0]*8, 
2047
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2048
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2049
           a+1, (1<<(2*a+1)) - s->no_rounding,
2050
           s->h_edge_pos, s->v_edge_pos);
2051

    
2052
    if(s->flags&CODEC_FLAG_GRAY) return;
2053

    
2054

    
2055
    dest_cb+=dest_offset>>1;
2056
    dest_cr+=dest_offset>>1;
2057
    
2058
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2059
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2060

    
2061
    ptr = ref_picture[1] + (src_offset>>1);
2062
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2063
           ox, 
2064
           oy, 
2065
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2066
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2067
           a+1, (1<<(2*a+1)) - s->no_rounding,
2068
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2069
    
2070
    ptr = ref_picture[2] + (src_offset>>1);
2071
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2072
           ox, 
2073
           oy, 
2074
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2075
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2076
           a+1, (1<<(2*a+1)) - s->no_rounding,
2077
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2078
}
2079

    
2080
/**
2081
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2082
 * @param buf destination buffer
2083
 * @param src source buffer
2084
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2085
 * @param block_w width of block
2086
 * @param block_h height of block
2087
 * @param src_x x coordinate of the top left sample of the block in the source buffer
2088
 * @param src_y y coordinate of the top left sample of the block in the source buffer
2089
 * @param w width of the source buffer
2090
 * @param h height of the source buffer
2091
 */
2092
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
2093
                                    int src_x, int src_y, int w, int h){
2094
    int x, y;
2095
    int start_y, start_x, end_y, end_x;
2096

    
2097
    if(src_y>= h){
2098
        src+= (h-1-src_y)*linesize;
2099
        src_y=h-1;
2100
    }else if(src_y<=-block_h){
2101
        src+= (1-block_h-src_y)*linesize;
2102
        src_y=1-block_h;
2103
    }
2104
    if(src_x>= w){
2105
        src+= (w-1-src_x);
2106
        src_x=w-1;
2107
    }else if(src_x<=-block_w){
2108
        src+= (1-block_w-src_x);
2109
        src_x=1-block_w;
2110
    }
2111

    
2112
    start_y= FFMAX(0, -src_y);
2113
    start_x= FFMAX(0, -src_x);
2114
    end_y= FFMIN(block_h, h-src_y);
2115
    end_x= FFMIN(block_w, w-src_x);
2116

    
2117
    // copy existing part
2118
    for(y=start_y; y<end_y; y++){
2119
        for(x=start_x; x<end_x; x++){
2120
            buf[x + y*linesize]= src[x + y*linesize];
2121
        }
2122
    }
2123

    
2124
    //top
2125
    for(y=0; y<start_y; y++){
2126
        for(x=start_x; x<end_x; x++){
2127
            buf[x + y*linesize]= buf[x + start_y*linesize];
2128
        }
2129
    }
2130

    
2131
    //bottom
2132
    for(y=end_y; y<block_h; y++){
2133
        for(x=start_x; x<end_x; x++){
2134
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2135
        }
2136
    }
2137
                                    
2138
    for(y=0; y<block_h; y++){
2139
       //left
2140
        for(x=0; x<start_x; x++){
2141
            buf[x + y*linesize]= buf[start_x + y*linesize];
2142
        }
2143
       
2144
       //right
2145
        for(x=end_x; x<block_w; x++){
2146
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2147
        }
2148
    }
2149
}
2150

    
2151
static inline int hpel_motion(MpegEncContext *s, 
2152
                                  uint8_t *dest, uint8_t *src, 
2153
                                  int src_x, int src_y,
2154
                                  int width, int height, int stride,
2155
                                  int h_edge_pos, int v_edge_pos,
2156
                                  int w, int h, op_pixels_func *pix_op,
2157
                                  int motion_x, int motion_y)
2158
{
2159
    int dxy;
2160
    int emu=0;
2161

    
2162
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2163
    src_x += motion_x >> 1;
2164
    src_y += motion_y >> 1;
2165
                
2166
    /* WARNING: do no forget half pels */
2167
    src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2168
    if (src_x == width)
2169
        dxy &= ~1;
2170
    src_y = clip(src_y, -16, height);
2171
    if (src_y == height)
2172
        dxy &= ~2;
2173
    src += src_y * stride + src_x;
2174

    
2175
    if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2176
        if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2177
           || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2178
            ff_emulated_edge_mc(s->edge_emu_buffer, src, stride, w+1, h+1,
2179
                             src_x, src_y, h_edge_pos, v_edge_pos);
2180
            src= s->edge_emu_buffer;
2181
            emu=1;
2182
        }
2183
    }
2184
    pix_op[dxy](dest, src, stride, h);
2185
    return emu;
2186
}
2187

    
2188
/* apply one mpeg motion vector to the three components */
2189
static inline void mpeg_motion(MpegEncContext *s,
2190
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2191
                               int dest_offset,
2192
                               uint8_t **ref_picture, int src_offset,
2193
                               int field_based, op_pixels_func (*pix_op)[4],
2194
                               int motion_x, int motion_y, int h)
2195
{
2196
    uint8_t *ptr;
2197
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, uvlinesize;
2198
    int emu=0;
2199
#if 0    
2200
if(s->quarter_sample)
2201
{
2202
    motion_x>>=1;
2203
    motion_y>>=1;
2204
}
2205
#endif
2206

    
2207
    height = s->height >> field_based;
2208
    v_edge_pos = s->v_edge_pos >> field_based;
2209
    uvlinesize = s->current_picture.linesize[1] << field_based;
2210

    
2211
    emu= hpel_motion(s, 
2212
                dest_y + dest_offset, ref_picture[0] + src_offset,
2213
                s->mb_x * 16, s->mb_y * (16 >> field_based),
2214
                s->width, height, s->current_picture.linesize[0] << field_based,
2215
                s->h_edge_pos, v_edge_pos,
2216
                16, h, pix_op[0],
2217
                motion_x, motion_y);
2218

    
2219

    
2220
    if(s->flags&CODEC_FLAG_GRAY) return;
2221

    
2222
    if (s->out_format == FMT_H263) {
2223
        dxy = 0;
2224
        if ((motion_x & 3) != 0)
2225
            dxy |= 1;
2226
        if ((motion_y & 3) != 0)
2227
            dxy |= 2;
2228
        mx = motion_x >> 2;
2229
        my = motion_y >> 2;
2230
    } else {
2231
        mx = motion_x / 2;
2232
        my = motion_y / 2;
2233
        dxy = ((my & 1) << 1) | (mx & 1);
2234
        mx >>= 1;
2235
        my >>= 1;
2236
    }
2237
    
2238
    src_x = s->mb_x * 8 + mx;
2239
    src_y = s->mb_y * (8 >> field_based) + my;
2240
    src_x = clip(src_x, -8, s->width >> 1);
2241
    if (src_x == (s->width >> 1))
2242
        dxy &= ~1;
2243
    src_y = clip(src_y, -8, height >> 1);
2244
    if (src_y == (height >> 1))
2245
        dxy &= ~2;
2246
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
2247
    ptr = ref_picture[1] + offset;
2248
    if(emu){
2249
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
2250
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2251
        ptr= s->edge_emu_buffer + (src_offset >> 1);
2252
    }
2253
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
2254

    
2255
    ptr = ref_picture[2] + offset;
2256
    if(emu){
2257
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
2258
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2259
        ptr= s->edge_emu_buffer + (src_offset >> 1);
2260
    }
2261
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
2262
}
2263
//FIXME move to dsputil, avg variant, 16x16 version
2264
static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2265
    int x;
2266
    uint8_t * const top   = src[1];
2267
    uint8_t * const left  = src[2];
2268
    uint8_t * const mid   = src[0];
2269
    uint8_t * const right = src[3];
2270
    uint8_t * const bottom= src[4];
2271
#define OBMC_FILTER(x, t, l, m, r, b)\
2272
    dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2273
#define OBMC_FILTER4(x, t, l, m, r, b)\
2274
    OBMC_FILTER(x         , t, l, m, r, b);\
2275
    OBMC_FILTER(x+1       , t, l, m, r, b);\
2276
    OBMC_FILTER(x  +stride, t, l, m, r, b);\
2277
    OBMC_FILTER(x+1+stride, t, l, m, r, b);
2278
    
2279
    x=0;
2280
    OBMC_FILTER (x  , 2, 2, 4, 0, 0);
2281
    OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2282
    OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2283
    OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2284
    OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2285
    OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2286
    x+= stride;
2287
    OBMC_FILTER (x  , 1, 2, 5, 0, 0);
2288
    OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2289
    OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2290
    OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2291
    x+= stride;
2292
    OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
2293
    OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2294
    OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2295
    OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2296
    x+= 2*stride;
2297
    OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
2298
    OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2299
    OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2300
    OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2301
    x+= 2*stride;
2302
    OBMC_FILTER (x  , 0, 2, 5, 0, 1);
2303
    OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2304
    OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2305
    OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2306
    OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2307
    OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2308
    x+= stride;
2309
    OBMC_FILTER (x  , 0, 2, 4, 0, 2);
2310
    OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2311
    OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2312
    OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2313
}
2314

    
2315
/* obmc for 1 8x8 luma block */
2316
static inline void obmc_motion(MpegEncContext *s,
2317
                               uint8_t *dest, uint8_t *src,
2318
                               int src_x, int src_y,
2319
                               op_pixels_func *pix_op,
2320
                               int16_t mv[5][2]/* mid top left right bottom*/)
2321
#define MID    0
2322
{
2323
    int i;
2324
    uint8_t *ptr[5];
2325
    
2326
    assert(s->quarter_sample==0);
2327
    
2328
    for(i=0; i<5; i++){
2329
        if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2330
            ptr[i]= ptr[MID];
2331
        }else{
2332
            ptr[i]= s->edge_emu_buffer + 16 + 8*(i&1) + s->linesize*8*(i>>1);
2333
            hpel_motion(s, ptr[i], src,
2334
                        src_x, src_y,
2335
                        s->width, s->height, s->linesize,
2336
                        s->h_edge_pos, s->v_edge_pos,
2337
                        8, 8, pix_op,
2338
                        mv[i][0], mv[i][1]);
2339
        }
2340
    }
2341

    
2342
    put_obmc(dest, ptr, s->linesize);                
2343
}
2344

    
2345
static inline void qpel_motion(MpegEncContext *s,
2346
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2347
                               int dest_offset,
2348
                               uint8_t **ref_picture, int src_offset,
2349
                               int field_based, op_pixels_func (*pix_op)[4],
2350
                               qpel_mc_func (*qpix_op)[16],
2351
                               int motion_x, int motion_y, int h)
2352
{
2353
    uint8_t *ptr;
2354
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
2355
    int emu=0;
2356

    
2357
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2358
    src_x = s->mb_x * 16 + (motion_x >> 2);
2359
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2360

    
2361
    height = s->height >> field_based;
2362
    v_edge_pos = s->v_edge_pos >> field_based;
2363
    src_x = clip(src_x, -16, s->width);
2364
    if (src_x == s->width)
2365
        dxy &= ~3;
2366
    src_y = clip(src_y, -16, height);
2367
    if (src_y == height)
2368
        dxy &= ~12;
2369
    linesize = s->linesize << field_based;
2370
    uvlinesize = s->uvlinesize << field_based;
2371
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
2372
    dest_y += dest_offset;
2373
//printf("%d %d %d\n", src_x, src_y, dxy);
2374
    
2375
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2376
        if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 
2377
           || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
2378
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr - src_offset, s->linesize, 17, 17+field_based, 
2379
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2380
            ptr= s->edge_emu_buffer + src_offset;
2381
            emu=1;
2382
        }
2383
    }
2384
    if(!field_based)
2385
        qpix_op[0][dxy](dest_y, ptr, linesize);
2386
    else{
2387
        //damn interlaced mode
2388
        //FIXME boundary mirroring is not exactly correct here
2389
        qpix_op[1][dxy](dest_y  , ptr  , linesize);
2390
        qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
2391
    }
2392

    
2393
    if(s->flags&CODEC_FLAG_GRAY) return;
2394

    
2395
    if(field_based){
2396
        mx= motion_x/2;
2397
        my= motion_y>>1;
2398
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2399
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
2400
        mx= (motion_x>>1) + rtab[motion_x&7];
2401
        my= (motion_y>>1) + rtab[motion_y&7];
2402
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2403
        mx= (motion_x>>1)|(motion_x&1);
2404
        my= (motion_y>>1)|(motion_y&1);
2405
    }else{
2406
        mx= motion_x/2;
2407
        my= motion_y/2;
2408
    }
2409
    mx= (mx>>1)|(mx&1);
2410
    my= (my>>1)|(my&1);
2411

    
2412
    dxy= (mx&1) | ((my&1)<<1);
2413
    mx>>=1;
2414
    my>>=1;
2415

    
2416
    src_x = s->mb_x * 8 + mx;
2417
    src_y = s->mb_y * (8 >> field_based) + my;
2418
    src_x = clip(src_x, -8, s->width >> 1);
2419
    if (src_x == (s->width >> 1))
2420
        dxy &= ~1;
2421
    src_y = clip(src_y, -8, height >> 1);
2422
    if (src_y == (height >> 1))
2423
        dxy &= ~2;
2424

    
2425
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
2426
    ptr = ref_picture[1] + offset;
2427
    if(emu){
2428
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
2429
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2430
        ptr= s->edge_emu_buffer + (src_offset >> 1);
2431
    }
2432
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
2433
    
2434
    ptr = ref_picture[2] + offset;
2435
    if(emu){
2436
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
2437
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2438
        ptr= s->edge_emu_buffer + (src_offset >> 1);
2439
    }
2440
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
2441
}
2442

    
2443
inline int ff_h263_round_chroma(int x){
2444
    if (x >= 0)
2445
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2446
    else {
2447
        x = -x;
2448
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2449
    }
2450
}
2451

    
2452
/**
2453
 * h263 chorma 4mv motion compensation.
2454
 */
2455
static inline void chroma_4mv_motion(MpegEncContext *s,
2456
                                     uint8_t *dest_cb, uint8_t *dest_cr,
2457
                                     uint8_t **ref_picture,
2458
                                     op_pixels_func *pix_op,
2459
                                     int mx, int my){
2460
    int dxy, emu=0, src_x, src_y, offset;
2461
    uint8_t *ptr;
2462
    
2463
    /* In case of 8X8, we construct a single chroma motion vector
2464
       with a special rounding */
2465
    mx= ff_h263_round_chroma(mx);
2466
    my= ff_h263_round_chroma(my);
2467
    
2468
    dxy = ((my & 1) << 1) | (mx & 1);
2469
    mx >>= 1;
2470
    my >>= 1;
2471

    
2472
    src_x = s->mb_x * 8 + mx;
2473
    src_y = s->mb_y * 8 + my;
2474
    src_x = clip(src_x, -8, s->width/2);
2475
    if (src_x == s->width/2)
2476
        dxy &= ~1;
2477
    src_y = clip(src_y, -8, s->height/2);
2478
    if (src_y == s->height/2)
2479
        dxy &= ~2;
2480
    
2481
    offset = (src_y * (s->uvlinesize)) + src_x;
2482
    ptr = ref_picture[1] + offset;
2483
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2484
        if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
2485
           || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
2486
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2487
            ptr= s->edge_emu_buffer;
2488
            emu=1;
2489
        }
2490
    }
2491
    pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
2492

    
2493
    ptr = ref_picture[2] + offset;
2494
    if(emu){
2495
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2496
        ptr= s->edge_emu_buffer;
2497
    }
2498
    pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
2499
}
2500

    
2501
/**
2502
 * motion compesation of a single macroblock
2503
 * @param s context
2504
 * @param dest_y luma destination pointer
2505
 * @param dest_cb chroma cb/u destination pointer
2506
 * @param dest_cr chroma cr/v destination pointer
2507
 * @param dir direction (0->forward, 1->backward)
2508
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2509
 * @param pic_op halfpel motion compensation function (average or put normally)
2510
 * @param pic_op qpel motion compensation function (average or put normally)
2511
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2512
 */
2513
static inline void MPV_motion(MpegEncContext *s, 
2514
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2515
                              int dir, uint8_t **ref_picture, 
2516
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
2517
{
2518
    int dxy, mx, my, src_x, src_y, motion_x, motion_y;
2519
    int mb_x, mb_y, i;
2520
    uint8_t *ptr, *dest;
2521

    
2522
    mb_x = s->mb_x;
2523
    mb_y = s->mb_y;
2524

    
2525
    if(s->obmc && s->pict_type != B_TYPE){
2526
        int16_t mv_cache[4][4][2];
2527
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
2528
        const int mot_stride= s->mb_width*2 + 2;
2529
        const int mot_xy= 1 + mb_x*2 + (mb_y*2 + 1)*mot_stride;
2530

    
2531
        assert(!s->mb_skiped);
2532
                
2533
        memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
2534
        memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2535
        memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2536

    
2537
        if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
2538
            memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
2539
        }else{
2540
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
2541
        }
2542

    
2543
        if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
2544
            *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
2545
            *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
2546
        }else{
2547
            *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
2548
            *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
2549
        }
2550

    
2551
        if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
2552
            *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
2553
            *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
2554
        }else{
2555
            *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
2556
            *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
2557
        }
2558
        
2559
        mx = 0;
2560
        my = 0;
2561
        for(i=0;i<4;i++) {
2562
            const int x= (i&1)+1;
2563
            const int y= (i>>1)+1;
2564
            int16_t mv[5][2]= {
2565
                {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
2566
                {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
2567
                {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
2568
                {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
2569
                {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
2570
            //FIXME cleanup
2571
            obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2572
                        ref_picture[0],
2573
                        mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2574
                        pix_op[1],
2575
                        mv);
2576

    
2577
            mx += mv[0][0];
2578
            my += mv[0][1];
2579
        }
2580
        if(!(s->flags&CODEC_FLAG_GRAY))
2581
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2582

    
2583
        return;
2584
    }
2585
   
2586
    switch(s->mv_type) {
2587
    case MV_TYPE_16X16:
2588
#ifdef CONFIG_RISKY
2589
        if(s->mcsel){
2590
            if(s->real_sprite_warping_points==1){
2591
                gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
2592
                            ref_picture, 0);
2593
            }else{
2594
                gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
2595
                            ref_picture, 0);
2596
            }
2597
        }else if(s->quarter_sample){
2598
            qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2599
                        ref_picture, 0,
2600
                        0, pix_op, qpix_op,
2601
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2602
        }else if(s->mspel){
2603
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
2604
                        ref_picture, pix_op,
2605
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2606
        }else
2607
#endif
2608
        {
2609
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2610
                        ref_picture, 0,
2611
                        0, pix_op,
2612
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2613
        }           
2614
        break;
2615
    case MV_TYPE_8X8:
2616
        mx = 0;
2617
        my = 0;
2618
        if(s->quarter_sample){
2619
            for(i=0;i<4;i++) {
2620
                motion_x = s->mv[dir][i][0];
2621
                motion_y = s->mv[dir][i][1];
2622

    
2623
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2624
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
2625
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
2626
                    
2627
                /* WARNING: do no forget half pels */
2628
                src_x = clip(src_x, -16, s->width);
2629
                if (src_x == s->width)
2630
                    dxy &= ~3;
2631
                src_y = clip(src_y, -16, s->height);
2632
                if (src_y == s->height)
2633
                    dxy &= ~12;
2634
                    
2635
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2636
                if(s->flags&CODEC_FLAG_EMU_EDGE){
2637
                    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8 
2638
                       || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
2639
                        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2640
                        ptr= s->edge_emu_buffer;
2641
                    }
2642
                }
2643
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2644
                qpix_op[1][dxy](dest, ptr, s->linesize);
2645

    
2646
                mx += s->mv[dir][i][0]/2;
2647
                my += s->mv[dir][i][1]/2;
2648
            }
2649
        }else{
2650
            for(i=0;i<4;i++) {
2651
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2652
                            ref_picture[0],
2653
                            mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2654
                            s->width, s->height, s->linesize,
2655
                            s->h_edge_pos, s->v_edge_pos,
2656
                            8, 8, pix_op[1],
2657
                            s->mv[dir][i][0], s->mv[dir][i][1]);
2658

    
2659
                mx += s->mv[dir][i][0];
2660
                my += s->mv[dir][i][1];
2661
            }
2662
        }
2663

    
2664
        if(!(s->flags&CODEC_FLAG_GRAY))
2665
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2666
        break;
2667
    case MV_TYPE_FIELD:
2668
        if (s->picture_structure == PICT_FRAME) {
2669
            if(s->quarter_sample){
2670
                /* top field */
2671
                qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2672
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2673
                            1, pix_op, qpix_op,
2674
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
2675
                /* bottom field */
2676
                qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2677
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2678
                            1, pix_op, qpix_op,
2679
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
2680
            }else{
2681
                /* top field */       
2682
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2683
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2684
                            1, pix_op,
2685
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
2686
                /* bottom field */
2687
                mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2688
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2689
                            1, pix_op,
2690
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
2691
            }
2692
        } else {
2693
            int offset;
2694
            if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2695
                offset= s->field_select[dir][0] ? s->linesize : 0;
2696
            }else{
2697
                ref_picture= s->current_picture.data;
2698
                offset= s->field_select[dir][0] ? s->linesize : -s->linesize; 
2699
            } 
2700

    
2701
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2702
                        ref_picture, offset,
2703
                        0, pix_op,
2704
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2705
        }
2706
        break;
2707
    case MV_TYPE_16X8:{
2708
        int offset;
2709
         uint8_t ** ref2picture;
2710

    
2711
            if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2712
                ref2picture= ref_picture;
2713
                offset= s->field_select[dir][0] ? s->linesize : 0;
2714
            }else{
2715
                ref2picture= s->current_picture.data;
2716
                offset= s->field_select[dir][0] ? s->linesize : -s->linesize; 
2717
            } 
2718

    
2719
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2720
                        ref2picture, offset,
2721
                        0, pix_op,
2722
                        s->mv[dir][0][0], s->mv[dir][0][1], 8);
2723

    
2724

    
2725
            if(s->picture_structure == s->field_select[dir][1] + 1 || s->pict_type == B_TYPE || s->first_field){
2726
                ref2picture= ref_picture;
2727
                offset= s->field_select[dir][1] ? s->linesize : 0;
2728
            }else{
2729
                ref2picture= s->current_picture.data;
2730
                offset= s->field_select[dir][1] ? s->linesize : -s->linesize; 
2731
            } 
2732
            // I know it is ugly but this is the only way to fool emu_edge without rewrite mpeg_motion
2733
            mpeg_motion(s, dest_y+16*s->linesize, dest_cb+8*s->uvlinesize, dest_cr+8*s->uvlinesize,
2734
                        0,
2735
                        ref2picture, offset,
2736
                        0, pix_op,
2737
                        s->mv[dir][1][0], s->mv[dir][1][1]+16, 8);
2738
        }
2739
        
2740
        break;
2741
    case MV_TYPE_DMV:
2742
    {
2743
    op_pixels_func (*dmv_pix_op)[4];
2744
    int offset;
2745

    
2746
        dmv_pix_op = s->dsp.put_pixels_tab;
2747

    
2748
        if(s->picture_structure == PICT_FRAME){
2749
            //put top field from top field
2750
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2751
                        ref_picture, 0,
2752
                        1, dmv_pix_op,
2753
                        s->mv[dir][0][0], s->mv[dir][0][1], 8);
2754
            //put bottom field from bottom field
2755
            mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2756
                        ref_picture, s->linesize,
2757
                        1, dmv_pix_op,
2758
                        s->mv[dir][0][0], s->mv[dir][0][1], 8);
2759

    
2760
            dmv_pix_op = s->dsp.avg_pixels_tab; 
2761
        
2762
            //avg top field from bottom field
2763
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2764
                        ref_picture, s->linesize,
2765
                        1, dmv_pix_op,
2766
                        s->mv[dir][2][0], s->mv[dir][2][1], 8);
2767
            //avg bottom field from top field
2768
            mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2769
                        ref_picture, 0,
2770
                        1, dmv_pix_op,
2771
                        s->mv[dir][3][0], s->mv[dir][3][1], 8);
2772

    
2773
        }else{
2774
            offset=(s->picture_structure == PICT_BOTTOM_FIELD)? 
2775
                         s->linesize : 0;
2776

    
2777
            //put field from the same parity
2778
            //same parity is never in the same frame
2779
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2780
                        ref_picture,offset,
2781
                        0,dmv_pix_op,
2782
                        s->mv[dir][0][0],s->mv[dir][0][1],16);
2783

    
2784
            // after put we make avg of the same block
2785
            dmv_pix_op=s->dsp.avg_pixels_tab; 
2786

    
2787
            //opposite parity is always in the same frame if this is second field
2788
            if(!s->first_field){
2789
                ref_picture = s->current_picture.data;    
2790
                //top field is one linesize from frame beginig
2791
                offset=(s->picture_structure == PICT_BOTTOM_FIELD)? 
2792
                        -s->linesize : s->linesize;
2793
            }else 
2794
                offset=(s->picture_structure == PICT_BOTTOM_FIELD)? 
2795
                        0 : s->linesize;
2796

    
2797
            //avg field from the opposite parity
2798
            mpeg_motion(s, dest_y, dest_cb, dest_cr,0,
2799
                        ref_picture, offset,
2800
                        0,dmv_pix_op,
2801
                        s->mv[dir][2][0],s->mv[dir][2][1],16);
2802
        }
2803
    }
2804
    break;
2805
    default: assert(0);
2806
    }
2807
}
2808

    
2809

    
2810
/* put block[] to dest[] */
2811
static inline void put_dct(MpegEncContext *s, 
2812
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2813
{
2814
    s->dct_unquantize_intra(s, block, i, qscale);
2815
    s->dsp.idct_put (dest, line_size, block);
2816
}
2817

    
2818
/* add block[] to dest[] */
2819
static inline void add_dct(MpegEncContext *s, 
2820
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
2821
{
2822
    if (s->block_last_index[i] >= 0) {
2823
        s->dsp.idct_add (dest, line_size, block);
2824
    }
2825
}
2826

    
2827
static inline void add_dequant_dct(MpegEncContext *s, 
2828
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2829
{
2830
    if (s->block_last_index[i] >= 0) {
2831
        s->dct_unquantize_inter(s, block, i, qscale);
2832

    
2833
        s->dsp.idct_add (dest, line_size, block);
2834
    }
2835
}
2836

    
2837
/**
2838
 * cleans dc, ac, coded_block for the current non intra MB
2839
 */
2840
void ff_clean_intra_table_entries(MpegEncContext *s)
2841
{
2842
    int wrap = s->block_wrap[0];
2843
    int xy = s->block_index[0];
2844
    
2845
    s->dc_val[0][xy           ] = 
2846
    s->dc_val[0][xy + 1       ] = 
2847
    s->dc_val[0][xy     + wrap] =
2848
    s->dc_val[0][xy + 1 + wrap] = 1024;
2849
    /* ac pred */
2850
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2851
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2852
    if (s->msmpeg4_version>=3) {
2853
        s->coded_block[xy           ] =
2854
        s->coded_block[xy + 1       ] =
2855
        s->coded_block[xy     + wrap] =
2856
        s->coded_block[xy + 1 + wrap] = 0;
2857
    }
2858
    /* chroma */
2859
    wrap = s->block_wrap[4];
2860
    xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
2861
    s->dc_val[1][xy] =
2862
    s->dc_val[2][xy] = 1024;
2863
    /* ac pred */
2864
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2865
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2866
    
2867
    s->mbintra_table[s->mb_x + s->mb_y*s->mb_stride]= 0;
2868
}
2869

    
2870
/* generic function called after a macroblock has been parsed by the
2871
   decoder or after it has been encoded by the encoder.
2872

2873
   Important variables used:
2874
   s->mb_intra : true if intra macroblock
2875
   s->mv_dir   : motion vector direction
2876
   s->mv_type  : motion vector type
2877
   s->mv       : motion vector
2878
   s->interlaced_dct : true if interlaced dct used (mpeg2)
2879
 */
2880
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
2881
{
2882
    int mb_x, mb_y;
2883
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2884
#ifdef HAVE_XVMC
2885
    if(s->avctx->xvmc_acceleration){
2886
        XVMC_decode_mb(s);//xvmc uses pblocks
2887
        return;
2888
    }
2889
#endif
2890

    
2891
    mb_x = s->mb_x;
2892
    mb_y = s->mb_y;
2893

    
2894
    s->current_picture.qscale_table[mb_xy]= s->qscale;
2895

    
2896
    /* update DC predictors for P macroblocks */
2897
    if (!s->mb_intra) {
2898
        if (s->h263_pred || s->h263_aic) {
2899
            if(s->mbintra_table[mb_xy])
2900
                ff_clean_intra_table_entries(s);
2901
        } else {
2902
            s->last_dc[0] =
2903
            s->last_dc[1] =
2904
            s->last_dc[2] = 128 << s->intra_dc_precision;
2905
        }
2906
    }
2907
    else if (s->h263_pred || s->h263_aic)
2908
        s->mbintra_table[mb_xy]=1;
2909

    
2910
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
2911
        uint8_t *dest_y, *dest_cb, *dest_cr;
2912
        int dct_linesize, dct_offset;
2913
        op_pixels_func (*op_pix)[4];
2914
        qpel_mc_func (*op_qpix)[16];
2915
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
2916
        const int uvlinesize= s->current_picture.linesize[1];
2917
        const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band;
2918

    
2919
        /* avoid copy if macroblock skipped in last frame too */
2920
        /* skip only during decoding as we might trash the buffers during encoding a bit */
2921
        if(!s->encoding){
2922
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2923
            const int age= s->current_picture.age;
2924

    
2925
            assert(age);
2926

    
2927
            if (s->mb_skiped) {
2928
                s->mb_skiped= 0;
2929
                assert(s->pict_type!=I_TYPE);
2930
 
2931
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
2932
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2933

    
2934
                /* if previous was skipped too, then nothing to do !  */
2935
                if (*mbskip_ptr >= age && s->current_picture.reference){
2936
                    return;
2937
                }
2938
            } else if(!s->current_picture.reference){
2939
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2940
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2941
            } else{
2942
                *mbskip_ptr = 0; /* not skipped */
2943
            }
2944
        }
2945

    
2946
        if (s->interlaced_dct) {
2947
            dct_linesize = linesize * 2;
2948
            dct_offset = linesize;
2949
        } else {
2950
            dct_linesize = linesize;
2951
            dct_offset = linesize * 8;
2952
        }
2953
        if(readable){
2954
            dest_y=  s->dest[0];
2955
            dest_cb= s->dest[1];
2956
            dest_cr= s->dest[2];
2957
        }else{
2958
            dest_y = s->edge_emu_buffer+32; //FIXME cleanup scratchpad pointers
2959
            dest_cb= s->edge_emu_buffer+48;
2960
            dest_cr= s->edge_emu_buffer+56;
2961
        }
2962
        if (!s->mb_intra) {
2963
            /* motion handling */
2964
            /* decoding or more than one mb_type (MC was allready done otherwise) */
2965
            if(!s->encoding){
2966
                if ((!s->no_rounding) || s->pict_type==B_TYPE){                
2967
                    op_pix = s->dsp.put_pixels_tab;
2968
                    op_qpix= s->dsp.put_qpel_pixels_tab;
2969
                }else{
2970
                    op_pix = s->dsp.put_no_rnd_pixels_tab;
2971
                    op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2972
                }
2973

    
2974
                if (s->mv_dir & MV_DIR_FORWARD) {
2975
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2976
                    op_pix = s->dsp.avg_pixels_tab;
2977
                    op_qpix= s->dsp.avg_qpel_pixels_tab;
2978
                }
2979
                if (s->mv_dir & MV_DIR_BACKWARD) {
2980
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2981
                }
2982
            }
2983

    
2984
            /* skip dequant / idct if we are really late ;) */
2985
            if(s->hurry_up>1) return;
2986

    
2987
            /* add dct residue */
2988
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
2989
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2990
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
2991
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
2992
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
2993
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
2994

    
2995
                if(!(s->flags&CODEC_FLAG_GRAY)){
2996
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2997
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2998
                }
2999
            } else if(s->codec_id != CODEC_ID_WMV2){
3000
                add_dct(s, block[0], 0, dest_y, dct_linesize);
3001
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
3002
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
3003
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
3004

    
3005
                if(!(s->flags&CODEC_FLAG_GRAY)){
3006
                    add_dct(s, block[4], 4, dest_cb, uvlinesize);
3007
                    add_dct(s, block[5], 5, dest_cr, uvlinesize);
3008
                }
3009
            } 
3010
#ifdef CONFIG_RISKY
3011
            else{
3012
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3013
            }
3014
#endif
3015
        } else {
3016
            /* dct only in intra block */
3017
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3018
                put_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
3019
                put_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
3020
                put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
3021
                put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
3022

    
3023
                if(!(s->flags&CODEC_FLAG_GRAY)){
3024
                    put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3025
                    put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3026
                }
3027
            }else{
3028
                s->dsp.idct_put(dest_y                 , dct_linesize, block[0]);
3029
                s->dsp.idct_put(dest_y              + 8, dct_linesize, block[1]);
3030
                s->dsp.idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
3031
                s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
3032

    
3033
                if(!(s->flags&CODEC_FLAG_GRAY)){
3034
                    s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3035
                    s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3036
                }
3037
            }
3038
        }
3039
        if(!readable){
3040
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3041
            s->dsp.put_pixels_tab[1][0](s->dest[1], dest_cb, uvlinesize, 8);
3042
            s->dsp.put_pixels_tab[1][0](s->dest[2], dest_cr, uvlinesize, 8);
3043
        }
3044
    }
3045
}
3046

    
3047
#ifdef CONFIG_ENCODERS
3048

    
3049
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3050
{
3051
    static const char tab[64]=
3052
        {3,2,2,1,1,1,1,1,
3053
         1,1,1,1,1,1,1,1,
3054
         1,1,1,1,1,1,1,1,
3055
         0,0,0,0,0,0,0,0,
3056
         0,0,0,0,0,0,0,0,
3057
         0,0,0,0,0,0,0,0,
3058
         0,0,0,0,0,0,0,0,
3059
         0,0,0,0,0,0,0,0};
3060
    int score=0;
3061
    int run=0;
3062
    int i;
3063
    DCTELEM *block= s->block[n];
3064
    const int last_index= s->block_last_index[n];
3065
    int skip_dc;
3066

    
3067
    if(threshold<0){
3068
        skip_dc=0;
3069
        threshold= -threshold;
3070
    }else
3071
        skip_dc=1;
3072

    
3073
    /* are all which we could set to zero are allready zero? */
3074
    if(last_index<=skip_dc - 1) return;
3075

    
3076
    for(i=0; i<=last_index; i++){
3077
        const int j = s->intra_scantable.permutated[i];
3078
        const int level = ABS(block[j]);
3079
        if(level==1){
3080
            if(skip_dc && i==0) continue;
3081
            score+= tab[run];
3082
            run=0;
3083
        }else if(level>1){
3084
            return;
3085
        }else{
3086
            run++;
3087
        }
3088
    }
3089
    if(score >= threshold) return;
3090
    for(i=skip_dc; i<=last_index; i++){
3091
        const int j = s->intra_scantable.permutated[i];
3092
        block[j]=0;
3093
    }
3094
    if(block[0]) s->block_last_index[n]= 0;
3095
    else         s->block_last_index[n]= -1;
3096
}
3097

    
3098
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
3099
{
3100
    int i;
3101
    const int maxlevel= s->max_qcoeff;
3102
    const int minlevel= s->min_qcoeff;
3103
    
3104
    if(s->mb_intra){
3105
        i=1; //skip clipping of intra dc
3106
    }else
3107
        i=0;
3108
    
3109
    for(;i<=last_index; i++){
3110
        const int j= s->intra_scantable.permutated[i];
3111
        int level = block[j];
3112
       
3113
        if     (level>maxlevel) level=maxlevel;
3114
        else if(level<minlevel) level=minlevel;
3115

    
3116
        block[j]= level;
3117
    }
3118
}
3119

    
3120
#if 0
3121
static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
3122
    int score=0;
3123
    int x,y;
3124
    
3125
    for(y=0; y<7; y++){
3126
        for(x=0; x<16; x+=4){
3127
            score+= ABS(s[x  ] - s[x  +stride]) + ABS(s[x+1] - s[x+1+stride]) 
3128
                   +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
3129
        }
3130
        s+= stride;
3131
    }
3132
    
3133
    return score;
3134
}
3135

3136
static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
3137
    int score=0;
3138
    int x,y;
3139
    
3140
    for(y=0; y<7; y++){
3141
        for(x=0; x<16; x++){
3142
            score+= ABS(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
3143
        }
3144
        s1+= stride;
3145
        s2+= stride;
3146
    }
3147
    
3148
    return score;
3149
}
3150
#else
3151
#define SQ(a) ((a)*(a))
3152

    
3153
static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
3154
    int score=0;
3155
    int x,y;
3156
    
3157
    for(y=0; y<7; y++){
3158
        for(x=0; x<16; x+=4){
3159
            score+= SQ(s[x  ] - s[x  +stride]) + SQ(s[x+1] - s[x+1+stride]) 
3160
                   +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
3161
        }
3162
        s+= stride;
3163
    }
3164
    
3165
    return score;
3166
}
3167

    
3168
static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
3169
    int score=0;
3170
    int x,y;
3171
    
3172
    for(y=0; y<7; y++){
3173
        for(x=0; x<16; x++){
3174
            score+= SQ(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
3175
        }
3176
        s1+= stride;
3177
        s2+= stride;
3178
    }
3179
    
3180
    return score;
3181
}
3182

    
3183
#endif
3184

    
3185
#endif //CONFIG_ENCODERS
3186

    
3187
/**
3188
 *
3189
 * @param h is the normal height, this will be reduced automatically if needed for the last row
3190
 */
3191
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3192
    if (s->avctx->draw_horiz_band) {
3193
        AVFrame *src;
3194
        int offset[4];
3195
        
3196
        if(s->picture_structure != PICT_FRAME){
3197
            h <<= 1;
3198
            y <<= 1;
3199
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3200
        }
3201

    
3202
        h= FFMIN(h, s->height - y);
3203

    
3204
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) 
3205
            src= (AVFrame*)s->current_picture_ptr;
3206
        else if(s->last_picture_ptr)
3207
            src= (AVFrame*)s->last_picture_ptr;
3208
        else
3209
            return;
3210
            
3211
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3212
            offset[0]=
3213
            offset[1]=
3214
            offset[2]=
3215
            offset[3]= 0;
3216
        }else{
3217
            offset[0]= y * s->linesize;;
3218
            offset[1]= 
3219
            offset[2]= (y>>1) * s->uvlinesize;;
3220
            offset[3]= 0;
3221
        }
3222

    
3223
        emms_c();
3224

    
3225
        s->avctx->draw_horiz_band(s->avctx, src, offset,
3226
                                  y, s->picture_structure, h);
3227
    }
3228
}
3229

    
3230
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3231
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3232
    const int uvlinesize= s->current_picture.linesize[1];
3233
        
3234
    s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3235
    s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1)     + s->mb_x*2;
3236
    s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1 + s->mb_x*2;
3237
    s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2)     + s->mb_x*2;
3238
    s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
3239
    s->block_index[5]= s->block_wrap[4]*(s->mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
3240
    
3241
    if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){
3242
        s->dest[0] = s->current_picture.data[0] + s->mb_x * 16 - 16;
3243
        s->dest[1] = s->current_picture.data[1] + s->mb_x * 8 - 8;
3244
        s->dest[2] = s->current_picture.data[2] + s->mb_x * 8 - 8;
3245
    }else{
3246
        s->dest[0] = s->current_picture.data[0] + (s->mb_y * 16* linesize  ) + s->mb_x * 16 - 16;
3247
        s->dest[1] = s->current_picture.data[1] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
3248
        s->dest[2] = s->current_picture.data[2] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
3249
    }    
3250
}
3251

    
3252
#ifdef CONFIG_ENCODERS
3253

    
3254
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
3255
{
3256
    const int mb_x= s->mb_x;
3257
    const int mb_y= s->mb_y;
3258
    int i;
3259
    int skip_dct[6];
3260
    int dct_offset   = s->linesize*8; //default for progressive frames
3261
    
3262
    for(i=0; i<6; i++) skip_dct[i]=0;
3263
    
3264
    if(s->adaptive_quant){
3265
        const int last_qp= s->qscale;
3266
        const int mb_xy= mb_x + mb_y*s->mb_stride;
3267

    
3268
        s->lambda= s->lambda_table[mb_xy];
3269
        update_qscale(s);
3270
    
3271
        if(!(s->flags&CODEC_FLAG_QP_RD)){
3272
            s->dquant= s->qscale - last_qp;
3273

    
3274
            if(s->out_format==FMT_H263)
3275
                s->dquant= clip(s->dquant, -2, 2); //FIXME RD
3276
            
3277
            if(s->codec_id==CODEC_ID_MPEG4){        
3278
                if(!s->mb_intra){
3279
                    if((s->mv_dir&MV_DIRECT) || s->mv_type==MV_TYPE_8X8)
3280
                        s->dquant=0;
3281
                }
3282
            }
3283
        }
3284
        ff_set_qscale(s, last_qp + s->dquant);
3285
    }
3286

    
3287
    if (s->mb_intra) {
3288
        uint8_t *ptr;
3289
        int wrap_y;
3290
        int emu=0;
3291

    
3292
        wrap_y = s->linesize;
3293
        ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
3294

    
3295
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
3296
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
3297
            ptr= s->edge_emu_buffer;
3298
            emu=1;
3299
        }
3300
        
3301
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3302
            int progressive_score, interlaced_score;
3303
            
3304
            progressive_score= pix_vcmp16x8(ptr, wrap_y  ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
3305
            interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y  , wrap_y*2);
3306
            
3307
            if(progressive_score > interlaced_score + 100){
3308
                s->interlaced_dct=1;
3309
            
3310
                dct_offset= wrap_y;
3311
                wrap_y<<=1;
3312
            }else
3313
                s->interlaced_dct=0;
3314
        }
3315
        
3316
        s->dsp.get_pixels(s->block[0], ptr                 , wrap_y);
3317
        s->dsp.get_pixels(s->block[1], ptr              + 8, wrap_y);
3318
        s->dsp.get_pixels(s->block[2], ptr + dct_offset    , wrap_y);
3319
        s->dsp.get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
3320

    
3321
        if(s->flags&CODEC_FLAG_GRAY){
3322
            skip_dct[4]= 1;
3323
            skip_dct[5]= 1;
3324
        }else{
3325
            int wrap_c = s->uvlinesize;
3326
            ptr = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
3327
            if(emu){
3328
                ff_emulated_edge_mc(s->edge_emu_buffer, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3329
                ptr= s->edge_emu_buffer;
3330
            }
3331
            s->dsp.get_pixels(s->block[4], ptr, wrap_c);
3332

    
3333
            ptr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3334
            if(emu){
3335
                ff_emulated_edge_mc(s->edge_emu_buffer, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3336
                ptr= s->edge_emu_buffer;
3337
            }
3338
            s->dsp.get_pixels(s->block[5], ptr, wrap_c);
3339
        }
3340
    }else{
3341
        op_pixels_func (*op_pix)[4];
3342
        qpel_mc_func (*op_qpix)[16];
3343
        uint8_t *dest_y, *dest_cb, *dest_cr;
3344
        uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3345
        int wrap_y, wrap_c;
3346
        int emu=0;
3347

    
3348
        dest_y  = s->dest[0];
3349
        dest_cb = s->dest[1];
3350
        dest_cr = s->dest[2];
3351
        wrap_y = s->linesize;
3352
        wrap_c = s->uvlinesize;
3353
        ptr_y  = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
3354
        ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
3355
        ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3356

    
3357
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
3358
            op_pix = s->dsp.put_pixels_tab;
3359
            op_qpix= s->dsp.put_qpel_pixels_tab;
3360
        }else{
3361
            op_pix = s->dsp.put_no_rnd_pixels_tab;
3362
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3363
        }
3364

    
3365
        if (s->mv_dir & MV_DIR_FORWARD) {
3366
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3367
            op_pix = s->dsp.avg_pixels_tab;
3368
            op_qpix= s->dsp.avg_qpel_pixels_tab;
3369
        }
3370
        if (s->mv_dir & MV_DIR_BACKWARD) {
3371
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3372
        }
3373

    
3374
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
3375
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
3376
            ptr_y= s->edge_emu_buffer;
3377
            emu=1;
3378
        }
3379
        
3380
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3381
            int progressive_score, interlaced_score;
3382
            
3383
            progressive_score= pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y  ) 
3384
                             + pix_diff_vcmp16x8(ptr_y + wrap_y*8, dest_y + wrap_y*8, wrap_y  );
3385
            interlaced_score = pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y*2)
3386
                             + pix_diff_vcmp16x8(ptr_y + wrap_y  , dest_y + wrap_y  , wrap_y*2);
3387
            
3388
            if(progressive_score > interlaced_score + 600){
3389
                s->interlaced_dct=1;
3390
            
3391
                dct_offset= wrap_y;
3392
                wrap_y<<=1;
3393
            }else
3394
                s->interlaced_dct=0;
3395
        }
3396
        
3397
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
3398
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
3399
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
3400
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
3401
        
3402
        if(s->flags&CODEC_FLAG_GRAY){
3403
            skip_dct[4]= 1;
3404
            skip_dct[5]= 1;
3405
        }else{
3406
            if(emu){
3407
                ff_emulated_edge_mc(s->edge_emu_buffer, ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3408
                ptr_cb= s->edge_emu_buffer;
3409
            }
3410
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
3411
            if(emu){
3412
                ff_emulated_edge_mc(s->edge_emu_buffer, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3413
                ptr_cr= s->edge_emu_buffer;
3414
            }
3415
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
3416
        }
3417
        /* pre quantization */         
3418
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
3419
            //FIXME optimize
3420
            if(s->dsp.pix_abs8x8(ptr_y               , dest_y               , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
3421
            if(s->dsp.pix_abs8x8(ptr_y            + 8, dest_y            + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
3422
            if(s->dsp.pix_abs8x8(ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
3423
            if(s->dsp.pix_abs8x8(ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
3424
            if(s->dsp.pix_abs8x8(ptr_cb              , dest_cb              , wrap_c) < 20*s->qscale) skip_dct[4]= 1;
3425
            if(s->dsp.pix_abs8x8(ptr_cr              , dest_cr              , wrap_c) < 20*s->qscale) skip_dct[5]= 1;
3426
#if 0
3427
{
3428
 static int stat[7];
3429
 int num=0;
3430
 for(i=0; i<6; i++)
3431
  if(skip_dct[i]) num++;
3432
 stat[num]++;
3433
 
3434
 if(s->mb_x==0 && s->mb_y==0){
3435
  for(i=0; i<7; i++){
3436
   printf("%6d %1d\n", stat[i], i);
3437
  }
3438
 }
3439
}
3440
#endif
3441
        }
3442

    
3443
    }
3444
            
3445
    /* DCT & quantize */
3446
    if(s->out_format==FMT_MJPEG){
3447
        for(i=0;i<6;i++) {
3448
            int overflow;
3449
            s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
3450
            if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
3451
        }
3452
    }else{
3453
        for(i=0;i<6;i++) {
3454
            if(!skip_dct[i]){
3455
                int overflow;
3456
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
3457
            // FIXME we could decide to change to quantizer instead of clipping
3458
            // JS: I don't think that would be a good idea it could lower quality instead
3459
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
3460
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
3461
            }else
3462
                s->block_last_index[i]= -1;
3463
        }
3464
        
3465
        if(s->luma_elim_threshold && !s->mb_intra)
3466
            for(i=0; i<4; i++)
3467
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
3468
        if(s->chroma_elim_threshold && !s->mb_intra)
3469
            for(i=4; i<6; i++)
3470
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
3471

    
3472
        if(s->flags & CODEC_FLAG_CBP_RD){
3473
            for(i=0;i<6;i++) {
3474
                if(s->block_last_index[i] == -1)
3475
                    s->coded_score[i]= INT_MAX/256;
3476
            }
3477
        }
3478
    }
3479

    
3480
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
3481
        s->block_last_index[4]=
3482
        s->block_last_index[5]= 0;
3483
        s->block[4][0]=
3484
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
3485
    }
3486

    
3487
    /* huffman encode */
3488
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
3489
    case CODEC_ID_MPEG1VIDEO:
3490
    case CODEC_ID_MPEG2VIDEO:
3491
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
3492
#ifdef CONFIG_RISKY
3493
    case CODEC_ID_MPEG4:
3494
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3495
    case CODEC_ID_MSMPEG4V2:
3496
    case CODEC_ID_MSMPEG4V3:
3497
    case CODEC_ID_WMV1:
3498
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3499
    case CODEC_ID_WMV2:
3500
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
3501
    case CODEC_ID_H263:
3502
    case CODEC_ID_H263P:
3503
    case CODEC_ID_FLV1:
3504
    case CODEC_ID_RV10:
3505
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
3506
#endif
3507
    case CODEC_ID_MJPEG:
3508
        mjpeg_encode_mb(s, s->block); break;
3509
    default:
3510
        assert(0);
3511
    }
3512
}
3513

    
3514
#endif //CONFIG_ENCODERS
3515

    
3516
/**
3517
 * combines the (truncated) bitstream to a complete frame
3518
 * @returns -1 if no complete frame could be created
3519
 */
3520
int ff_combine_frame( MpegEncContext *s, int next, uint8_t **buf, int *buf_size){
3521
    ParseContext *pc= &s->parse_context;
3522

    
3523
#if 0
3524
    if(pc->overread){
3525
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
3526
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
3527
    }
3528
#endif
3529

    
3530
    /* copy overreaded byes from last frame into buffer */
3531
    for(; pc->overread>0; pc->overread--){
3532
        pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
3533
    }
3534
    
3535
    pc->last_index= pc->index;
3536

    
3537
    /* copy into buffer end return */
3538
    if(next == END_NOT_FOUND){
3539
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
3540

    
3541
        memcpy(&pc->buffer[pc->index], *buf, *buf_size);
3542
        pc->index += *buf_size;
3543
        return -1;
3544
    }
3545

    
3546
    *buf_size=
3547
    pc->overread_index= pc->index + next;
3548
    
3549
    /* append to buffer */
3550
    if(pc->index){
3551
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
3552

    
3553
        memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
3554
        pc->index = 0;
3555
        *buf= pc->buffer;
3556
    }
3557

    
3558
    /* store overread bytes */
3559
    for(;next < 0; next++){
3560
        pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
3561
        pc->overread++;
3562
    }
3563

    
3564
#if 0
3565
    if(pc->overread){
3566
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
3567
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
3568
    }
3569
#endif
3570

    
3571
    return 0;
3572
}
3573

    
3574
void ff_mpeg_flush(AVCodecContext *avctx){
3575
    int i;
3576
    MpegEncContext *s = avctx->priv_data;
3577
    
3578
    for(i=0; i<MAX_PICTURE_COUNT; i++){
3579
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
3580
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
3581
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
3582
    }
3583
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
3584
    
3585
    s->parse_context.state= -1;
3586
    s->parse_context.frame_start_found= 0;
3587
    s->parse_context.overread= 0;
3588
    s->parse_context.overread_index= 0;
3589
    s->parse_context.index= 0;
3590
    s->parse_context.last_index= 0;
3591
}
3592

    
3593
#ifdef CONFIG_ENCODERS
3594
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
3595
{
3596
    int bytes= length>>4;
3597
    int bits= length&15;
3598
    int i;
3599

    
3600
    if(length==0) return;
3601

    
3602
    for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
3603
    put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
3604
}
3605

    
3606
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
3607
    int i;
3608

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

    
3611
    /* mpeg1 */
3612
    d->mb_skip_run= s->mb_skip_run;
3613
    for(i=0; i<3; i++)
3614
        d->last_dc[i]= s->last_dc[i];
3615
    
3616
    /* statistics */
3617
    d->mv_bits= s->mv_bits;
3618
    d->i_tex_bits= s->i_tex_bits;
3619
    d->p_tex_bits= s->p_tex_bits;
3620
    d->i_count= s->i_count;
3621
    d->f_count= s->f_count;
3622
    d->b_count= s->b_count;
3623
    d->skip_count= s->skip_count;
3624
    d->misc_bits= s->misc_bits;
3625
    d->last_bits= 0;
3626

    
3627
    d->mb_skiped= 0;
3628
    d->qscale= s->qscale;
3629
    d->dquant= s->dquant;
3630
}
3631

    
3632
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
3633
    int i;
3634

    
3635
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
3636
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
3637
    
3638
    /* mpeg1 */
3639
    d->mb_skip_run= s->mb_skip_run;
3640
    for(i=0; i<3; i++)
3641
        d->last_dc[i]= s->last_dc[i];
3642
    
3643
    /* statistics */
3644
    d->mv_bits= s->mv_bits;
3645
    d->i_tex_bits= s->i_tex_bits;
3646
    d->p_tex_bits= s->p_tex_bits;
3647
    d->i_count= s->i_count;
3648
    d->f_count= s->f_count;
3649
    d->b_count= s->b_count;
3650
    d->skip_count= s->skip_count;
3651
    d->misc_bits= s->misc_bits;
3652

    
3653
    d->mb_intra= s->mb_intra;
3654
    d->mb_skiped= s->mb_skiped;
3655
    d->mv_type= s->mv_type;
3656
    d->mv_dir= s->mv_dir;
3657
    d->pb= s->pb;
3658
    if(s->data_partitioning){
3659
        d->pb2= s->pb2;
3660
        d->tex_pb= s->tex_pb;
3661
    }
3662
    d->block= s->block;
3663
    for(i=0; i<6; i++)
3664
        d->block_last_index[i]= s->block_last_index[i];
3665
    d->interlaced_dct= s->interlaced_dct;
3666
    d->qscale= s->qscale;
3667
}
3668

    
3669
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
3670
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
3671
                           int *dmin, int *next_block, int motion_x, int motion_y)
3672
{
3673
    int score;
3674
    uint8_t *dest_backup[3];
3675
    
3676
    copy_context_before_encode(s, backup, type);
3677

    
3678
    s->block= s->blocks[*next_block];
3679
    s->pb= pb[*next_block];
3680
    if(s->data_partitioning){
3681
        s->pb2   = pb2   [*next_block];
3682
        s->tex_pb= tex_pb[*next_block];
3683
    }
3684
    
3685
    if(*next_block){
3686
        memcpy(dest_backup, s->dest, sizeof(s->dest));
3687
        s->dest[0] = s->me.scratchpad;
3688
        s->dest[1] = s->me.scratchpad + 16;
3689
        s->dest[2] = s->me.scratchpad + 16 + 8;
3690
        assert(2*s->uvlinesize == s->linesize); //should be no prob for encoding
3691
        assert(s->linesize >= 64); //FIXME
3692
    }
3693

    
3694
    encode_mb(s, motion_x, motion_y);
3695
    
3696
    score= get_bit_count(&s->pb);
3697
    if(s->data_partitioning){
3698
        score+= get_bit_count(&s->pb2);
3699
        score+= get_bit_count(&s->tex_pb);
3700
    }
3701
   
3702
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
3703
        MPV_decode_mb(s, s->block);
3704

    
3705
        score *= s->lambda2;
3706
        score += sse_mb(s) << FF_LAMBDA_SHIFT;
3707
    }
3708
    
3709
    if(*next_block){
3710
        memcpy(s->dest, dest_backup, sizeof(s->dest));
3711
    }
3712

    
3713
    if(score<*dmin){
3714
        *dmin= score;
3715
        *next_block^=1;
3716

    
3717
        copy_context_after_encode(best, s, type);
3718
    }
3719
}
3720
                
3721
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
3722
    uint32_t *sq = squareTbl + 256;
3723
    int acc=0;
3724
    int x,y;
3725
    
3726
    if(w==16 && h==16) 
3727
        return s->dsp.sse[0](NULL, src1, src2, stride);
3728
    else if(w==8 && h==8)
3729
        return s->dsp.sse[1](NULL, src1, src2, stride);
3730
    
3731
    for(y=0; y<h; y++){
3732
        for(x=0; x<w; x++){
3733
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
3734
        } 
3735
    }
3736
    
3737
    assert(acc>=0);
3738
    
3739
    return acc;
3740
}
3741

    
3742
static int sse_mb(MpegEncContext *s){
3743
    int w= 16;
3744
    int h= 16;
3745

    
3746
    if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3747
    if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3748

    
3749
    if(w==16 && h==16)
3750
        return  s->dsp.sse[0](NULL, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize)
3751
               +s->dsp.sse[1](NULL, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize)
3752
               +s->dsp.sse[1](NULL, s->new_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize);
3753
    else
3754
        return  sse(s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], w, h, s->linesize)
3755
               +sse(s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[1], w>>1, h>>1, s->uvlinesize)
3756
               +sse(s, s->new_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[2], w>>1, h>>1, s->uvlinesize);
3757
}
3758

    
3759
static void encode_picture(MpegEncContext *s, int picture_number)
3760
{
3761
    int mb_x, mb_y, pdif = 0;
3762
    int i;
3763
    int bits;
3764
    MpegEncContext best_s, backup_s;
3765
    uint8_t bit_buf[2][3000];
3766
    uint8_t bit_buf2[2][3000];
3767
    uint8_t bit_buf_tex[2][3000];
3768
    PutBitContext pb[2], pb2[2], tex_pb[2];
3769

    
3770
    for(i=0; i<2; i++){
3771
        init_put_bits(&pb    [i], bit_buf    [i], 3000);
3772
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000);
3773
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000);
3774
    }
3775

    
3776
    s->picture_number = picture_number;
3777
    
3778
    /* Reset the average MB variance */
3779
    s->current_picture.mb_var_sum = 0;
3780
    s->current_picture.mc_mb_var_sum = 0;
3781

    
3782
#ifdef CONFIG_RISKY
3783
    /* we need to initialize some time vars before we can encode b-frames */
3784
    // RAL: Condition added for MPEG1VIDEO
3785
    if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
3786
        ff_set_mpeg4_time(s, s->picture_number); 
3787
#endif
3788
        
3789
    s->scene_change_score=0;
3790
    
3791
    s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration
3792
    
3793
    if(s->pict_type==I_TYPE){
3794
        if(s->msmpeg4_version >= 3) s->no_rounding=1;
3795
        else                        s->no_rounding=0;
3796
    }else if(s->pict_type!=B_TYPE){
3797
        if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
3798
            s->no_rounding ^= 1;          
3799
    }
3800
    
3801
    /* Estimate motion for every MB */
3802
    s->mb_intra=0; //for the rate distoration & bit compare functions
3803
    if(s->pict_type != I_TYPE){
3804
        if(s->pict_type != B_TYPE){
3805
            if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
3806
                s->me.pre_pass=1;
3807
                s->me.dia_size= s->avctx->pre_dia_size;
3808

    
3809
                for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) {
3810
                    for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) {
3811
                        s->mb_x = mb_x;
3812
                        s->mb_y = mb_y;
3813
                        ff_pre_estimate_p_frame_motion(s, mb_x, mb_y);
3814
                    }
3815
                }
3816
                s->me.pre_pass=0;
3817
            }
3818
        }
3819

    
3820
        s->me.dia_size= s->avctx->dia_size;
3821
        for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3822
            s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3823
            s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3824
            s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3825
            s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3826
            for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3827
                s->mb_x = mb_x;
3828
                s->mb_y = mb_y;
3829
                s->block_index[0]+=2;
3830
                s->block_index[1]+=2;
3831
                s->block_index[2]+=2;
3832
                s->block_index[3]+=2;
3833
                
3834
                /* compute motion vector & mb_type and store in context */
3835
                if(s->pict_type==B_TYPE)
3836
                    ff_estimate_b_frame_motion(s, mb_x, mb_y);
3837
                else
3838
                    ff_estimate_p_frame_motion(s, mb_x, mb_y);
3839
            }
3840
        }
3841
    }else /* if(s->pict_type == I_TYPE) */{
3842
        /* I-Frame */
3843
        //FIXME do we need to zero them?
3844
        memset(s->current_picture.motion_val[0][0], 0, sizeof(int16_t)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
3845
        memset(s->p_mv_table   , 0, sizeof(int16_t)*(s->mb_stride)*s->mb_height*2);
3846
        memset(s->mb_type      , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3847
        
3848
        if(!s->fixed_qscale){
3849
            /* finding spatial complexity for I-frame rate control */
3850
            for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3851
                for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3852
                    int xx = mb_x * 16;
3853
                    int yy = mb_y * 16;
3854
                    uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
3855
                    int varc;
3856
                    int sum = s->dsp.pix_sum(pix, s->linesize);
3857
    
3858
                    varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
3859

    
3860
                    s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
3861
                    s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
3862
                    s->current_picture.mb_var_sum    += varc;
3863
                }
3864
            }
3865
        }
3866
    }
3867
    emms_c();
3868

    
3869
    if(s->scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){
3870
        s->pict_type= I_TYPE;
3871
        memset(s->mb_type   , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3872
//printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3873
    }
3874

    
3875
    if(!s->umvplus){
3876
        if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
3877
            s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
3878
        
3879
            ff_fix_long_p_mvs(s);
3880
        }
3881

    
3882
        if(s->pict_type==B_TYPE){
3883
            int a, b;
3884

    
3885
            a = ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
3886
            b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, MB_TYPE_BIDIR);
3887
            s->f_code = FFMAX(a, b);
3888

    
3889
            a = ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
3890
            b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, MB_TYPE_BIDIR);
3891
            s->b_code = FFMAX(a, b);
3892

    
3893
            ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
3894
            ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
3895
            ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
3896
            ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
3897
        }
3898
    }
3899
    
3900
    if (!s->fixed_qscale) 
3901
        s->current_picture.quality = ff_rate_estimate_qscale(s);
3902

    
3903
    if(s->adaptive_quant){
3904
#ifdef CONFIG_RISKY
3905
        switch(s->codec_id){
3906
        case CODEC_ID_MPEG4:
3907
            ff_clean_mpeg4_qscales(s);
3908
            break;
3909
        case CODEC_ID_H263:
3910
        case CODEC_ID_H263P:
3911
        case CODEC_ID_FLV1:
3912
            ff_clean_h263_qscales(s);
3913
            break;
3914
        }
3915
#endif
3916

    
3917
        s->lambda= s->lambda_table[0];
3918
        //FIXME broken
3919
    }else
3920
        s->lambda= s->current_picture.quality;
3921
//printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
3922
    update_qscale(s);
3923
    
3924
    if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==I_TYPE && !(s->flags & CODEC_FLAG_QSCALE)) 
3925
        s->qscale= 3; //reduce cliping problems
3926
        
3927
    if (s->out_format == FMT_MJPEG) {
3928
        /* for mjpeg, we do include qscale in the matrix */
3929
        s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
3930
        for(i=1;i<64;i++){
3931
            int j= s->dsp.idct_permutation[i];
3932

    
3933
            s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3934
        }
3935
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 
3936
                       s->intra_matrix, s->intra_quant_bias, 8, 8);
3937
    }
3938
    
3939
    //FIXME var duplication
3940
    s->current_picture.key_frame= s->pict_type == I_TYPE;
3941
    s->current_picture.pict_type= s->pict_type;
3942

    
3943
    if(s->current_picture.key_frame)
3944
        s->picture_in_gop_number=0;
3945

    
3946
    s->last_bits= get_bit_count(&s->pb);
3947
    switch(s->out_format) {
3948
    case FMT_MJPEG:
3949
        mjpeg_picture_header(s);
3950
        break;
3951
#ifdef CONFIG_RISKY
3952
    case FMT_H263:
3953
        if (s->codec_id == CODEC_ID_WMV2) 
3954
            ff_wmv2_encode_picture_header(s, picture_number);
3955
        else if (s->h263_msmpeg4) 
3956
            msmpeg4_encode_picture_header(s, picture_number);
3957
        else if (s->h263_pred)
3958
            mpeg4_encode_picture_header(s, picture_number);
3959
        else if (s->codec_id == CODEC_ID_RV10) 
3960
            rv10_encode_picture_header(s, picture_number);
3961
        else if (s->codec_id == CODEC_ID_FLV1)
3962
            ff_flv_encode_picture_header(s, picture_number);
3963
        else
3964
            h263_encode_picture_header(s, picture_number);
3965
        break;
3966
#endif
3967
    case FMT_MPEG1:
3968
        mpeg1_encode_picture_header(s, picture_number);
3969
        break;
3970
    case FMT_H264:
3971
        break;
3972
    }
3973
    bits= get_bit_count(&s->pb);
3974
    s->header_bits= bits - s->last_bits;
3975
    s->last_bits= bits;
3976
    s->mv_bits=0;
3977
    s->misc_bits=0;
3978
    s->i_tex_bits=0;
3979
    s->p_tex_bits=0;
3980
    s->i_count=0;
3981
    s->f_count=0;
3982
    s->b_count=0;
3983
    s->skip_count=0;
3984

    
3985
    for(i=0; i<3; i++){
3986
        /* init last dc values */
3987
        /* note: quant matrix value (8) is implied here */
3988
        s->last_dc[i] = 128;
3989
        
3990
        s->current_picture_ptr->error[i] = 0;
3991
    }
3992
    s->mb_skip_run = 0;
3993
    s->last_mv[0][0][0] = 0;
3994
    s->last_mv[0][0][1] = 0;
3995
    s->last_mv[1][0][0] = 0;
3996
    s->last_mv[1][0][1] = 0;
3997
     
3998
    s->last_mv_dir = 0;
3999

    
4000
#ifdef CONFIG_RISKY
4001
    switch(s->codec_id){
4002
    case CODEC_ID_H263:
4003
    case CODEC_ID_H263P:
4004
    case CODEC_ID_FLV1:
4005
        s->gob_index = ff_h263_get_gob_height(s);
4006
        break;
4007
    case CODEC_ID_MPEG4:
4008
        if(s->partitioned_frame)
4009
            ff_mpeg4_init_partitions(s);
4010
        break;
4011
    }
4012
#endif
4013

    
4014
    s->resync_mb_x=0;
4015
    s->resync_mb_y=0;
4016
    s->first_slice_line = 1;
4017
    s->ptr_lastgob = s->pb.buf;
4018
    for(mb_y=0; mb_y < s->mb_height; mb_y++) {
4019
        s->mb_x=0;
4020
        s->mb_y= mb_y;
4021

    
4022
        ff_set_qscale(s, s->qscale);
4023
        ff_init_block_index(s);
4024
        
4025
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4026
            const int xy= mb_y*s->mb_stride + mb_x;
4027
            int mb_type= s->mb_type[xy];
4028
//            int d;
4029
            int dmin= INT_MAX;
4030

    
4031
            s->mb_x = mb_x;
4032
            ff_update_block_index(s);
4033

    
4034
            /* write gob / video packet header  */
4035
#ifdef CONFIG_RISKY
4036
            if(s->rtp_mode){
4037
                int current_packet_size, is_gob_start;
4038
                
4039
                current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4040
                
4041
                is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0; 
4042
                
4043
                switch(s->codec_id){
4044
                case CODEC_ID_H263:
4045
                case CODEC_ID_H263P:
4046
                    if(!s->h263_slice_structured)
4047
                        if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
4048
                    break;
4049
                case CODEC_ID_MPEG2VIDEO:
4050
                    if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
4051
                case CODEC_ID_MPEG1VIDEO:
4052
                    if(s->mb_skip_run) is_gob_start=0;
4053
                    break;
4054
                }
4055
                
4056
                if(is_gob_start){
4057
                    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
4058
                        ff_mpeg4_merge_partitions(s);
4059
                        ff_mpeg4_init_partitions(s);
4060
                    }
4061
                
4062
                    if(s->codec_id==CODEC_ID_MPEG4) 
4063
                        ff_mpeg4_stuffing(&s->pb);
4064

    
4065
                    align_put_bits(&s->pb);
4066
                    flush_put_bits(&s->pb);
4067

    
4068
                    assert((get_bit_count(&s->pb)&7) == 0);
4069
                    current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4070
                    
4071
                    if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
4072
                        int r= get_bit_count(&s->pb)/8 + s->picture_number + s->codec_id + s->mb_x + s->mb_y;
4073
                        int d= 100 / s->avctx->error_rate;
4074
                        if(r % d == 0){
4075
                            current_packet_size=0;
4076
#ifndef ALT_BITSTREAM_WRITER
4077
                            s->pb.buf_ptr= s->ptr_lastgob;
4078
#endif
4079
                            assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
4080
                        }
4081
                    }
4082
        
4083
                    if (s->avctx->rtp_callback)
4084
                        s->avctx->rtp_callback(s->ptr_lastgob, current_packet_size, 0);
4085
                    
4086
                    switch(s->codec_id){
4087
                    case CODEC_ID_MPEG4:
4088
                        ff_mpeg4_encode_video_packet_header(s);
4089
                        ff_mpeg4_clean_buffers(s);
4090
                    break;
4091
                    case CODEC_ID_MPEG1VIDEO:
4092
                    case CODEC_ID_MPEG2VIDEO:
4093
                        ff_mpeg1_encode_slice_header(s);
4094
                        ff_mpeg1_clean_buffers(s);
4095
                    break;
4096
                    case CODEC_ID_H263:
4097
                    case CODEC_ID_H263P:
4098
                        h263_encode_gob_header(s, mb_y);                       
4099
                    break;
4100
                    }
4101

    
4102
                    if(s->flags&CODEC_FLAG_PASS1){
4103
                        int bits= get_bit_count(&s->pb);
4104
                        s->misc_bits+= bits - s->last_bits;
4105
                        s->last_bits= bits;
4106
                    }
4107
    
4108
                    s->ptr_lastgob += current_packet_size;
4109
                    s->first_slice_line=1;
4110
                    s->resync_mb_x=mb_x;
4111
                    s->resync_mb_y=mb_y;
4112
                }
4113
            }
4114
#endif
4115

    
4116
            if(  (s->resync_mb_x   == s->mb_x)
4117
               && s->resync_mb_y+1 == s->mb_y){
4118
                s->first_slice_line=0; 
4119
            }
4120

    
4121
            s->mb_skiped=0;
4122
            s->dquant=0; //only for QP_RD
4123

    
4124
            if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible
4125
                int next_block=0;
4126
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
4127

    
4128
                copy_context_before_encode(&backup_s, s, -1);
4129
                backup_s.pb= s->pb;
4130
                best_s.data_partitioning= s->data_partitioning;
4131
                best_s.partitioned_frame= s->partitioned_frame;
4132
                if(s->data_partitioning){
4133
                    backup_s.pb2= s->pb2;
4134
                    backup_s.tex_pb= s->tex_pb;
4135
                }
4136

    
4137
                if(mb_type&MB_TYPE_INTER){
4138
                    s->mv_dir = MV_DIR_FORWARD;
4139
                    s->mv_type = MV_TYPE_16X16;
4140
                    s->mb_intra= 0;
4141
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
4142
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
4143
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb, 
4144
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4145
                }
4146
                if(mb_type&MB_TYPE_SKIPED){
4147
                    s->mv_dir = MV_DIR_FORWARD;
4148
                    s->mv_type = MV_TYPE_16X16;
4149
                    s->mb_intra= 0;
4150
                    s->mv[0][0][0] = 0;
4151
                    s->mv[0][0][1] = 0;
4152
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_SKIPED, pb, pb2, tex_pb, 
4153
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4154
                }
4155
                if(mb_type&MB_TYPE_INTER4V){                 
4156
                    s->mv_dir = MV_DIR_FORWARD;
4157
                    s->mv_type = MV_TYPE_8X8;
4158
                    s->mb_intra= 0;
4159
                    for(i=0; i<4; i++){
4160
                        s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
4161
                        s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
4162
                    }
4163
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb, 
4164
                                 &dmin, &next_block, 0, 0);
4165
                }
4166
                if(mb_type&MB_TYPE_FORWARD){
4167
                    s->mv_dir = MV_DIR_FORWARD;
4168
                    s->mv_type = MV_TYPE_16X16;
4169
                    s->mb_intra= 0;
4170
                    s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
4171
                    s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
4172
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb, 
4173
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4174
                }
4175
                if(mb_type&MB_TYPE_BACKWARD){
4176
                    s->mv_dir = MV_DIR_BACKWARD;
4177
                    s->mv_type = MV_TYPE_16X16;
4178
                    s->mb_intra= 0;
4179
                    s->mv[1][0][0] = s->b_back_mv_table[xy][0];
4180
                    s->mv[1][0][1] = s->b_back_mv_table[xy][1];
4181
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb, 
4182
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
4183
                }
4184
                if(mb_type&MB_TYPE_BIDIR){
4185
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4186
                    s->mv_type = MV_TYPE_16X16;
4187
                    s->mb_intra= 0;
4188
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
4189
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
4190
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
4191
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
4192
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb, 
4193
                                 &dmin, &next_block, 0, 0);
4194
                }
4195
                if(mb_type&MB_TYPE_DIRECT){
4196
                    int mx= s->b_direct_mv_table[xy][0];
4197
                    int my= s->b_direct_mv_table[xy][1];
4198
                    
4199
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4200
                    s->mb_intra= 0;
4201
#ifdef CONFIG_RISKY
4202
                    ff_mpeg4_set_direct_mv(s, mx, my);
4203
#endif
4204
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb, 
4205
                                 &dmin, &next_block, mx, my);
4206
                }
4207
                if(mb_type&MB_TYPE_INTRA){
4208
                    s->mv_dir = 0;
4209
                    s->mv_type = MV_TYPE_16X16;
4210
                    s->mb_intra= 1;
4211
                    s->mv[0][0][0] = 0;
4212
                    s->mv[0][0][1] = 0;
4213
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb, 
4214
                                 &dmin, &next_block, 0, 0);
4215
                    if(s->h263_pred || s->h263_aic){
4216
                        if(best_s.mb_intra)
4217
                            s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
4218
                        else
4219
                            ff_clean_intra_table_entries(s); //old mode?
4220
                    }
4221
                }
4222

    
4223
                if(s->flags & CODEC_FLAG_QP_RD){
4224
                    if(best_s.mv_type==MV_TYPE_16X16 && !(best_s.mv_dir&MV_DIRECT)){
4225
                        const int last_qp= backup_s.qscale;
4226
                        int dquant, dir, qp, dc[6];
4227
                        DCTELEM ac[6][16];
4228
                        const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
4229
                        
4230
                        assert(backup_s.dquant == 0);
4231

    
4232
                        //FIXME intra
4233
                        s->mv_dir= best_s.mv_dir;
4234
                        s->mv_type = MV_TYPE_16X16;
4235
                        s->mb_intra= best_s.mb_intra;
4236
                        s->mv[0][0][0] = best_s.mv[0][0][0];
4237
                        s->mv[0][0][1] = best_s.mv[0][0][1];
4238
                        s->mv[1][0][0] = best_s.mv[1][0][0];
4239
                        s->mv[1][0][1] = best_s.mv[1][0][1];
4240
                        
4241
                        dir= s->pict_type == B_TYPE ? 2 : 1;
4242
                        if(last_qp + dir > s->avctx->qmax) dir= -dir;
4243
                        for(dquant= dir; dquant<=2 && dquant>=-2; dquant += dir){
4244
                            qp= last_qp + dquant;
4245
                            if(qp < s->avctx->qmin || qp > s->avctx->qmax)
4246
                                break;
4247
                            backup_s.dquant= dquant;
4248
                            if(s->mb_intra){
4249
                                for(i=0; i<6; i++){
4250
                                    dc[i]= s->dc_val[0][ s->block_index[i] ];
4251
                                    memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
4252
                                }
4253
                            }
4254

    
4255
                            encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb, 
4256
                                         &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
4257
                            if(best_s.qscale != qp){
4258
                                if(s->mb_intra){
4259
                                    for(i=0; i<6; i++){
4260
                                        s->dc_val[0][ s->block_index[i] ]= dc[i];
4261
                                        memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
4262
                                    }
4263
                                }
4264
                                if(dir > 0 && dquant==dir){
4265
                                    dquant= 0;
4266
                                    dir= -dir;
4267
                                }else
4268
                                    break;
4269
                            }
4270
                        }
4271
                        qp= best_s.qscale;
4272
                        s->current_picture.qscale_table[xy]= qp;
4273
                    }
4274
                }
4275

    
4276
                copy_context_after_encode(s, &best_s, -1);
4277
                
4278
                pb_bits_count= get_bit_count(&s->pb);
4279
                flush_put_bits(&s->pb);
4280
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
4281
                s->pb= backup_s.pb;
4282
                
4283
                if(s->data_partitioning){
4284
                    pb2_bits_count= get_bit_count(&s->pb2);
4285
                    flush_put_bits(&s->pb2);
4286
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
4287
                    s->pb2= backup_s.pb2;
4288
                    
4289
                    tex_pb_bits_count= get_bit_count(&s->tex_pb);
4290
                    flush_put_bits(&s->tex_pb);
4291
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
4292
                    s->tex_pb= backup_s.tex_pb;
4293
                }
4294
                s->last_bits= get_bit_count(&s->pb);
4295
               
4296
#ifdef CONFIG_RISKY
4297
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4298
                    ff_h263_update_motion_val(s);
4299
#endif
4300
        
4301
                if(next_block==0){
4302
                    s->dsp.put_pixels_tab[0][0](s->dest[0], s->me.scratchpad     , s->linesize  ,16);
4303
                    s->dsp.put_pixels_tab[1][0](s->dest[1], s->me.scratchpad + 16, s->uvlinesize, 8);
4304
                    s->dsp.put_pixels_tab[1][0](s->dest[2], s->me.scratchpad + 24, s->uvlinesize, 8);
4305
                }
4306

    
4307
                if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
4308
                    MPV_decode_mb(s, s->block);
4309
            } else {
4310
                int motion_x, motion_y;
4311
                s->mv_type=MV_TYPE_16X16;
4312
                // only one MB-Type possible
4313
                
4314
                switch(mb_type){
4315
                case MB_TYPE_INTRA:
4316
                    s->mv_dir = 0;
4317
                    s->mb_intra= 1;
4318
                    motion_x= s->mv[0][0][0] = 0;
4319
                    motion_y= s->mv[0][0][1] = 0;
4320
                    break;
4321
                case MB_TYPE_INTER:
4322
                    s->mv_dir = MV_DIR_FORWARD;
4323
                    s->mb_intra= 0;
4324
                    motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
4325
                    motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
4326
                    break;
4327
                case MB_TYPE_INTER4V:
4328
                    s->mv_dir = MV_DIR_FORWARD;
4329
                    s->mv_type = MV_TYPE_8X8;
4330
                    s->mb_intra= 0;
4331
                    for(i=0; i<4; i++){
4332
                        s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
4333
                        s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
4334
                    }
4335
                    motion_x= motion_y= 0;
4336
                    break;
4337
                case MB_TYPE_DIRECT:
4338
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4339
                    s->mb_intra= 0;
4340
                    motion_x=s->b_direct_mv_table[xy][0];
4341
                    motion_y=s->b_direct_mv_table[xy][1];
4342
#ifdef CONFIG_RISKY
4343
                    ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
4344
#endif
4345
                    break;
4346
                case MB_TYPE_BIDIR:
4347
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4348
                    s->mb_intra= 0;
4349
                    motion_x=0;
4350
                    motion_y=0;
4351
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
4352
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
4353
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
4354
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
4355
                    break;
4356
                case MB_TYPE_BACKWARD:
4357
                    s->mv_dir = MV_DIR_BACKWARD;
4358
                    s->mb_intra= 0;
4359
                    motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
4360
                    motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
4361
                    break;
4362
                case MB_TYPE_FORWARD:
4363
                    s->mv_dir = MV_DIR_FORWARD;
4364
                    s->mb_intra= 0;
4365
                    motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
4366
                    motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
4367
//                    printf(" %d %d ", motion_x, motion_y);
4368
                    break;
4369
                default:
4370
                    motion_x=motion_y=0; //gcc warning fix
4371
                    av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
4372
                }
4373

    
4374
                encode_mb(s, motion_x, motion_y);
4375

    
4376
                // RAL: Update last macrobloc type
4377
                s->last_mv_dir = s->mv_dir;
4378
            
4379
#ifdef CONFIG_RISKY
4380
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4381
                    ff_h263_update_motion_val(s);
4382
#endif
4383
                
4384
                MPV_decode_mb(s, s->block);
4385
            }
4386

    
4387
            /* clean the MV table in IPS frames for direct mode in B frames */
4388
            if(s->mb_intra /* && I,P,S_TYPE */){
4389
                s->p_mv_table[xy][0]=0;
4390
                s->p_mv_table[xy][1]=0;
4391
            }
4392
            
4393
            if(s->flags&CODEC_FLAG_PSNR){
4394
                int w= 16;
4395
                int h= 16;
4396

    
4397
                if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4398
                if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4399

    
4400
                s->current_picture_ptr->error[0] += sse(
4401
                    s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
4402
                    s->dest[0], w, h, s->linesize);
4403
                s->current_picture_ptr->error[1] += sse(
4404
                    s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
4405
                    s->dest[1], w>>1, h>>1, s->uvlinesize);
4406
                s->current_picture_ptr->error[2] += sse(
4407
                    s, s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
4408
                    s->dest[2], w>>1, h>>1, s->uvlinesize);
4409
            }
4410
            if(s->loop_filter)
4411
                ff_h263_loop_filter(s);
4412
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, get_bit_count(&s->pb));
4413
        }
4414
    }
4415
    emms_c();
4416

    
4417
#ifdef CONFIG_RISKY
4418
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
4419
        ff_mpeg4_merge_partitions(s);
4420

    
4421
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
4422
        msmpeg4_encode_ext_header(s);
4423

    
4424
    if(s->codec_id==CODEC_ID_MPEG4) 
4425
        ff_mpeg4_stuffing(&s->pb);
4426
#endif
4427

    
4428
    /* Send the last GOB if RTP */    
4429
    if (s->avctx->rtp_callback) {
4430
        flush_put_bits(&s->pb);
4431
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
4432
        /* Call the RTP callback to send the last GOB */
4433
        s->avctx->rtp_callback(s->ptr_lastgob, pdif, 0);
4434
    }
4435
}
4436

    
4437
#endif //CONFIG_ENCODERS
4438

    
4439
void ff_denoise_dct(MpegEncContext *s, DCTELEM *block){
4440
    const int intra= s->mb_intra;
4441
    int i;
4442

    
4443
    s->dct_count[intra]++;
4444

    
4445
    for(i=0; i<64; i++){
4446
        int level= block[i];
4447

    
4448
        if(level){
4449
            if(level>0){
4450
                s->dct_error_sum[intra][i] += level;
4451
                level -= s->dct_offset[intra][i];
4452
                if(level<0) level=0;
4453
            }else{
4454
                s->dct_error_sum[intra][i] -= level;
4455
                level += s->dct_offset[intra][i];
4456
                if(level>0) level=0;
4457
            }
4458
            block[i]= level;
4459
        }
4460
    }
4461
}
4462

    
4463
#ifdef CONFIG_ENCODERS
4464

    
4465
static int dct_quantize_trellis_c(MpegEncContext *s, 
4466
                        DCTELEM *block, int n,
4467
                        int qscale, int *overflow){
4468
    const int *qmat;
4469
    const uint8_t *scantable= s->intra_scantable.scantable;
4470
    int max=0;
4471
    unsigned int threshold1, threshold2;
4472
    int bias=0;
4473
    int run_tab[65];
4474
    int level_tab[65];
4475
    int score_tab[65];
4476
    int last_run=0;
4477
    int last_level=0;
4478
    int last_score= 0;
4479
    int last_i= 0;
4480
    int not_coded_score= 0;
4481
    int coeff[3][64];
4482
    int coeff_count[64];
4483
    int qmul, qadd, start_i, last_non_zero, i, dc;
4484
    const int esc_length= s->ac_esc_length;
4485
    uint8_t * length;
4486
    uint8_t * last_length;
4487
    int score_limit=0;
4488
    int left_limit= 0;
4489
    const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
4490
    const int patch_table= s->out_format == FMT_MPEG1 && !s->mb_intra;
4491
        
4492
    s->dsp.fdct (block);
4493
    
4494
    if(s->dct_error_sum)
4495
        ff_denoise_dct(s, block);
4496
    
4497
    qmul= qscale*16;
4498
    qadd= ((qscale-1)|1)*8;
4499

    
4500
    if (s->mb_intra) {
4501
        int q;
4502
        if (!s->h263_aic) {
4503
            if (n < 4)
4504
                q = s->y_dc_scale;
4505
            else
4506
                q = s->c_dc_scale;
4507
            q = q << 3;
4508
        } else{
4509
            /* For AIC we skip quant/dequant of INTRADC */
4510
            q = 1 << 3;
4511
            qadd=0;
4512
        }
4513
            
4514
        /* note: block[0] is assumed to be positive */
4515
        block[0] = (block[0] + (q >> 1)) / q;
4516
        start_i = 1;
4517
        last_non_zero = 0;
4518
        qmat = s->q_intra_matrix[qscale];
4519
        if(s->mpeg_quant || s->out_format == FMT_MPEG1)
4520
            bias= 1<<(QMAT_SHIFT-1);
4521
        length     = s->intra_ac_vlc_length;
4522
        last_length= s->intra_ac_vlc_last_length;
4523
    } else {
4524
        start_i = 0;
4525
        last_non_zero = -1;
4526
        qmat = s->q_inter_matrix[qscale];
4527
        length     = s->inter_ac_vlc_length;
4528
        last_length= s->inter_ac_vlc_last_length;
4529
    }
4530

    
4531
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
4532
    threshold2= (threshold1<<1);
4533

    
4534
    for(i=start_i; i<64; i++) {
4535
        const int j = scantable[i];
4536
        const int k= i-start_i;
4537
        int level = block[j];
4538
        level = level * qmat[j];
4539

    
4540
//        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
4541
//           || bias-level >= (1<<(QMAT_SHIFT - 3))){
4542
        if(((unsigned)(level+threshold1))>threshold2){
4543
            if(level>0){
4544
                level= (bias + level)>>QMAT_SHIFT;
4545
                coeff[0][k]= level;
4546
                coeff[1][k]= level-1;
4547
//                coeff[2][k]= level-2;
4548
            }else{
4549
                level= (bias - level)>>QMAT_SHIFT;
4550
                coeff[0][k]= -level;
4551
                coeff[1][k]= -level+1;
4552
//                coeff[2][k]= -level+2;
4553
            }
4554
            coeff_count[k]= FFMIN(level, 2);
4555
            assert(coeff_count[k]);
4556
            max |=level;
4557
            last_non_zero = i;
4558
        }else{
4559
            coeff[0][k]= (level>>31)|1;
4560
            coeff_count[k]= 1;
4561
        }
4562
    }
4563
    
4564
    *overflow= s->max_qcoeff < max; //overflow might have happend
4565
    
4566
    if(last_non_zero < start_i){
4567
        memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
4568
        return last_non_zero;
4569
    }
4570

    
4571
    score_tab[0]= 0;
4572
    
4573
    if(patch_table){
4574
//        length[UNI_AC_ENC_INDEX(0, 63)]=
4575
//        length[UNI_AC_ENC_INDEX(0, 65)]= 2;
4576
    }
4577

    
4578
    for(i=0; i<=last_non_zero - start_i; i++){
4579
        int level_index, run, j;
4580
        const int dct_coeff= block[ scantable[i + start_i] ];
4581
        const int zero_distoration= dct_coeff*dct_coeff;
4582
        int best_score=256*256*256*120;
4583

    
4584
        last_score += zero_distoration;
4585
        not_coded_score += zero_distoration;
4586
        for(level_index=0; level_index < coeff_count[i]; level_index++){
4587
            int distoration;
4588
            int level= coeff[level_index][i];
4589
            int unquant_coeff;
4590
            
4591
            assert(level);
4592

    
4593
            if(s->out_format == FMT_H263){
4594
                if(level>0){
4595
                    unquant_coeff= level*qmul + qadd;
4596
                }else{
4597
                    unquant_coeff= level*qmul - qadd;
4598
                }
4599
            }else{ //MPEG1
4600
                j= s->dsp.idct_permutation[ scantable[i + start_i] ]; //FIXME optimize
4601
                if(s->mb_intra){
4602
                    if (level < 0) {
4603
                        unquant_coeff = (int)((-level) * qscale * s->intra_matrix[j]) >> 3;
4604
                        unquant_coeff = -((unquant_coeff - 1) | 1);
4605
                    } else {
4606
                        unquant_coeff = (int)(  level  * qscale * s->intra_matrix[j]) >> 3;
4607
                        unquant_coeff =   (unquant_coeff - 1) | 1;
4608
                    }
4609
                }else{
4610
                    if (level < 0) {
4611
                        unquant_coeff = ((((-level) << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
4612
                        unquant_coeff = -((unquant_coeff - 1) | 1);
4613
                    } else {
4614
                        unquant_coeff = (((  level  << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
4615
                        unquant_coeff =   (unquant_coeff - 1) | 1;
4616
                    }
4617
                }
4618
                unquant_coeff<<= 3;
4619
            }
4620

    
4621
            distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff);
4622
            level+=64;
4623
            if((level&(~127)) == 0){
4624
                for(run=0; run<=i - left_limit; run++){
4625
                    int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4626
                    score += score_tab[i-run];
4627
                    
4628
                    if(score < best_score){
4629
                        best_score= 
4630
                        score_tab[i+1]= score;
4631
                        run_tab[i+1]= run;
4632
                        level_tab[i+1]= level-64;
4633
                    }
4634
                }
4635

    
4636
                if(s->out_format == FMT_H263){
4637
                    for(run=0; run<=i - left_limit; run++){
4638
                        int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4639
                        score += score_tab[i-run];
4640
                        if(score < last_score){
4641
                            last_score= score;
4642
                            last_run= run;
4643
                            last_level= level-64;
4644
                            last_i= i+1;
4645
                        }
4646
                    }
4647
                }
4648
            }else{
4649
                distoration += esc_length*lambda;
4650
                for(run=0; run<=i - left_limit; run++){
4651
                    int score= distoration + score_tab[i-run];
4652
                    
4653
                    if(score < best_score){
4654
                        best_score= 
4655
                        score_tab[i+1]= score;
4656
                        run_tab[i+1]= run;
4657
                        level_tab[i+1]= level-64;
4658
                    }
4659
                }
4660

    
4661
                if(s->out_format == FMT_H263){
4662
                    for(run=0; run<=i - left_limit; run++){
4663
                        int score= distoration + score_tab[i-run];
4664
                        if(score < last_score){
4665
                            last_score= score;
4666
                            last_run= run;
4667
                            last_level= level-64;
4668
                            last_i= i+1;
4669
                        }
4670
                    }
4671
                }
4672
            }
4673
        }
4674

    
4675
        for(j=left_limit; j<=i; j++){
4676
            score_tab[j] += zero_distoration;
4677
        }
4678
        score_limit+= zero_distoration;
4679
        if(score_tab[i+1] < score_limit)
4680
            score_limit= score_tab[i+1];
4681
        
4682
        //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
4683
        while(score_tab[ left_limit ] > score_limit + lambda) left_limit++;
4684
    
4685
        if(patch_table){
4686
//