Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ fbb89806

History | View | Annotate | Download (193 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
    if(s->alternate_scan){
256
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
257
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
258
    }else{
259
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
260
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
261
    }
262
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
263
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
264

    
265
    s->picture_structure= PICT_FRAME;
266
    
267
    return 0;
268
}
269

    
270
static void copy_picture(Picture *dst, Picture *src){
271
    *dst = *src;
272
    dst->type= FF_BUFFER_TYPE_COPY;
273
}
274

    
275
static void copy_picture_attributes(AVFrame *dst, AVFrame *src){
276
    dst->pict_type              = src->pict_type;
277
    dst->quality                = src->quality;
278
    dst->coded_picture_number   = src->coded_picture_number;
279
    dst->display_picture_number = src->display_picture_number;
280
//    dst->reference              = src->reference;
281
    dst->pts                    = src->pts;
282
    dst->interlaced_frame       = src->interlaced_frame;
283
    dst->top_field_first        = src->top_field_first;
284
}
285

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

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

    
318
        if(pic->linesize[1] != pic->linesize[2]){
319
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride missmatch)\n");
320
            return -1;
321
        }
322

    
323
        s->linesize  = pic->linesize[0];
324
        s->uvlinesize= pic->linesize[1];
325
    }
326
    
327
    if(pic->qscale_table==NULL){
328
        if (s->encoding) {        
329
            CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
330
            CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
331
            CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
332
        }
333

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

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

    
367
/**
368
 * deallocates a picture
369
 */
370
static void free_picture(MpegEncContext *s, Picture *pic){
371
    int i;
372

    
373
    if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
374
        s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
375
    }
376

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

    
399
/* init common structure for both encoder and decoder */
400
int MPV_common_init(MpegEncContext *s)
401
{
402
    int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
403

    
404
    dsputil_init(&s->dsp, s->avctx);
405
    DCT_common_init(s);
406

    
407
    s->flags= s->avctx->flags;
408

    
409
    s->mb_width  = (s->width  + 15) / 16;
410
    s->mb_height = (s->height + 15) / 16;
411
    s->mb_stride = s->mb_width + 1;
412
    s->b8_stride = s->mb_width*2 + 1;
413
    s->b4_stride = s->mb_width*4 + 1;
414
    mb_array_size= s->mb_height * s->mb_stride;
415
    mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
416

    
417
    /* set default edge pos, will be overriden in decode_header if needed */
418
    s->h_edge_pos= s->mb_width*16;
419
    s->v_edge_pos= s->mb_height*16;
420

    
421
    s->mb_num = s->mb_width * s->mb_height;
422
    
423
    s->block_wrap[0]=
424
    s->block_wrap[1]=
425
    s->block_wrap[2]=
426
    s->block_wrap[3]= s->mb_width*2 + 2;
427
    s->block_wrap[4]=
428
    s->block_wrap[5]= s->mb_width + 2;
429

    
430
    s->y_dc_scale_table=
431
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
432
    s->chroma_qscale_table= ff_default_chroma_qscale_table;
433
    if (!s->encoding)
434
        s->progressive_sequence= 1;
435
    s->progressive_frame= 1;
436
    s->coded_picture_number = 0;
437

    
438
    y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
439
    c_size = (s->mb_width + 2) * (s->mb_height + 2);
440
    yc_size = y_size + 2 * c_size;
441

    
442
    /* convert fourcc to upper case */
443
    s->avctx->codec_tag=   toupper( s->avctx->codec_tag     &0xFF)          
444
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
445
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16) 
446
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
447

    
448
    s->avctx->stream_codec_tag=   toupper( s->avctx->stream_codec_tag     &0xFF)          
449
                               + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
450
                               + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16) 
451
                               + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
452

    
453
    CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
454
    s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
455

    
456
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
457

    
458
    CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
459
    for(y=0; y<s->mb_height; y++){
460
        for(x=0; x<s->mb_width; x++){
461
            s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
462
        }
463
    }
464
    s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
465
    
466
    if (s->encoding) {
467
        /* Allocate MV tables */
468
        CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
469
        CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
470
        CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
471
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
472
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
473
        CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
474
        s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
475
        s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
476
        s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
477
        s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
478
        s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
479
        s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
480

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

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

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

    
518
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
519
    
520
    if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
521
        /* interlaced direct mode decoding tables */
522
            for(i=0; i<2; i++){
523
                int j, k;
524
                for(j=0; j<2; j++){
525
                    for(k=0; k<2; k++){
526
                        CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k]     , mv_table_size * 2 * sizeof(int16_t))
527
                        s->b_field_mv_table[i][j][k]    = s->b_field_mv_table_base[i][j][k]     + s->mb_stride + 1;
528
                    }
529
                    CHECKED_ALLOCZ(s->b_field_select_table[i][j]     , mb_array_size * 2 * sizeof(uint8_t))
530
                    CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j]     , mv_table_size * 2 * sizeof(int16_t))
531
                    s->p_field_mv_table[i][j]    = s->p_field_mv_table_base[i][j]     + s->mb_stride + 1;
532
                }
533
                CHECKED_ALLOCZ(s->p_field_select_table[i]      , mb_array_size * 2 * sizeof(uint8_t))
534
            }
535
    }
536
    if (s->out_format == FMT_H263) {
537
        /* ac values */
538
        CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(int16_t) * 16);
539
        s->ac_val[1] = s->ac_val[0] + y_size;
540
        s->ac_val[2] = s->ac_val[1] + c_size;
541
        
542
        /* cbp values */
543
        CHECKED_ALLOCZ(s->coded_block, y_size);
544
        
545
        /* divx501 bitstream reorder buffer */
546
        CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
547

    
548
        /* cbp, ac_pred, pred_dir */
549
        CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
550
        CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
551
    }
552
    
553
    if (s->h263_pred || s->h263_plus || !s->encoding) {
554
        /* dc values */
555
        //MN: we need these for error resilience of intra-frames
556
        CHECKED_ALLOCZ(s->dc_val[0], yc_size * sizeof(int16_t));
557
        s->dc_val[1] = s->dc_val[0] + y_size;
558
        s->dc_val[2] = s->dc_val[1] + c_size;
559
        for(i=0;i<yc_size;i++)
560
            s->dc_val[0][i] = 1024;
561
    }
562

    
563
    /* which mb is a intra block */
564
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
565
    memset(s->mbintra_table, 1, mb_array_size);
566
    
567
    /* default structure is frame */
568
    s->picture_structure = PICT_FRAME;
569
    
570
    /* init macroblock skip table */
571
    CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
572
    //Note the +1 is for a quicker mpeg4 slice_end detection
573
    CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
574
    
575
    s->block= s->blocks[0];
576

    
577
    for(i=0;i<12;i++){
578
        s->pblocks[i] = (short *)(&s->block[i]);
579
    }
580

    
581
    s->parse_context.state= -1;
582
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
583
       s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
584
       s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
585
       s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
586
    }
587

    
588
    s->context_initialized = 1;
589
    return 0;
590
 fail:
591
    MPV_common_end(s);
592
    return -1;
593
}
594

    
595

    
596
//extern int sads;
597

    
598
/* init common structure for both encoder and decoder */
599
void MPV_common_end(MpegEncContext *s)
600
{
601
    int i, j, k;
602

    
603
    av_freep(&s->parse_context.buffer);
604
    s->parse_context.buffer_size=0;
605

    
606
    av_freep(&s->mb_type);
607
    av_freep(&s->p_mv_table_base);
608
    av_freep(&s->b_forw_mv_table_base);
609
    av_freep(&s->b_back_mv_table_base);
610
    av_freep(&s->b_bidir_forw_mv_table_base);
611
    av_freep(&s->b_bidir_back_mv_table_base);
612
    av_freep(&s->b_direct_mv_table_base);
613
    s->p_mv_table= NULL;
614
    s->b_forw_mv_table= NULL;
615
    s->b_back_mv_table= NULL;
616
    s->b_bidir_forw_mv_table= NULL;
617
    s->b_bidir_back_mv_table= NULL;
618
    s->b_direct_mv_table= NULL;
619
    for(i=0; i<2; i++){
620
        for(j=0; j<2; j++){
621
            for(k=0; k<2; k++){
622
                av_freep(&s->b_field_mv_table_base[i][j][k]);
623
                s->b_field_mv_table[i][j][k]=NULL;
624
            }
625
            av_freep(&s->b_field_select_table[i][j]);
626
            av_freep(&s->p_field_mv_table_base[i][j]);
627
            s->p_field_mv_table[i][j]=NULL;
628
        }
629
        av_freep(&s->p_field_select_table[i]);
630
    }
631
    
632
    av_freep(&s->dc_val[0]);
633
    av_freep(&s->ac_val[0]);
634
    av_freep(&s->coded_block);
635
    av_freep(&s->mbintra_table);
636
    av_freep(&s->cbp_table);
637
    av_freep(&s->pred_dir_table);
638
    av_freep(&s->me.scratchpad);
639
    av_freep(&s->me.map);
640
    av_freep(&s->me.score_map);
641
    
642
    av_freep(&s->mbskip_table);
643
    av_freep(&s->prev_pict_types);
644
    av_freep(&s->bitstream_buffer);
645
    av_freep(&s->tex_pb_buffer);
646
    av_freep(&s->pb2_buffer);
647
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
648
    av_freep(&s->avctx->stats_out);
649
    av_freep(&s->ac_stats);
650
    av_freep(&s->error_status_table);
651
    av_freep(&s->mb_index2xy);
652
    av_freep(&s->lambda_table);
653
    av_freep(&s->q_intra_matrix);
654
    av_freep(&s->q_inter_matrix);
655
    av_freep(&s->q_intra_matrix16);
656
    av_freep(&s->q_inter_matrix16);
657
    av_freep(&s->blocks);
658
    av_freep(&s->input_picture);
659
    av_freep(&s->reordered_input_picture);
660
    av_freep(&s->dct_error_sum);
661
    av_freep(&s->dct_offset);
662

    
663
    if(s->picture){
664
        for(i=0; i<MAX_PICTURE_COUNT; i++){
665
            free_picture(s, &s->picture[i]);
666
        }
667
    }
668
    av_freep(&s->picture);
669
    avcodec_default_free_buffers(s->avctx);
670
    s->context_initialized = 0;
671
    s->last_picture_ptr=
672
    s->next_picture_ptr=
673
    s->current_picture_ptr= NULL;
674
    for(i=0; i<3; i++)
675
        if (s->visualization_buffer[i])
676
            av_free(s->visualization_buffer[i]);
677
}
678

    
679
#ifdef CONFIG_ENCODERS
680

    
681
/* init video encoder */
682
int MPV_encode_init(AVCodecContext *avctx)
683
{
684
    MpegEncContext *s = avctx->priv_data;
685
    int i, dummy;
686
    int chroma_h_shift, chroma_v_shift;
687

    
688
    avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME
689

    
690
    s->bit_rate = avctx->bit_rate;
691
    s->width = avctx->width;
692
    s->height = avctx->height;
693
    if(avctx->gop_size > 600){
694
        av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
695
        avctx->gop_size=600;
696
    }
697
    s->gop_size = avctx->gop_size;
698
    s->avctx = avctx;
699
    s->flags= avctx->flags;
700
    s->max_b_frames= avctx->max_b_frames;
701
    s->codec_id= avctx->codec->id;
702
    s->luma_elim_threshold  = avctx->luma_elim_threshold;
703
    s->chroma_elim_threshold= avctx->chroma_elim_threshold;
704
    s->strict_std_compliance= avctx->strict_std_compliance;
705
    s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
706
    s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
707
    s->mpeg_quant= avctx->mpeg_quant;
708
    s->rtp_mode= !!avctx->rtp_payload_size;
709

    
710
    if (s->gop_size <= 1) {
711
        s->intra_only = 1;
712
        s->gop_size = 12;
713
    } else {
714
        s->intra_only = 0;
715
    }
716

    
717
    s->me_method = avctx->me_method;
718

    
719
    /* Fixed QSCALE */
720
    s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
721
    
722
    s->adaptive_quant= (   s->avctx->lumi_masking
723
                        || s->avctx->dark_masking
724
                        || s->avctx->temporal_cplx_masking 
725
                        || s->avctx->spatial_cplx_masking
726
                        || s->avctx->p_masking
727
                        || (s->flags&CODEC_FLAG_QP_RD))
728
                       && !s->fixed_qscale;
729
    
730
    s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
731
    s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
732
    s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
733

    
734
    if(avctx->rc_max_rate && !avctx->rc_buffer_size){
735
        av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
736
        return -1;
737
    }    
738

    
739
    if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
740
        av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isnt recommanded!\n");
741
    }    
742
        
743
    if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 
744
       && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
745
        av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
746
        return -1;
747
    }
748
        
749
    if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
750
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decission\n");
751
        return -1;
752
    }
753
    
754
    if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
755
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
756
        return -1;
757
    }
758
    
759
    if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
760
        av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
761
        return -1;
762
    }
763

    
764
    if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
765
        av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
766
        return -1;
767
    }
768
    
769
    if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
770
        av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
771
        return -1;
772
    }
773
    
774
    if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
775
        av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n");
776
        return -1;
777
    }
778
        
779
    if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
780
        av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
781
        return -1;
782
    }
783

    
784
    if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
785
        av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
786
        return -1;
787
    }
788
    
789
    if(s->codec_id==CODEC_ID_MJPEG){
790
        s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
791
        s->inter_quant_bias= 0;
792
    }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
793
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
794
        s->inter_quant_bias= 0;
795
    }else{
796
        s->intra_quant_bias=0;
797
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
798
    }
799
    
800
    if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
801
        s->intra_quant_bias= avctx->intra_quant_bias;
802
    if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
803
        s->inter_quant_bias= avctx->inter_quant_bias;
804
        
805
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
806

    
807
    av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
808
    s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
809

    
810
    switch(avctx->codec->id) {
811
    case CODEC_ID_MPEG1VIDEO:
812
        s->out_format = FMT_MPEG1;
813
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
814
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
815
        break;
816
    case CODEC_ID_MPEG2VIDEO:
817
        s->out_format = FMT_MPEG1;
818
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
819
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
820
        s->rtp_mode= 1;
821
        break;
822
    case CODEC_ID_LJPEG:
823
    case CODEC_ID_MJPEG:
824
        s->out_format = FMT_MJPEG;
825
        s->intra_only = 1; /* force intra only for jpeg */
826
        s->mjpeg_write_tables = 1; /* write all tables */
827
        s->mjpeg_data_only_frames = 0; /* write all the needed headers */
828
        s->mjpeg_vsample[0] = 1<<chroma_v_shift;
829
        s->mjpeg_vsample[1] = 1;
830
        s->mjpeg_vsample[2] = 1; 
831
        s->mjpeg_hsample[0] = 1<<chroma_h_shift;
832
        s->mjpeg_hsample[1] = 1; 
833
        s->mjpeg_hsample[2] = 1; 
834
        if (mjpeg_init(s) < 0)
835
            return -1;
836
        avctx->delay=0;
837
        s->low_delay=1;
838
        break;
839
#ifdef CONFIG_RISKY
840
    case CODEC_ID_H263:
841
        if (h263_get_picture_format(s->width, s->height) == 7) {
842
            av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
843
            return -1;
844
        }
845
        s->out_format = FMT_H263;
846
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
847
        avctx->delay=0;
848
        s->low_delay=1;
849
        break;
850
    case CODEC_ID_H263P:
851
        s->out_format = FMT_H263;
852
        s->h263_plus = 1;
853
        /* Fx */
854
        s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
855
        s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
856
        s->modified_quant= s->h263_aic;
857
        s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
858
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
859
        s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
860
        s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
861
        s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
862

    
863
        /* /Fx */
864
        /* These are just to be sure */
865
        avctx->delay=0;
866
        s->low_delay=1;
867
        break;
868
    case CODEC_ID_FLV1:
869
        s->out_format = FMT_H263;
870
        s->h263_flv = 2; /* format = 1; 11-bit codes */
871
        s->unrestricted_mv = 1;
872
        s->rtp_mode=0; /* don't allow GOB */
873
        avctx->delay=0;
874
        s->low_delay=1;
875
        break;
876
    case CODEC_ID_RV10:
877
        s->out_format = FMT_H263;
878
        avctx->delay=0;
879
        s->low_delay=1;
880
        break;
881
    case CODEC_ID_MPEG4:
882
        s->out_format = FMT_H263;
883
        s->h263_pred = 1;
884
        s->unrestricted_mv = 1;
885
        s->low_delay= s->max_b_frames ? 0 : 1;
886
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
887
        break;
888
    case CODEC_ID_MSMPEG4V1:
889
        s->out_format = FMT_H263;
890
        s->h263_msmpeg4 = 1;
891
        s->h263_pred = 1;
892
        s->unrestricted_mv = 1;
893
        s->msmpeg4_version= 1;
894
        avctx->delay=0;
895
        s->low_delay=1;
896
        break;
897
    case CODEC_ID_MSMPEG4V2:
898
        s->out_format = FMT_H263;
899
        s->h263_msmpeg4 = 1;
900
        s->h263_pred = 1;
901
        s->unrestricted_mv = 1;
902
        s->msmpeg4_version= 2;
903
        avctx->delay=0;
904
        s->low_delay=1;
905
        break;
906
    case CODEC_ID_MSMPEG4V3:
907
        s->out_format = FMT_H263;
908
        s->h263_msmpeg4 = 1;
909
        s->h263_pred = 1;
910
        s->unrestricted_mv = 1;
911
        s->msmpeg4_version= 3;
912
        s->flipflop_rounding=1;
913
        avctx->delay=0;
914
        s->low_delay=1;
915
        break;
916
    case CODEC_ID_WMV1:
917
        s->out_format = FMT_H263;
918
        s->h263_msmpeg4 = 1;
919
        s->h263_pred = 1;
920
        s->unrestricted_mv = 1;
921
        s->msmpeg4_version= 4;
922
        s->flipflop_rounding=1;
923
        avctx->delay=0;
924
        s->low_delay=1;
925
        break;
926
    case CODEC_ID_WMV2:
927
        s->out_format = FMT_H263;
928
        s->h263_msmpeg4 = 1;
929
        s->h263_pred = 1;
930
        s->unrestricted_mv = 1;
931
        s->msmpeg4_version= 5;
932
        s->flipflop_rounding=1;
933
        avctx->delay=0;
934
        s->low_delay=1;
935
        break;
936
#endif
937
    default:
938
        return -1;
939
    }
940
    
941
    { /* set up some save defaults, some codecs might override them later */
942
        static int done=0;
943
        if(!done){
944
            int i;
945
            done=1;
946

    
947
            default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
948
            memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
949
            memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
950

    
951
            for(i=-16; i<16; i++){
952
                default_fcode_tab[i + MAX_MV]= 1;
953
            }
954
        }
955
    }
956
    s->me.mv_penalty= default_mv_penalty;
957
    s->fcode_tab= default_fcode_tab;
958
 
959
    /* dont use mv_penalty table for crap MV as it would be confused */
960
    //FIXME remove after fixing / removing old ME
961
    if (s->me_method < ME_EPZS) s->me.mv_penalty = default_mv_penalty;
962

    
963
    s->encoding = 1;
964

    
965
    /* init */
966
    if (MPV_common_init(s) < 0)
967
        return -1;
968

    
969
    if(s->modified_quant)
970
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
971
    s->progressive_frame= 
972
    s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
973
    
974
    ff_init_me(s);
975

    
976
#ifdef CONFIG_ENCODERS
977
#ifdef CONFIG_RISKY
978
    if (s->out_format == FMT_H263)
979
        h263_encode_init(s);
980
    if(s->msmpeg4_version)
981
        ff_msmpeg4_encode_init(s);
982
#endif
983
    if (s->out_format == FMT_MPEG1)
984
        ff_mpeg1_encode_init(s);
985
#endif
986

    
987
    /* init default q matrix */
988
    for(i=0;i<64;i++) {
989
        int j= s->dsp.idct_permutation[i];
990
#ifdef CONFIG_RISKY
991
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
992
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
993
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
994
        }else if(s->out_format == FMT_H263){
995
            s->intra_matrix[j] =
996
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
997
        }else
998
#endif
999
        { /* mpeg1/2 */
1000
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1001
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1002
        }
1003
        if(s->avctx->intra_matrix)
1004
            s->intra_matrix[j] = s->avctx->intra_matrix[i];
1005
        if(s->avctx->inter_matrix)
1006
            s->inter_matrix[j] = s->avctx->inter_matrix[i];
1007
    }
1008

    
1009
    /* precompute matrix */
1010
    /* for mjpeg, we do include qscale in the matrix */
1011
    if (s->out_format != FMT_MJPEG) {
1012
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 
1013
                       s->intra_matrix, s->intra_quant_bias, 1, 31);
1014
        convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, 
1015
                       s->inter_matrix, s->inter_quant_bias, 1, 31);
1016
    }
1017

    
1018
    if(ff_rate_control_init(s) < 0)
1019
        return -1;
1020

    
1021
    s->picture_number = 0;
1022
    s->input_picture_number = 0;
1023
    s->picture_in_gop_number = 0;
1024
    s->fake_picture_number = 0;
1025
    /* motion detector init */
1026
    s->f_code = 1;
1027
    s->b_code = 1;
1028

    
1029
    return 0;
1030
}
1031

    
1032
int MPV_encode_end(AVCodecContext *avctx)
1033
{
1034
    MpegEncContext *s = avctx->priv_data;
1035

    
1036
#ifdef STATS
1037
    print_stats();
1038
#endif
1039

    
1040
    ff_rate_control_uninit(s);
1041

    
1042
    MPV_common_end(s);
1043
    if (s->out_format == FMT_MJPEG)
1044
        mjpeg_close(s);
1045

    
1046
    av_freep(&avctx->extradata);
1047
      
1048
    return 0;
1049
}
1050

    
1051
#endif //CONFIG_ENCODERS
1052

    
1053
void init_rl(RLTable *rl)
1054
{
1055
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1056
    uint8_t index_run[MAX_RUN+1];
1057
    int last, run, level, start, end, i;
1058

    
1059
    /* compute max_level[], max_run[] and index_run[] */
1060
    for(last=0;last<2;last++) {
1061
        if (last == 0) {
1062
            start = 0;
1063
            end = rl->last;
1064
        } else {
1065
            start = rl->last;
1066
            end = rl->n;
1067
        }
1068

    
1069
        memset(max_level, 0, MAX_RUN + 1);
1070
        memset(max_run, 0, MAX_LEVEL + 1);
1071
        memset(index_run, rl->n, MAX_RUN + 1);
1072
        for(i=start;i<end;i++) {
1073
            run = rl->table_run[i];
1074
            level = rl->table_level[i];
1075
            if (index_run[run] == rl->n)
1076
                index_run[run] = i;
1077
            if (level > max_level[run])
1078
                max_level[run] = level;
1079
            if (run > max_run[level])
1080
                max_run[level] = run;
1081
        }
1082
        rl->max_level[last] = av_malloc(MAX_RUN + 1);
1083
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1084
        rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1085
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1086
        rl->index_run[last] = av_malloc(MAX_RUN + 1);
1087
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1088
    }
1089
}
1090

    
1091
/* draw the edges of width 'w' of an image of size width, height */
1092
//FIXME check that this is ok for mpeg4 interlaced
1093
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1094
{
1095
    uint8_t *ptr, *last_line;
1096
    int i;
1097

    
1098
    last_line = buf + (height - 1) * wrap;
1099
    for(i=0;i<w;i++) {
1100
        /* top and bottom */
1101
        memcpy(buf - (i + 1) * wrap, buf, width);
1102
        memcpy(last_line + (i + 1) * wrap, last_line, width);
1103
    }
1104
    /* left and right */
1105
    ptr = buf;
1106
    for(i=0;i<height;i++) {
1107
        memset(ptr - w, ptr[0], w);
1108
        memset(ptr + width, ptr[width-1], w);
1109
        ptr += wrap;
1110
    }
1111
    /* corners */
1112
    for(i=0;i<w;i++) {
1113
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1114
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1115
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1116
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1117
    }
1118
}
1119

    
1120
int ff_find_unused_picture(MpegEncContext *s, int shared){
1121
    int i;
1122
    
1123
    if(shared){
1124
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1125
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1126
        }
1127
    }else{
1128
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1129
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1130
        }
1131
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1132
            if(s->picture[i].data[0]==NULL) return i;
1133
        }
1134
    }
1135

    
1136
    assert(0);
1137
    return -1;
1138
}
1139

    
1140
static void update_noise_reduction(MpegEncContext *s){
1141
    int intra, i;
1142

    
1143
    for(intra=0; intra<2; intra++){
1144
        if(s->dct_count[intra] > (1<<16)){
1145
            for(i=0; i<64; i++){
1146
                s->dct_error_sum[intra][i] >>=1;
1147
            }
1148
            s->dct_count[intra] >>= 1;
1149
        }
1150
        
1151
        for(i=0; i<64; i++){
1152
            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);
1153
        }
1154
    }
1155
}
1156

    
1157
/**
1158
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1159
 */
1160
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1161
{
1162
    int i;
1163
    AVFrame *pic;
1164
    s->mb_skiped = 0;
1165

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

    
1168
    /* mark&release old frames */
1169
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr->data[0]) {
1170
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1171

    
1172
        /* release forgotten pictures */
1173
        /* if(mpeg124/h263) */
1174
        if(!s->encoding){
1175
            for(i=0; i<MAX_PICTURE_COUNT; i++){
1176
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1177
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1178
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
1179
                }
1180
            }
1181
        }
1182
    }
1183
alloc:
1184
    if(!s->encoding){
1185
        /* release non refernce frames */
1186
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1187
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1188
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1189
            }
1190
        }
1191

    
1192
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1193
            pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1194
        else{
1195
            i= ff_find_unused_picture(s, 0);
1196
            pic= (AVFrame*)&s->picture[i];
1197
        }
1198

    
1199
        pic->reference= s->pict_type != B_TYPE ? 3 : 0;
1200

    
1201
        pic->coded_picture_number= s->coded_picture_number++;
1202
        
1203
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1204
            return -1;
1205

    
1206
        s->current_picture_ptr= (Picture*)pic;
1207
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1208
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1209
    }
1210

    
1211
    s->current_picture_ptr->pict_type= s->pict_type;
1212
//    if(s->flags && CODEC_FLAG_QSCALE) 
1213
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1214
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1215

    
1216
    copy_picture(&s->current_picture, s->current_picture_ptr);
1217
  
1218
  if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1219
    if (s->pict_type != B_TYPE) {
1220
        s->last_picture_ptr= s->next_picture_ptr;
1221
        s->next_picture_ptr= s->current_picture_ptr;
1222
    }
1223
    
1224
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1225
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1226
    
1227
    if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1228
        av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1229
        assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1230
        goto alloc;
1231
    }
1232

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

    
1235
    if(s->picture_structure!=PICT_FRAME){
1236
        int i;
1237
        for(i=0; i<4; i++){
1238
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1239
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1240
            } 
1241
            s->current_picture.linesize[i] *= 2;
1242
            s->last_picture.linesize[i] *=2;
1243
            s->next_picture.linesize[i] *=2;
1244
        }
1245
    }
1246
  }
1247
   
1248
    s->hurry_up= s->avctx->hurry_up;
1249
    s->error_resilience= avctx->error_resilience;
1250

    
1251
    /* set dequantizer, we cant do it during init as it might change for mpeg4
1252
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1253
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1254
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1255
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1256
    }else if(s->out_format == FMT_H263){
1257
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1258
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1259
    }else{
1260
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1261
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1262
    }
1263

    
1264
    if(s->dct_error_sum){
1265
        assert(s->avctx->noise_reduction && s->encoding);
1266

    
1267
        update_noise_reduction(s);
1268
    }
1269
        
1270
#ifdef HAVE_XVMC
1271
    if(s->avctx->xvmc_acceleration)
1272
        return XVMC_field_start(s, avctx);
1273
#endif
1274
    return 0;
1275
}
1276

    
1277
/* generic function for encode/decode called after a frame has been coded/decoded */
1278
void MPV_frame_end(MpegEncContext *s)
1279
{
1280
    int i;
1281
    /* draw edge for correct motion prediction if outside */
1282
#ifdef HAVE_XVMC
1283
//just to make sure that all data is rendered.
1284
    if(s->avctx->xvmc_acceleration){
1285
        XVMC_field_end(s);
1286
    }else
1287
#endif
1288
    if(s->unrestricted_mv && s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1289
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1290
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1291
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1292
    }
1293
    emms_c();
1294
    
1295
    s->last_pict_type    = s->pict_type;
1296
    if(s->pict_type!=B_TYPE){
1297
        s->last_non_b_pict_type= s->pict_type;
1298
    }
1299
#if 0
1300
        /* copy back current_picture variables */
1301
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1302
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1303
            s->picture[i]= s->current_picture;
1304
            break;
1305
        }    
1306
    }
1307
    assert(i<MAX_PICTURE_COUNT);
1308
#endif    
1309

    
1310
    if(s->encoding){
1311
        /* release non refernce frames */
1312
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1313
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1314
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1315
            }
1316
        }
1317
    }
1318
    // clear copies, to avoid confusion
1319
#if 0
1320
    memset(&s->last_picture, 0, sizeof(Picture));
1321
    memset(&s->next_picture, 0, sizeof(Picture));
1322
    memset(&s->current_picture, 0, sizeof(Picture));
1323
#endif
1324
}
1325

    
1326
/**
1327
 * draws an line from (ex, ey) -> (sx, sy).
1328
 * @param w width of the image
1329
 * @param h height of the image
1330
 * @param stride stride/linesize of the image
1331
 * @param color color of the arrow
1332
 */
1333
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1334
    int t, x, y, f;
1335
    
1336
    sx= clip(sx, 0, w-1);
1337
    sy= clip(sy, 0, h-1);
1338
    ex= clip(ex, 0, w-1);
1339
    ey= clip(ey, 0, h-1);
1340
    
1341
    buf[sy*stride + sx]+= color;
1342
    
1343
    if(ABS(ex - sx) > ABS(ey - sy)){
1344
        if(sx > ex){
1345
            t=sx; sx=ex; ex=t;
1346
            t=sy; sy=ey; ey=t;
1347
        }
1348
        buf+= sx + sy*stride;
1349
        ex-= sx;
1350
        f= ((ey-sy)<<16)/ex;
1351
        for(x= 0; x <= ex; x++){
1352
            y= ((x*f) + (1<<15))>>16;
1353
            buf[y*stride + x]+= color;
1354
        }
1355
    }else{
1356
        if(sy > ey){
1357
            t=sx; sx=ex; ex=t;
1358
            t=sy; sy=ey; ey=t;
1359
        }
1360
        buf+= sx + sy*stride;
1361
        ey-= sy;
1362
        if(ey) f= ((ex-sx)<<16)/ey;
1363
        else   f= 0;
1364
        for(y= 0; y <= ey; y++){
1365
            x= ((y*f) + (1<<15))>>16;
1366
            buf[y*stride + x]+= color;
1367
        }
1368
    }
1369
}
1370

    
1371
/**
1372
 * draws an arrow from (ex, ey) -> (sx, sy).
1373
 * @param w width of the image
1374
 * @param h height of the image
1375
 * @param stride stride/linesize of the image
1376
 * @param color color of the arrow
1377
 */
1378
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1379
    int dx,dy;
1380

    
1381
    sx= clip(sx, -100, w+100);
1382
    sy= clip(sy, -100, h+100);
1383
    ex= clip(ex, -100, w+100);
1384
    ey= clip(ey, -100, h+100);
1385
    
1386
    dx= ex - sx;
1387
    dy= ey - sy;
1388
    
1389
    if(dx*dx + dy*dy > 3*3){
1390
        int rx=  dx + dy;
1391
        int ry= -dx + dy;
1392
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1393
        
1394
        //FIXME subpixel accuracy
1395
        rx= ROUNDED_DIV(rx*3<<4, length);
1396
        ry= ROUNDED_DIV(ry*3<<4, length);
1397
        
1398
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1399
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1400
    }
1401
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1402
}
1403

    
1404
/**
1405
 * prints debuging info for the given picture.
1406
 */
1407
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1408

    
1409
    if(!pict || !pict->mb_type) return;
1410

    
1411
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1412
        int x,y;
1413
        
1414
        av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1415
        switch (pict->pict_type) {
1416
            case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1417
            case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1418
            case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1419
            case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1420
            case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1421
            case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;            
1422
        }
1423
        for(y=0; y<s->mb_height; y++){
1424
            for(x=0; x<s->mb_width; x++){
1425
                if(s->avctx->debug&FF_DEBUG_SKIP){
1426
                    int count= s->mbskip_table[x + y*s->mb_stride];
1427
                    if(count>9) count=9;
1428
                    av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1429
                }
1430
                if(s->avctx->debug&FF_DEBUG_QP){
1431
                    av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1432
                }
1433
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1434
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
1435
                    //Type & MV direction
1436
                    if(IS_PCM(mb_type))
1437
                        av_log(s->avctx, AV_LOG_DEBUG, "P");
1438
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1439
                        av_log(s->avctx, AV_LOG_DEBUG, "A");
1440
                    else if(IS_INTRA4x4(mb_type))
1441
                        av_log(s->avctx, AV_LOG_DEBUG, "i");
1442
                    else if(IS_INTRA16x16(mb_type))
1443
                        av_log(s->avctx, AV_LOG_DEBUG, "I");
1444
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1445
                        av_log(s->avctx, AV_LOG_DEBUG, "d");
1446
                    else if(IS_DIRECT(mb_type))
1447
                        av_log(s->avctx, AV_LOG_DEBUG, "D");
1448
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1449
                        av_log(s->avctx, AV_LOG_DEBUG, "g");
1450
                    else if(IS_GMC(mb_type))
1451
                        av_log(s->avctx, AV_LOG_DEBUG, "G");
1452
                    else if(IS_SKIP(mb_type))
1453
                        av_log(s->avctx, AV_LOG_DEBUG, "S");
1454
                    else if(!USES_LIST(mb_type, 1))
1455
                        av_log(s->avctx, AV_LOG_DEBUG, ">");
1456
                    else if(!USES_LIST(mb_type, 0))
1457
                        av_log(s->avctx, AV_LOG_DEBUG, "<");
1458
                    else{
1459
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1460
                        av_log(s->avctx, AV_LOG_DEBUG, "X");
1461
                    }
1462
                    
1463
                    //segmentation
1464
                    if(IS_8X8(mb_type))
1465
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1466
                    else if(IS_16X8(mb_type))
1467
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1468
                    else if(IS_8X16(mb_type))
1469
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1470
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1471
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1472
                    else
1473
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1474
                    
1475
                        
1476
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1477
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1478
                    else
1479
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1480
                }
1481
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1482
            }
1483
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1484
        }
1485
    }
1486

    
1487
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1488
        const int shift= 1 + s->quarter_sample;
1489
        int mb_y;
1490
        uint8_t *ptr;
1491
        int i;
1492
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1493

    
1494
        for(i=0; i<3; i++){
1495
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*s->height:pict->linesize[i]*s->height/2);
1496
            pict->data[i]= s->visualization_buffer[i];
1497
        }
1498
        pict->type= FF_BUFFER_TYPE_COPY;
1499
        ptr= pict->data[0];
1500

    
1501
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1502
            int mb_x;
1503
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1504
                const int mb_index= mb_x + mb_y*s->mb_stride;
1505
                if((s->avctx->debug_mv) && pict->motion_val){
1506
                  int type;
1507
                  for(type=0; type<3; type++){
1508
                    int direction;
1509
                    switch (type) {
1510
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1511
                                continue;
1512
                              direction = 0;
1513
                              break;
1514
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1515
                                continue;
1516
                              direction = 0;
1517
                              break;
1518
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1519
                                continue;
1520
                              direction = 1;
1521
                              break;
1522
                    }
1523
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1524
                        continue;
1525

    
1526
                    if(IS_8X8(pict->mb_type[mb_index])){
1527
                      int i;
1528
                      for(i=0; i<4; i++){
1529
                        int sx= mb_x*16 + 4 + 8*(i&1);
1530
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1531
                        int xy= 1 + mb_x*2 + (i&1) + (mb_y*2 + 1 + (i>>1))*(s->mb_width*2 + 2);
1532
                        int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1533
                        int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1534
                        draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1535
                      }
1536
                    }else if(IS_16X8(pict->mb_type[mb_index])){
1537
                      int i;
1538
                      for(i=0; i<2; i++){
1539
                        int sx=mb_x*16 + 8;
1540
                        int sy=mb_y*16 + 4 + 8*i;
1541
                        int xy=1 + mb_x*2 + (mb_y*2 + 1 + i)*(s->mb_width*2 + 2);
1542
                        int mx=(pict->motion_val[direction][xy][0]>>shift) + sx;
1543
                        int my=(pict->motion_val[direction][xy][1]>>shift) + sy;
1544
                        draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1545
                      }
1546
                    }else{
1547
                      int sx= mb_x*16 + 8;
1548
                      int sy= mb_y*16 + 8;
1549
                      int xy= 1 + mb_x*2 + (mb_y*2 + 1)*(s->mb_width*2 + 2);
1550
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1551
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1552
                      draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1553
                    }
1554
                  }                  
1555
                }
1556
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1557
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1558
                    int y;
1559
                    for(y=0; y<8; y++){
1560
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1561
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1562
                    }
1563
                }
1564
                if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1565
                    int mb_type= pict->mb_type[mb_index];
1566
                    uint64_t u,v;
1567
                    int y;
1568
#define COLOR(theta, r)\
1569
u= (int)(128 + r*cos(theta*3.141592/180));\
1570
v= (int)(128 + r*sin(theta*3.141592/180));
1571

    
1572
                    
1573
                    u=v=128;
1574
                    if(IS_PCM(mb_type)){
1575
                        COLOR(120,48)
1576
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1577
                        COLOR(30,48)
1578
                    }else if(IS_INTRA4x4(mb_type)){
1579
                        COLOR(90,48)
1580
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1581
//                        COLOR(120,48)
1582
                    }else if(IS_DIRECT(mb_type)){
1583
                        COLOR(150,48)
1584
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1585
                        COLOR(170,48)
1586
                    }else if(IS_GMC(mb_type)){
1587
                        COLOR(190,48)
1588
                    }else if(IS_SKIP(mb_type)){
1589
//                        COLOR(180,48)
1590
                    }else if(!USES_LIST(mb_type, 1)){
1591
                        COLOR(240,48)
1592
                    }else if(!USES_LIST(mb_type, 0)){
1593
                        COLOR(0,48)
1594
                    }else{
1595
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1596
                        COLOR(300,48)
1597
                    }
1598

    
1599
                    u*= 0x0101010101010101ULL;
1600
                    v*= 0x0101010101010101ULL;
1601
                    for(y=0; y<8; y++){
1602
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1603
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1604
                    }
1605

    
1606
                    //segmentation
1607
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1608
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1609
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1610
                    }
1611
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1612
                        for(y=0; y<16; y++)
1613
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1614
                    }
1615
                        
1616
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1617
                        // hmm
1618
                    }
1619
                }
1620
                s->mbskip_table[mb_index]=0;
1621
            }
1622
        }
1623
    }
1624
}
1625

    
1626
#ifdef CONFIG_ENCODERS
1627

    
1628
static int get_sae(uint8_t *src, int ref, int stride){
1629
    int x,y;
1630
    int acc=0;
1631
    
1632
    for(y=0; y<16; y++){
1633
        for(x=0; x<16; x++){
1634
            acc+= ABS(src[x+y*stride] - ref);
1635
        }
1636
    }
1637
    
1638
    return acc;
1639
}
1640

    
1641
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1642
    int x, y, w, h;
1643
    int acc=0;
1644
    
1645
    w= s->width &~15;
1646
    h= s->height&~15;
1647
    
1648
    for(y=0; y<h; y+=16){
1649
        for(x=0; x<w; x+=16){
1650
            int offset= x + y*stride;
1651
            int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1652
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1653
            int sae = get_sae(src + offset, mean, stride);
1654
            
1655
            acc+= sae + 500 < sad;
1656
        }
1657
    }
1658
    return acc;
1659
}
1660

    
1661

    
1662
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1663
    AVFrame *pic=NULL;
1664
    int i;
1665
    const int encoding_delay= s->max_b_frames;
1666
    int direct=1;
1667
    
1668
  if(pic_arg){
1669
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1670
    if(pic_arg->linesize[0] != s->linesize) direct=0;
1671
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1672
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1673
  
1674
//    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1675
    
1676
    if(direct){
1677
        i= ff_find_unused_picture(s, 1);
1678

    
1679
        pic= (AVFrame*)&s->picture[i];
1680
        pic->reference= 3;
1681
    
1682
        for(i=0; i<4; i++){
1683
            pic->data[i]= pic_arg->data[i];
1684
            pic->linesize[i]= pic_arg->linesize[i];
1685
        }
1686
        alloc_picture(s, (Picture*)pic, 1);
1687
    }else{
1688
        int offset= 16;
1689
        i= ff_find_unused_picture(s, 0);
1690

    
1691
        pic= (AVFrame*)&s->picture[i];
1692
        pic->reference= 3;
1693

    
1694
        alloc_picture(s, (Picture*)pic, 0);
1695

    
1696
        if(   pic->data[0] + offset == pic_arg->data[0] 
1697
           && pic->data[1] + offset == pic_arg->data[1]
1698
           && pic->data[2] + offset == pic_arg->data[2]){
1699
       // empty
1700
        }else{
1701
            int h_chroma_shift, v_chroma_shift;
1702
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1703
        
1704
            for(i=0; i<3; i++){
1705
                int src_stride= pic_arg->linesize[i];
1706
                int dst_stride= i ? s->uvlinesize : s->linesize;
1707
                int h_shift= i ? h_chroma_shift : 0;
1708
                int v_shift= i ? v_chroma_shift : 0;
1709
                int w= s->width >>h_shift;
1710
                int h= s->height>>v_shift;
1711
                uint8_t *src= pic_arg->data[i];
1712
                uint8_t *dst= pic->data[i] + offset;
1713
            
1714
                if(src_stride==dst_stride)
1715
                    memcpy(dst, src, src_stride*h);
1716
                else{
1717
                    while(h--){
1718
                        memcpy(dst, src, w);
1719
                        dst += dst_stride;
1720
                        src += src_stride;
1721
                    }
1722
                }
1723
            }
1724
        }
1725
    }
1726
    copy_picture_attributes(pic, pic_arg);
1727
    
1728
    pic->display_picture_number= s->input_picture_number++;
1729
  }
1730

    
1731
    /* shift buffer entries */
1732
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1733
        s->input_picture[i-1]= s->input_picture[i];
1734
        
1735
    s->input_picture[encoding_delay]= (Picture*)pic;
1736

    
1737
    return 0;
1738
}
1739

    
1740
static void select_input_picture(MpegEncContext *s){
1741
    int i;
1742

    
1743
    for(i=1; i<MAX_PICTURE_COUNT; i++)
1744
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1745
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1746

    
1747
    /* set next picture types & ordering */
1748
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1749
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
1750
            s->reordered_input_picture[0]= s->input_picture[0];
1751
            s->reordered_input_picture[0]->pict_type= I_TYPE;
1752
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
1753
        }else{
1754
            int b_frames;
1755
            
1756
            if(s->flags&CODEC_FLAG_PASS2){
1757
                for(i=0; i<s->max_b_frames+1; i++){
1758
                    int pict_num= s->input_picture[0]->display_picture_number + i;
1759
                    int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1760
                    s->input_picture[i]->pict_type= pict_type;
1761
                    
1762
                    if(i + 1 >= s->rc_context.num_entries) break;
1763
                }
1764
            }
1765

    
1766
            if(s->input_picture[0]->pict_type){
1767
                /* user selected pict_type */
1768
                for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
1769
                    if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
1770
                }
1771
            
1772
                if(b_frames > s->max_b_frames){
1773
                    av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
1774
                    b_frames = s->max_b_frames;
1775
                }
1776
            }else if(s->avctx->b_frame_strategy==0){
1777
                b_frames= s->max_b_frames;
1778
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
1779
            }else if(s->avctx->b_frame_strategy==1){
1780
                for(i=1; i<s->max_b_frames+1; i++){
1781
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
1782
                        s->input_picture[i]->b_frame_score= 
1783
                            get_intra_count(s, s->input_picture[i  ]->data[0], 
1784
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
1785
                    }
1786
                }
1787
                for(i=0; i<s->max_b_frames; i++){
1788
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
1789
                }
1790
                                
1791
                b_frames= FFMAX(0, i-1);
1792
                
1793
                /* reset scores */
1794
                for(i=0; i<b_frames+1; i++){
1795
                    s->input_picture[i]->b_frame_score=0;
1796
                }
1797
            }else{
1798
                av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1799
                b_frames=0;
1800
            }
1801

    
1802
            emms_c();
1803
//static int b_count=0;
1804
//b_count+= b_frames;
1805
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
1806
                        
1807
            s->reordered_input_picture[0]= s->input_picture[b_frames];
1808
            if(   s->picture_in_gop_number + b_frames >= s->gop_size 
1809
               || s->reordered_input_picture[0]->pict_type== I_TYPE)
1810
                s->reordered_input_picture[0]->pict_type= I_TYPE;
1811
            else
1812
                s->reordered_input_picture[0]->pict_type= P_TYPE;
1813
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
1814
            for(i=0; i<b_frames; i++){
1815
                s->reordered_input_picture[i+1]= s->input_picture[i];
1816
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
1817
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
1818
            }
1819
        }
1820
    }
1821
    
1822
    if(s->reordered_input_picture[0]){
1823
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
1824

    
1825
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
1826

    
1827
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
1828
            // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
1829
        
1830
            int i= ff_find_unused_picture(s, 0);
1831
            Picture *pic= &s->picture[i];
1832

    
1833
            /* mark us unused / free shared pic */
1834
            for(i=0; i<4; i++)
1835
                s->reordered_input_picture[0]->data[i]= NULL;
1836
            s->reordered_input_picture[0]->type= 0;
1837
            
1838
            copy_picture_attributes((AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
1839
            pic->reference              = s->reordered_input_picture[0]->reference;
1840
            
1841
            alloc_picture(s, pic, 0);
1842

    
1843
            s->current_picture_ptr= pic;
1844
        }else{
1845
            // input is not a shared pix -> reuse buffer for current_pix
1846

    
1847
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
1848
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
1849
            
1850
            s->current_picture_ptr= s->reordered_input_picture[0];
1851
            for(i=0; i<4; i++){
1852
                s->new_picture.data[i]+=16;
1853
            }
1854
        }
1855
        copy_picture(&s->current_picture, s->current_picture_ptr);
1856
    
1857
        s->picture_number= s->new_picture.display_picture_number;
1858
//printf("dpn:%d\n", s->picture_number);
1859
    }else{
1860
       memset(&s->new_picture, 0, sizeof(Picture));
1861
    }
1862
}
1863

    
1864
int MPV_encode_picture(AVCodecContext *avctx,
1865
                       unsigned char *buf, int buf_size, void *data)
1866
{
1867
    MpegEncContext *s = avctx->priv_data;
1868
    AVFrame *pic_arg = data;
1869
    int i, stuffing_count;
1870

    
1871
    if(avctx->pix_fmt != PIX_FMT_YUV420P){
1872
        av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
1873
        return -1;
1874
    }
1875
    
1876
    init_put_bits(&s->pb, buf, buf_size);
1877

    
1878
    s->picture_in_gop_number++;
1879

    
1880
    load_input_picture(s, pic_arg);
1881
    
1882
    select_input_picture(s);
1883
    
1884
    /* output? */
1885
    if(s->new_picture.data[0]){
1886
        s->pict_type= s->new_picture.pict_type;
1887
//emms_c();
1888
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
1889
        MPV_frame_start(s, avctx);
1890

    
1891
        encode_picture(s, s->picture_number);
1892
        
1893
        avctx->real_pict_num  = s->picture_number;
1894
        avctx->header_bits = s->header_bits;
1895
        avctx->mv_bits     = s->mv_bits;
1896
        avctx->misc_bits   = s->misc_bits;
1897
        avctx->i_tex_bits  = s->i_tex_bits;
1898
        avctx->p_tex_bits  = s->p_tex_bits;
1899
        avctx->i_count     = s->i_count;
1900
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
1901
        avctx->skip_count  = s->skip_count;
1902

    
1903
        MPV_frame_end(s);
1904

    
1905
        if (s->out_format == FMT_MJPEG)
1906
            mjpeg_picture_trailer(s);
1907
        
1908
        if(s->flags&CODEC_FLAG_PASS1)
1909
            ff_write_pass1_stats(s);
1910

    
1911
        for(i=0; i<4; i++){
1912
            avctx->error[i] += s->current_picture_ptr->error[i];
1913
        }
1914
    }
1915

    
1916
    flush_put_bits(&s->pb);
1917
    s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1918

    
1919
    stuffing_count= ff_vbv_update(s, s->frame_bits);
1920
    if(stuffing_count){
1921
        switch(s->codec_id){
1922
        case CODEC_ID_MPEG1VIDEO:
1923
        case CODEC_ID_MPEG2VIDEO:
1924
            while(stuffing_count--){
1925
                put_bits(&s->pb, 8, 0);
1926
            }
1927
        break;
1928
        case CODEC_ID_MPEG4:
1929
            put_bits(&s->pb, 16, 0);
1930
            put_bits(&s->pb, 16, 0x1C3);
1931
            stuffing_count -= 4;
1932
            while(stuffing_count--){
1933
                put_bits(&s->pb, 8, 0xFF);
1934
            }
1935
        break;
1936
        default:
1937
            av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1938
        }
1939
        flush_put_bits(&s->pb);
1940
        s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1941
    }
1942

    
1943
    /* update mpeg1/2 vbv_delay for CBR */    
1944
    if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate){
1945
        int vbv_delay;
1946

    
1947
        assert(s->repeat_first_field==0);
1948
        
1949
        vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
1950
        assert(vbv_delay < 0xFFFF);
1951

    
1952
        s->vbv_delay_ptr[0] &= 0xF8;
1953
        s->vbv_delay_ptr[0] |= vbv_delay>>13;
1954
        s->vbv_delay_ptr[1]  = vbv_delay>>5;
1955
        s->vbv_delay_ptr[2] &= 0x07;
1956
        s->vbv_delay_ptr[2] |= vbv_delay<<3;
1957
    }
1958

    
1959
    s->total_bits += s->frame_bits;
1960
    avctx->frame_bits  = s->frame_bits;
1961
    
1962
    return s->frame_bits/8;
1963
}
1964

    
1965
#endif //CONFIG_ENCODERS
1966

    
1967
static inline void gmc1_motion(MpegEncContext *s,
1968
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1969
                               int dest_offset,
1970
                               uint8_t **ref_picture, int src_offset)
1971
{
1972
    uint8_t *ptr;
1973
    int offset, src_x, src_y, linesize, uvlinesize;
1974
    int motion_x, motion_y;
1975
    int emu=0;
1976

    
1977
    motion_x= s->sprite_offset[0][0];
1978
    motion_y= s->sprite_offset[0][1];
1979
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1980
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1981
    motion_x<<=(3-s->sprite_warping_accuracy);
1982
    motion_y<<=(3-s->sprite_warping_accuracy);
1983
    src_x = clip(src_x, -16, s->width);
1984
    if (src_x == s->width)
1985
        motion_x =0;
1986
    src_y = clip(src_y, -16, s->height);
1987
    if (src_y == s->height)
1988
        motion_y =0;
1989

    
1990
    linesize = s->linesize;
1991
    uvlinesize = s->uvlinesize;
1992
    
1993
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1994

    
1995
    dest_y+=dest_offset;
1996
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1997
        if(   (unsigned)src_x >= s->h_edge_pos - 17
1998
           || (unsigned)src_y >= s->v_edge_pos - 17){
1999
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2000
            ptr= s->edge_emu_buffer;
2001
        }
2002
    }
2003
    
2004
    if((motion_x|motion_y)&7){
2005
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2006
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2007
    }else{
2008
        int dxy;
2009
        
2010
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2011
        if (s->no_rounding){
2012
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2013
        }else{
2014
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2015
        }
2016
    }
2017
    
2018
    if(s->flags&CODEC_FLAG_GRAY) return;
2019

    
2020
    motion_x= s->sprite_offset[1][0];
2021
    motion_y= s->sprite_offset[1][1];
2022
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2023
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2024
    motion_x<<=(3-s->sprite_warping_accuracy);
2025
    motion_y<<=(3-s->sprite_warping_accuracy);
2026
    src_x = clip(src_x, -8, s->width>>1);
2027
    if (src_x == s->width>>1)
2028
        motion_x =0;
2029
    src_y = clip(src_y, -8, s->height>>1);
2030
    if (src_y == s->height>>1)
2031
        motion_y =0;
2032

    
2033
    offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
2034
    ptr = ref_picture[1] + offset;
2035
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2036
        if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2037
           || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2038
            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);
2039
            ptr= s->edge_emu_buffer;
2040
            emu=1;
2041
        }
2042
    }
2043
    s->dsp.gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2044
    
2045
    ptr = ref_picture[2] + offset;
2046
    if(emu){
2047
        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);
2048
        ptr= s->edge_emu_buffer;
2049
    }
2050
    s->dsp.gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2051
    
2052
    return;
2053
}
2054

    
2055
static inline void gmc_motion(MpegEncContext *s,
2056
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2057
                               int dest_offset,
2058
                               uint8_t **ref_picture, int src_offset)
2059
{
2060
    uint8_t *ptr;
2061
    int linesize, uvlinesize;
2062
    const int a= s->sprite_warping_accuracy;
2063
    int ox, oy;
2064

    
2065
    linesize = s->linesize;
2066
    uvlinesize = s->uvlinesize;
2067

    
2068
    ptr = ref_picture[0] + src_offset;
2069

    
2070
    dest_y+=dest_offset;
2071
    
2072
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2073
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2074

    
2075
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2076
           ox, 
2077
           oy, 
2078
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2079
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2080
           a+1, (1<<(2*a+1)) - s->no_rounding,
2081
           s->h_edge_pos, s->v_edge_pos);
2082
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2083
           ox + s->sprite_delta[0][0]*8, 
2084
           oy + s->sprite_delta[1][0]*8, 
2085
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2086
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2087
           a+1, (1<<(2*a+1)) - s->no_rounding,
2088
           s->h_edge_pos, s->v_edge_pos);
2089

    
2090
    if(s->flags&CODEC_FLAG_GRAY) return;
2091

    
2092

    
2093
    dest_cb+=dest_offset>>1;
2094
    dest_cr+=dest_offset>>1;
2095
    
2096
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2097
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2098

    
2099
    ptr = ref_picture[1] + (src_offset>>1);
2100
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2101
           ox, 
2102
           oy, 
2103
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2104
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2105
           a+1, (1<<(2*a+1)) - s->no_rounding,
2106
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2107
    
2108
    ptr = ref_picture[2] + (src_offset>>1);
2109
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2110
           ox, 
2111
           oy, 
2112
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2113
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2114
           a+1, (1<<(2*a+1)) - s->no_rounding,
2115
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2116
}
2117

    
2118
/**
2119
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2120
 * @param buf destination buffer
2121
 * @param src source buffer
2122
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2123
 * @param block_w width of block
2124
 * @param block_h height of block
2125
 * @param src_x x coordinate of the top left sample of the block in the source buffer
2126
 * @param src_y y coordinate of the top left sample of the block in the source buffer
2127
 * @param w width of the source buffer
2128
 * @param h height of the source buffer
2129
 */
2130
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
2131
                                    int src_x, int src_y, int w, int h){
2132
    int x, y;
2133
    int start_y, start_x, end_y, end_x;
2134

    
2135
    if(src_y>= h){
2136
        src+= (h-1-src_y)*linesize;
2137
        src_y=h-1;
2138
    }else if(src_y<=-block_h){
2139
        src+= (1-block_h-src_y)*linesize;
2140
        src_y=1-block_h;
2141
    }
2142
    if(src_x>= w){
2143
        src+= (w-1-src_x);
2144
        src_x=w-1;
2145
    }else if(src_x<=-block_w){
2146
        src+= (1-block_w-src_x);
2147
        src_x=1-block_w;
2148
    }
2149

    
2150
    start_y= FFMAX(0, -src_y);
2151
    start_x= FFMAX(0, -src_x);
2152
    end_y= FFMIN(block_h, h-src_y);
2153
    end_x= FFMIN(block_w, w-src_x);
2154

    
2155
    // copy existing part
2156
    for(y=start_y; y<end_y; y++){
2157
        for(x=start_x; x<end_x; x++){
2158
            buf[x + y*linesize]= src[x + y*linesize];
2159
        }
2160
    }
2161

    
2162
    //top
2163
    for(y=0; y<start_y; y++){
2164
        for(x=start_x; x<end_x; x++){
2165
            buf[x + y*linesize]= buf[x + start_y*linesize];
2166
        }
2167
    }
2168

    
2169
    //bottom
2170
    for(y=end_y; y<block_h; y++){
2171
        for(x=start_x; x<end_x; x++){
2172
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2173
        }
2174
    }
2175
                                    
2176
    for(y=0; y<block_h; y++){
2177
       //left
2178
        for(x=0; x<start_x; x++){
2179
            buf[x + y*linesize]= buf[start_x + y*linesize];
2180
        }
2181
       
2182
       //right
2183
        for(x=end_x; x<block_w; x++){
2184
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2185
        }
2186
    }
2187
}
2188

    
2189
static inline int hpel_motion(MpegEncContext *s, 
2190
                                  uint8_t *dest, uint8_t *src, 
2191
                                  int src_x, int src_y,
2192
                                  int width, int height, int stride,
2193
                                  int h_edge_pos, int v_edge_pos,
2194
                                  int w, int h, op_pixels_func *pix_op,
2195
                                  int motion_x, int motion_y)
2196
{
2197
    int dxy;
2198
    int emu=0;
2199

    
2200
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2201
    src_x += motion_x >> 1;
2202
    src_y += motion_y >> 1;
2203
                
2204
    /* WARNING: do no forget half pels */
2205
    src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2206
    if (src_x == width)
2207
        dxy &= ~1;
2208
    src_y = clip(src_y, -16, height);
2209
    if (src_y == height)
2210
        dxy &= ~2;
2211
    src += src_y * stride + src_x;
2212

    
2213
    if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2214
        if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2215
           || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2216
            ff_emulated_edge_mc(s->edge_emu_buffer, src, stride, w+1, h+1,
2217
                             src_x, src_y, h_edge_pos, v_edge_pos);
2218
            src= s->edge_emu_buffer;
2219
            emu=1;
2220
        }
2221
    }
2222
    pix_op[dxy](dest, src, stride, h);
2223
    return emu;
2224
}
2225

    
2226
/* apply one mpeg motion vector to the three components */
2227
static inline void mpeg_motion(MpegEncContext *s,
2228
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2229
                               int dest_offset,
2230
                               uint8_t **ref_picture, int src_offset,
2231
                               int field_based, op_pixels_func (*pix_op)[4],
2232
                               int motion_x, int motion_y, int h)
2233
{
2234
    uint8_t *ptr;
2235
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, uvlinesize;
2236
    int emu=0;
2237
#if 0    
2238
if(s->quarter_sample)
2239
{
2240
    motion_x>>=1;
2241
    motion_y>>=1;
2242
}
2243
#endif
2244

    
2245
    height = s->height >> field_based;
2246
    v_edge_pos = s->v_edge_pos >> field_based;
2247
    uvlinesize = s->current_picture.linesize[1] << field_based;
2248

    
2249
    emu= hpel_motion(s, 
2250
                dest_y + dest_offset, ref_picture[0] + src_offset,
2251
                s->mb_x * 16, s->mb_y * (16 >> field_based),
2252
                s->width, height, s->current_picture.linesize[0] << field_based,
2253
                s->h_edge_pos, v_edge_pos,
2254
                16, h, pix_op[0],
2255
                motion_x, motion_y);
2256

    
2257

    
2258
    if(s->flags&CODEC_FLAG_GRAY) return;
2259

    
2260
    if (s->out_format == FMT_H263) {
2261
        dxy = 0;
2262
        if ((motion_x & 3) != 0)
2263
            dxy |= 1;
2264
        if ((motion_y & 3) != 0)
2265
            dxy |= 2;
2266
        mx = motion_x >> 2;
2267
        my = motion_y >> 2;
2268
    } else {
2269
        mx = motion_x / 2;
2270
        my = motion_y / 2;
2271
        dxy = ((my & 1) << 1) | (mx & 1);
2272
        mx >>= 1;
2273
        my >>= 1;
2274
    }
2275
    
2276
    src_x = s->mb_x * 8 + mx;
2277
    src_y = s->mb_y * (8 >> field_based) + my;
2278
    src_x = clip(src_x, -8, s->width >> 1);
2279
    if (src_x == (s->width >> 1))
2280
        dxy &= ~1;
2281
    src_y = clip(src_y, -8, height >> 1);
2282
    if (src_y == (height >> 1))
2283
        dxy &= ~2;
2284
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
2285
    ptr = ref_picture[1] + offset;
2286
    if(emu){
2287
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
2288
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2289
        ptr= s->edge_emu_buffer + (src_offset >> 1);
2290
    }
2291
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
2292

    
2293
    ptr = ref_picture[2] + offset;
2294
    if(emu){
2295
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
2296
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2297
        ptr= s->edge_emu_buffer + (src_offset >> 1);
2298
    }
2299
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
2300
}
2301
//FIXME move to dsputil, avg variant, 16x16 version
2302
static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2303
    int x;
2304
    uint8_t * const top   = src[1];
2305
    uint8_t * const left  = src[2];
2306
    uint8_t * const mid   = src[0];
2307
    uint8_t * const right = src[3];
2308
    uint8_t * const bottom= src[4];
2309
#define OBMC_FILTER(x, t, l, m, r, b)\
2310
    dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2311
#define OBMC_FILTER4(x, t, l, m, r, b)\
2312
    OBMC_FILTER(x         , t, l, m, r, b);\
2313
    OBMC_FILTER(x+1       , t, l, m, r, b);\
2314
    OBMC_FILTER(x  +stride, t, l, m, r, b);\
2315
    OBMC_FILTER(x+1+stride, t, l, m, r, b);
2316
    
2317
    x=0;
2318
    OBMC_FILTER (x  , 2, 2, 4, 0, 0);
2319
    OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2320
    OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2321
    OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2322
    OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2323
    OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2324
    x+= stride;
2325
    OBMC_FILTER (x  , 1, 2, 5, 0, 0);
2326
    OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2327
    OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2328
    OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2329
    x+= stride;
2330
    OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
2331
    OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2332
    OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2333
    OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2334
    x+= 2*stride;
2335
    OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
2336
    OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2337
    OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2338
    OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2339
    x+= 2*stride;
2340
    OBMC_FILTER (x  , 0, 2, 5, 0, 1);
2341
    OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2342
    OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2343
    OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2344
    OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2345
    OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2346
    x+= stride;
2347
    OBMC_FILTER (x  , 0, 2, 4, 0, 2);
2348
    OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2349
    OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2350
    OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2351
}
2352

    
2353
/* obmc for 1 8x8 luma block */
2354
static inline void obmc_motion(MpegEncContext *s,
2355
                               uint8_t *dest, uint8_t *src,
2356
                               int src_x, int src_y,
2357
                               op_pixels_func *pix_op,
2358
                               int16_t mv[5][2]/* mid top left right bottom*/)
2359
#define MID    0
2360
{
2361
    int i;
2362
    uint8_t *ptr[5];
2363
    
2364
    assert(s->quarter_sample==0);
2365
    
2366
    for(i=0; i<5; i++){
2367
        if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2368
            ptr[i]= ptr[MID];
2369
        }else{
2370
            ptr[i]= s->edge_emu_buffer + 16 + 8*(i&1) + s->linesize*8*(i>>1);
2371
            hpel_motion(s, ptr[i], src,
2372
                        src_x, src_y,
2373
                        s->width, s->height, s->linesize,
2374
                        s->h_edge_pos, s->v_edge_pos,
2375
                        8, 8, pix_op,
2376
                        mv[i][0], mv[i][1]);
2377
        }
2378
    }
2379

    
2380
    put_obmc(dest, ptr, s->linesize);                
2381
}
2382

    
2383
static inline void qpel_motion(MpegEncContext *s,
2384
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2385
                               int dest_offset,
2386
                               uint8_t **ref_picture, int src_offset,
2387
                               int field_based, op_pixels_func (*pix_op)[4],
2388
                               qpel_mc_func (*qpix_op)[16],
2389
                               int motion_x, int motion_y, int h)
2390
{
2391
    uint8_t *ptr;
2392
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
2393
    int emu=0;
2394

    
2395
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2396
    src_x = s->mb_x * 16 + (motion_x >> 2);
2397
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2398

    
2399
    height = s->height >> field_based;
2400
    v_edge_pos = s->v_edge_pos >> field_based;
2401
    src_x = clip(src_x, -16, s->width);
2402
    if (src_x == s->width)
2403
        dxy &= ~3;
2404
    src_y = clip(src_y, -16, height);
2405
    if (src_y == height)
2406
        dxy &= ~12;
2407
    linesize = s->linesize << field_based;
2408
    uvlinesize = s->uvlinesize << field_based;
2409
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
2410
    dest_y += dest_offset;
2411
//printf("%d %d %d\n", src_x, src_y, dxy);
2412
    
2413
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2414
        if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 
2415
           || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
2416
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr - src_offset, s->linesize, 17, 17+field_based, 
2417
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2418
            ptr= s->edge_emu_buffer + src_offset;
2419
            emu=1;
2420
        }
2421
    }
2422
    if(!field_based)
2423
        qpix_op[0][dxy](dest_y, ptr, linesize);
2424
    else{
2425
        //damn interlaced mode
2426
        //FIXME boundary mirroring is not exactly correct here
2427
        qpix_op[1][dxy](dest_y  , ptr  , linesize);
2428
        qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
2429
    }
2430

    
2431
    if(s->flags&CODEC_FLAG_GRAY) return;
2432

    
2433
    if(field_based){
2434
        mx= motion_x/2;
2435
        my= motion_y>>1;
2436
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2437
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
2438
        mx= (motion_x>>1) + rtab[motion_x&7];
2439
        my= (motion_y>>1) + rtab[motion_y&7];
2440
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2441
        mx= (motion_x>>1)|(motion_x&1);
2442
        my= (motion_y>>1)|(motion_y&1);
2443
    }else{
2444
        mx= motion_x/2;
2445
        my= motion_y/2;
2446
    }
2447
    mx= (mx>>1)|(mx&1);
2448
    my= (my>>1)|(my&1);
2449

    
2450
    dxy= (mx&1) | ((my&1)<<1);
2451
    mx>>=1;
2452
    my>>=1;
2453

    
2454
    src_x = s->mb_x * 8 + mx;
2455
    src_y = s->mb_y * (8 >> field_based) + my;
2456
    src_x = clip(src_x, -8, s->width >> 1);
2457
    if (src_x == (s->width >> 1))
2458
        dxy &= ~1;
2459
    src_y = clip(src_y, -8, height >> 1);
2460
    if (src_y == (height >> 1))
2461
        dxy &= ~2;
2462

    
2463
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
2464
    ptr = ref_picture[1] + offset;
2465
    if(emu){
2466
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
2467
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2468
        ptr= s->edge_emu_buffer + (src_offset >> 1);
2469
    }
2470
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
2471
    
2472
    ptr = ref_picture[2] + offset;
2473
    if(emu){
2474
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
2475
                         src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2476
        ptr= s->edge_emu_buffer + (src_offset >> 1);
2477
    }
2478
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
2479
}
2480

    
2481
inline int ff_h263_round_chroma(int x){
2482
    if (x >= 0)
2483
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2484
    else {
2485
        x = -x;
2486
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2487
    }
2488
}
2489

    
2490
/**
2491
 * h263 chorma 4mv motion compensation.
2492
 */
2493
static inline void chroma_4mv_motion(MpegEncContext *s,
2494
                                     uint8_t *dest_cb, uint8_t *dest_cr,
2495
                                     uint8_t **ref_picture,
2496
                                     op_pixels_func *pix_op,
2497
                                     int mx, int my){
2498
    int dxy, emu=0, src_x, src_y, offset;
2499
    uint8_t *ptr;
2500
    
2501
    /* In case of 8X8, we construct a single chroma motion vector
2502
       with a special rounding */
2503
    mx= ff_h263_round_chroma(mx);
2504
    my= ff_h263_round_chroma(my);
2505
    
2506
    dxy = ((my & 1) << 1) | (mx & 1);
2507
    mx >>= 1;
2508
    my >>= 1;
2509

    
2510
    src_x = s->mb_x * 8 + mx;
2511
    src_y = s->mb_y * 8 + my;
2512
    src_x = clip(src_x, -8, s->width/2);
2513
    if (src_x == s->width/2)
2514
        dxy &= ~1;
2515
    src_y = clip(src_y, -8, s->height/2);
2516
    if (src_y == s->height/2)
2517
        dxy &= ~2;
2518
    
2519
    offset = (src_y * (s->uvlinesize)) + src_x;
2520
    ptr = ref_picture[1] + offset;
2521
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2522
        if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
2523
           || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
2524
            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);
2525
            ptr= s->edge_emu_buffer;
2526
            emu=1;
2527
        }
2528
    }
2529
    pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
2530

    
2531
    ptr = ref_picture[2] + offset;
2532
    if(emu){
2533
        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);
2534
        ptr= s->edge_emu_buffer;
2535
    }
2536
    pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
2537
}
2538

    
2539
/**
2540
 * motion compesation of a single macroblock
2541
 * @param s context
2542
 * @param dest_y luma destination pointer
2543
 * @param dest_cb chroma cb/u destination pointer
2544
 * @param dest_cr chroma cr/v destination pointer
2545
 * @param dir direction (0->forward, 1->backward)
2546
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2547
 * @param pic_op halfpel motion compensation function (average or put normally)
2548
 * @param pic_op qpel motion compensation function (average or put normally)
2549
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2550
 */
2551
static inline void MPV_motion(MpegEncContext *s, 
2552
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2553
                              int dir, uint8_t **ref_picture, 
2554
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
2555
{
2556
    int dxy, mx, my, src_x, src_y, motion_x, motion_y;
2557
    int mb_x, mb_y, i;
2558
    uint8_t *ptr, *dest;
2559

    
2560
    mb_x = s->mb_x;
2561
    mb_y = s->mb_y;
2562

    
2563
    if(s->obmc && s->pict_type != B_TYPE){
2564
        int16_t mv_cache[4][4][2];
2565
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
2566
        const int mot_stride= s->mb_width*2 + 2;
2567
        const int mot_xy= 1 + mb_x*2 + (mb_y*2 + 1)*mot_stride;
2568

    
2569
        assert(!s->mb_skiped);
2570
                
2571
        memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
2572
        memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2573
        memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2574

    
2575
        if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
2576
            memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
2577
        }else{
2578
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
2579
        }
2580

    
2581
        if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
2582
            *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
2583
            *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
2584
        }else{
2585
            *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
2586
            *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
2587
        }
2588

    
2589
        if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
2590
            *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
2591
            *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
2592
        }else{
2593
            *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
2594
            *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
2595
        }
2596
        
2597
        mx = 0;
2598
        my = 0;
2599
        for(i=0;i<4;i++) {
2600
            const int x= (i&1)+1;
2601
            const int y= (i>>1)+1;
2602
            int16_t mv[5][2]= {
2603
                {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
2604
                {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
2605
                {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
2606
                {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
2607
                {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
2608
            //FIXME cleanup
2609
            obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2610
                        ref_picture[0],
2611
                        mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2612
                        pix_op[1],
2613
                        mv);
2614

    
2615
            mx += mv[0][0];
2616
            my += mv[0][1];
2617
        }
2618
        if(!(s->flags&CODEC_FLAG_GRAY))
2619
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2620

    
2621
        return;
2622
    }
2623
   
2624
    switch(s->mv_type) {
2625
    case MV_TYPE_16X16:
2626
#ifdef CONFIG_RISKY
2627
        if(s->mcsel){
2628
            if(s->real_sprite_warping_points==1){
2629
                gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
2630
                            ref_picture, 0);
2631
            }else{
2632
                gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
2633
                            ref_picture, 0);
2634
            }
2635
        }else if(s->quarter_sample){
2636
            qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2637
                        ref_picture, 0,
2638
                        0, pix_op, qpix_op,
2639
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2640
        }else if(s->mspel){
2641
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
2642
                        ref_picture, pix_op,
2643
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2644
        }else
2645
#endif
2646
        {
2647
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2648
                        ref_picture, 0,
2649
                        0, pix_op,
2650
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2651
        }           
2652
        break;
2653
    case MV_TYPE_8X8:
2654
        mx = 0;
2655
        my = 0;
2656
        if(s->quarter_sample){
2657
            for(i=0;i<4;i++) {
2658
                motion_x = s->mv[dir][i][0];
2659
                motion_y = s->mv[dir][i][1];
2660

    
2661
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2662
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
2663
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
2664
                    
2665
                /* WARNING: do no forget half pels */
2666
                src_x = clip(src_x, -16, s->width);
2667
                if (src_x == s->width)
2668
                    dxy &= ~3;
2669
                src_y = clip(src_y, -16, s->height);
2670
                if (src_y == s->height)
2671
                    dxy &= ~12;
2672
                    
2673
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2674
                if(s->flags&CODEC_FLAG_EMU_EDGE){
2675
                    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8 
2676
                       || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
2677
                        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);
2678
                        ptr= s->edge_emu_buffer;
2679
                    }
2680
                }
2681
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2682
                qpix_op[1][dxy](dest, ptr, s->linesize);
2683

    
2684
                mx += s->mv[dir][i][0]/2;
2685
                my += s->mv[dir][i][1]/2;
2686
            }
2687
        }else{
2688
            for(i=0;i<4;i++) {
2689
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2690
                            ref_picture[0],
2691
                            mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2692
                            s->width, s->height, s->linesize,
2693
                            s->h_edge_pos, s->v_edge_pos,
2694
                            8, 8, pix_op[1],
2695
                            s->mv[dir][i][0], s->mv[dir][i][1]);
2696

    
2697
                mx += s->mv[dir][i][0];
2698
                my += s->mv[dir][i][1];
2699
            }
2700
        }
2701

    
2702
        if(!(s->flags&CODEC_FLAG_GRAY))
2703
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2704
        break;
2705
    case MV_TYPE_FIELD:
2706
        if (s->picture_structure == PICT_FRAME) {
2707
            if(s->quarter_sample){
2708
                /* top field */
2709
                qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2710
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2711
                            1, pix_op, qpix_op,
2712
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
2713
                /* bottom field */
2714
                qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2715
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2716
                            1, pix_op, qpix_op,
2717
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
2718
            }else{
2719
                /* top field */       
2720
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2721
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2722
                            1, pix_op,
2723
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
2724
                /* bottom field */
2725
                mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2726
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2727
                            1, pix_op,
2728
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
2729
            }
2730
        } else {
2731
            int offset;
2732
            if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2733
                offset= s->field_select[dir][0] ? s->linesize : 0;
2734
            }else{
2735
                ref_picture= s->current_picture.data;
2736
                offset= s->field_select[dir][0] ? s->linesize : -s->linesize; 
2737
            } 
2738

    
2739
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2740
                        ref_picture, offset,
2741
                        0, pix_op,
2742
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2743
        }
2744
        break;
2745
    case MV_TYPE_16X8:{
2746
        int offset;
2747
         uint8_t ** ref2picture;
2748

    
2749
            if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2750
                ref2picture= ref_picture;
2751
                offset= s->field_select[dir][0] ? s->linesize : 0;
2752
            }else{
2753
                ref2picture= s->current_picture.data;
2754
                offset= s->field_select[dir][0] ? s->linesize : -s->linesize; 
2755
            } 
2756

    
2757
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2758
                        ref2picture, offset,
2759
                        0, pix_op,
2760
                        s->mv[dir][0][0], s->mv[dir][0][1], 8);
2761

    
2762

    
2763
            if(s->picture_structure == s->field_select[dir][1] + 1 || s->pict_type == B_TYPE || s->first_field){
2764
                ref2picture= ref_picture;
2765
                offset= s->field_select[dir][1] ? s->linesize : 0;
2766
            }else{
2767
                ref2picture= s->current_picture.data;
2768
                offset= s->field_select[dir][1] ? s->linesize : -s->linesize; 
2769
            } 
2770
            // I know it is ugly but this is the only way to fool emu_edge without rewrite mpeg_motion
2771
            mpeg_motion(s, dest_y+16*s->linesize, dest_cb+8*s->uvlinesize, dest_cr+8*s->uvlinesize,
2772
                        0,
2773
                        ref2picture, offset,
2774
                        0, pix_op,
2775
                        s->mv[dir][1][0], s->mv[dir][1][1]+16, 8);
2776
        }
2777
        
2778
        break;
2779
    case MV_TYPE_DMV:
2780
    {
2781
    op_pixels_func (*dmv_pix_op)[4];
2782
    int offset;
2783

    
2784
        dmv_pix_op = s->dsp.put_pixels_tab;
2785

    
2786
        if(s->picture_structure == PICT_FRAME){
2787
            //put top field from top field
2788
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2789
                        ref_picture, 0,
2790
                        1, dmv_pix_op,
2791
                        s->mv[dir][0][0], s->mv[dir][0][1], 8);
2792
            //put bottom field from bottom field
2793
            mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2794
                        ref_picture, s->linesize,
2795
                        1, dmv_pix_op,
2796
                        s->mv[dir][0][0], s->mv[dir][0][1], 8);
2797

    
2798
            dmv_pix_op = s->dsp.avg_pixels_tab; 
2799
        
2800
            //avg top field from bottom field
2801
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2802
                        ref_picture, s->linesize,
2803
                        1, dmv_pix_op,
2804
                        s->mv[dir][2][0], s->mv[dir][2][1], 8);
2805
            //avg bottom field from top field
2806
            mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2807
                        ref_picture, 0,
2808
                        1, dmv_pix_op,
2809
                        s->mv[dir][3][0], s->mv[dir][3][1], 8);
2810

    
2811
        }else{
2812
            offset=(s->picture_structure == PICT_BOTTOM_FIELD)? 
2813
                         s->linesize : 0;
2814

    
2815
            //put field from the same parity
2816
            //same parity is never in the same frame
2817
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2818
                        ref_picture,offset,
2819
                        0,dmv_pix_op,
2820
                        s->mv[dir][0][0],s->mv[dir][0][1],16);
2821

    
2822
            // after put we make avg of the same block
2823
            dmv_pix_op=s->dsp.avg_pixels_tab; 
2824

    
2825
            //opposite parity is always in the same frame if this is second field
2826
            if(!s->first_field){
2827
                ref_picture = s->current_picture.data;    
2828
                //top field is one linesize from frame beginig
2829
                offset=(s->picture_structure == PICT_BOTTOM_FIELD)? 
2830
                        -s->linesize : s->linesize;
2831
            }else 
2832
                offset=(s->picture_structure == PICT_BOTTOM_FIELD)? 
2833
                        0 : s->linesize;
2834

    
2835
            //avg field from the opposite parity
2836
            mpeg_motion(s, dest_y, dest_cb, dest_cr,0,
2837
                        ref_picture, offset,
2838
                        0,dmv_pix_op,
2839
                        s->mv[dir][2][0],s->mv[dir][2][1],16);
2840
        }
2841
    }
2842
    break;
2843
    default: assert(0);
2844
    }
2845
}
2846

    
2847

    
2848
/* put block[] to dest[] */
2849
static inline void put_dct(MpegEncContext *s, 
2850
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2851
{
2852
    s->dct_unquantize_intra(s, block, i, qscale);
2853
    s->dsp.idct_put (dest, line_size, block);
2854
}
2855

    
2856
/* add block[] to dest[] */
2857
static inline void add_dct(MpegEncContext *s, 
2858
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
2859
{
2860
    if (s->block_last_index[i] >= 0) {
2861
        s->dsp.idct_add (dest, line_size, block);
2862
    }
2863
}
2864

    
2865
static inline void add_dequant_dct(MpegEncContext *s, 
2866
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2867
{
2868
    if (s->block_last_index[i] >= 0) {
2869
        s->dct_unquantize_inter(s, block, i, qscale);
2870

    
2871
        s->dsp.idct_add (dest, line_size, block);
2872
    }
2873
}
2874

    
2875
/**
2876
 * cleans dc, ac, coded_block for the current non intra MB
2877
 */
2878
void ff_clean_intra_table_entries(MpegEncContext *s)
2879
{
2880
    int wrap = s->block_wrap[0];
2881
    int xy = s->block_index[0];
2882
    
2883
    s->dc_val[0][xy           ] = 
2884
    s->dc_val[0][xy + 1       ] = 
2885
    s->dc_val[0][xy     + wrap] =
2886
    s->dc_val[0][xy + 1 + wrap] = 1024;
2887
    /* ac pred */
2888
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2889
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2890
    if (s->msmpeg4_version>=3) {
2891
        s->coded_block[xy           ] =
2892
        s->coded_block[xy + 1       ] =
2893
        s->coded_block[xy     + wrap] =
2894
        s->coded_block[xy + 1 + wrap] = 0;
2895
    }
2896
    /* chroma */
2897
    wrap = s->block_wrap[4];
2898
    xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
2899
    s->dc_val[1][xy] =
2900
    s->dc_val[2][xy] = 1024;
2901
    /* ac pred */
2902
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2903
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2904
    
2905
    s->mbintra_table[s->mb_x + s->mb_y*s->mb_stride]= 0;
2906
}
2907

    
2908
/* generic function called after a macroblock has been parsed by the
2909
   decoder or after it has been encoded by the encoder.
2910

2911
   Important variables used:
2912
   s->mb_intra : true if intra macroblock
2913
   s->mv_dir   : motion vector direction
2914
   s->mv_type  : motion vector type
2915
   s->mv       : motion vector
2916
   s->interlaced_dct : true if interlaced dct used (mpeg2)
2917
 */
2918
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
2919
{
2920
    int mb_x, mb_y;
2921
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2922
#ifdef HAVE_XVMC
2923
    if(s->avctx->xvmc_acceleration){
2924
        XVMC_decode_mb(s);//xvmc uses pblocks
2925
        return;
2926
    }
2927
#endif
2928

    
2929
    mb_x = s->mb_x;
2930
    mb_y = s->mb_y;
2931

    
2932
    s->current_picture.qscale_table[mb_xy]= s->qscale;
2933

    
2934
    /* update DC predictors for P macroblocks */
2935
    if (!s->mb_intra) {
2936
        if (s->h263_pred || s->h263_aic) {
2937
            if(s->mbintra_table[mb_xy])
2938
                ff_clean_intra_table_entries(s);
2939
        } else {
2940
            s->last_dc[0] =
2941
            s->last_dc[1] =
2942
            s->last_dc[2] = 128 << s->intra_dc_precision;
2943
        }
2944
    }
2945
    else if (s->h263_pred || s->h263_aic)
2946
        s->mbintra_table[mb_xy]=1;
2947

    
2948
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
2949
        uint8_t *dest_y, *dest_cb, *dest_cr;
2950
        int dct_linesize, dct_offset;
2951
        op_pixels_func (*op_pix)[4];
2952
        qpel_mc_func (*op_qpix)[16];
2953
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
2954
        const int uvlinesize= s->current_picture.linesize[1];
2955
        const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band;
2956

    
2957
        /* avoid copy if macroblock skipped in last frame too */
2958
        /* skip only during decoding as we might trash the buffers during encoding a bit */
2959
        if(!s->encoding){
2960
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2961
            const int age= s->current_picture.age;
2962

    
2963
            assert(age);
2964

    
2965
            if (s->mb_skiped) {
2966
                s->mb_skiped= 0;
2967
                assert(s->pict_type!=I_TYPE);
2968
 
2969
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
2970
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2971

    
2972
                /* if previous was skipped too, then nothing to do !  */
2973
                if (*mbskip_ptr >= age && s->current_picture.reference){
2974
                    return;
2975
                }
2976
            } else if(!s->current_picture.reference){
2977
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2978
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2979
            } else{
2980
                *mbskip_ptr = 0; /* not skipped */
2981
            }
2982
        }
2983

    
2984
        if (s->interlaced_dct) {
2985
            dct_linesize = linesize * 2;
2986
            dct_offset = linesize;
2987
        } else {
2988
            dct_linesize = linesize;
2989
            dct_offset = linesize * 8;
2990
        }
2991
        if(readable){
2992
            dest_y=  s->dest[0];
2993
            dest_cb= s->dest[1];
2994
            dest_cr= s->dest[2];
2995
        }else{
2996
            dest_y = s->edge_emu_buffer+32; //FIXME cleanup scratchpad pointers
2997
            dest_cb= s->edge_emu_buffer+48;
2998
            dest_cr= s->edge_emu_buffer+56;
2999
        }
3000
        if (!s->mb_intra) {
3001
            /* motion handling */
3002
            /* decoding or more than one mb_type (MC was allready done otherwise) */
3003
            if(!s->encoding){
3004
                if ((!s->no_rounding) || s->pict_type==B_TYPE){                
3005
                    op_pix = s->dsp.put_pixels_tab;
3006
                    op_qpix= s->dsp.put_qpel_pixels_tab;
3007
                }else{
3008
                    op_pix = s->dsp.put_no_rnd_pixels_tab;
3009
                    op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3010
                }
3011

    
3012
                if (s->mv_dir & MV_DIR_FORWARD) {
3013
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3014
                    op_pix = s->dsp.avg_pixels_tab;
3015
                    op_qpix= s->dsp.avg_qpel_pixels_tab;
3016
                }
3017
                if (s->mv_dir & MV_DIR_BACKWARD) {
3018
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3019
                }
3020
            }
3021

    
3022
            /* skip dequant / idct if we are really late ;) */
3023
            if(s->hurry_up>1) return;
3024

    
3025
            /* add dct residue */
3026
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3027
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3028
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
3029
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
3030
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
3031
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
3032

    
3033
                if(!(s->flags&CODEC_FLAG_GRAY)){
3034
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3035
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3036
                }
3037
            } else if(s->codec_id != CODEC_ID_WMV2){
3038
                add_dct(s, block[0], 0, dest_y, dct_linesize);
3039
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
3040
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
3041
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
3042

    
3043
                if(!(s->flags&CODEC_FLAG_GRAY)){
3044
                    add_dct(s, block[4], 4, dest_cb, uvlinesize);
3045
                    add_dct(s, block[5], 5, dest_cr, uvlinesize);
3046
                }
3047
            } 
3048
#ifdef CONFIG_RISKY
3049
            else{
3050
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3051
            }
3052
#endif
3053
        } else {
3054
            /* dct only in intra block */
3055
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3056
                put_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
3057
                put_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
3058
                put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
3059
                put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
3060

    
3061
                if(!(s->flags&CODEC_FLAG_GRAY)){
3062
                    put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3063
                    put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3064
                }
3065
            }else{
3066
                s->dsp.idct_put(dest_y                 , dct_linesize, block[0]);
3067
                s->dsp.idct_put(dest_y              + 8, dct_linesize, block[1]);
3068
                s->dsp.idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
3069
                s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
3070

    
3071
                if(!(s->flags&CODEC_FLAG_GRAY)){
3072
                    s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3073
                    s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3074
                }
3075
            }
3076
        }
3077
        if(!readable){
3078
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3079
            s->dsp.put_pixels_tab[1][0](s->dest[1], dest_cb, uvlinesize, 8);
3080
            s->dsp.put_pixels_tab[1][0](s->dest[2], dest_cr, uvlinesize, 8);
3081
        }
3082
    }
3083
}
3084

    
3085
#ifdef CONFIG_ENCODERS
3086

    
3087
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3088
{
3089
    static const char tab[64]=
3090
        {3,2,2,1,1,1,1,1,
3091
         1,1,1,1,1,1,1,1,
3092
         1,1,1,1,1,1,1,1,
3093
         0,0,0,0,0,0,0,0,
3094
         0,0,0,0,0,0,0,0,
3095
         0,0,0,0,0,0,0,0,
3096
         0,0,0,0,0,0,0,0,
3097
         0,0,0,0,0,0,0,0};
3098
    int score=0;
3099
    int run=0;
3100
    int i;
3101
    DCTELEM *block= s->block[n];
3102
    const int last_index= s->block_last_index[n];
3103
    int skip_dc;
3104

    
3105
    if(threshold<0){
3106
        skip_dc=0;
3107
        threshold= -threshold;
3108
    }else
3109
        skip_dc=1;
3110

    
3111
    /* are all which we could set to zero are allready zero? */
3112
    if(last_index<=skip_dc - 1) return;
3113

    
3114
    for(i=0; i<=last_index; i++){
3115
        const int j = s->intra_scantable.permutated[i];
3116
        const int level = ABS(block[j]);
3117
        if(level==1){
3118
            if(skip_dc && i==0) continue;
3119
            score+= tab[run];
3120
            run=0;
3121
        }else if(level>1){
3122
            return;
3123
        }else{
3124
            run++;
3125
        }
3126
    }
3127
    if(score >= threshold) return;
3128
    for(i=skip_dc; i<=last_index; i++){
3129
        const int j = s->intra_scantable.permutated[i];
3130
        block[j]=0;
3131
    }
3132
    if(block[0]) s->block_last_index[n]= 0;
3133
    else         s->block_last_index[n]= -1;
3134
}
3135

    
3136
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
3137
{
3138
    int i;
3139
    const int maxlevel= s->max_qcoeff;
3140
    const int minlevel= s->min_qcoeff;
3141
    
3142
    if(s->mb_intra){
3143
        i=1; //skip clipping of intra dc
3144
    }else
3145
        i=0;
3146
    
3147
    for(;i<=last_index; i++){
3148
        const int j= s->intra_scantable.permutated[i];
3149
        int level = block[j];
3150
       
3151
        if     (level>maxlevel) level=maxlevel;
3152
        else if(level<minlevel) level=minlevel;
3153

    
3154
        block[j]= level;
3155
    }
3156
}
3157

    
3158
#if 0
3159
static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
3160
    int score=0;
3161
    int x,y;
3162
    
3163
    for(y=0; y<7; y++){
3164
        for(x=0; x<16; x+=4){
3165
            score+= ABS(s[x  ] - s[x  +stride]) + ABS(s[x+1] - s[x+1+stride]) 
3166
                   +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
3167
        }
3168
        s+= stride;
3169
    }
3170
    
3171
    return score;
3172
}
3173

3174
static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
3175
    int score=0;
3176
    int x,y;
3177
    
3178
    for(y=0; y<7; y++){
3179
        for(x=0; x<16; x++){
3180
            score+= ABS(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
3181
        }
3182
        s1+= stride;
3183
        s2+= stride;
3184
    }
3185
    
3186
    return score;
3187
}
3188
#else
3189
#define SQ(a) ((a)*(a))
3190

    
3191
static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
3192
    int score=0;
3193
    int x,y;
3194
    
3195
    for(y=0; y<7; y++){
3196
        for(x=0; x<16; x+=4){
3197
            score+= SQ(s[x  ] - s[x  +stride]) + SQ(s[x+1] - s[x+1+stride]) 
3198
                   +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
3199
        }
3200
        s+= stride;
3201
    }
3202
    
3203
    return score;
3204
}
3205

    
3206
static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
3207
    int score=0;
3208
    int x,y;
3209
    
3210
    for(y=0; y<7; y++){
3211
        for(x=0; x<16; x++){
3212
            score+= SQ(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
3213
        }
3214
        s1+= stride;
3215
        s2+= stride;
3216
    }
3217
    
3218
    return score;
3219
}
3220

    
3221
#endif
3222

    
3223
#endif //CONFIG_ENCODERS
3224

    
3225
/**
3226
 *
3227
 * @param h is the normal height, this will be reduced automatically if needed for the last row
3228
 */
3229
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3230
    if (s->avctx->draw_horiz_band) {
3231
        AVFrame *src;
3232
        int offset[4];
3233
        
3234
        if(s->picture_structure != PICT_FRAME){
3235
            h <<= 1;
3236
            y <<= 1;
3237
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3238
        }
3239

    
3240
        h= FFMIN(h, s->height - y);
3241

    
3242
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) 
3243
            src= (AVFrame*)s->current_picture_ptr;
3244
        else if(s->last_picture_ptr)
3245
            src= (AVFrame*)s->last_picture_ptr;
3246
        else
3247
            return;
3248
            
3249
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3250
            offset[0]=
3251
            offset[1]=
3252
            offset[2]=
3253
            offset[3]= 0;
3254
        }else{
3255
            offset[0]= y * s->linesize;;
3256
            offset[1]= 
3257
            offset[2]= (y>>1) * s->uvlinesize;;
3258
            offset[3]= 0;
3259
        }
3260

    
3261
        emms_c();
3262

    
3263
        s->avctx->draw_horiz_band(s->avctx, src, offset,
3264
                                  y, s->picture_structure, h);
3265
    }
3266
}
3267

    
3268
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3269
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3270
    const int uvlinesize= s->current_picture.linesize[1];
3271
        
3272
    s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3273
    s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1)     + s->mb_x*2;
3274
    s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1 + s->mb_x*2;
3275
    s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2)     + s->mb_x*2;
3276
    s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
3277
    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;
3278
    
3279
    if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){
3280
        s->dest[0] = s->current_picture.data[0] + s->mb_x * 16 - 16;
3281
        s->dest[1] = s->current_picture.data[1] + s->mb_x * 8 - 8;
3282
        s->dest[2] = s->current_picture.data[2] + s->mb_x * 8 - 8;
3283
    }else{
3284
        s->dest[0] = s->current_picture.data[0] + (s->mb_y * 16* linesize  ) + s->mb_x * 16 - 16;
3285
        s->dest[1] = s->current_picture.data[1] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
3286
        s->dest[2] = s->current_picture.data[2] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
3287
    }    
3288
}
3289

    
3290
#ifdef CONFIG_ENCODERS
3291

    
3292
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
3293
{
3294
    const int mb_x= s->mb_x;
3295
    const int mb_y= s->mb_y;
3296
    int i;
3297
    int skip_dct[6];
3298
    int dct_offset   = s->linesize*8; //default for progressive frames
3299
    
3300
    for(i=0; i<6; i++) skip_dct[i]=0;
3301
    
3302
    if(s->adaptive_quant){
3303
        const int last_qp= s->qscale;
3304
        const int mb_xy= mb_x + mb_y*s->mb_stride;
3305

    
3306
        s->lambda= s->lambda_table[mb_xy];
3307
        update_qscale(s);
3308
    
3309
        if(!(s->flags&CODEC_FLAG_QP_RD)){
3310
            s->dquant= s->qscale - last_qp;
3311

    
3312
            if(s->out_format==FMT_H263)
3313
                s->dquant= clip(s->dquant, -2, 2); //FIXME RD
3314
            
3315
            if(s->codec_id==CODEC_ID_MPEG4){        
3316
                if(!s->mb_intra){
3317
                    if((s->mv_dir&MV_DIRECT) || s->mv_type==MV_TYPE_8X8)
3318
                        s->dquant=0;
3319
                }
3320
            }
3321
        }
3322
        ff_set_qscale(s, last_qp + s->dquant);
3323
    }
3324

    
3325
    if (s->mb_intra) {
3326
        uint8_t *ptr;
3327
        int wrap_y;
3328
        int emu=0;
3329

    
3330
        wrap_y = s->linesize;
3331
        ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
3332

    
3333
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
3334
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
3335
            ptr= s->edge_emu_buffer;
3336
            emu=1;
3337
        }
3338
        
3339
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3340
            int progressive_score, interlaced_score;
3341

    
3342
            progressive_score= pix_vcmp16x8(ptr, wrap_y  ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
3343
            interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y  , wrap_y*2);
3344
            
3345
            if(progressive_score > interlaced_score + 100){
3346
                s->interlaced_dct=1;
3347
            
3348
                dct_offset= wrap_y;
3349
                wrap_y<<=1;
3350
            }else
3351
                s->interlaced_dct=0;
3352
        }
3353
        
3354
        s->dsp.get_pixels(s->block[0], ptr                 , wrap_y);
3355
        s->dsp.get_pixels(s->block[1], ptr              + 8, wrap_y);
3356
        s->dsp.get_pixels(s->block[2], ptr + dct_offset    , wrap_y);
3357
        s->dsp.get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
3358

    
3359
        if(s->flags&CODEC_FLAG_GRAY){
3360
            skip_dct[4]= 1;
3361
            skip_dct[5]= 1;
3362
        }else{
3363
            int wrap_c = s->uvlinesize;
3364
            ptr = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
3365
            if(emu){
3366
                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);
3367
                ptr= s->edge_emu_buffer;
3368
            }
3369
            s->dsp.get_pixels(s->block[4], ptr, wrap_c);
3370

    
3371
            ptr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3372
            if(emu){
3373
                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);
3374
                ptr= s->edge_emu_buffer;
3375
            }
3376
            s->dsp.get_pixels(s->block[5], ptr, wrap_c);
3377
        }
3378
    }else{
3379
        op_pixels_func (*op_pix)[4];
3380
        qpel_mc_func (*op_qpix)[16];
3381
        uint8_t *dest_y, *dest_cb, *dest_cr;
3382
        uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3383
        int wrap_y, wrap_c;
3384
        int emu=0;
3385

    
3386
        dest_y  = s->dest[0];
3387
        dest_cb = s->dest[1];
3388
        dest_cr = s->dest[2];
3389
        wrap_y = s->linesize;
3390
        wrap_c = s->uvlinesize;
3391
        ptr_y  = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
3392
        ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
3393
        ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3394

    
3395
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
3396
            op_pix = s->dsp.put_pixels_tab;
3397
            op_qpix= s->dsp.put_qpel_pixels_tab;
3398
        }else{
3399
            op_pix = s->dsp.put_no_rnd_pixels_tab;
3400
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3401
        }
3402

    
3403
        if (s->mv_dir & MV_DIR_FORWARD) {
3404
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3405
            op_pix = s->dsp.avg_pixels_tab;
3406
            op_qpix= s->dsp.avg_qpel_pixels_tab;
3407
        }
3408
        if (s->mv_dir & MV_DIR_BACKWARD) {
3409
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3410
        }
3411

    
3412
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
3413
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
3414
            ptr_y= s->edge_emu_buffer;
3415
            emu=1;
3416
        }
3417
        
3418
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3419
            int progressive_score, interlaced_score;
3420
            
3421
            progressive_score= pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y  ) 
3422
                             + pix_diff_vcmp16x8(ptr_y + wrap_y*8, dest_y + wrap_y*8, wrap_y  );
3423
            interlaced_score = pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y*2)
3424
                             + pix_diff_vcmp16x8(ptr_y + wrap_y  , dest_y + wrap_y  , wrap_y*2);
3425
            
3426
            if(progressive_score > interlaced_score + 600){
3427
                s->interlaced_dct=1;
3428
            
3429
                dct_offset= wrap_y;
3430
                wrap_y<<=1;
3431
            }else
3432
                s->interlaced_dct=0;
3433
        }
3434
        
3435
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
3436
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
3437
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
3438
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
3439
        
3440
        if(s->flags&CODEC_FLAG_GRAY){
3441
            skip_dct[4]= 1;
3442
            skip_dct[5]= 1;
3443
        }else{
3444
            if(emu){
3445
                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);
3446
                ptr_cb= s->edge_emu_buffer;
3447
            }
3448
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
3449
            if(emu){
3450
                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);
3451
                ptr_cr= s->edge_emu_buffer;
3452
            }
3453
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
3454
        }
3455
        /* pre quantization */         
3456
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
3457
            //FIXME optimize
3458
            if(s->dsp.sad[1](NULL, ptr_y               , dest_y               , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
3459
            if(s->dsp.sad[1](NULL, ptr_y            + 8, dest_y            + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
3460
            if(s->dsp.sad[1](NULL, ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
3461
            if(s->dsp.sad[1](NULL, ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y, 8) < 20*s->qscale) skip_dct[3]= 1;
3462
            if(s->dsp.sad[1](NULL, ptr_cb              , dest_cb              , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
3463
            if(s->dsp.sad[1](NULL, ptr_cr              , dest_cr              , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
3464
#if 0
3465
{
3466
 static int stat[7];
3467
 int num=0;
3468
 for(i=0; i<6; i++)
3469
  if(skip_dct[i]) num++;
3470
 stat[num]++;
3471
 
3472
 if(s->mb_x==0 && s->mb_y==0){
3473
  for(i=0; i<7; i++){
3474
   printf("%6d %1d\n", stat[i], i);
3475
  }
3476
 }
3477
}
3478
#endif
3479
        }
3480

    
3481
    }
3482
            
3483
    /* DCT & quantize */
3484
    if(s->out_format==FMT_MJPEG){
3485
        for(i=0;i<6;i++) {
3486
            int overflow;
3487
            s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
3488
            if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
3489
        }
3490
    }else{
3491
        for(i=0;i<6;i++) {
3492
            if(!skip_dct[i]){
3493
                int overflow;
3494
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
3495
            // FIXME we could decide to change to quantizer instead of clipping
3496
            // JS: I don't think that would be a good idea it could lower quality instead
3497
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
3498
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
3499
            }else
3500
                s->block_last_index[i]= -1;
3501
        }
3502
        
3503
        if(s->luma_elim_threshold && !s->mb_intra)
3504
            for(i=0; i<4; i++)
3505
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
3506
        if(s->chroma_elim_threshold && !s->mb_intra)
3507
            for(i=4; i<6; i++)
3508
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
3509

    
3510
        if(s->flags & CODEC_FLAG_CBP_RD){
3511
            for(i=0;i<6;i++) {
3512
                if(s->block_last_index[i] == -1)
3513
                    s->coded_score[i]= INT_MAX/256;
3514
            }
3515
        }
3516
    }
3517

    
3518
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
3519
        s->block_last_index[4]=
3520
        s->block_last_index[5]= 0;
3521
        s->block[4][0]=
3522
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
3523
    }
3524

    
3525
    //non c quantize code returns incorrect block_last_index FIXME
3526
    if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
3527
        for(i=0; i<6; i++){
3528
            int j;
3529
            if(s->block_last_index[i]>0){
3530
                for(j=63; j>0; j--){
3531
                    if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
3532
                }
3533
                s->block_last_index[i]= j;
3534
            }
3535
        }
3536
    }
3537

    
3538
    /* huffman encode */
3539
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
3540
    case CODEC_ID_MPEG1VIDEO:
3541
    case CODEC_ID_MPEG2VIDEO:
3542
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
3543
#ifdef CONFIG_RISKY
3544
    case CODEC_ID_MPEG4:
3545
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3546
    case CODEC_ID_MSMPEG4V2:
3547
    case CODEC_ID_MSMPEG4V3:
3548
    case CODEC_ID_WMV1:
3549
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3550
    case CODEC_ID_WMV2:
3551
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
3552
    case CODEC_ID_H263:
3553
    case CODEC_ID_H263P:
3554
    case CODEC_ID_FLV1:
3555
    case CODEC_ID_RV10:
3556
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
3557
#endif
3558
    case CODEC_ID_MJPEG:
3559
        mjpeg_encode_mb(s, s->block); break;
3560
    default:
3561
        assert(0);
3562
    }
3563
}
3564

    
3565
#endif //CONFIG_ENCODERS
3566

    
3567
/**
3568
 * combines the (truncated) bitstream to a complete frame
3569
 * @returns -1 if no complete frame could be created
3570
 */
3571
int ff_combine_frame( MpegEncContext *s, int next, uint8_t **buf, int *buf_size){
3572
    ParseContext *pc= &s->parse_context;
3573

    
3574
#if 0
3575
    if(pc->overread){
3576
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
3577
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
3578
    }
3579
#endif
3580

    
3581
    /* copy overreaded byes from last frame into buffer */
3582
    for(; pc->overread>0; pc->overread--){
3583
        pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
3584
    }
3585
    
3586
    pc->last_index= pc->index;
3587

    
3588
    /* copy into buffer end return */
3589
    if(next == END_NOT_FOUND){
3590
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
3591

    
3592
        memcpy(&pc->buffer[pc->index], *buf, *buf_size);
3593
        pc->index += *buf_size;
3594
        return -1;
3595
    }
3596

    
3597
    *buf_size=
3598
    pc->overread_index= pc->index + next;
3599
    
3600
    /* append to buffer */
3601
    if(pc->index){
3602
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
3603

    
3604
        memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
3605
        pc->index = 0;
3606
        *buf= pc->buffer;
3607
    }
3608

    
3609
    /* store overread bytes */
3610
    for(;next < 0; next++){
3611
        pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
3612
        pc->overread++;
3613
    }
3614

    
3615
#if 0
3616
    if(pc->overread){
3617
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
3618
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
3619
    }
3620
#endif
3621

    
3622
    return 0;
3623
}
3624

    
3625
void ff_mpeg_flush(AVCodecContext *avctx){
3626
    int i;
3627
    MpegEncContext *s = avctx->priv_data;
3628
    
3629
    for(i=0; i<MAX_PICTURE_COUNT; i++){
3630
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
3631
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
3632
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
3633
    }
3634
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
3635
    
3636
    s->parse_context.state= -1;
3637
    s->parse_context.frame_start_found= 0;
3638
    s->parse_context.overread= 0;
3639
    s->parse_context.overread_index= 0;
3640
    s->parse_context.index= 0;
3641
    s->parse_context.last_index= 0;
3642
}
3643

    
3644
#ifdef CONFIG_ENCODERS
3645
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
3646
{
3647
    int bytes= length>>4;
3648
    int bits= length&15;
3649
    int i;
3650

    
3651
    if(length==0) return;
3652

    
3653
    for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
3654
    put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
3655
}
3656

    
3657
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
3658
    int i;
3659

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

    
3662
    /* mpeg1 */
3663
    d->mb_skip_run= s->mb_skip_run;
3664
    for(i=0; i<3; i++)
3665
        d->last_dc[i]= s->last_dc[i];
3666
    
3667
    /* statistics */
3668
    d->mv_bits= s->mv_bits;
3669
    d->i_tex_bits= s->i_tex_bits;
3670
    d->p_tex_bits= s->p_tex_bits;
3671
    d->i_count= s->i_count;
3672
    d->f_count= s->f_count;
3673
    d->b_count= s->b_count;
3674
    d->skip_count= s->skip_count;
3675
    d->misc_bits= s->misc_bits;
3676
    d->last_bits= 0;
3677

    
3678
    d->mb_skiped= 0;
3679
    d->qscale= s->qscale;
3680
    d->dquant= s->dquant;
3681
}
3682

    
3683
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
3684
    int i;
3685

    
3686
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
3687
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
3688
    
3689
    /* mpeg1 */
3690
    d->mb_skip_run= s->mb_skip_run;
3691
    for(i=0; i<3; i++)
3692
        d->last_dc[i]= s->last_dc[i];
3693
    
3694
    /* statistics */
3695
    d->mv_bits= s->mv_bits;
3696
    d->i_tex_bits= s->i_tex_bits;
3697
    d->p_tex_bits= s->p_tex_bits;
3698
    d->i_count= s->i_count;
3699
    d->f_count= s->f_count;
3700
    d->b_count= s->b_count;
3701
    d->skip_count= s->skip_count;
3702
    d->misc_bits= s->misc_bits;
3703

    
3704
    d->mb_intra= s->mb_intra;
3705
    d->mb_skiped= s->mb_skiped;
3706
    d->mv_type= s->mv_type;
3707
    d->mv_dir= s->mv_dir;
3708
    d->pb= s->pb;
3709
    if(s->data_partitioning){
3710
        d->pb2= s->pb2;
3711
        d->tex_pb= s->tex_pb;
3712
    }
3713
    d->block= s->block;
3714
    for(i=0; i<6; i++)
3715
        d->block_last_index[i]= s->block_last_index[i];
3716
    d->interlaced_dct= s->interlaced_dct;
3717
    d->qscale= s->qscale;
3718
}
3719

    
3720
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
3721
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
3722
                           int *dmin, int *next_block, int motion_x, int motion_y)
3723
{
3724
    int score;
3725
    uint8_t *dest_backup[3];
3726
    
3727
    copy_context_before_encode(s, backup, type);
3728

    
3729
    s->block= s->blocks[*next_block];
3730
    s->pb= pb[*next_block];
3731
    if(s->data_partitioning){
3732
        s->pb2   = pb2   [*next_block];
3733
        s->tex_pb= tex_pb[*next_block];
3734
    }
3735
    
3736
    if(*next_block){
3737
        memcpy(dest_backup, s->dest, sizeof(s->dest));
3738
        s->dest[0] = s->me.scratchpad;
3739
        s->dest[1] = s->me.scratchpad + 16;
3740
        s->dest[2] = s->me.scratchpad + 16 + 8;
3741
        assert(2*s->uvlinesize == s->linesize); //should be no prob for encoding
3742
        assert(s->linesize >= 64); //FIXME
3743
    }
3744

    
3745
    encode_mb(s, motion_x, motion_y);
3746
    
3747
    score= get_bit_count(&s->pb);
3748
    if(s->data_partitioning){
3749
        score+= get_bit_count(&s->pb2);
3750
        score+= get_bit_count(&s->tex_pb);
3751
    }
3752
   
3753
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
3754
        MPV_decode_mb(s, s->block);
3755

    
3756
        score *= s->lambda2;
3757
        score += sse_mb(s) << FF_LAMBDA_SHIFT;
3758
    }
3759
    
3760
    if(*next_block){
3761
        memcpy(s->dest, dest_backup, sizeof(s->dest));
3762
    }
3763

    
3764
    if(score<*dmin){
3765
        *dmin= score;
3766
        *next_block^=1;
3767

    
3768
        copy_context_after_encode(best, s, type);
3769
    }
3770
}
3771
                
3772
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
3773
    uint32_t *sq = squareTbl + 256;
3774
    int acc=0;
3775
    int x,y;
3776
    
3777
    if(w==16 && h==16) 
3778
        return s->dsp.sse[0](NULL, src1, src2, stride, 16);
3779
    else if(w==8 && h==8)
3780
        return s->dsp.sse[1](NULL, src1, src2, stride, 8);
3781
    
3782
    for(y=0; y<h; y++){
3783
        for(x=0; x<w; x++){
3784
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
3785
        } 
3786
    }
3787
    
3788
    assert(acc>=0);
3789
    
3790
    return acc;
3791
}
3792

    
3793
static int sse_mb(MpegEncContext *s){
3794
    int w= 16;
3795
    int h= 16;
3796

    
3797
    if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3798
    if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3799

    
3800
    if(w==16 && h==16)
3801
        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, 16)
3802
               +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, 8)
3803
               +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, 8);
3804
    else
3805
        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)
3806
               +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)
3807
               +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);
3808
}
3809

    
3810
static void encode_picture(MpegEncContext *s, int picture_number)
3811
{
3812
    int mb_x, mb_y, pdif = 0;
3813
    int i, j;
3814
    int bits;
3815
    MpegEncContext best_s, backup_s;
3816
    uint8_t bit_buf[2][3000];
3817
    uint8_t bit_buf2[2][3000];
3818
    uint8_t bit_buf_tex[2][3000];
3819
    PutBitContext pb[2], pb2[2], tex_pb[2];
3820

    
3821
    for(i=0; i<2; i++){
3822
        init_put_bits(&pb    [i], bit_buf    [i], 3000);
3823
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000);
3824
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000);
3825
    }
3826

    
3827
    s->picture_number = picture_number;
3828
    
3829
    /* Reset the average MB variance */
3830
    s->current_picture.mb_var_sum = 0;
3831
    s->current_picture.mc_mb_var_sum = 0;
3832

    
3833
#ifdef CONFIG_RISKY
3834
    /* we need to initialize some time vars before we can encode b-frames */
3835
    // RAL: Condition added for MPEG1VIDEO
3836
    if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
3837
        ff_set_mpeg4_time(s, s->picture_number); 
3838
#endif
3839
        
3840
    s->scene_change_score=0;
3841
    
3842
    s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration
3843
    
3844
    if(s->pict_type==I_TYPE){
3845
        if(s->msmpeg4_version >= 3) s->no_rounding=1;
3846
        else                        s->no_rounding=0;
3847
    }else if(s->pict_type!=B_TYPE){
3848
        if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
3849
            s->no_rounding ^= 1;          
3850
    }
3851
    
3852
    /* Estimate motion for every MB */
3853
    s->mb_intra=0; //for the rate distoration & bit compare functions
3854
    if(s->pict_type != I_TYPE){
3855
        if(s->pict_type != B_TYPE){
3856
            if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
3857
                s->me.pre_pass=1;
3858
                s->me.dia_size= s->avctx->pre_dia_size;
3859

    
3860
                for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) {
3861
                    for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) {
3862
                        s->mb_x = mb_x;
3863
                        s->mb_y = mb_y;
3864
                        ff_pre_estimate_p_frame_motion(s, mb_x, mb_y);
3865
                    }
3866
                }
3867
                s->me.pre_pass=0;
3868
            }
3869
        }
3870

    
3871
        s->me.dia_size= s->avctx->dia_size;
3872
        for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3873
            s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3874
            s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3875
            s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3876
            s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3877
            for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3878
                s->mb_x = mb_x;
3879
                s->mb_y = mb_y;
3880
                s->block_index[0]+=2;
3881
                s->block_index[1]+=2;
3882
                s->block_index[2]+=2;
3883
                s->block_index[3]+=2;
3884
                
3885
                /* compute motion vector & mb_type and store in context */
3886
                if(s->pict_type==B_TYPE)
3887
                    ff_estimate_b_frame_motion(s, mb_x, mb_y);
3888
                else
3889
                    ff_estimate_p_frame_motion(s, mb_x, mb_y);
3890
            }
3891
        }
3892
    }else /* if(s->pict_type == I_TYPE) */{
3893
        /* I-Frame */
3894
        //FIXME do we need to zero them?
3895
        memset(s->current_picture.motion_val[0][0], 0, sizeof(int16_t)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
3896
        memset(s->p_mv_table   , 0, sizeof(int16_t)*(s->mb_stride)*s->mb_height*2);
3897
        for(i=0; i<s->mb_stride*s->mb_height; i++)
3898
            s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3899
        
3900
        if(!s->fixed_qscale){
3901
            /* finding spatial complexity for I-frame rate control */
3902
            for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3903
                for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3904
                    int xx = mb_x * 16;
3905
                    int yy = mb_y * 16;
3906
                    uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
3907
                    int varc;
3908
                    int sum = s->dsp.pix_sum(pix, s->linesize);
3909
    
3910
                    varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
3911

    
3912
                    s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
3913
                    s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
3914
                    s->current_picture.mb_var_sum    += varc;
3915
                }
3916
            }
3917
        }
3918
    }
3919
    emms_c();
3920

    
3921
    if(s->scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){
3922
        s->pict_type= I_TYPE;
3923
        for(i=0; i<s->mb_stride*s->mb_height; i++)
3924
            s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3925
//printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3926
    }
3927

    
3928
    if(!s->umvplus){
3929
        if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
3930
            s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3931

    
3932
            if(s->flags & CODEC_FLAG_INTERLACED_ME){
3933
                int a,b;
3934
                a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3935
                b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3936
                s->f_code= FFMAX(s->f_code, FFMAX(a,b));
3937
            }
3938
                    
3939
            ff_fix_long_p_mvs(s);
3940
            ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3941
            if(s->flags & CODEC_FLAG_INTERLACED_ME){
3942
                for(i=0; i<2; i++){
3943
                    for(j=0; j<2; j++)
3944
                        ff_fix_long_mvs(s, s->p_field_select_table[i], j, 
3945
                                        s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3946
                }
3947
            }
3948
        }
3949

    
3950
        if(s->pict_type==B_TYPE){
3951
            int a, b;
3952

    
3953
            a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3954
            b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3955
            s->f_code = FFMAX(a, b);
3956

    
3957
            a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3958
            b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3959
            s->b_code = FFMAX(a, b);
3960

    
3961
            ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3962
            ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3963
            ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3964
            ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3965
            if(s->flags & CODEC_FLAG_INTERLACED_ME){
3966
                int dir;
3967
                for(dir=0; dir<2; dir++){
3968
                    for(i=0; i<2; i++){
3969
                        for(j=0; j<2; j++){
3970
                            int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I) 
3971
                                          : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3972
                            ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j, 
3973
                                            s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3974
                        }
3975
                    }
3976
                }
3977
            }
3978
        }
3979
    }
3980
    
3981
    if (!s->fixed_qscale) 
3982
        s->current_picture.quality = ff_rate_estimate_qscale(s);
3983

    
3984
    if(s->adaptive_quant){
3985
#ifdef CONFIG_RISKY
3986
        switch(s->codec_id){
3987
        case CODEC_ID_MPEG4:
3988
            ff_clean_mpeg4_qscales(s);
3989
            break;
3990
        case CODEC_ID_H263:
3991
        case CODEC_ID_H263P:
3992
        case CODEC_ID_FLV1:
3993
            ff_clean_h263_qscales(s);
3994
            break;
3995
        }
3996
#endif
3997

    
3998
        s->lambda= s->lambda_table[0];
3999
        //FIXME broken
4000
    }else
4001
        s->lambda= s->current_picture.quality;
4002
//printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
4003
    update_qscale(s);
4004
    
4005
    if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==I_TYPE && !(s->flags & CODEC_FLAG_QSCALE)) 
4006
        s->qscale= 3; //reduce cliping problems
4007
        
4008
    if (s->out_format == FMT_MJPEG) {
4009
        /* for mjpeg, we do include qscale in the matrix */
4010
        s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
4011
        for(i=1;i<64;i++){
4012
            int j= s->dsp.idct_permutation[i];
4013

    
4014
            s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
4015
        }
4016
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 
4017
                       s->intra_matrix, s->intra_quant_bias, 8, 8);
4018
    }
4019
    
4020
    //FIXME var duplication
4021
    s->current_picture.key_frame= s->pict_type == I_TYPE;
4022
    s->current_picture.pict_type= s->pict_type;
4023

    
4024
    if(s->current_picture.key_frame)
4025
        s->picture_in_gop_number=0;
4026

    
4027
    s->last_bits= get_bit_count(&s->pb);
4028
    switch(s->out_format) {
4029
    case FMT_MJPEG:
4030
        mjpeg_picture_header(s);
4031
        break;
4032
#ifdef CONFIG_RISKY
4033
    case FMT_H263:
4034
        if (s->codec_id == CODEC_ID_WMV2) 
4035
            ff_wmv2_encode_picture_header(s, picture_number);
4036
        else if (s->h263_msmpeg4) 
4037
            msmpeg4_encode_picture_header(s, picture_number);
4038
        else if (s->h263_pred)
4039
            mpeg4_encode_picture_header(s, picture_number);
4040
        else if (s->codec_id == CODEC_ID_RV10) 
4041
            rv10_encode_picture_header(s, picture_number);
4042
        else if (s->codec_id == CODEC_ID_FLV1)
4043
            ff_flv_encode_picture_header(s, picture_number);
4044
        else
4045
            h263_encode_picture_header(s, picture_number);
4046
        break;
4047
#endif
4048
    case FMT_MPEG1:
4049
        mpeg1_encode_picture_header(s, picture_number);
4050
        break;
4051
    case FMT_H264:
4052
        break;
4053
    }
4054
    bits= get_bit_count(&s->pb);
4055
    s->header_bits= bits - s->last_bits;
4056
    s->last_bits= bits;
4057
    s->mv_bits=0;
4058
    s->misc_bits=0;
4059
    s->i_tex_bits=0;
4060
    s->p_tex_bits=0;
4061
    s->i_count=0;
4062
    s->f_count=0;
4063
    s->b_count=0;
4064
    s->skip_count=0;
4065

    
4066
    for(i=0; i<3; i++){
4067
        /* init last dc values */
4068
        /* note: quant matrix value (8) is implied here */
4069
        s->last_dc[i] = 128;
4070
        
4071
        s->current_picture_ptr->error[i] = 0;
4072
    }
4073
    s->mb_skip_run = 0;
4074
    memset(s->last_mv, 0, sizeof(s->last_mv));
4075
     
4076
    s->last_mv_dir = 0;
4077

    
4078
#ifdef CONFIG_RISKY
4079
    switch(s->codec_id){
4080
    case CODEC_ID_H263:
4081
    case CODEC_ID_H263P:
4082
    case CODEC_ID_FLV1:
4083
        s->gob_index = ff_h263_get_gob_height(s);
4084
        break;
4085
    case CODEC_ID_MPEG4:
4086
        if(s->partitioned_frame)
4087
            ff_mpeg4_init_partitions(s);
4088
        break;
4089
    }
4090
#endif
4091

    
4092
    s->resync_mb_x=0;
4093
    s->resync_mb_y=0;
4094
    s->first_slice_line = 1;
4095
    s->ptr_lastgob = s->pb.buf;
4096
    for(mb_y=0; mb_y < s->mb_height; mb_y++) {
4097
        s->mb_x=0;
4098
        s->mb_y= mb_y;
4099

    
4100
        ff_set_qscale(s, s->qscale);
4101
        ff_init_block_index(s);
4102
        
4103
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4104
            const int xy= mb_y*s->mb_stride + mb_x;
4105
            int mb_type= s->mb_type[xy];
4106
//            int d;
4107
            int dmin= INT_MAX;
4108
            int dir;
4109

    
4110
            s->mb_x = mb_x;
4111
            ff_update_block_index(s);
4112

    
4113
            /* write gob / video packet header  */
4114
#ifdef CONFIG_RISKY
4115
            if(s->rtp_mode){
4116
                int current_packet_size, is_gob_start;
4117
                
4118
                current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4119
                
4120
                is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0; 
4121
                
4122
                switch(s->codec_id){
4123
                case CODEC_ID_H263:
4124
                case CODEC_ID_H263P:
4125
                    if(!s->h263_slice_structured)
4126
                        if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
4127
                    break;
4128
                case CODEC_ID_MPEG2VIDEO:
4129
                    if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
4130
                case CODEC_ID_MPEG1VIDEO:
4131
                    if(s->mb_skip_run) is_gob_start=0;
4132
                    break;
4133
                }
4134
                
4135
                if(is_gob_start){
4136
                    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
4137
                        ff_mpeg4_merge_partitions(s);
4138
                        ff_mpeg4_init_partitions(s);
4139
                    }
4140
                
4141
                    if(s->codec_id==CODEC_ID_MPEG4) 
4142
                        ff_mpeg4_stuffing(&s->pb);
4143

    
4144
                    align_put_bits(&s->pb);
4145
                    flush_put_bits(&s->pb);
4146

    
4147
                    assert((get_bit_count(&s->pb)&7) == 0);
4148
                    current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4149
                    
4150
                    if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
4151
                        int r= get_bit_count(&s->pb)/8 + s->picture_number + s->codec_id + s->mb_x + s->mb_y;
4152
                        int d= 100 / s->avctx->error_rate;
4153
                        if(r % d == 0){
4154
                            current_packet_size=0;
4155
#ifndef ALT_BITSTREAM_WRITER
4156
                            s->pb.buf_ptr= s->ptr_lastgob;
4157
#endif
4158
                            assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
4159
                        }
4160
                    }
4161
        
4162
                    if (s->avctx->rtp_callback)
4163
                        s->avctx->rtp_callback(s->ptr_lastgob, current_packet_size, 0);
4164
                    
4165
                    switch(s->codec_id){
4166
                    case CODEC_ID_MPEG4:
4167
                        ff_mpeg4_encode_video_packet_header(s);
4168
                        ff_mpeg4_clean_buffers(s);
4169
                    break;
4170
                    case CODEC_ID_MPEG1VIDEO:
4171
                    case CODEC_ID_MPEG2VIDEO:
4172
                        ff_mpeg1_encode_slice_header(s);
4173
                        ff_mpeg1_clean_buffers(s);
4174
                    break;
4175
                    case CODEC_ID_H263:
4176
                    case CODEC_ID_H263P:
4177
                        h263_encode_gob_header(s, mb_y);                       
4178
                    break;
4179
                    }
4180

    
4181
                    if(s->flags&CODEC_FLAG_PASS1){
4182
                        int bits= get_bit_count(&s->pb);
4183
                        s->misc_bits+= bits - s->last_bits;
4184
                        s->last_bits= bits;
4185
                    }
4186
    
4187
                    s->ptr_lastgob += current_packet_size;
4188
                    s->first_slice_line=1;
4189
                    s->resync_mb_x=mb_x;
4190
                    s->resync_mb_y=mb_y;
4191
                }
4192
            }
4193
#endif
4194

    
4195
            if(  (s->resync_mb_x   == s->mb_x)
4196
               && s->resync_mb_y+1 == s->mb_y){
4197
                s->first_slice_line=0; 
4198
            }
4199

    
4200
            s->mb_skiped=0;
4201
            s->dquant=0; //only for QP_RD
4202

    
4203
            if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible
4204
                int next_block=0;
4205
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
4206

    
4207
                copy_context_before_encode(&backup_s, s, -1);
4208
                backup_s.pb= s->pb;
4209
                best_s.data_partitioning= s->data_partitioning;
4210
                best_s.partitioned_frame= s->partitioned_frame;
4211
                if(s->data_partitioning){
4212
                    backup_s.pb2= s->pb2;
4213
                    backup_s.tex_pb= s->tex_pb;
4214
                }
4215

    
4216
                if(mb_type&CANDIDATE_MB_TYPE_INTER){
4217
                    s->mv_dir = MV_DIR_FORWARD;
4218
                    s->mv_type = MV_TYPE_16X16;
4219
                    s->mb_intra= 0;
4220
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
4221
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
4222
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb, 
4223
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4224
                }
4225
                if(mb_type&CANDIDATE_MB_TYPE_INTER_I){ 
4226
                    s->mv_dir = MV_DIR_FORWARD;
4227
                    s->mv_type = MV_TYPE_FIELD;
4228
                    s->mb_intra= 0;
4229
                    for(i=0; i<2; i++){
4230
                        j= s->field_select[0][i] = s->p_field_select_table[i][xy];
4231
                        s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
4232
                        s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
4233
                    }
4234
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb, 
4235
                                 &dmin, &next_block, 0, 0);
4236
                }
4237
                if(mb_type&CANDIDATE_MB_TYPE_SKIPED){
4238
                    s->mv_dir = MV_DIR_FORWARD;
4239
                    s->mv_type = MV_TYPE_16X16;
4240
                    s->mb_intra= 0;
4241
                    s->mv[0][0][0] = 0;
4242
                    s->mv[0][0][1] = 0;
4243
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPED, pb, pb2, tex_pb, 
4244
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4245
                }
4246
                if(mb_type&CANDIDATE_MB_TYPE_INTER4V){                 
4247
                    s->mv_dir = MV_DIR_FORWARD;
4248
                    s->mv_type = MV_TYPE_8X8;
4249
                    s->mb_intra= 0;
4250
                    for(i=0; i<4; i++){
4251
                        s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
4252
                        s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
4253
                    }
4254
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb, 
4255
                                 &dmin, &next_block, 0, 0);
4256
                }
4257
                if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
4258
                    s->mv_dir = MV_DIR_FORWARD;
4259
                    s->mv_type = MV_TYPE_16X16;
4260
                    s->mb_intra= 0;
4261
                    s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
4262
                    s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
4263
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb, 
4264
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4265
                }
4266
                if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
4267
                    s->mv_dir = MV_DIR_BACKWARD;
4268
                    s->mv_type = MV_TYPE_16X16;
4269
                    s->mb_intra= 0;
4270
                    s->mv[1][0][0] = s->b_back_mv_table[xy][0];
4271
                    s->mv[1][0][1] = s->b_back_mv_table[xy][1];
4272
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb, 
4273
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
4274
                }
4275
                if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
4276
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4277
                    s->mv_type = MV_TYPE_16X16;
4278
                    s->mb_intra= 0;
4279
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
4280
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
4281
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
4282
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
4283
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb, 
4284
                                 &dmin, &next_block, 0, 0);
4285
                }
4286
                if(mb_type&CANDIDATE_MB_TYPE_DIRECT){
4287
                    int mx= s->b_direct_mv_table[xy][0];
4288
                    int my= s->b_direct_mv_table[xy][1];
4289
                    
4290
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4291
                    s->mb_intra= 0;
4292
#ifdef CONFIG_RISKY
4293
                    ff_mpeg4_set_direct_mv(s, mx, my);
4294
#endif
4295
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb, 
4296
                                 &dmin, &next_block, mx, my);
4297
                }
4298
                if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){ 
4299
                    s->mv_dir = MV_DIR_FORWARD;
4300
                    s->mv_type = MV_TYPE_FIELD;
4301
                    s->mb_intra= 0;
4302
                    for(i=0; i<2; i++){
4303
                        j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
4304
                        s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
4305
                        s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
4306
                    }
4307
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb, 
4308
                                 &dmin, &next_block, 0, 0);
4309
                }
4310
                if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){ 
4311
                    s->mv_dir = MV_DIR_BACKWARD;
4312
                    s->mv_type = MV_TYPE_FIELD;
4313
                    s->mb_intra= 0;
4314
                    for(i=0; i<2; i++){
4315
                        j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
4316
                        s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
4317
                        s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
4318
                    }
4319
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb, 
4320
                                 &dmin, &next_block, 0, 0);
4321
                }
4322
                if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){ 
4323
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4324
                    s->mv_type = MV_TYPE_FIELD;
4325
                    s->mb_intra= 0;
4326
                    for(dir=0; dir<2; dir++){
4327
                        for(i=0; i<2; i++){
4328
                            j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
4329
                            s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
4330
                            s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
4331
                        }
4332
                    }
4333
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb, 
4334
                                 &dmin, &next_block, 0, 0);
4335
                }
4336
                if(mb_type&CANDIDATE_MB_TYPE_INTRA){
4337
                    s->mv_dir = 0;
4338
                    s->mv_type = MV_TYPE_16X16;
4339
                    s->mb_intra= 1;
4340
                    s->mv[0][0][0] = 0;
4341
                    s->mv[0][0][1] = 0;
4342
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb, 
4343
                                 &dmin, &next_block, 0, 0);
4344
                    if(s->h263_pred || s->h263_aic){
4345
                        if(best_s.mb_intra)
4346
                            s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
4347
                        else
4348
                            ff_clean_intra_table_entries(s); //old mode?
4349
                    }
4350
                }
4351

    
4352
                if(s->flags & CODEC_FLAG_QP_RD){
4353
                    if(best_s.mv_type==MV_TYPE_16X16 && !(best_s.mv_dir&MV_DIRECT)){
4354
                        const int last_qp= backup_s.qscale;
4355
                        int dquant, dir, qp, dc[6];
4356
                        DCTELEM ac[6][16];
4357
                        const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
4358
                        
4359
                        assert(backup_s.dquant == 0);
4360

    
4361
                        //FIXME intra
4362
                        s->mv_dir= best_s.mv_dir;
4363
                        s->mv_type = MV_TYPE_16X16;
4364
                        s->mb_intra= best_s.mb_intra;
4365
                        s->mv[0][0][0] = best_s.mv[0][0][0];
4366
                        s->mv[0][0][1] = best_s.mv[0][0][1];
4367
                        s->mv[1][0][0] = best_s.mv[1][0][0];
4368
                        s->mv[1][0][1] = best_s.mv[1][0][1];
4369
                        
4370
                        dir= s->pict_type == B_TYPE ? 2 : 1;
4371
                        if(last_qp + dir > s->avctx->qmax) dir= -dir;
4372
                        for(dquant= dir; dquant<=2 && dquant>=-2; dquant += dir){
4373
                            qp= last_qp + dquant;
4374
                            if(qp < s->avctx->qmin || qp > s->avctx->qmax)
4375
                                break;
4376
                            backup_s.dquant= dquant;
4377
                            if(s->mb_intra){
4378
                                for(i=0; i<6; i++){
4379
                                    dc[i]= s->dc_val[0][ s->block_index[i] ];
4380
                                    memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
4381
                                }
4382
                            }
4383

    
4384
                            encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb, 
4385
                                         &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
4386
                            if(best_s.qscale != qp){
4387
                                if(s->mb_intra){
4388
                                    for(i=0; i<6; i++){
4389
                                        s->dc_val[0][ s->block_index[i] ]= dc[i];
4390
                                        memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
4391
                                    }
4392
                                }
4393
                                if(dir > 0 && dquant==dir){
4394
                                    dquant= 0;
4395
                                    dir= -dir;
4396
                                }else
4397
                                    break;
4398
                            }
4399
                        }
4400
                        qp= best_s.qscale;
4401
                        s->current_picture.qscale_table[xy]= qp;
4402
                    }
4403
                }
4404

    
4405
                copy_context_after_encode(s, &best_s, -1);
4406
                
4407
                pb_bits_count= get_bit_count(&s->pb);
4408
                flush_put_bits(&s->pb);
4409
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
4410
                s->pb= backup_s.pb;
4411
                
4412
                if(s->data_partitioning){
4413
                    pb2_bits_count= get_bit_count(&s->pb2);
4414
                    flush_put_bits(&s->pb2);
4415
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
4416
                    s->pb2= backup_s.pb2;
4417
                    
4418
                    tex_pb_bits_count= get_bit_count(&s->tex_pb);
4419
                    flush_put_bits(&s->tex_pb);
4420
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
4421
                    s->tex_pb= backup_s.tex_pb;
4422
                }
4423
                s->last_bits= get_bit_count(&s->pb);
4424
               
4425
#ifdef CONFIG_RISKY
4426
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4427
                    ff_h263_update_motion_val(s);
4428
#endif
4429
        
4430
                if(next_block==0){
4431
                    s->dsp.put_pixels_tab[0][0](s->dest[0], s->me.scratchpad     , s->linesize  ,16);
4432
                    s->dsp.put_pixels_tab[1][0](s->dest[1], s->me.scratchpad + 16, s->uvlinesize, 8);
4433
                    s->dsp.put_pixels_tab[1][0](s->dest[2], s->me.scratchpad + 24, s->uvlinesize, 8);
4434
                }
4435

    
4436
                if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
4437
                    MPV_decode_mb(s, s->block);
4438
            } else {
4439
                int motion_x, motion_y;
4440
                s->mv_type=MV_TYPE_16X16;
4441
                // only one MB-Type possible
4442
                
4443
                switch(mb_type){
4444
                case CANDIDATE_MB_TYPE_INTRA:
4445
                    s->mv_dir = 0;
4446
                    s->mb_intra= 1;
4447
                    motion_x= s->mv[0][0][0] = 0;
4448
                    motion_y= s->mv[0][0][1] = 0;
4449
                    break;
4450
                case CANDIDATE_MB_TYPE_INTER:
4451
                    s->mv_dir = MV_DIR_FORWARD;
4452
                    s->mb_intra= 0;
4453
                    motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
4454
                    motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
4455
                    break;
4456
                case CANDIDATE_MB_TYPE_INTER_I:
4457
                    s->mv_dir = MV_DIR_FORWARD;
4458
                    s->mv_type = MV_TYPE_FIELD;
4459
                    s->mb_intra= 0;
4460
                    for(i=0; i<2; i++){
4461
                        j= s->field_select[0][i] = s->p_field_select_table[i][xy];
4462
                        s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
4463
                        s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
4464
                    }
4465
                    motion_x = motion_y = 0;
4466
                    break;
4467
                case CANDIDATE_MB_TYPE_INTER4V:
4468
                    s->mv_dir = MV_DIR_FORWARD;
4469
                    s->mv_type = MV_TYPE_8X8;
4470
                    s->mb_intra= 0;
4471
                    for(i=0; i<4; i++){
4472
                        s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
4473
                        s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
4474
                    }
4475
                    motion_x= motion_y= 0;
4476
                    break;
4477
                case CANDIDATE_MB_TYPE_DIRECT:
4478
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4479
                    s->mb_intra= 0;
4480
                    motion_x=s->b_direct_mv_table[xy][0];
4481
                    motion_y=s->b_direct_mv_table[xy][1];
4482
#ifdef CONFIG_RISKY
4483
                    ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
4484
#endif
4485
                    break;
4486
                case CANDIDATE_MB_TYPE_BIDIR:
4487
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4488
                    s->mb_intra= 0;
4489
                    motion_x=0;
4490
                    motion_y=0;
4491
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
4492
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
4493
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
4494
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
4495
                    break;
4496
                case CANDIDATE_MB_TYPE_BACKWARD:
4497
                    s->mv_dir = MV_DIR_BACKWARD;
4498
                    s->mb_intra= 0;
4499
                    motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
4500
                    motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
4501
                    break;
4502
                case CANDIDATE_MB_TYPE_FORWARD:
4503
                    s->mv_dir = MV_DIR_FORWARD;
4504
                    s->mb_intra= 0;
4505
                    motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
4506
                    motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
4507
//                    printf(" %d %d ", motion_x, motion_y);
4508
                    break;
4509
                case CANDIDATE_MB_TYPE_FORWARD_I:
4510
                    s->mv_dir = MV_DIR_FORWARD;
4511
                    s->mv_type = MV_TYPE_FIELD;
4512
                    s->mb_intra= 0;
4513
                    for(i=0; i<2; i++){
4514
                        j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
4515
                        s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
4516
                        s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
4517
                    }
4518
                    motion_x=motion_y=0;
4519
                    break;
4520
                case CANDIDATE_MB_TYPE_BACKWARD_I:
4521
                    s->mv_dir = MV_DIR_BACKWARD;
4522
                    s->mv_type = MV_TYPE_FIELD;
4523
                    s->mb_intra= 0;
4524
                    for(i=0; i<2; i++){
4525
                        j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
4526
                        s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
4527
                        s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
4528
                    }
4529
                    motion_x=motion_y=0;
4530
                    break;
4531
                case CANDIDATE_MB_TYPE_BIDIR_I:
4532
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4533
                    s->mv_type = MV_TYPE_FIELD;
4534
                    s->mb_intra= 0;
4535
                    for(dir=0; dir<2; dir++){
4536
                        for(i=0; i<2; i++){
4537
                            j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
4538
                            s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
4539
                            s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
4540
                        }
4541
                    }
4542
                    motion_x=motion_y=0;
4543
                    break;
4544
                default:
4545
                    motion_x=motion_y=0; //gcc warning fix
4546
                    av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
4547
                }
4548

    
4549
                encode_mb(s, motion_x, motion_y);
4550

    
4551
                // RAL: Update last macrobloc type
4552
                s->last_mv_dir = s->mv_dir;
4553
            
4554
#ifdef CONFIG_RISKY
4555
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4556
                    ff_h263_update_motion_val(s);
4557
#endif
4558
                
4559
                MPV_decode_mb(s, s->block);
4560
            }
4561

    
4562
            /* clean the MV table in IPS frames for direct mode in B frames */
4563
            if(s->mb_intra /* && I,P,S_TYPE */){
4564
                s->p_mv_table[xy][0]=0;
4565
                s->p_mv_table[xy][1]=0;
4566
            }
4567
            
4568
            if(s->flags&CODEC_FLAG_PSNR){
4569
                int w= 16;
4570
                int h= 16;
4571

    
4572
                if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4573
                if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4574

    
4575
                s->current_picture_ptr->error[0] += sse(
4576
                    s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
4577
                    s->dest[0], w, h, s->linesize);
4578
                s->current_picture_ptr->error[1] += sse(
4579
                    s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
4580
                    s->dest[1], w>>1, h>>1, s->uvlinesize);
4581
                s->current_picture_ptr->error[2] += sse(
4582
                    s, s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
4583
                    s->dest[2], w>>1, h>>1, s->uvlinesize);
4584
            }
4585
            if(s->loop_filter)
4586
                ff_h263_loop_filter(s);
4587
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, get_bit_count(&s->pb));
4588
        }
4589
    }
4590
    emms_c();
4591

    
4592
#ifdef CONFIG_RISKY
4593
    if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
4594
        ff_mpeg4_merge_partitions(s);
4595

    
4596
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
4597
        msmpeg4_encode_ext_header(s);
4598

    
4599
    if(s->codec_id==CODEC_ID_MPEG4) 
4600
        ff_mpeg4_stuffing(&s->pb);
4601
#endif
4602

    
4603
    /* Send the last GOB if RTP */    
4604
    if (s->avctx->rtp_callback) {
4605
        flush_put_bits(&s->pb);
4606
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
4607
        /* Call the RTP callback to send the last GOB */
4608
        s->avctx->rtp_callback(s->ptr_lastgob, pdif, 0);
4609
    }
4610
}
4611

    
4612
#endif //CONFIG_ENCODERS
4613

    
4614
void ff_denoise_dct(MpegEncContext *s, DCTELEM *block){
4615
    const int intra= s->mb_intra;
4616
    int i;
4617

    
4618
    s->dct_count[intra]++;
4619

    
4620
    for(i=0; i<64; i++){
4621
        int level= block[i];
4622

    
4623
        if(level){
4624
            if(level>0){
4625
                s->dct_error_sum[intra][i] += level;
4626
                level -= s->dct_offset[intra][i];
4627
                if(level<0) level=0;
4628
            }else{
4629
                s->dct_error_sum[intra][i] -= level;
4630
                level += s->dct_offset[intra][i];
4631
                if(level>0) level=0;
4632
            }
4633
            block[i]= level;
4634
        }
4635
    }
4636
}
4637

    
4638
#ifdef CONFIG_ENCODERS
4639

    
4640
static int dct_quantize_trellis_c(MpegEncContext *s, 
4641
                        DCTELEM *block, int n,
4642
                        int qscale, int *overflow){
4643
    const int *qmat;
4644
    const uint8_t *scantable= s->intra_scantable.scantable;
4645
    const uint8_t *perm_scantable= s->intra_scantable.permutated;
4646
    int max=0;
4647
    unsigned int threshold1, threshold2;
4648
    int bias=0;
4649
    int run_tab[65];
4650
    int level_tab[65];
4651
    int score_tab[65];
4652
    int survivor[65];
4653
    int survivor_count;
4654
    int last_run=0;
4655
    int last_level=0;
4656
    int last_score= 0;
4657
    int last_i;
4658
    int coeff[2][64];