Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ a1e07d39

History | View | Annotate | Download (215 KB)

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

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

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

    
41
#ifdef CONFIG_ENCODERS
42
static void encode_picture(MpegEncContext *s, int picture_number);
43
#endif //CONFIG_ENCODERS
44
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s, 
45
                                   DCTELEM *block, int n, int qscale);
46
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, 
47
                                   DCTELEM *block, int n, int qscale);
48
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
49
                                   DCTELEM *block, int n, int qscale);
50
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
51
                                   DCTELEM *block, int n, int qscale);
52
static void dct_unquantize_h263_intra_c(MpegEncContext *s, 
53
                                  DCTELEM *block, int n, int qscale);
54
static void dct_unquantize_h263_inter_c(MpegEncContext *s, 
55
                                  DCTELEM *block, int n, int qscale);
56
static void dct_unquantize_h261_intra_c(MpegEncContext *s, 
57
                                  DCTELEM *block, int n, int qscale);
58
static void dct_unquantize_h261_inter_c(MpegEncContext *s, 
59
                                  DCTELEM *block, int n, int qscale);
60
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
61
#ifdef CONFIG_ENCODERS
62
static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
63
static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
64
static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
65
static int sse_mb(MpegEncContext *s);
66
static void  denoise_dct_c(MpegEncContext *s, DCTELEM *block);
67
#endif //CONFIG_ENCODERS
68

    
69
#ifdef HAVE_XVMC
70
extern int  XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
71
extern void XVMC_field_end(MpegEncContext *s);
72
extern void XVMC_decode_mb(MpegEncContext *s);
73
#endif
74

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

    
77

    
78
/* enable all paranoid tests for rounding, overflows, etc... */
79
//#define PARANOID
80

    
81
//#define DEBUG
82

    
83

    
84
/* for jpeg fast DCT */
85
#define CONST_BITS 14
86

    
87
static const uint16_t aanscales[64] = {
88
    /* precomputed values scaled up by 14 bits */
89
    16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
90
    22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
91
    21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
92
    19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
93
    16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
94
    12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
95
    8867 , 12299, 11585, 10426,  8867,  6967,  4799,  2446,
96
    4520 ,  6270,  5906,  5315,  4520,  3552,  2446,  1247
97
};
98

    
99
static const uint8_t h263_chroma_roundtab[16] = {
100
//  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
101
    0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
102
};
103

    
104
static const uint8_t ff_default_chroma_qscale_table[32]={
105
//  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
106
    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
107
};
108

    
109
#ifdef CONFIG_ENCODERS
110
static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
111
static uint8_t default_fcode_tab[MAX_MV*2+1];
112

    
113
enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
114

    
115
static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
116
                           const uint16_t *quant_matrix, int bias, int qmin, int qmax)
117
{
118
    int qscale;
119

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

    
164
                if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
165
                qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
166
            }
167
        }
168
    }
169
}
170

    
171
static inline void update_qscale(MpegEncContext *s){
172
    s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
173
    s->qscale= clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
174
    
175
    s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
176
}
177
#endif //CONFIG_ENCODERS
178

    
179
void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
180
    int i;
181
    int end;
182
    
183
    st->scantable= src_scantable;
184

    
185
    for(i=0; i<64; i++){
186
        int j;
187
        j = src_scantable[i];
188
        st->permutated[i] = permutation[j];
189
#ifdef ARCH_POWERPC
190
        st->inverse[j] = i;
191
#endif
192
    }
193
    
194
    end=-1;
195
    for(i=0; i<64; i++){
196
        int j;
197
        j = st->permutated[i];
198
        if(j>end) end=j;
199
        st->raster_end[i]= end;
200
    }
201
}
202

    
203
#ifdef CONFIG_ENCODERS
204
void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
205
    int i;
206

    
207
    if(matrix){
208
        put_bits(pb, 1, 1);
209
        for(i=0;i<64;i++) {
210
            put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
211
        }
212
    }else
213
        put_bits(pb, 1, 0);
214
}
215
#endif //CONFIG_ENCODERS
216

    
217
/* init common dct for both encoder and decoder */
218
int DCT_common_init(MpegEncContext *s)
219
{
220
    s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
221
    s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
222
    s->dct_unquantize_h261_intra = dct_unquantize_h261_intra_c;
223
    s->dct_unquantize_h261_inter = dct_unquantize_h261_inter_c;
224
    s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
225
    s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
226
    s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
227
    s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
228

    
229
#ifdef CONFIG_ENCODERS
230
    s->dct_quantize= dct_quantize_c;
231
    s->denoise_dct= denoise_dct_c;
232
#endif
233
        
234
#ifdef HAVE_MMX
235
    MPV_common_init_mmx(s);
236
#endif
237
#ifdef ARCH_ALPHA
238
    MPV_common_init_axp(s);
239
#endif
240
#ifdef HAVE_MLIB
241
    MPV_common_init_mlib(s);
242
#endif
243
#ifdef HAVE_MMI
244
    MPV_common_init_mmi(s);
245
#endif
246
#ifdef ARCH_ARMV4L
247
    MPV_common_init_armv4l(s);
248
#endif
249
#ifdef ARCH_POWERPC
250
    MPV_common_init_ppc(s);
251
#endif
252

    
253
#ifdef CONFIG_ENCODERS
254
    s->fast_dct_quantize= s->dct_quantize;
255

    
256
    if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
257
        s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
258
    }
259

    
260
#endif //CONFIG_ENCODERS
261

    
262
    /* load & permutate scantables
263
       note: only wmv uses differnt ones 
264
    */
265
    if(s->alternate_scan){
266
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
267
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
268
    }else{
269
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
270
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
271
    }
272
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
273
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
274

    
275
    return 0;
276
}
277

    
278
static void copy_picture(Picture *dst, Picture *src){
279
    *dst = *src;
280
    dst->type= FF_BUFFER_TYPE_COPY;
281
}
282

    
283
static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
284
    int i;
285

    
286
    dst->pict_type              = src->pict_type;
287
    dst->quality                = src->quality;
288
    dst->coded_picture_number   = src->coded_picture_number;
289
    dst->display_picture_number = src->display_picture_number;
290
//    dst->reference              = src->reference;
291
    dst->pts                    = src->pts;
292
    dst->interlaced_frame       = src->interlaced_frame;
293
    dst->top_field_first        = src->top_field_first;
294

    
295
    if(s->avctx->me_threshold){
296
        if(!src->motion_val[0])
297
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
298
        if(!src->mb_type)
299
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
300
        if(!src->ref_index[0])
301
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
302
        if(src->motion_subsample_log2 != dst->motion_subsample_log2)
303
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesnt match! (%d!=%d)\n",
304
            src->motion_subsample_log2, dst->motion_subsample_log2);
305

    
306
        memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
307
        
308
        for(i=0; i<2; i++){
309
            int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
310
            int height= ((16*s->mb_height)>>src->motion_subsample_log2);
311

    
312
            if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
313
                memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
314
            }
315
            if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
316
                memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
317
            }
318
        }
319
    }
320
}
321

    
322
/**
323
 * allocates a Picture
324
 * The pixels are allocated/set by calling get_buffer() if shared=0
325
 */
326
static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
327
    const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
328
    const int mb_array_size= s->mb_stride*s->mb_height;
329
    const int b8_array_size= s->b8_stride*s->mb_height*2;
330
    const int b4_array_size= s->b4_stride*s->mb_height*4;
331
    int i;
332
    
333
    if(shared){
334
        assert(pic->data[0]);
335
        assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
336
        pic->type= FF_BUFFER_TYPE_SHARED;
337
    }else{
338
        int r;
339
        
340
        assert(!pic->data[0]);
341
        
342
        r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
343
        
344
        if(r<0 || !pic->age || !pic->type || !pic->data[0]){
345
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
346
            return -1;
347
        }
348

    
349
        if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
350
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
351
            return -1;
352
        }
353

    
354
        if(pic->linesize[1] != pic->linesize[2]){
355
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride missmatch)\n");
356
            return -1;
357
        }
358

    
359
        s->linesize  = pic->linesize[0];
360
        s->uvlinesize= pic->linesize[1];
361
    }
362
    
363
    if(pic->qscale_table==NULL){
364
        if (s->encoding) {        
365
            CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
366
            CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
367
            CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
368
        }
369

    
370
        CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
371
        CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
372
        CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num    * sizeof(uint32_t))
373
        pic->mb_type= pic->mb_type_base + s->mb_stride+1;
374
        if(s->out_format == FMT_H264){
375
            for(i=0; i<2; i++){
376
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+2)  * sizeof(int16_t))
377
                pic->motion_val[i]= pic->motion_val_base[i]+2;
378
                CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
379
            }
380
            pic->motion_subsample_log2= 2;
381
        }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
382
            for(i=0; i<2; i++){
383
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+2) * sizeof(int16_t))
384
                pic->motion_val[i]= pic->motion_val_base[i]+2;
385
                CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
386
            }
387
            pic->motion_subsample_log2= 3;
388
        }
389
        if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
390
            CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
391
        }
392
        pic->qstride= s->mb_stride;
393
        CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
394
    }
395

    
396
    //it might be nicer if the application would keep track of these but it would require a API change
397
    memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
398
    s->prev_pict_types[0]= s->pict_type;
399
    if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
400
        pic->age= INT_MAX; // skiped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
401
    
402
    return 0;
403
fail: //for the CHECKED_ALLOCZ macro
404
    return -1;
405
}
406

    
407
/**
408
 * deallocates a picture
409
 */
410
static void free_picture(MpegEncContext *s, Picture *pic){
411
    int i;
412

    
413
    if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
414
        s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
415
    }
416

    
417
    av_freep(&pic->mb_var);
418
    av_freep(&pic->mc_mb_var);
419
    av_freep(&pic->mb_mean);
420
    av_freep(&pic->mbskip_table);
421
    av_freep(&pic->qscale_table);
422
    av_freep(&pic->mb_type_base);
423
    av_freep(&pic->dct_coeff);
424
    av_freep(&pic->pan_scan);
425
    pic->mb_type= NULL;
426
    for(i=0; i<2; i++){
427
        av_freep(&pic->motion_val_base[i]);
428
        av_freep(&pic->ref_index[i]);
429
    }
430
    
431
    if(pic->type == FF_BUFFER_TYPE_SHARED){
432
        for(i=0; i<4; i++){
433
            pic->base[i]=
434
            pic->data[i]= NULL;
435
        }
436
        pic->type= 0;        
437
    }
438
}
439

    
440
static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
441
    int i;
442

    
443
    // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264) 
444
    CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
445
    s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
446

    
447
     //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
448
    CHECKED_ALLOCZ(s->me.scratchpad,  (s->width+64)*2*16*2*sizeof(uint8_t)) 
449
    s->rd_scratchpad=   s->me.scratchpad;
450
    s->b_scratchpad=    s->me.scratchpad;
451
    s->obmc_scratchpad= s->me.scratchpad + 16;
452
    if (s->encoding) {
453
        CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
454
        CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
455
        if(s->avctx->noise_reduction){
456
            CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
457
        }
458
    }   
459
    CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
460
    s->block= s->blocks[0];
461

    
462
    for(i=0;i<12;i++){
463
        s->pblocks[i] = (short *)(&s->block[i]);
464
    }
465
    return 0;
466
fail:
467
    return -1; //free() through MPV_common_end()
468
}
469

    
470
static void free_duplicate_context(MpegEncContext *s){
471
    if(s==NULL) return;
472

    
473
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
474
    av_freep(&s->me.scratchpad);
475
    s->rd_scratchpad=   
476
    s->b_scratchpad=    
477
    s->obmc_scratchpad= NULL;
478
    
479
    av_freep(&s->dct_error_sum);
480
    av_freep(&s->me.map);
481
    av_freep(&s->me.score_map);
482
    av_freep(&s->blocks);
483
    s->block= NULL;
484
}
485

    
486
static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
487
#define COPY(a) bak->a= src->a
488
    COPY(allocated_edge_emu_buffer);
489
    COPY(edge_emu_buffer);
490
    COPY(me.scratchpad);
491
    COPY(rd_scratchpad);
492
    COPY(b_scratchpad);
493
    COPY(obmc_scratchpad);
494
    COPY(me.map);
495
    COPY(me.score_map);
496
    COPY(blocks);
497
    COPY(block);
498
    COPY(start_mb_y);
499
    COPY(end_mb_y);
500
    COPY(me.map_generation);
501
    COPY(pb);
502
    COPY(dct_error_sum);
503
    COPY(dct_count[0]);
504
    COPY(dct_count[1]);
505
#undef COPY
506
}
507

    
508
void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
509
    MpegEncContext bak;
510
    int i;
511
    //FIXME copy only needed parts
512
//START_TIMER
513
    backup_duplicate_context(&bak, dst);
514
    memcpy(dst, src, sizeof(MpegEncContext));
515
    backup_duplicate_context(dst, &bak);
516
    for(i=0;i<12;i++){
517
        dst->pblocks[i] = (short *)(&dst->block[i]);
518
    }
519
//STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
520
}
521

    
522
static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
523
#define COPY(a) dst->a= src->a
524
    COPY(pict_type);
525
    COPY(current_picture);
526
    COPY(f_code);
527
    COPY(b_code);
528
    COPY(qscale);
529
    COPY(lambda);
530
    COPY(lambda2);
531
    COPY(picture_in_gop_number);
532
    COPY(gop_picture_number);
533
    COPY(frame_pred_frame_dct); //FIXME dont set in encode_header
534
    COPY(progressive_frame); //FIXME dont set in encode_header
535
    COPY(partitioned_frame); //FIXME dont set in encode_header
536
#undef COPY
537
}
538

    
539
/**
540
 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
541
 * the changed fields will not depend upon the prior state of the MpegEncContext.
542
 */
543
static void MPV_common_defaults(MpegEncContext *s){
544
    s->y_dc_scale_table=
545
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
546
    s->chroma_qscale_table= ff_default_chroma_qscale_table;
547
    s->progressive_frame= 1;
548
    s->progressive_sequence= 1;
549
    s->picture_structure= PICT_FRAME;
550

    
551
    s->coded_picture_number = 0;
552
    s->picture_number = 0;
553
    s->input_picture_number = 0;
554

    
555
    s->picture_in_gop_number = 0;
556

    
557
    s->f_code = 1;
558
    s->b_code = 1;
559
}
560

    
561
/**
562
 * sets the given MpegEncContext to defaults for decoding.
563
 * the changed fields will not depend upon the prior state of the MpegEncContext.
564
 */
565
void MPV_decode_defaults(MpegEncContext *s){
566
    MPV_common_defaults(s);
567
}
568

    
569
/**
570
 * sets the given MpegEncContext to defaults for encoding.
571
 * the changed fields will not depend upon the prior state of the MpegEncContext.
572
 */
573

    
574
#ifdef CONFIG_ENCODERS
575
static void MPV_encode_defaults(MpegEncContext *s){
576
    static int done=0;
577
    
578
    MPV_common_defaults(s);
579
    
580
    if(!done){
581
        int i;
582
        done=1;
583

    
584
        default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
585
        memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
586
        memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
587

    
588
        for(i=-16; i<16; i++){
589
            default_fcode_tab[i + MAX_MV]= 1;
590
        }
591
    }
592
    s->me.mv_penalty= default_mv_penalty;
593
    s->fcode_tab= default_fcode_tab;
594
}
595
#endif //CONFIG_ENCODERS
596

    
597
/** 
598
 * init common structure for both encoder and decoder.
599
 * this assumes that some variables like width/height are already set
600
 */
601
int MPV_common_init(MpegEncContext *s)
602
{
603
    int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
604

    
605
    if(s->avctx->thread_count > MAX_THREADS || (16*s->avctx->thread_count > s->height && s->height)){
606
        av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
607
        return -1;
608
    }
609

    
610
    dsputil_init(&s->dsp, s->avctx);
611
    DCT_common_init(s);
612

    
613
    s->flags= s->avctx->flags;
614
    s->flags2= s->avctx->flags2;
615

    
616
    s->mb_width  = (s->width  + 15) / 16;
617
    s->mb_height = (s->height + 15) / 16;
618
    s->mb_stride = s->mb_width + 1;
619
    s->b8_stride = s->mb_width*2 + 1;
620
    s->b4_stride = s->mb_width*4 + 1;
621
    mb_array_size= s->mb_height * s->mb_stride;
622
    mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
623

    
624
    /* set default edge pos, will be overriden in decode_header if needed */
625
    s->h_edge_pos= s->mb_width*16;
626
    s->v_edge_pos= s->mb_height*16;
627

    
628
    s->mb_num = s->mb_width * s->mb_height;
629
    
630
    s->block_wrap[0]=
631
    s->block_wrap[1]=
632
    s->block_wrap[2]=
633
    s->block_wrap[3]= s->b8_stride;
634
    s->block_wrap[4]=
635
    s->block_wrap[5]= s->mb_stride;
636
 
637
    y_size = s->b8_stride * (2 * s->mb_height + 1);
638
    c_size = s->mb_stride * (s->mb_height + 1);
639
    yc_size = y_size + 2 * c_size;
640
    
641
    /* convert fourcc to upper case */
642
    s->avctx->codec_tag=   toupper( s->avctx->codec_tag     &0xFF)          
643
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
644
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16) 
645
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
646

    
647
    s->avctx->stream_codec_tag=   toupper( s->avctx->stream_codec_tag     &0xFF)          
648
                               + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
649
                               + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16) 
650
                               + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
651

    
652
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
653

    
654
    CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
655
    for(y=0; y<s->mb_height; y++){
656
        for(x=0; x<s->mb_width; x++){
657
            s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
658
        }
659
    }
660
    s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
661
    
662
    if (s->encoding) {
663
        /* Allocate MV tables */
664
        CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
665
        CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
666
        CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
667
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
668
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
669
        CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
670
        s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
671
        s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
672
        s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
673
        s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
674
        s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
675
        s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
676

    
677
        if(s->msmpeg4_version){
678
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
679
        }
680
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
681

    
682
        /* Allocate MB type table */
683
        CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint16_t)) //needed for encoding
684
        
685
        CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
686
        
687
        CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
688
        CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
689
        CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
690
        CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
691
        CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
692
        CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
693
        
694
        if(s->avctx->noise_reduction){
695
            CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
696
        }
697
    }
698
    CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
699

    
700
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
701
    
702
    if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
703
        /* interlaced direct mode decoding tables */
704
            for(i=0; i<2; i++){
705
                int j, k;
706
                for(j=0; j<2; j++){
707
                    for(k=0; k<2; k++){
708
                        CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k]     , mv_table_size * 2 * sizeof(int16_t))
709
                        s->b_field_mv_table[i][j][k]    = s->b_field_mv_table_base[i][j][k]     + s->mb_stride + 1;
710
                    }
711
                    CHECKED_ALLOCZ(s->b_field_select_table[i][j]     , mb_array_size * 2 * sizeof(uint8_t))
712
                    CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j]     , mv_table_size * 2 * sizeof(int16_t))
713
                    s->p_field_mv_table[i][j]    = s->p_field_mv_table_base[i][j]     + s->mb_stride + 1;
714
                }
715
                CHECKED_ALLOCZ(s->p_field_select_table[i]      , mb_array_size * 2 * sizeof(uint8_t))
716
            }
717
    }
718
    if (s->out_format == FMT_H263) {
719
        /* ac values */
720
        CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
721
        s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
722
        s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
723
        s->ac_val[2] = s->ac_val[1] + c_size;
724
        
725
        /* cbp values */
726
        CHECKED_ALLOCZ(s->coded_block_base, y_size);
727
        s->coded_block= s->coded_block_base + s->b8_stride + 1;
728
        
729
        /* divx501 bitstream reorder buffer */
730
        CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
731

    
732
        /* cbp, ac_pred, pred_dir */
733
        CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
734
        CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
735
    }
736
    
737
    if (s->h263_pred || s->h263_plus || !s->encoding) {
738
        /* dc values */
739
        //MN: we need these for error resilience of intra-frames
740
        CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
741
        s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
742
        s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
743
        s->dc_val[2] = s->dc_val[1] + c_size;
744
        for(i=0;i<yc_size;i++)
745
            s->dc_val_base[i] = 1024;
746
    }
747

    
748
    /* which mb is a intra block */
749
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
750
    memset(s->mbintra_table, 1, mb_array_size);
751
    
752
    /* init macroblock skip table */
753
    CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
754
    //Note the +1 is for a quicker mpeg4 slice_end detection
755
    CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
756
    
757
    s->parse_context.state= -1;
758
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
759
       s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
760
       s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
761
       s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
762
    }
763

    
764
    s->context_initialized = 1;
765

    
766
    s->thread_context[0]= s;
767
    for(i=1; i<s->avctx->thread_count; i++){
768
        s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
769
        memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
770
    }
771

    
772
    for(i=0; i<s->avctx->thread_count; i++){
773
        if(init_duplicate_context(s->thread_context[i], s) < 0)
774
           goto fail;
775
        s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
776
        s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
777
    }
778

    
779
    return 0;
780
 fail:
781
    MPV_common_end(s);
782
    return -1;
783
}
784

    
785
/* init common structure for both encoder and decoder */
786
void MPV_common_end(MpegEncContext *s)
787
{
788
    int i, j, k;
789

    
790
    for(i=0; i<s->avctx->thread_count; i++){
791
        free_duplicate_context(s->thread_context[i]);
792
    }
793
    for(i=1; i<s->avctx->thread_count; i++){
794
        av_freep(&s->thread_context[i]);
795
    }
796

    
797
    av_freep(&s->parse_context.buffer);
798
    s->parse_context.buffer_size=0;
799

    
800
    av_freep(&s->mb_type);
801
    av_freep(&s->p_mv_table_base);
802
    av_freep(&s->b_forw_mv_table_base);
803
    av_freep(&s->b_back_mv_table_base);
804
    av_freep(&s->b_bidir_forw_mv_table_base);
805
    av_freep(&s->b_bidir_back_mv_table_base);
806
    av_freep(&s->b_direct_mv_table_base);
807
    s->p_mv_table= NULL;
808
    s->b_forw_mv_table= NULL;
809
    s->b_back_mv_table= NULL;
810
    s->b_bidir_forw_mv_table= NULL;
811
    s->b_bidir_back_mv_table= NULL;
812
    s->b_direct_mv_table= NULL;
813
    for(i=0; i<2; i++){
814
        for(j=0; j<2; j++){
815
            for(k=0; k<2; k++){
816
                av_freep(&s->b_field_mv_table_base[i][j][k]);
817
                s->b_field_mv_table[i][j][k]=NULL;
818
            }
819
            av_freep(&s->b_field_select_table[i][j]);
820
            av_freep(&s->p_field_mv_table_base[i][j]);
821
            s->p_field_mv_table[i][j]=NULL;
822
        }
823
        av_freep(&s->p_field_select_table[i]);
824
    }
825
    
826
    av_freep(&s->dc_val_base);
827
    av_freep(&s->ac_val_base);
828
    av_freep(&s->coded_block_base);
829
    av_freep(&s->mbintra_table);
830
    av_freep(&s->cbp_table);
831
    av_freep(&s->pred_dir_table);
832
    
833
    av_freep(&s->mbskip_table);
834
    av_freep(&s->prev_pict_types);
835
    av_freep(&s->bitstream_buffer);
836
    av_freep(&s->avctx->stats_out);
837
    av_freep(&s->ac_stats);
838
    av_freep(&s->error_status_table);
839
    av_freep(&s->mb_index2xy);
840
    av_freep(&s->lambda_table);
841
    av_freep(&s->q_intra_matrix);
842
    av_freep(&s->q_inter_matrix);
843
    av_freep(&s->q_intra_matrix16);
844
    av_freep(&s->q_inter_matrix16);
845
    av_freep(&s->input_picture);
846
    av_freep(&s->reordered_input_picture);
847
    av_freep(&s->dct_offset);
848

    
849
    if(s->picture){
850
        for(i=0; i<MAX_PICTURE_COUNT; i++){
851
            free_picture(s, &s->picture[i]);
852
        }
853
    }
854
    av_freep(&s->picture);
855
    s->context_initialized = 0;
856
    s->last_picture_ptr=
857
    s->next_picture_ptr=
858
    s->current_picture_ptr= NULL;
859

    
860
    for(i=0; i<3; i++)
861
        av_freep(&s->visualization_buffer[i]);
862
}
863

    
864
#ifdef CONFIG_ENCODERS
865

    
866
/* init video encoder */
867
int MPV_encode_init(AVCodecContext *avctx)
868
{
869
    MpegEncContext *s = avctx->priv_data;
870
    int i, dummy;
871
    int chroma_h_shift, chroma_v_shift;
872
    
873
    MPV_encode_defaults(s);
874

    
875
    avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME
876

    
877
    s->bit_rate = avctx->bit_rate;
878
    s->width = avctx->width;
879
    s->height = avctx->height;
880
    if(avctx->gop_size > 600){
881
        av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
882
        avctx->gop_size=600;
883
    }
884
    s->gop_size = avctx->gop_size;
885
    s->avctx = avctx;
886
    s->flags= avctx->flags;
887
    s->flags2= avctx->flags2;
888
    s->max_b_frames= avctx->max_b_frames;
889
    s->codec_id= avctx->codec->id;
890
    s->luma_elim_threshold  = avctx->luma_elim_threshold;
891
    s->chroma_elim_threshold= avctx->chroma_elim_threshold;
892
    s->strict_std_compliance= avctx->strict_std_compliance;
893
    s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
894
    s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
895
    s->mpeg_quant= avctx->mpeg_quant;
896
    s->rtp_mode= !!avctx->rtp_payload_size;
897
    s->intra_dc_precision= avctx->intra_dc_precision;
898

    
899
    if (s->gop_size <= 1) {
900
        s->intra_only = 1;
901
        s->gop_size = 12;
902
    } else {
903
        s->intra_only = 0;
904
    }
905

    
906
    s->me_method = avctx->me_method;
907

    
908
    /* Fixed QSCALE */
909
    s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
910
    
911
    s->adaptive_quant= (   s->avctx->lumi_masking
912
                        || s->avctx->dark_masking
913
                        || s->avctx->temporal_cplx_masking 
914
                        || s->avctx->spatial_cplx_masking
915
                        || s->avctx->p_masking
916
                        || (s->flags&CODEC_FLAG_QP_RD))
917
                       && !s->fixed_qscale;
918
    
919
    s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
920
    s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
921
    s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
922

    
923
    if(avctx->rc_max_rate && !avctx->rc_buffer_size){
924
        av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
925
        return -1;
926
    }    
927

    
928
    if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
929
        av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isnt recommanded!\n");
930
    }
931
    
932
    if(   s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate 
933
       && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
934
       && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
935
        
936
        av_log(avctx, AV_LOG_INFO, "Warning vbv_delay will be set to 0xFFFF (=VBR) as the specified vbv buffer is too large for the given bitrate!\n");
937
    }
938
       
939
    if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 
940
       && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
941
        av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
942
        return -1;
943
    }
944
        
945
    if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
946
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decission\n");
947
        return -1;
948
    }
949
    
950
    if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
951
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
952
        return -1;
953
    }
954
    
955
    if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
956
        av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
957
        return -1;
958
    }
959

    
960
    if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
961
        av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
962
        return -1;
963
    }
964
    
965
    if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
966
        av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
967
        return -1;
968
    }
969

    
970
    if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN)) 
971
       && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
972
        av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
973
        return -1;
974
    }
975
        
976
    if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
977
        av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n");
978
        return -1;
979
    }
980
        
981
    if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
982
        av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
983
        return -1;
984
    }
985

    
986
    if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
987
        av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
988
        return -1;
989
    }
990
    
991
    if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
992
        av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
993
        return -1;
994
    }
995
    
996
    if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4 
997
       && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO 
998
       && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
999
        av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1000
        return -1;
1001
    }
1002
    
1003
    if(s->avctx->thread_count > 1)
1004
        s->rtp_mode= 1;
1005

    
1006
    i= ff_gcd(avctx->frame_rate, avctx->frame_rate_base);
1007
    if(i > 1){
1008
        av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1009
        avctx->frame_rate /= i;
1010
        avctx->frame_rate_base /= i;
1011
//        return -1;
1012
    }
1013
    
1014
    if(s->codec_id==CODEC_ID_MJPEG){
1015
        s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1016
        s->inter_quant_bias= 0;
1017
    }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1018
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1019
        s->inter_quant_bias= 0;
1020
    }else{
1021
        s->intra_quant_bias=0;
1022
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1023
    }
1024
    
1025
    if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1026
        s->intra_quant_bias= avctx->intra_quant_bias;
1027
    if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1028
        s->inter_quant_bias= avctx->inter_quant_bias;
1029
        
1030
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1031

    
1032
    av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1033
    s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1034

    
1035
    switch(avctx->codec->id) {
1036
    case CODEC_ID_MPEG1VIDEO:
1037
        s->out_format = FMT_MPEG1;
1038
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1039
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1040
        break;
1041
    case CODEC_ID_MPEG2VIDEO:
1042
        s->out_format = FMT_MPEG1;
1043
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1044
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1045
        s->rtp_mode= 1;
1046
        break;
1047
    case CODEC_ID_LJPEG:
1048
    case CODEC_ID_MJPEG:
1049
        s->out_format = FMT_MJPEG;
1050
        s->intra_only = 1; /* force intra only for jpeg */
1051
        s->mjpeg_write_tables = 1; /* write all tables */
1052
        s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1053
        s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1054
        s->mjpeg_vsample[1] = 1;
1055
        s->mjpeg_vsample[2] = 1; 
1056
        s->mjpeg_hsample[0] = 1<<chroma_h_shift;
1057
        s->mjpeg_hsample[1] = 1; 
1058
        s->mjpeg_hsample[2] = 1; 
1059
        if (mjpeg_init(s) < 0)
1060
            return -1;
1061
        avctx->delay=0;
1062
        s->low_delay=1;
1063
        break;
1064
#ifdef CONFIG_RISKY
1065
    case CODEC_ID_H263:
1066
        if (h263_get_picture_format(s->width, s->height) == 7) {
1067
            av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
1068
            return -1;
1069
        }
1070
        s->out_format = FMT_H263;
1071
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1072
        avctx->delay=0;
1073
        s->low_delay=1;
1074
        break;
1075
    case CODEC_ID_H263P:
1076
        s->out_format = FMT_H263;
1077
        s->h263_plus = 1;
1078
        /* Fx */
1079
        s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1080
        s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1081
        s->modified_quant= s->h263_aic;
1082
        s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1083
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1084
        s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1085
        s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1086
        s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1087

    
1088
        /* /Fx */
1089
        /* These are just to be sure */
1090
        avctx->delay=0;
1091
        s->low_delay=1;
1092
        break;
1093
    case CODEC_ID_FLV1:
1094
        s->out_format = FMT_H263;
1095
        s->h263_flv = 2; /* format = 1; 11-bit codes */
1096
        s->unrestricted_mv = 1;
1097
        s->rtp_mode=0; /* don't allow GOB */
1098
        avctx->delay=0;
1099
        s->low_delay=1;
1100
        break;
1101
    case CODEC_ID_RV10:
1102
        s->out_format = FMT_H263;
1103
        avctx->delay=0;
1104
        s->low_delay=1;
1105
        break;
1106
    case CODEC_ID_MPEG4:
1107
        s->out_format = FMT_H263;
1108
        s->h263_pred = 1;
1109
        s->unrestricted_mv = 1;
1110
        s->low_delay= s->max_b_frames ? 0 : 1;
1111
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1112
        break;
1113
    case CODEC_ID_MSMPEG4V1:
1114
        s->out_format = FMT_H263;
1115
        s->h263_msmpeg4 = 1;
1116
        s->h263_pred = 1;
1117
        s->unrestricted_mv = 1;
1118
        s->msmpeg4_version= 1;
1119
        avctx->delay=0;
1120
        s->low_delay=1;
1121
        break;
1122
    case CODEC_ID_MSMPEG4V2:
1123
        s->out_format = FMT_H263;
1124
        s->h263_msmpeg4 = 1;
1125
        s->h263_pred = 1;
1126
        s->unrestricted_mv = 1;
1127
        s->msmpeg4_version= 2;
1128
        avctx->delay=0;
1129
        s->low_delay=1;
1130
        break;
1131
    case CODEC_ID_MSMPEG4V3:
1132
        s->out_format = FMT_H263;
1133
        s->h263_msmpeg4 = 1;
1134
        s->h263_pred = 1;
1135
        s->unrestricted_mv = 1;
1136
        s->msmpeg4_version= 3;
1137
        s->flipflop_rounding=1;
1138
        avctx->delay=0;
1139
        s->low_delay=1;
1140
        break;
1141
    case CODEC_ID_WMV1:
1142
        s->out_format = FMT_H263;
1143
        s->h263_msmpeg4 = 1;
1144
        s->h263_pred = 1;
1145
        s->unrestricted_mv = 1;
1146
        s->msmpeg4_version= 4;
1147
        s->flipflop_rounding=1;
1148
        avctx->delay=0;
1149
        s->low_delay=1;
1150
        break;
1151
    case CODEC_ID_WMV2:
1152
        s->out_format = FMT_H263;
1153
        s->h263_msmpeg4 = 1;
1154
        s->h263_pred = 1;
1155
        s->unrestricted_mv = 1;
1156
        s->msmpeg4_version= 5;
1157
        s->flipflop_rounding=1;
1158
        avctx->delay=0;
1159
        s->low_delay=1;
1160
        break;
1161
#endif
1162
    default:
1163
        return -1;
1164
    }
1165
    
1166
    avctx->has_b_frames= !s->low_delay;
1167

    
1168
    s->encoding = 1;
1169

    
1170
    /* init */
1171
    if (MPV_common_init(s) < 0)
1172
        return -1;
1173

    
1174
    if(s->modified_quant)
1175
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1176
    s->progressive_frame= 
1177
    s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1178
    s->quant_precision=5;
1179
    
1180
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1181
    
1182
#ifdef CONFIG_ENCODERS
1183
#ifdef CONFIG_RISKY
1184
    if (s->out_format == FMT_H263)
1185
        h263_encode_init(s);
1186
    if(s->msmpeg4_version)
1187
        ff_msmpeg4_encode_init(s);
1188
#endif
1189
    if (s->out_format == FMT_MPEG1)
1190
        ff_mpeg1_encode_init(s);
1191
#endif
1192

    
1193
    /* init q matrix */
1194
    for(i=0;i<64;i++) {
1195
        int j= s->dsp.idct_permutation[i];
1196
#ifdef CONFIG_RISKY
1197
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1198
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1199
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1200
        }else if(s->out_format == FMT_H263){
1201
            s->intra_matrix[j] =
1202
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1203
        }else
1204
#endif
1205
        { /* mpeg1/2 */
1206
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1207
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1208
        }
1209
        if(s->avctx->intra_matrix)
1210
            s->intra_matrix[j] = s->avctx->intra_matrix[i];
1211
        if(s->avctx->inter_matrix)
1212
            s->inter_matrix[j] = s->avctx->inter_matrix[i];
1213
    }
1214

    
1215
    /* precompute matrix */
1216
    /* for mjpeg, we do include qscale in the matrix */
1217
    if (s->out_format != FMT_MJPEG) {
1218
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 
1219
                       s->intra_matrix, s->intra_quant_bias, 1, 31);
1220
        convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, 
1221
                       s->inter_matrix, s->inter_quant_bias, 1, 31);
1222
    }
1223

    
1224
    if(ff_rate_control_init(s) < 0)
1225
        return -1;
1226
    
1227
    return 0;
1228
}
1229

    
1230
int MPV_encode_end(AVCodecContext *avctx)
1231
{
1232
    MpegEncContext *s = avctx->priv_data;
1233

    
1234
#ifdef STATS
1235
    print_stats();
1236
#endif
1237

    
1238
    ff_rate_control_uninit(s);
1239

    
1240
    MPV_common_end(s);
1241
    if (s->out_format == FMT_MJPEG)
1242
        mjpeg_close(s);
1243

    
1244
    av_freep(&avctx->extradata);
1245
      
1246
    return 0;
1247
}
1248

    
1249
#endif //CONFIG_ENCODERS
1250

    
1251
void init_rl(RLTable *rl)
1252
{
1253
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1254
    uint8_t index_run[MAX_RUN+1];
1255
    int last, run, level, start, end, i;
1256

    
1257
    /* compute max_level[], max_run[] and index_run[] */
1258
    for(last=0;last<2;last++) {
1259
        if (last == 0) {
1260
            start = 0;
1261
            end = rl->last;
1262
        } else {
1263
            start = rl->last;
1264
            end = rl->n;
1265
        }
1266

    
1267
        memset(max_level, 0, MAX_RUN + 1);
1268
        memset(max_run, 0, MAX_LEVEL + 1);
1269
        memset(index_run, rl->n, MAX_RUN + 1);
1270
        for(i=start;i<end;i++) {
1271
            run = rl->table_run[i];
1272
            level = rl->table_level[i];
1273
            if (index_run[run] == rl->n)
1274
                index_run[run] = i;
1275
            if (level > max_level[run])
1276
                max_level[run] = level;
1277
            if (run > max_run[level])
1278
                max_run[level] = run;
1279
        }
1280
        rl->max_level[last] = av_malloc(MAX_RUN + 1);
1281
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1282
        rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1283
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1284
        rl->index_run[last] = av_malloc(MAX_RUN + 1);
1285
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1286
    }
1287
}
1288

    
1289
/* draw the edges of width 'w' of an image of size width, height */
1290
//FIXME check that this is ok for mpeg4 interlaced
1291
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1292
{
1293
    uint8_t *ptr, *last_line;
1294
    int i;
1295

    
1296
    last_line = buf + (height - 1) * wrap;
1297
    for(i=0;i<w;i++) {
1298
        /* top and bottom */
1299
        memcpy(buf - (i + 1) * wrap, buf, width);
1300
        memcpy(last_line + (i + 1) * wrap, last_line, width);
1301
    }
1302
    /* left and right */
1303
    ptr = buf;
1304
    for(i=0;i<height;i++) {
1305
        memset(ptr - w, ptr[0], w);
1306
        memset(ptr + width, ptr[width-1], w);
1307
        ptr += wrap;
1308
    }
1309
    /* corners */
1310
    for(i=0;i<w;i++) {
1311
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1312
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1313
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1314
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1315
    }
1316
}
1317

    
1318
int ff_find_unused_picture(MpegEncContext *s, int shared){
1319
    int i;
1320
    
1321
    if(shared){
1322
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1323
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1324
        }
1325
    }else{
1326
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1327
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1328
        }
1329
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1330
            if(s->picture[i].data[0]==NULL) return i;
1331
        }
1332
    }
1333

    
1334
    assert(0);
1335
    return -1;
1336
}
1337

    
1338
static void update_noise_reduction(MpegEncContext *s){
1339
    int intra, i;
1340

    
1341
    for(intra=0; intra<2; intra++){
1342
        if(s->dct_count[intra] > (1<<16)){
1343
            for(i=0; i<64; i++){
1344
                s->dct_error_sum[intra][i] >>=1;
1345
            }
1346
            s->dct_count[intra] >>= 1;
1347
        }
1348
        
1349
        for(i=0; i<64; i++){
1350
            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);
1351
        }
1352
    }
1353
}
1354

    
1355
/**
1356
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1357
 */
1358
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1359
{
1360
    int i;
1361
    AVFrame *pic;
1362
    s->mb_skiped = 0;
1363

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

    
1366
    /* mark&release old frames */
1367
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1368
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1369

    
1370
        /* release forgotten pictures */
1371
        /* if(mpeg124/h263) */
1372
        if(!s->encoding){
1373
            for(i=0; i<MAX_PICTURE_COUNT; i++){
1374
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1375
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1376
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
1377
                }
1378
            }
1379
        }
1380
    }
1381
alloc:
1382
    if(!s->encoding){
1383
        /* release non refernce frames */
1384
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1385
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1386
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1387
            }
1388
        }
1389

    
1390
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1391
            pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1392
        else{
1393
            i= ff_find_unused_picture(s, 0);
1394
            pic= (AVFrame*)&s->picture[i];
1395
        }
1396

    
1397
        pic->reference= s->pict_type != B_TYPE && !s->dropable ? 3 : 0;
1398

    
1399
        pic->coded_picture_number= s->coded_picture_number++;
1400
        
1401
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1402
            return -1;
1403

    
1404
        s->current_picture_ptr= (Picture*)pic;
1405
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1406
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1407
    }
1408

    
1409
    s->current_picture_ptr->pict_type= s->pict_type;
1410
//    if(s->flags && CODEC_FLAG_QSCALE) 
1411
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1412
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1413

    
1414
    copy_picture(&s->current_picture, s->current_picture_ptr);
1415
  
1416
  if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1417
    if (s->pict_type != B_TYPE) {
1418
        s->last_picture_ptr= s->next_picture_ptr;
1419
        if(!s->dropable)
1420
            s->next_picture_ptr= s->current_picture_ptr;
1421
    }
1422
/*    av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n", s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1423
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL, 
1424
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL, 
1425
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1426
        s->pict_type, s->dropable);*/
1427
    
1428
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1429
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1430
    
1431
    if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1432
        av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1433
        assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1434
        goto alloc;
1435
    }
1436

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

    
1439
    if(s->picture_structure!=PICT_FRAME){
1440
        int i;
1441
        for(i=0; i<4; i++){
1442
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1443
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1444
            } 
1445
            s->current_picture.linesize[i] *= 2;
1446
            s->last_picture.linesize[i] *=2;
1447
            s->next_picture.linesize[i] *=2;
1448
        }
1449
    }
1450
  }
1451
   
1452
    s->hurry_up= s->avctx->hurry_up;
1453
    s->error_resilience= avctx->error_resilience;
1454

    
1455
    /* set dequantizer, we cant do it during init as it might change for mpeg4
1456
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1457
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1458
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1459
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1460
    }else if(s->out_format == FMT_H263){
1461
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1462
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1463
    }else if(s->out_format == FMT_H261){
1464
        s->dct_unquantize_intra = s->dct_unquantize_h261_intra;
1465
        s->dct_unquantize_inter = s->dct_unquantize_h261_inter;
1466
    }else{
1467
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1468
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1469
    }
1470

    
1471
    if(s->dct_error_sum){
1472
        assert(s->avctx->noise_reduction && s->encoding);
1473

    
1474
        update_noise_reduction(s);
1475
    }
1476
        
1477
#ifdef HAVE_XVMC
1478
    if(s->avctx->xvmc_acceleration)
1479
        return XVMC_field_start(s, avctx);
1480
#endif
1481
    return 0;
1482
}
1483

    
1484
/* generic function for encode/decode called after a frame has been coded/decoded */
1485
void MPV_frame_end(MpegEncContext *s)
1486
{
1487
    int i;
1488
    /* draw edge for correct motion prediction if outside */
1489
#ifdef HAVE_XVMC
1490
//just to make sure that all data is rendered.
1491
    if(s->avctx->xvmc_acceleration){
1492
        XVMC_field_end(s);
1493
    }else
1494
#endif
1495
    if(s->unrestricted_mv && s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1496
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1497
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1498
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1499
    }
1500
    emms_c();
1501
    
1502
    s->last_pict_type    = s->pict_type;
1503
    if(s->pict_type!=B_TYPE){
1504
        s->last_non_b_pict_type= s->pict_type;
1505
    }
1506
#if 0
1507
        /* copy back current_picture variables */
1508
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1509
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1510
            s->picture[i]= s->current_picture;
1511
            break;
1512
        }    
1513
    }
1514
    assert(i<MAX_PICTURE_COUNT);
1515
#endif    
1516

    
1517
    if(s->encoding){
1518
        /* release non refernce frames */
1519
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1520
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1521
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1522
            }
1523
        }
1524
    }
1525
    // clear copies, to avoid confusion
1526
#if 0
1527
    memset(&s->last_picture, 0, sizeof(Picture));
1528
    memset(&s->next_picture, 0, sizeof(Picture));
1529
    memset(&s->current_picture, 0, sizeof(Picture));
1530
#endif
1531
}
1532

    
1533
/**
1534
 * draws an line from (ex, ey) -> (sx, sy).
1535
 * @param w width of the image
1536
 * @param h height of the image
1537
 * @param stride stride/linesize of the image
1538
 * @param color color of the arrow
1539
 */
1540
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1541
    int t, x, y, fr, f;
1542
    
1543
    sx= clip(sx, 0, w-1);
1544
    sy= clip(sy, 0, h-1);
1545
    ex= clip(ex, 0, w-1);
1546
    ey= clip(ey, 0, h-1);
1547
    
1548
    buf[sy*stride + sx]+= color;
1549
    
1550
    if(ABS(ex - sx) > ABS(ey - sy)){
1551
        if(sx > ex){
1552
            t=sx; sx=ex; ex=t;
1553
            t=sy; sy=ey; ey=t;
1554
        }
1555
        buf+= sx + sy*stride;
1556
        ex-= sx;
1557
        f= ((ey-sy)<<16)/ex;
1558
        for(x= 0; x <= ex; x++){
1559
            y = (x*f)>>16;
1560
            fr= (x*f)&0xFFFF;
1561
            buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1562
            buf[(y+1)*stride + x]+= (color*         fr )>>16;
1563
        }
1564
    }else{
1565
        if(sy > ey){
1566
            t=sx; sx=ex; ex=t;
1567
            t=sy; sy=ey; ey=t;
1568
        }
1569
        buf+= sx + sy*stride;
1570
        ey-= sy;
1571
        if(ey) f= ((ex-sx)<<16)/ey;
1572
        else   f= 0;
1573
        for(y= 0; y <= ey; y++){
1574
            x = (y*f)>>16;
1575
            fr= (y*f)&0xFFFF;
1576
            buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;;
1577
            buf[y*stride + x+1]+= (color*         fr )>>16;;
1578
        }
1579
    }
1580
}
1581

    
1582
/**
1583
 * draws an arrow from (ex, ey) -> (sx, sy).
1584
 * @param w width of the image
1585
 * @param h height of the image
1586
 * @param stride stride/linesize of the image
1587
 * @param color color of the arrow
1588
 */
1589
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1590
    int dx,dy;
1591

    
1592
    sx= clip(sx, -100, w+100);
1593
    sy= clip(sy, -100, h+100);
1594
    ex= clip(ex, -100, w+100);
1595
    ey= clip(ey, -100, h+100);
1596
    
1597
    dx= ex - sx;
1598
    dy= ey - sy;
1599
    
1600
    if(dx*dx + dy*dy > 3*3){
1601
        int rx=  dx + dy;
1602
        int ry= -dx + dy;
1603
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1604
        
1605
        //FIXME subpixel accuracy
1606
        rx= ROUNDED_DIV(rx*3<<4, length);
1607
        ry= ROUNDED_DIV(ry*3<<4, length);
1608
        
1609
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1610
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1611
    }
1612
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1613
}
1614

    
1615
/**
1616
 * prints debuging info for the given picture.
1617
 */
1618
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1619

    
1620
    if(!pict || !pict->mb_type) return;
1621

    
1622
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1623
        int x,y;
1624
        
1625
        av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1626
        switch (pict->pict_type) {
1627
            case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1628
            case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1629
            case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1630
            case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1631
            case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1632
            case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;            
1633
        }
1634
        for(y=0; y<s->mb_height; y++){
1635
            for(x=0; x<s->mb_width; x++){
1636
                if(s->avctx->debug&FF_DEBUG_SKIP){
1637
                    int count= s->mbskip_table[x + y*s->mb_stride];
1638
                    if(count>9) count=9;
1639
                    av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1640
                }
1641
                if(s->avctx->debug&FF_DEBUG_QP){
1642
                    av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1643
                }
1644
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1645
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
1646
                    //Type & MV direction
1647
                    if(IS_PCM(mb_type))
1648
                        av_log(s->avctx, AV_LOG_DEBUG, "P");
1649
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1650
                        av_log(s->avctx, AV_LOG_DEBUG, "A");
1651
                    else if(IS_INTRA4x4(mb_type))
1652
                        av_log(s->avctx, AV_LOG_DEBUG, "i");
1653
                    else if(IS_INTRA16x16(mb_type))
1654
                        av_log(s->avctx, AV_LOG_DEBUG, "I");
1655
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1656
                        av_log(s->avctx, AV_LOG_DEBUG, "d");
1657
                    else if(IS_DIRECT(mb_type))
1658
                        av_log(s->avctx, AV_LOG_DEBUG, "D");
1659
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1660
                        av_log(s->avctx, AV_LOG_DEBUG, "g");
1661
                    else if(IS_GMC(mb_type))
1662
                        av_log(s->avctx, AV_LOG_DEBUG, "G");
1663
                    else if(IS_SKIP(mb_type))
1664
                        av_log(s->avctx, AV_LOG_DEBUG, "S");
1665
                    else if(!USES_LIST(mb_type, 1))
1666
                        av_log(s->avctx, AV_LOG_DEBUG, ">");
1667
                    else if(!USES_LIST(mb_type, 0))
1668
                        av_log(s->avctx, AV_LOG_DEBUG, "<");
1669
                    else{
1670
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1671
                        av_log(s->avctx, AV_LOG_DEBUG, "X");
1672
                    }
1673
                    
1674
                    //segmentation
1675
                    if(IS_8X8(mb_type))
1676
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1677
                    else if(IS_16X8(mb_type))
1678
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1679
                    else if(IS_8X16(mb_type))
1680
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1681
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1682
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1683
                    else
1684
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1685
                    
1686
                        
1687
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1688
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1689
                    else
1690
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1691
                }
1692
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1693
            }
1694
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1695
        }
1696
    }
1697

    
1698
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1699
        const int shift= 1 + s->quarter_sample;
1700
        int mb_y;
1701
        uint8_t *ptr;
1702
        int i;
1703
        int h_chroma_shift, v_chroma_shift;
1704
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1705

    
1706
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1707
        for(i=0; i<3; i++){
1708
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*s->height:pict->linesize[i]*s->height >> v_chroma_shift);
1709
            pict->data[i]= s->visualization_buffer[i];
1710
        }
1711
        pict->type= FF_BUFFER_TYPE_COPY;
1712
        ptr= pict->data[0];
1713

    
1714
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1715
            int mb_x;
1716
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1717
                const int mb_index= mb_x + mb_y*s->mb_stride;
1718
                if((s->avctx->debug_mv) && pict->motion_val){
1719
                  int type;
1720
                  for(type=0; type<3; type++){
1721
                    int direction = 0;
1722
                    switch (type) {
1723
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1724
                                continue;
1725
                              direction = 0;
1726
                              break;
1727
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1728
                                continue;
1729
                              direction = 0;
1730
                              break;
1731
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1732
                                continue;
1733
                              direction = 1;
1734
                              break;
1735
                    }
1736
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1737
                        continue;
1738

    
1739
                    //FIXME for h264
1740
                    if(IS_8X8(pict->mb_type[mb_index])){
1741
                      int i;
1742
                      for(i=0; i<4; i++){
1743
                        int sx= mb_x*16 + 4 + 8*(i&1);
1744
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1745
                        int xy= mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*s->b8_stride;
1746
                        int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1747
                        int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1748
                        draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1749
                      }
1750
                    }else if(IS_16X8(pict->mb_type[mb_index])){
1751
                      int i;
1752
                      for(i=0; i<2; i++){
1753
                        int sx=mb_x*16 + 8;
1754
                        int sy=mb_y*16 + 4 + 8*i;
1755
                        int xy= mb_x*2 + (mb_y*2 + i)*s->b8_stride;
1756
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1757
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1758
                        
1759
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1760
                            my*=2;
1761
                        
1762
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, s->width, s->height, s->linesize, 100);
1763
                      }
1764
                    }else{
1765
                      int sx= mb_x*16 + 8;
1766
                      int sy= mb_y*16 + 8;
1767
                      int xy= mb_x*2 + mb_y*2*s->b8_stride;
1768
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1769
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1770
                      draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1771
                    }
1772
                  }                  
1773
                }
1774
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1775
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1776
                    int y;
1777
                    for(y=0; y<8; y++){
1778
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1779
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1780
                    }
1781
                }
1782
                if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1783
                    int mb_type= pict->mb_type[mb_index];
1784
                    uint64_t u,v;
1785
                    int y;
1786
#define COLOR(theta, r)\
1787
u= (int)(128 + r*cos(theta*3.141592/180));\
1788
v= (int)(128 + r*sin(theta*3.141592/180));
1789

    
1790
                    
1791
                    u=v=128;
1792
                    if(IS_PCM(mb_type)){
1793
                        COLOR(120,48)
1794
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1795
                        COLOR(30,48)
1796
                    }else if(IS_INTRA4x4(mb_type)){
1797
                        COLOR(90,48)
1798
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1799
//                        COLOR(120,48)
1800
                    }else if(IS_DIRECT(mb_type)){
1801
                        COLOR(150,48)
1802
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1803
                        COLOR(170,48)
1804
                    }else if(IS_GMC(mb_type)){
1805
                        COLOR(190,48)
1806
                    }else if(IS_SKIP(mb_type)){
1807
//                        COLOR(180,48)
1808
                    }else if(!USES_LIST(mb_type, 1)){
1809
                        COLOR(240,48)
1810
                    }else if(!USES_LIST(mb_type, 0)){
1811
                        COLOR(0,48)
1812
                    }else{
1813
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1814
                        COLOR(300,48)
1815
                    }
1816

    
1817
                    u*= 0x0101010101010101ULL;
1818
                    v*= 0x0101010101010101ULL;
1819
                    for(y=0; y<8; y++){
1820
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1821
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1822
                    }
1823

    
1824
                    //segmentation
1825
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1826
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1827
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1828
                    }
1829
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1830
                        for(y=0; y<16; y++)
1831
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1832
                    }
1833
                        
1834
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1835
                        // hmm
1836
                    }
1837
                }
1838
                s->mbskip_table[mb_index]=0;
1839
            }
1840
        }
1841
    }
1842
}
1843

    
1844
#ifdef CONFIG_ENCODERS
1845

    
1846
static int get_sae(uint8_t *src, int ref, int stride){
1847
    int x,y;
1848
    int acc=0;
1849
    
1850
    for(y=0; y<16; y++){
1851
        for(x=0; x<16; x++){
1852
            acc+= ABS(src[x+y*stride] - ref);
1853
        }
1854
    }
1855
    
1856
    return acc;
1857
}
1858

    
1859
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1860
    int x, y, w, h;
1861
    int acc=0;
1862
    
1863
    w= s->width &~15;
1864
    h= s->height&~15;
1865
    
1866
    for(y=0; y<h; y+=16){
1867
        for(x=0; x<w; x+=16){
1868
            int offset= x + y*stride;
1869
            int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1870
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1871
            int sae = get_sae(src + offset, mean, stride);
1872
            
1873
            acc+= sae + 500 < sad;
1874
        }
1875
    }
1876
    return acc;
1877
}
1878

    
1879

    
1880
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1881
    AVFrame *pic=NULL;
1882
    int i;
1883
    const int encoding_delay= s->max_b_frames;
1884
    int direct=1;
1885
    
1886
  if(pic_arg){
1887
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1888
    if(pic_arg->linesize[0] != s->linesize) direct=0;
1889
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1890
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1891
  
1892
//    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1893
    
1894
    if(direct){
1895
        i= ff_find_unused_picture(s, 1);
1896

    
1897
        pic= (AVFrame*)&s->picture[i];
1898
        pic->reference= 3;
1899
    
1900
        for(i=0; i<4; i++){
1901
            pic->data[i]= pic_arg->data[i];
1902
            pic->linesize[i]= pic_arg->linesize[i];
1903
        }
1904
        alloc_picture(s, (Picture*)pic, 1);
1905
    }else{
1906
        int offset= 16;
1907
        i= ff_find_unused_picture(s, 0);
1908

    
1909
        pic= (AVFrame*)&s->picture[i];
1910
        pic->reference= 3;
1911

    
1912
        alloc_picture(s, (Picture*)pic, 0);
1913

    
1914
        if(   pic->data[0] + offset == pic_arg->data[0] 
1915
           && pic->data[1] + offset == pic_arg->data[1]
1916
           && pic->data[2] + offset == pic_arg->data[2]){
1917
       // empty
1918
        }else{
1919
            int h_chroma_shift, v_chroma_shift;
1920
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1921
        
1922
            for(i=0; i<3; i++){
1923
                int src_stride= pic_arg->linesize[i];
1924
                int dst_stride= i ? s->uvlinesize : s->linesize;
1925
                int h_shift= i ? h_chroma_shift : 0;
1926
                int v_shift= i ? v_chroma_shift : 0;
1927
                int w= s->width >>h_shift;
1928
                int h= s->height>>v_shift;
1929
                uint8_t *src= pic_arg->data[i];
1930
                uint8_t *dst= pic->data[i] + offset;
1931
            
1932
                if(src_stride==dst_stride)
1933
                    memcpy(dst, src, src_stride*h);
1934
                else{
1935
                    while(h--){
1936
                        memcpy(dst, src, w);
1937
                        dst += dst_stride;
1938
                        src += src_stride;
1939
                    }
1940
                }
1941
            }
1942
        }
1943
    }
1944
    copy_picture_attributes(s, pic, pic_arg);
1945
    
1946
    pic->display_picture_number= s->input_picture_number++;
1947
    if(pic->pts != AV_NOPTS_VALUE){ 
1948
        s->user_specified_pts= pic->pts;
1949
    }else{
1950
        if(s->user_specified_pts){
1951
            pic->pts= s->user_specified_pts + AV_TIME_BASE*(int64_t)s->avctx->frame_rate_base / s->avctx->frame_rate;
1952
            av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%Ld)\n", pic->pts);
1953
        }else{
1954
            pic->pts= av_rescale(pic->display_picture_number*(int64_t)s->avctx->frame_rate_base, AV_TIME_BASE, s->avctx->frame_rate);
1955
        }
1956
    }
1957
  }
1958
  
1959
    /* shift buffer entries */
1960
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1961
        s->input_picture[i-1]= s->input_picture[i];
1962
        
1963
    s->input_picture[encoding_delay]= (Picture*)pic;
1964

    
1965
    return 0;
1966
}
1967

    
1968
static void select_input_picture(MpegEncContext *s){
1969
    int i;
1970

    
1971
    for(i=1; i<MAX_PICTURE_COUNT; i++)
1972
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1973
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1974

    
1975
    /* set next picture types & ordering */
1976
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1977
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
1978
            s->reordered_input_picture[0]= s->input_picture[0];
1979
            s->reordered_input_picture[0]->pict_type= I_TYPE;
1980
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
1981
        }else{
1982
            int b_frames;
1983
            
1984
            if(s->flags&CODEC_FLAG_PASS2){
1985
                for(i=0; i<s->max_b_frames+1; i++){
1986
                    int pict_num= s->input_picture[0]->display_picture_number + i;
1987
                    int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1988
                    s->input_picture[i]->pict_type= pict_type;
1989
                    
1990
                    if(i + 1 >= s->rc_context.num_entries) break;
1991
                }
1992
            }
1993

    
1994
            if(s->input_picture[0]->pict_type){
1995
                /* user selected pict_type */
1996
                for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
1997
                    if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
1998
                }
1999
            
2000
                if(b_frames > s->max_b_frames){
2001
                    av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
2002
                    b_frames = s->max_b_frames;
2003
                }
2004
            }else if(s->avctx->b_frame_strategy==0){
2005
                b_frames= s->max_b_frames;
2006
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
2007
            }else if(s->avctx->b_frame_strategy==1){
2008
                for(i=1; i<s->max_b_frames+1; i++){
2009
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2010
                        s->input_picture[i]->b_frame_score= 
2011
                            get_intra_count(s, s->input_picture[i  ]->data[0], 
2012
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
2013
                    }
2014
                }
2015
                for(i=0; i<s->max_b_frames; i++){
2016
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2017
                }
2018
                                
2019
                b_frames= FFMAX(0, i-1);
2020
                
2021
                /* reset scores */
2022
                for(i=0; i<b_frames+1; i++){
2023
                    s->input_picture[i]->b_frame_score=0;
2024
                }
2025
            }else{
2026
                av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2027
                b_frames=0;
2028
            }
2029

    
2030
            emms_c();
2031
//static int b_count=0;
2032
//b_count+= b_frames;
2033
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2034
            if(s->picture_in_gop_number + b_frames >= s->gop_size){
2035
                if(s->flags & CODEC_FLAG_CLOSED_GOP)
2036
                    b_frames=0;
2037
                s->input_picture[b_frames]->pict_type= I_TYPE;
2038
            }
2039
            
2040
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2041
               && b_frames
2042
               && s->input_picture[b_frames]->pict_type== I_TYPE)
2043
                b_frames--;
2044

    
2045
            s->reordered_input_picture[0]= s->input_picture[b_frames];
2046
            if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2047
                s->reordered_input_picture[0]->pict_type= P_TYPE;
2048
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2049
            for(i=0; i<b_frames; i++){
2050
                s->reordered_input_picture[i+1]= s->input_picture[i];
2051
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2052
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2053
            }
2054
        }
2055
    }
2056
    
2057
    if(s->reordered_input_picture[0]){
2058
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2059

    
2060
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2061

    
2062
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2063
            // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2064
        
2065
            int i= ff_find_unused_picture(s, 0);
2066
            Picture *pic= &s->picture[i];
2067

    
2068
            /* mark us unused / free shared pic */
2069
            for(i=0; i<4; i++)
2070
                s->reordered_input_picture[0]->data[i]= NULL;
2071
            s->reordered_input_picture[0]->type= 0;
2072
            
2073
            pic->reference              = s->reordered_input_picture[0]->reference;
2074
            
2075
            alloc_picture(s, pic, 0);
2076

    
2077
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2078

    
2079
            s->current_picture_ptr= pic;
2080
        }else{
2081
            // input is not a shared pix -> reuse buffer for current_pix
2082

    
2083
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
2084
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2085
            
2086
            s->current_picture_ptr= s->reordered_input_picture[0];
2087
            for(i=0; i<4; i++){
2088
                s->new_picture.data[i]+=16;
2089
            }
2090
        }
2091
        copy_picture(&s->current_picture, s->current_picture_ptr);
2092
    
2093
        s->picture_number= s->new_picture.display_picture_number;
2094
//printf("dpn:%d\n", s->picture_number);
2095
    }else{
2096
       memset(&s->new_picture, 0, sizeof(Picture));
2097
    }
2098
}
2099

    
2100
int MPV_encode_picture(AVCodecContext *avctx,
2101
                       unsigned char *buf, int buf_size, void *data)
2102
{
2103
    MpegEncContext *s = avctx->priv_data;
2104
    AVFrame *pic_arg = data;
2105
    int i, stuffing_count;
2106

    
2107
    if(avctx->pix_fmt != PIX_FMT_YUV420P){
2108
        av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2109
        return -1;
2110
    }
2111
    
2112
    for(i=0; i<avctx->thread_count; i++){
2113
        int start_y= s->thread_context[i]->start_mb_y;
2114
        int   end_y= s->thread_context[i]->  end_mb_y;
2115
        int h= s->mb_height;
2116
        uint8_t *start= buf + buf_size*start_y/h;
2117
        uint8_t *end  = buf + buf_size*  end_y/h;
2118

    
2119
        init_put_bits(&s->thread_context[i]->pb, start, end - start);
2120
    }
2121

    
2122
    s->picture_in_gop_number++;
2123

    
2124
    load_input_picture(s, pic_arg);
2125
    
2126
    select_input_picture(s);
2127
    
2128
    /* output? */
2129
    if(s->new_picture.data[0]){
2130
        s->pict_type= s->new_picture.pict_type;
2131
//emms_c();
2132
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2133
        MPV_frame_start(s, avctx);
2134

    
2135
        encode_picture(s, s->picture_number);
2136
        
2137
        avctx->real_pict_num  = s->picture_number;
2138
        avctx->header_bits = s->header_bits;
2139
        avctx->mv_bits     = s->mv_bits;
2140
        avctx->misc_bits   = s->misc_bits;
2141
        avctx->i_tex_bits  = s->i_tex_bits;
2142
        avctx->p_tex_bits  = s->p_tex_bits;
2143
        avctx->i_count     = s->i_count;
2144
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2145
        avctx->skip_count  = s->skip_count;
2146

    
2147
        MPV_frame_end(s);
2148

    
2149
        if (s->out_format == FMT_MJPEG)
2150
            mjpeg_picture_trailer(s);
2151
        
2152
        if(s->flags&CODEC_FLAG_PASS1)
2153
            ff_write_pass1_stats(s);
2154

    
2155
        for(i=0; i<4; i++){
2156
            avctx->error[i] += s->current_picture_ptr->error[i];
2157
        }
2158

    
2159
        flush_put_bits(&s->pb);
2160
        s->frame_bits  = put_bits_count(&s->pb);
2161

    
2162
        stuffing_count= ff_vbv_update(s, s->frame_bits);
2163
        if(stuffing_count){
2164
            switch(s->codec_id){
2165
            case CODEC_ID_MPEG1VIDEO:
2166
            case CODEC_ID_MPEG2VIDEO:
2167
                while(stuffing_count--){
2168
                    put_bits(&s->pb, 8, 0);
2169
                }
2170
            break;
2171
            case CODEC_ID_MPEG4:
2172
                put_bits(&s->pb, 16, 0);
2173
                put_bits(&s->pb, 16, 0x1C3);
2174
                stuffing_count -= 4;
2175
                while(stuffing_count--){
2176
                    put_bits(&s->pb, 8, 0xFF);
2177
                }
2178
            break;
2179
            default:
2180
                av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2181
            }
2182
            flush_put_bits(&s->pb);
2183
            s->frame_bits  = put_bits_count(&s->pb);
2184
        }
2185

    
2186
        /* update mpeg1/2 vbv_delay for CBR */    
2187
        if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2188
           && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2189
            int vbv_delay;
2190

    
2191
            assert(s->repeat_first_field==0);
2192
            
2193
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2194
            assert(vbv_delay < 0xFFFF);
2195

    
2196
            s->vbv_delay_ptr[0] &= 0xF8;
2197
            s->vbv_delay_ptr[0] |= vbv_delay>>13;
2198
            s->vbv_delay_ptr[1]  = vbv_delay>>5;
2199
            s->vbv_delay_ptr[2] &= 0x07;
2200
            s->vbv_delay_ptr[2] |= vbv_delay<<3;
2201
        }
2202
        s->total_bits += s->frame_bits;
2203
        avctx->frame_bits  = s->frame_bits;
2204
    }else{
2205
        assert((pbBufPtr(&s->pb) == s->pb.buf));
2206
        s->frame_bits=0;
2207
    }
2208
    assert((s->frame_bits&7)==0);
2209
    
2210
    return s->frame_bits/8;
2211
}
2212

    
2213
#endif //CONFIG_ENCODERS
2214

    
2215
static inline void gmc1_motion(MpegEncContext *s,
2216
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2217
                               uint8_t **ref_picture)
2218
{
2219
    uint8_t *ptr;
2220
    int offset, src_x, src_y, linesize, uvlinesize;
2221
    int motion_x, motion_y;
2222
    int emu=0;
2223

    
2224
    motion_x= s->sprite_offset[0][0];
2225
    motion_y= s->sprite_offset[0][1];
2226
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2227
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2228
    motion_x<<=(3-s->sprite_warping_accuracy);
2229
    motion_y<<=(3-s->sprite_warping_accuracy);
2230
    src_x = clip(src_x, -16, s->width);
2231
    if (src_x == s->width)
2232
        motion_x =0;
2233
    src_y = clip(src_y, -16, s->height);
2234
    if (src_y == s->height)
2235
        motion_y =0;
2236

    
2237
    linesize = s->linesize;
2238
    uvlinesize = s->uvlinesize;
2239
    
2240
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2241

    
2242
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2243
        if(   (unsigned)src_x >= s->h_edge_pos - 17
2244
           || (unsigned)src_y >= s->v_edge_pos - 17){
2245
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2246
            ptr= s->edge_emu_buffer;
2247
        }
2248
    }
2249
    
2250
    if((motion_x|motion_y)&7){
2251
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2252
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2253
    }else{
2254
        int dxy;
2255
        
2256
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2257
        if (s->no_rounding){
2258
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2259
        }else{
2260
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2261
        }
2262
    }
2263
    
2264
    if(s->flags&CODEC_FLAG_GRAY) return;
2265

    
2266
    motion_x= s->sprite_offset[1][0];
2267
    motion_y= s->sprite_offset[1][1];
2268
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2269
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2270
    motion_x<<=(3-s->sprite_warping_accuracy);
2271
    motion_y<<=(3-s->sprite_warping_accuracy);
2272
    src_x = clip(src_x, -8, s->width>>1);
2273
    if (src_x == s->width>>1)
2274
        motion_x =0;
2275
    src_y = clip(src_y, -8, s->height>>1);
2276
    if (src_y == s->height>>1)
2277
        motion_y =0;
2278

    
2279
    offset = (src_y * uvlinesize) + src_x;
2280
    ptr = ref_picture[1] + offset;
2281
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2282
        if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2283
           || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2284
            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);
2285
            ptr= s->edge_emu_buffer;
2286
            emu=1;
2287
        }
2288
    }
2289
    s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2290
    
2291
    ptr = ref_picture[2] + offset;
2292
    if(emu){
2293
        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);
2294
        ptr= s->edge_emu_buffer;
2295
    }
2296
    s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2297
    
2298
    return;
2299
}
2300

    
2301
static inline void gmc_motion(MpegEncContext *s,
2302
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2303
                               uint8_t **ref_picture)
2304
{
2305
    uint8_t *ptr;
2306
    int linesize, uvlinesize;
2307
    const int a= s->sprite_warping_accuracy;
2308
    int ox, oy;
2309

    
2310
    linesize = s->linesize;
2311
    uvlinesize = s->uvlinesize;
2312

    
2313
    ptr = ref_picture[0];
2314

    
2315
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2316
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2317

    
2318
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2319
           ox, 
2320
           oy, 
2321
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2322
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2323
           a+1, (1<<(2*a+1)) - s->no_rounding,
2324
           s->h_edge_pos, s->v_edge_pos);
2325
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2326
           ox + s->sprite_delta[0][0]*8, 
2327
           oy + s->sprite_delta[1][0]*8, 
2328
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2329
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2330
           a+1, (1<<(2*a+1)) - s->no_rounding,
2331
           s->h_edge_pos, s->v_edge_pos);
2332

    
2333
    if(s->flags&CODEC_FLAG_GRAY) return;
2334

    
2335
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2336
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2337

    
2338
    ptr = ref_picture[1];
2339
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2340
           ox, 
2341
           oy, 
2342
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2343
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2344
           a+1, (1<<(2*a+1)) - s->no_rounding,
2345
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2346
    
2347
    ptr = ref_picture[2];
2348
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2349
           ox, 
2350
           oy, 
2351
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2352
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2353
           a+1, (1<<(2*a+1)) - s->no_rounding,
2354
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2355
}
2356

    
2357
/**
2358
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2359
 * @param buf destination buffer
2360
 * @param src source buffer
2361
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2362
 * @param block_w width of block
2363
 * @param block_h height of block
2364
 * @param src_x x coordinate of the top left sample of the block in the source buffer
2365
 * @param src_y y coordinate of the top left sample of the block in the source buffer
2366
 * @param w width of the source buffer
2367
 * @param h height of the source buffer
2368
 */
2369
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
2370
                                    int src_x, int src_y, int w, int h){
2371
    int x, y;
2372
    int start_y, start_x, end_y, end_x;
2373

    
2374
    if(src_y>= h){
2375
        src+= (h-1-src_y)*linesize;
2376
        src_y=h-1;
2377
    }else if(src_y<=-block_h){
2378
        src+= (1-block_h-src_y)*linesize;
2379
        src_y=1-block_h;
2380
    }
2381
    if(src_x>= w){
2382
        src+= (w-1-src_x);
2383
        src_x=w-1;
2384
    }else if(src_x<=-block_w){
2385
        src+= (1-block_w-src_x);
2386
        src_x=1-block_w;
2387
    }
2388

    
2389
    start_y= FFMAX(0, -src_y);
2390
    start_x= FFMAX(0, -src_x);
2391
    end_y= FFMIN(block_h, h-src_y);
2392
    end_x= FFMIN(block_w, w-src_x);
2393

    
2394
    // copy existing part
2395
    for(y=start_y; y<end_y; y++){
2396
        for(x=start_x; x<end_x; x++){
2397
            buf[x + y*linesize]= src[x + y*linesize];
2398
        }
2399
    }
2400

    
2401
    //top
2402
    for(y=0; y<start_y; y++){
2403
        for(x=start_x; x<end_x; x++){
2404
            buf[x + y*linesize]= buf[x + start_y*linesize];
2405
        }
2406
    }
2407

    
2408
    //bottom
2409
    for(y=end_y; y<block_h; y++){
2410
        for(x=start_x; x<end_x; x++){
2411
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2412
        }
2413
    }
2414
                                    
2415
    for(y=0; y<block_h; y++){
2416
       //left
2417
        for(x=0; x<start_x; x++){
2418
            buf[x + y*linesize]= buf[start_x + y*linesize];
2419
        }
2420
       
2421
       //right
2422
        for(x=end_x; x<block_w; x++){
2423
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2424
        }
2425
    }
2426
}
2427

    
2428
static inline int hpel_motion(MpegEncContext *s, 
2429
                                  uint8_t *dest, uint8_t *src,
2430
                                  int field_based, int field_select,
2431
                                  int src_x, int src_y,
2432
                                  int width, int height, int stride,
2433
                                  int h_edge_pos, int v_edge_pos,
2434
                                  int w, int h, op_pixels_func *pix_op,
2435
                                  int motion_x, int motion_y)
2436
{
2437
    int dxy;
2438
    int emu=0;
2439

    
2440
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2441
    src_x += motion_x >> 1;
2442
    src_y += motion_y >> 1;
2443
                
2444
    /* WARNING: do no forget half pels */
2445
    src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2446
    if (src_x == width)
2447
        dxy &= ~1;
2448
    src_y = clip(src_y, -16, height);
2449
    if (src_y == height)
2450
        dxy &= ~2;
2451
    src += src_y * stride + src_x;
2452

    
2453
    if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2454
        if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2455
           || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2456
            ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2457
                             src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2458
            src= s->edge_emu_buffer;
2459
            emu=1;
2460
        }
2461
    }
2462
    if(field_select)
2463
        src += s->linesize;
2464
    pix_op[dxy](dest, src, stride, h);
2465
    return emu;
2466
}
2467

    
2468
/* apply one mpeg motion vector to the three components */
2469
static inline void mpeg_motion(MpegEncContext *s,
2470
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2471
                               int field_based, int bottom_field, int field_select,
2472
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2473
                               int motion_x, int motion_y, int h)
2474
{
2475
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2476
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2477
    
2478
#if 0    
2479
if(s->quarter_sample)
2480
{
2481
    motion_x>>=1;
2482
    motion_y>>=1;
2483
}
2484
#endif
2485

    
2486
    v_edge_pos = s->v_edge_pos >> field_based;
2487
    linesize   = s->current_picture.linesize[0] << field_based;
2488
    uvlinesize = s->current_picture.linesize[1] << field_based;
2489

    
2490
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2491
    src_x = s->mb_x* 16               + (motion_x >> 1);
2492
    src_y = s->mb_y*(16>>field_based) + (motion_y >> 1);
2493

    
2494
    if (s->out_format == FMT_H263) {
2495
        if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2496
            mx = (motion_x>>1)|(motion_x&1);
2497
            my = motion_y >>1;
2498
            uvdxy = ((my & 1) << 1) | (mx & 1);
2499
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2500
            uvsrc_y = s->mb_y*(8>>field_based) + (my >> 1);
2501
        }else{
2502
            uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2503
            uvsrc_x = src_x>>1;
2504
            uvsrc_y = src_y>>1;
2505
        }
2506
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2507
        mx = motion_x / 4;
2508
        my = motion_y / 4;
2509
        uvdxy = 0;
2510
        uvsrc_x = s->mb_x*8 + mx;
2511
        uvsrc_y = s->mb_y*8 + my;
2512
    } else {
2513
        mx = motion_x / 2;
2514
        my = motion_y / 2;
2515
        uvdxy = ((my & 1) << 1) | (mx & 1);
2516
        uvsrc_x = s->mb_x* 8               + (mx >> 1);
2517
        uvsrc_y = s->mb_y*(8>>field_based) + (my >> 1);
2518
    }
2519

    
2520
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2521
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2522
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2523

    
2524
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2525
       || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
2526
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2527
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2528
            ptr_y = s->edge_emu_buffer;
2529
            if(!(s->flags&CODEC_FLAG_GRAY)){
2530
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2531
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2532
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2533
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2534
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2535
                ptr_cb= uvbuf;
2536
                ptr_cr= uvbuf+16;
2537
            }
2538
    }
2539

    
2540
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2541
        dest_y += s->linesize;
2542
        dest_cb+= s->uvlinesize;
2543
        dest_cr+= s->uvlinesize;
2544
    }
2545

    
2546
    if(field_select){
2547
        ptr_y += s->linesize;
2548
        ptr_cb+= s->uvlinesize;
2549
        ptr_cr+= s->uvlinesize;
2550
    }
2551

    
2552
    pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2553
    
2554
    if(!(s->flags&CODEC_FLAG_GRAY)){
2555
        pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
2556
        pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
2557
    }
2558
}
2559
//FIXME move to dsputil, avg variant, 16x16 version
2560
static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2561
    int x;
2562
    uint8_t * const top   = src[1];
2563
    uint8_t * const left  = src[2];
2564
    uint8_t * const mid   = src[0];
2565
    uint8_t * const right = src[3];
2566
    uint8_t * const bottom= src[4];
2567
#define OBMC_FILTER(x, t, l, m, r, b)\
2568
    dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2569
#define OBMC_FILTER4(x, t, l, m, r, b)\
2570
    OBMC_FILTER(x         , t, l, m, r, b);\
2571
    OBMC_FILTER(x+1       , t, l, m, r, b);\
2572
    OBMC_FILTER(x  +stride, t, l, m, r, b);\
2573
    OBMC_FILTER(x+1+stride, t, l, m, r, b);
2574
    
2575
    x=0;
2576
    OBMC_FILTER (x  , 2, 2, 4, 0, 0);
2577
    OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2578
    OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2579
    OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2580
    OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2581
    OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2582
    x+= stride;
2583
    OBMC_FILTER (x  , 1, 2, 5, 0, 0);
2584
    OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2585
    OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2586
    OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2587
    x+= stride;
2588
    OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
2589
    OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2590
    OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2591
    OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2592
    x+= 2*stride;
2593
    OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
2594
    OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2595
    OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2596
    OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2597
    x+= 2*stride;
2598
    OBMC_FILTER (x  , 0, 2, 5, 0, 1);
2599
    OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2600
    OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2601
    OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2602
    OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2603
    OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2604
    x+= stride;
2605
    OBMC_FILTER (x  , 0, 2, 4, 0, 2);
2606
    OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2607
    OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2608
    OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2609
}
2610

    
2611
/* obmc for 1 8x8 luma block */
2612
static inline void obmc_motion(MpegEncContext *s,
2613
                               uint8_t *dest, uint8_t *src,
2614
                               int src_x, int src_y,
2615
                               op_pixels_func *pix_op,
2616
                               int16_t mv[5][2]/* mid top left right bottom*/)
2617
#define MID    0
2618
{
2619
    int i;
2620
    uint8_t *ptr[5];
2621
    
2622
    assert(s->quarter_sample==0);
2623
    
2624
    for(i=0; i<5; i++){
2625
        if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2626
            ptr[i]= ptr[MID];
2627
        }else{
2628
            ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
2629
            hpel_motion(s, ptr[i], src, 0, 0,
2630
                        src_x, src_y,
2631
                        s->width, s->height, s->linesize,
2632
                        s->h_edge_pos, s->v_edge_pos,
2633
                        8, 8, pix_op,
2634
                        mv[i][0], mv[i][1]);
2635
        }
2636
    }
2637

    
2638
    put_obmc(dest, ptr, s->linesize);                
2639
}
2640

    
2641
static inline void qpel_motion(MpegEncContext *s,
2642
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2643
                               int field_based, int bottom_field, int field_select,
2644
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2645
                               qpel_mc_func (*qpix_op)[16],
2646
                               int motion_x, int motion_y, int h)
2647
{
2648
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2649
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
2650

    
2651
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2652
    src_x = s->mb_x *  16                 + (motion_x >> 2);
2653
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2654

    
2655
    v_edge_pos = s->v_edge_pos >> field_based;
2656
    linesize = s->linesize << field_based;
2657
    uvlinesize = s->uvlinesize << field_based;
2658
    
2659
    if(field_based){
2660
        mx= motion_x/2;
2661
        my= motion_y>>1;
2662
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2663
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
2664
        mx= (motion_x>>1) + rtab[motion_x&7];
2665
        my= (motion_y>>1) + rtab[motion_y&7];
2666
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2667
        mx= (motion_x>>1)|(motion_x&1);
2668
        my= (motion_y>>1)|(motion_y&1);
2669
    }else{
2670
        mx= motion_x/2;
2671
        my= motion_y/2;
2672
    }
2673
    mx= (mx>>1)|(mx&1);
2674
    my= (my>>1)|(my&1);
2675

    
2676
    uvdxy= (mx&1) | ((my&1)<<1);
2677
    mx>>=1;
2678
    my>>=1;
2679

    
2680
    uvsrc_x = s->mb_x *  8                 + mx;
2681
    uvsrc_y = s->mb_y * (8 >> field_based) + my;
2682

    
2683
    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
2684
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2685
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2686

    
2687
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 
2688
       || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
2689
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, 
2690
                         src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2691
        ptr_y= s->edge_emu_buffer;
2692
        if(!(s->flags&CODEC_FLAG_GRAY)){
2693
            uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
2694
            ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based, 
2695
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2696
            ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based, 
2697
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2698
            ptr_cb= uvbuf;
2699
            ptr_cr= uvbuf + 16;
2700
        }
2701
    }
2702

    
2703
    if(!field_based)
2704
        qpix_op[0][dxy](dest_y, ptr_y, linesize);
2705
    else{
2706
        if(bottom_field){
2707
            dest_y += s->linesize;
2708
            dest_cb+= s->uvlinesize;
2709
            dest_cr+= s->uvlinesize;
2710
        }
2711

    
2712
        if(field_select){
2713
            ptr_y  += s->linesize;
2714
            ptr_cb += s->uvlinesize;
2715
            ptr_cr += s->uvlinesize;
2716
        }
2717
        //damn interlaced mode
2718
        //FIXME boundary mirroring is not exactly correct here
2719
        qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
2720
        qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
2721
    }
2722
    if(!(s->flags&CODEC_FLAG_GRAY)){
2723
        pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
2724
        pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
2725
    }
2726
}
2727

    
2728
inline int ff_h263_round_chroma(int x){
2729
    if (x >= 0)
2730
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2731
    else {
2732
        x = -x;
2733
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2734
    }
2735
}
2736

    
2737
/**
2738
 * h263 chorma 4mv motion compensation.
2739
 */
2740
static inline void chroma_4mv_motion(MpegEncContext *s,
2741
                                     uint8_t *dest_cb, uint8_t *dest_cr,
2742
                                     uint8_t **ref_picture,
2743
                                     op_pixels_func *pix_op,
2744
                                     int mx, int my){
2745
    int dxy, emu=0, src_x, src_y, offset;
2746
    uint8_t *ptr;
2747
    
2748
    /* In case of 8X8, we construct a single chroma motion vector
2749
       with a special rounding */
2750
    mx= ff_h263_round_chroma(mx);
2751
    my= ff_h263_round_chroma(my);
2752
    
2753
    dxy = ((my & 1) << 1) | (mx & 1);
2754
    mx >>= 1;
2755
    my >>= 1;
2756

    
2757
    src_x = s->mb_x * 8 + mx;
2758
    src_y = s->mb_y * 8 + my;
2759
    src_x = clip(src_x, -8, s->width/2);
2760
    if (src_x == s->width/2)
2761
        dxy &= ~1;
2762
    src_y = clip(src_y, -8, s->height/2);
2763
    if (src_y == s->height/2)
2764
        dxy &= ~2;
2765
    
2766
    offset = (src_y * (s->uvlinesize)) + src_x;
2767
    ptr = ref_picture[1] + offset;
2768
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2769
        if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
2770
           || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
2771
            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);
2772
            ptr= s->edge_emu_buffer;
2773
            emu=1;
2774
        }
2775
    }
2776
    pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
2777

    
2778
    ptr = ref_picture[2] + offset;
2779
    if(emu){
2780
        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);
2781
        ptr= s->edge_emu_buffer;
2782
    }
2783
    pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
2784
}
2785

    
2786
/**
2787
 * motion compesation of a single macroblock
2788
 * @param s context
2789
 * @param dest_y luma destination pointer
2790
 * @param dest_cb chroma cb/u destination pointer
2791
 * @param dest_cr chroma cr/v destination pointer
2792
 * @param dir direction (0->forward, 1->backward)
2793
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2794
 * @param pic_op halfpel motion compensation function (average or put normally)
2795
 * @param pic_op qpel motion compensation function (average or put normally)
2796
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2797
 */
2798
static inline void MPV_motion(MpegEncContext *s, 
2799
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2800
                              int dir, uint8_t **ref_picture, 
2801
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
2802
{
2803
    int dxy, mx, my, src_x, src_y, motion_x, motion_y;
2804
    int mb_x, mb_y, i;
2805
    uint8_t *ptr, *dest;
2806

    
2807
    mb_x = s->mb_x;
2808
    mb_y = s->mb_y;
2809

    
2810
    if(s->obmc && s->pict_type != B_TYPE){
2811
        int16_t mv_cache[4][4][2];
2812
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
2813
        const int mot_stride= s->b8_stride;
2814
        const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
2815

    
2816
        assert(!s->mb_skiped);
2817
                
2818
        memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
2819
        memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2820
        memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2821

    
2822
        if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
2823
            memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
2824
        }else{
2825
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
2826
        }
2827

    
2828
        if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
2829
            *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
2830
            *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
2831
        }else{
2832
            *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
2833
            *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
2834
        }
2835

    
2836
        if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
2837
            *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
2838
            *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
2839
        }else{
2840
            *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
2841
            *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
2842
        }
2843
        
2844
        mx = 0;
2845
        my = 0;
2846
        for(i=0;i<4;i++) {
2847
            const int x= (i&1)+1;
2848
            const int y= (i>>1)+1;
2849
            int16_t mv[5][2]= {
2850
                {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
2851
                {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
2852
                {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
2853
                {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
2854
                {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
2855
            //FIXME cleanup
2856
            obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2857
                        ref_picture[0],
2858
                        mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2859
                        pix_op[1],
2860
                        mv);
2861

    
2862
            mx += mv[0][0];
2863
            my += mv[0][1];
2864
        }
2865
        if(!(s->flags&CODEC_FLAG_GRAY))
2866
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2867

    
2868
        return;
2869
    }
2870
   
2871
    switch(s->mv_type) {
2872
    case MV_TYPE_16X16:
2873
#ifdef CONFIG_RISKY
2874
        if(s->mcsel){
2875
            if(s->real_sprite_warping_points==1){
2876
                gmc1_motion(s, dest_y, dest_cb, dest_cr,
2877
                            ref_picture);
2878
            }else{
2879
                gmc_motion(s, dest_y, dest_cb, dest_cr,
2880
                            ref_picture);
2881
            }
2882
        }else if(s->quarter_sample){
2883
            qpel_motion(s, dest_y, dest_cb, dest_cr, 
2884
                        0, 0, 0,
2885
                        ref_picture, pix_op, qpix_op,
2886
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2887
        }else if(s->mspel){
2888
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
2889
                        ref_picture, pix_op,
2890
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2891
        }else
2892
#endif
2893
        {
2894
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 
2895
                        0, 0, 0,
2896
                        ref_picture, pix_op,
2897
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2898
        }           
2899
        break;
2900
    case MV_TYPE_8X8:
2901
        mx = 0;
2902
        my = 0;
2903
        if(s->quarter_sample){
2904
            for(i=0;i<4;i++) {
2905
                motion_x = s->mv[dir][i][0];
2906
                motion_y = s->mv[dir][i][1];
2907

    
2908
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2909
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
2910
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
2911
                    
2912
                /* WARNING: do no forget half pels */
2913
                src_x = clip(src_x, -16, s->width);
2914
                if (src_x == s->width)
2915
                    dxy &= ~3;
2916
                src_y = clip(src_y, -16, s->height);
2917
                if (src_y == s->height)
2918
                    dxy &= ~12;
2919
                    
2920
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2921
                if(s->flags&CODEC_FLAG_EMU_EDGE){
2922
                    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8 
2923
                       || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
2924
                        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);
2925
                        ptr= s->edge_emu_buffer;
2926
                    }
2927
                }
2928
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2929
                qpix_op[1][dxy](dest, ptr, s->linesize);
2930

    
2931
                mx += s->mv[dir][i][0]/2;
2932
                my += s->mv[dir][i][1]/2;
2933
            }
2934
        }else{
2935
            for(i=0;i<4;i++) {
2936
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2937
                            ref_picture[0], 0, 0,
2938
                            mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2939
                            s->width, s->height, s->linesize,
2940
                            s->h_edge_pos, s->v_edge_pos,
2941
                            8, 8, pix_op[1],
2942
                            s->mv[dir][i][0], s->mv[dir][i][1]);
2943

    
2944
                mx += s->mv[dir][i][0];
2945
                my += s->mv[dir][i][1];
2946
            }
2947
        }
2948

    
2949
        if(!(s->flags&CODEC_FLAG_GRAY))
2950
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2951
        break;
2952
    case MV_TYPE_FIELD:
2953
        if (s->picture_structure == PICT_FRAME) {
2954
            if(s->quarter_sample){
2955
                for(i=0; i<2; i++){
2956
                    qpel_motion(s, dest_y, dest_cb, dest_cr,
2957
                                1, i, s->field_select[dir][i],
2958
                                ref_picture, pix_op, qpix_op,
2959
                                s->mv[dir][i][0], s->mv[dir][i][1], 8);
2960
                }
2961
            }else{
2962
                /* top field */       
2963
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
2964
                            1, 0, s->field_select[dir][0],
2965
                            ref_picture, pix_op,
2966
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
2967
                /* bottom field */
2968
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
2969
                            1, 1, s->field_select[dir][1],
2970
                            ref_picture, pix_op,
2971
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
2972
            }
2973
        } else {
2974
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
2975
                ref_picture= s->current_picture_ptr->data;
2976
            } 
2977

    
2978
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
2979
                        0, 0, s->field_select[dir][0],
2980
                        ref_picture, pix_op,
2981
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2982
        }
2983
        break;
2984
    case MV_TYPE_16X8:
2985
        for(i=0; i<2; i++){
2986
            uint8_t ** ref2picture;
2987

    
2988
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
2989
                ref2picture= ref_picture;
2990
            }else{
2991
                ref2picture= s->current_picture_ptr->data;
2992
            } 
2993

    
2994
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 
2995
                        0, 0, s->field_select[dir][i],
2996
                        ref2picture, pix_op,
2997
                        s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
2998
                
2999
            dest_y += 16*s->linesize;
3000
            dest_cb+=  8*s->uvlinesize;
3001
            dest_cr+=  8*s->uvlinesize;
3002
        }        
3003
        break;
3004
    case MV_TYPE_DMV:
3005
        if(s->picture_structure == PICT_FRAME){
3006
            for(i=0; i<2; i++){
3007
                int j;
3008
                for(j=0; j<2; j++){
3009
                    mpeg_motion(s, dest_y, dest_cb, dest_cr,
3010
                                1, j, j^i,
3011
                                ref_picture, pix_op,
3012
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3013
                }
3014
                pix_op = s->dsp.avg_pixels_tab; 
3015
            }
3016
        }else{
3017
            for(i=0; i<2; i++){
3018
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3019
                            0, 0, s->picture_structure != i+1,
3020
                            ref_picture, pix_op,
3021
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3022

    
3023
                // after put we make avg of the same block
3024
                pix_op=s->dsp.avg_pixels_tab; 
3025

    
3026
                //opposite parity is always in the same frame if this is second field
3027
                if(!s->first_field){
3028
                    ref_picture = s->current_picture_ptr->data;    
3029
                }
3030
            }
3031
        }
3032
    break;
3033
    default: assert(0);
3034
    }
3035
}
3036

    
3037

    
3038
/* put block[] to dest[] */
3039
static inline void put_dct(MpegEncContext *s, 
3040
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3041
{
3042
    s->dct_unquantize_intra(s, block, i, qscale);
3043
    s->dsp.idct_put (dest, line_size, block);
3044
}
3045

    
3046
/* add block[] to dest[] */
3047
static inline void add_dct(MpegEncContext *s, 
3048
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
3049
{
3050
    if (s->block_last_index[i] >= 0) {
3051
        s->dsp.idct_add (dest, line_size, block);
3052
    }
3053
}
3054

    
3055
static inline void add_dequant_dct(MpegEncContext *s, 
3056
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3057
{
3058
    if (s->block_last_index[i] >= 0) {
3059
        s->dct_unquantize_inter(s, block, i, qscale);
3060

    
3061
        s->dsp.idct_add (dest, line_size, block);
3062
    }
3063
}
3064

    
3065
/**
3066
 * cleans dc, ac, coded_block for the current non intra MB
3067
 */
3068
void ff_clean_intra_table_entries(MpegEncContext *s)
3069
{
3070
    int wrap = s->b8_stride;
3071
    int xy = s->block_index[0];
3072
    
3073
    s->dc_val[0][xy           ] = 
3074
    s->dc_val[0][xy + 1       ] = 
3075
    s->dc_val[0][xy     + wrap] =
3076
    s->dc_val[0][xy + 1 + wrap] = 1024;
3077
    /* ac pred */
3078
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
3079
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3080
    if (s->msmpeg4_version>=3) {
3081
        s->coded_block[xy           ] =
3082
        s->coded_block[xy + 1       ] =
3083
        s->coded_block[xy     + wrap] =
3084
        s->coded_block[xy + 1 + wrap] = 0;
3085
    }
3086
    /* chroma */
3087
    wrap = s->mb_stride;
3088
    xy = s->mb_x + s->mb_y * wrap;
3089
    s->dc_val[1][xy] =
3090
    s->dc_val[2][xy] = 1024;
3091
    /* ac pred */
3092
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3093
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3094
    
3095
    s->mbintra_table[xy]= 0;
3096
}
3097

    
3098
/* generic function called after a macroblock has been parsed by the
3099
   decoder or after it has been encoded by the encoder.
3100

3101
   Important variables used:
3102
   s->mb_intra : true if intra macroblock
3103
   s->mv_dir   : motion vector direction
3104
   s->mv_type  : motion vector type
3105
   s->mv       : motion vector
3106
   s->interlaced_dct : true if interlaced dct used (mpeg2)
3107
 */
3108
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
3109
{
3110
    int mb_x, mb_y;
3111
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3112
#ifdef HAVE_XVMC
3113
    if(s->avctx->xvmc_acceleration){
3114
        XVMC_decode_mb(s);//xvmc uses pblocks
3115
        return;
3116
    }
3117
#endif
3118

    
3119
    mb_x = s->mb_x;
3120
    mb_y = s->mb_y;
3121

    
3122
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3123
       /* save DCT coefficients */
3124
       int i,j;
3125
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3126
       for(i=0; i<6; i++)
3127
           for(j=0; j<64; j++)
3128
               *dct++ = block[i][s->dsp.idct_permutation[j]];
3129
    }
3130

    
3131
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3132

    
3133
    /* update DC predictors for P macroblocks */
3134
    if (!s->mb_intra) {
3135
        if (s->h263_pred || s->h263_aic) {
3136
            if(s->mbintra_table[mb_xy])
3137
                ff_clean_intra_table_entries(s);
3138
        } else {
3139
            s->last_dc[0] =
3140
            s->last_dc[1] =
3141
            s->last_dc[2] = 128 << s->intra_dc_precision;
3142
        }
3143
    }
3144
    else if (s->h263_pred || s->h263_aic)
3145
        s->mbintra_table[mb_xy]=1;
3146

    
3147
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3148
        uint8_t *dest_y, *dest_cb, *dest_cr;
3149
        int dct_linesize, dct_offset;
3150
        op_pixels_func (*op_pix)[4];
3151
        qpel_mc_func (*op_qpix)[16];
3152
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3153
        const int uvlinesize= s->current_picture.linesize[1];
3154
        const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band;
3155

    
3156
        /* avoid copy if macroblock skipped in last frame too */
3157
        /* skip only during decoding as we might trash the buffers during encoding a bit */
3158
        if(!s->encoding){
3159
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3160
            const int age= s->current_picture.age;
3161

    
3162
            assert(age);
3163

    
3164
            if (s->mb_skiped) {
3165
                s->mb_skiped= 0;
3166
                assert(s->pict_type!=I_TYPE);
3167
 
3168
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
3169
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3170

    
3171
                /* if previous was skipped too, then nothing to do !  */
3172
                if (*mbskip_ptr >= age && s->current_picture.reference){
3173
                    return;
3174
                }
3175
            } else if(!s->current_picture.reference){
3176
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3177
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3178
            } else{
3179
                *mbskip_ptr = 0; /* not skipped */
3180
            }
3181
        }
3182

    
3183
        if (s->interlaced_dct) {
3184
            dct_linesize = linesize * 2;
3185
            dct_offset = linesize;
3186
        } else {
3187
            dct_linesize = linesize;
3188
            dct_offset = linesize * 8;
3189
        }
3190
        if(readable){
3191
            dest_y=  s->dest[0];
3192
            dest_cb= s->dest[1];
3193
            dest_cr= s->dest[2];
3194
        }else{
3195
            dest_y = s->b_scratchpad;
3196
            dest_cb= s->b_scratchpad+16*linesize;
3197
            dest_cr= s->b_scratchpad+16*linesize+8;
3198
        }
3199
        if (!s->mb_intra) {
3200
            /* motion handling */
3201
            /* decoding or more than one mb_type (MC was allready done otherwise) */
3202
            if(!s->encoding){
3203
                if ((!s->no_rounding) || s->pict_type==B_TYPE){                
3204
                    op_pix = s->dsp.put_pixels_tab;
3205
                    op_qpix= s->dsp.put_qpel_pixels_tab;
3206
                }else{
3207
                    op_pix = s->dsp.put_no_rnd_pixels_tab;
3208
                    op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3209
                }
3210

    
3211
                if (s->mv_dir & MV_DIR_FORWARD) {
3212
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3213
                    op_pix = s->dsp.avg_pixels_tab;
3214
                    op_qpix= s->dsp.avg_qpel_pixels_tab;
3215
                }
3216
                if (s->mv_dir & MV_DIR_BACKWARD) {
3217
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3218
                }
3219
            }
3220

    
3221
            /* skip dequant / idct if we are really late ;) */
3222
            if(s->hurry_up>1) return;
3223

    
3224
            /* add dct residue */
3225
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3226
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3227
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
3228
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
3229
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
3230
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
3231

    
3232
                if(!(s->flags&CODEC_FLAG_GRAY)){
3233
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3234
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3235
                }
3236
            } else if(s->codec_id != CODEC_ID_WMV2){
3237
                add_dct(s, block[0], 0, dest_y, dct_linesize);
3238
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
3239
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
3240
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
3241

    
3242
                if(!(s->flags&CODEC_FLAG_GRAY)){
3243
                    add_dct(s, block[4], 4, dest_cb, uvlinesize);
3244
                    add_dct(s, block[5], 5, dest_cr, uvlinesize);
3245
                }
3246
            } 
3247
#ifdef CONFIG_RISKY
3248
            else{
3249
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3250
            }
3251
#endif
3252
        } else {
3253
            /* dct only in intra block */
3254
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3255
                put_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
3256
                put_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
3257
                put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
3258
                put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
3259

    
3260
                if(!(s->flags&CODEC_FLAG_GRAY)){
3261
                    put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3262
                    put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3263
                }
3264
            }else{
3265
                s->dsp.idct_put(dest_y                 , dct_linesize, block[0]);
3266
                s->dsp.idct_put(dest_y              + 8, dct_linesize, block[1]);
3267
                s->dsp.idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
3268
                s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
3269

    
3270
                if(!(s->flags&CODEC_FLAG_GRAY)){
3271
                    s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3272
                    s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3273
                }
3274
            }
3275
        }
3276
        if(!readable){
3277
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3278
            s->dsp.put_pixels_tab[1][0](s->dest[1], dest_cb, uvlinesize, 8);
3279
            s->dsp.put_pixels_tab[1][0](s->dest[2], dest_cr, uvlinesize, 8);
3280
        }
3281
    }
3282
}
3283

    
3284
#ifdef CONFIG_ENCODERS
3285

    
3286
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3287
{
3288
    static const char tab[64]=
3289
        {3,2,2,1,1,1,1,1,
3290
         1,1,1,1,1,1,1,1,
3291
         1,1,1,1,1,1,1,1,
3292
         0,0,0,0,0,0,0,0,
3293
         0,0,0,0,0,0,0,0,
3294
         0,0,0,0,0,0,0,0,
3295
         0,0,0,0,0,0,0,0,
3296
         0,0,0,0,0,0,0,0};
3297
    int score=0;
3298
    int run=0;
3299
    int i;
3300
    DCTELEM *block= s->block[n];
3301
    const int last_index= s->block_last_index[n];
3302
    int skip_dc;
3303

    
3304
    if(threshold<0){
3305
        skip_dc=0;
3306
        threshold= -threshold;
3307
    }else
3308
        skip_dc=1;
3309

    
3310
    /* are all which we could set to zero are allready zero? */
3311
    if(last_index<=skip_dc - 1) return;
3312

    
3313
    for(i=0; i<=last_index; i++){
3314
        const int j = s->intra_scantable.permutated[i];
3315
        const int level = ABS(block[j]);
3316
        if(level==1){
3317
            if(skip_dc && i==0) continue;
3318
            score+= tab[run];
3319
            run=0;
3320
        }else if(level>1){
3321
            return;
3322
        }else{
3323
            run++;
3324
        }
3325
    }
3326
    if(score >= threshold) return;
3327
    for(i=skip_dc; i<=last_index; i++){
3328
        const int j = s->intra_scantable.permutated[i];
3329
        block[j]=0;
3330
    }
3331
    if(block[0]) s->block_last_index[n]= 0;
3332
    else         s->block_last_index[n]= -1;
3333
}
3334

    
3335
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
3336
{
3337
    int i;
3338
    const int maxlevel= s->max_qcoeff;
3339
    const int minlevel= s->min_qcoeff;
3340
    int overflow=0;
3341
    
3342
    if(s->mb_intra){
3343
        i=1; //skip clipping of intra dc
3344
    }else
3345
        i=0;
3346
    
3347
    for(;i<=last_index; i++){
3348
        const int j= s->intra_scantable.permutated[i];
3349
        int level = block[j];
3350
       
3351
        if     (level>maxlevel){
3352
            level=maxlevel;
3353
            overflow++;
3354
        }else if(level<minlevel){
3355
            level=minlevel;
3356
            overflow++;
3357
        }
3358
        
3359
        block[j]= level;
3360
    }
3361
    
3362
    if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
3363
        av_log(s->avctx, AV_LOG_INFO, "warning, cliping %d dct coefficents to %d..%d\n", overflow, minlevel, maxlevel);
3364
}
3365

    
3366
#endif //CONFIG_ENCODERS
3367

    
3368
/**
3369
 *
3370
 * @param h is the normal height, this will be reduced automatically if needed for the last row
3371
 */
3372
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3373
    if (s->avctx->draw_horiz_band) {
3374
        AVFrame *src;
3375
        int offset[4];
3376
        
3377
        if(s->picture_structure != PICT_FRAME){
3378
            h <<= 1;
3379
            y <<= 1;
3380
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3381
        }
3382

    
3383
        h= FFMIN(h, s->height - y);
3384

    
3385
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) 
3386
            src= (AVFrame*)s->current_picture_ptr;
3387
        else if(s->last_picture_ptr)
3388
            src= (AVFrame*)s->last_picture_ptr;
3389
        else
3390
            return;
3391
            
3392
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3393
            offset[0]=
3394
            offset[1]=
3395
            offset[2]=
3396
            offset[3]= 0;
3397
        }else{
3398
            offset[0]= y * s->linesize;;
3399
            offset[1]= 
3400
            offset[2]= (y>>1) * s->uvlinesize;;
3401
            offset[3]= 0;
3402
        }
3403

    
3404
        emms_c();
3405

    
3406
        s->avctx->draw_horiz_band(s->avctx, src, offset,
3407
                                  y, s->picture_structure, h);
3408
    }
3409
}
3410

    
3411
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3412
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3413
    const int uvlinesize= s->current_picture.linesize[1];
3414
        
3415
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
3416
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
3417
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
3418
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3419
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3420
    s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3421
    
3422
    if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){
3423
        s->dest[0] = s->current_picture.data[0] + s->mb_x * 16 - 16;
3424
        s->dest[1] = s->current_picture.data[1] + s->mb_x * 8 - 8;
3425
        s->dest[2] = s->current_picture.data[2] + s->mb_x * 8 - 8;
3426
    }else{
3427
        s->dest[0] = s->current_picture.data[0] + (s->mb_y * 16* linesize  ) + s->mb_x * 16 - 16;
3428
        s->dest[1] = s->current_picture.data[1] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
3429
        s->dest[2] = s->current_picture.data[2] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
3430
    }    
3431
}
3432

    
3433
#ifdef CONFIG_ENCODERS
3434

    
3435
static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
3436
    int x, y;
3437
//FIXME optimize
3438
    for(y=0; y<8; y++){
3439
        for(x=0; x<8; x++){
3440
            int x2, y2;
3441
            int sum=0;
3442
            int sqr=0;
3443
            int count=0;
3444

    
3445
            for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
3446
                for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
3447
                    int v= ptr[x2 + y2*stride];
3448
                    sum += v;
3449
                    sqr += v*v;
3450
                    count++;
3451
                }
3452
            }
3453
            weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
3454
        }
3455
    }
3456
}
3457

    
3458
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
3459
{
3460
    int16_t weight[6][64];
3461
    DCTELEM orig[6][64];
3462
    const int mb_x= s->mb_x;
3463
    const int mb_y= s->mb_y;
3464
    int i;
3465
    int skip_dct[6];
3466
    int dct_offset   = s->linesize*8; //default for progressive frames
3467
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3468
    int wrap_y, wrap_c;
3469
    
3470
    for(i=0; i<6; i++) skip_dct[i]=0;
3471
    
3472
    if(s->adaptive_quant){
3473
        const int last_qp= s->qscale;
3474
        const int mb_xy= mb_x + mb_y*s->mb_stride;
3475

    
3476
        s->lambda= s->lambda_table[mb_xy];
3477
        update_qscale(s);
3478
    
3479
        if(!(s->flags&CODEC_FLAG_QP_RD)){
3480
            s->dquant= s->qscale - last_qp;
3481

    
3482
            if(s->out_format==FMT_H263){
3483
                s->dquant= clip(s->dquant, -2, 2); //FIXME RD
3484
            
3485
                if(s->codec_id==CODEC_ID_MPEG4){        
3486
                    if(!s->mb_intra){
3487
                        if(s->pict_type == B_TYPE){
3488
                            if(s->dquant&1) 
3489
                                s->dquant= (s->dquant/2)*2;
3490
                            if(s->mv_dir&MV_DIRECT)
3491
                                s->dquant= 0;
3492
                        }
3493
                        if(s->mv_type==MV_TYPE_8X8)
3494
                            s->dquant=0;
3495
                    }
3496
                }
3497
            }
3498
        }
3499
        ff_set_qscale(s, last_qp + s->dquant);
3500
    }else if(s->flags&CODEC_FLAG_QP_RD)
3501
        ff_set_qscale(s, s->qscale + s->dquant);
3502

    
3503
    wrap_y = s->linesize;
3504
    wrap_c = s->uvlinesize;
3505
    ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
3506
    ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
3507
    ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3508

    
3509
    if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
3510
        ff_emulated_edge_mc(s->edge_emu_buffer            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
3511
        ptr_y= s->edge_emu_buffer;
3512
        ff_emulated_edge_mc(s->edge_emu_buffer+18*wrap_y  , ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3513
        ptr_cb= s->edge_emu_buffer+18*wrap_y;
3514
        ff_emulated_edge_mc(s->edge_emu_buffer+18*wrap_y+9, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3515
        ptr_cr= s->edge_emu_buffer+18*wrap_y+9;
3516
    }
3517

    
3518
    if (s->mb_intra) {
3519
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3520
            int progressive_score, interlaced_score;
3521

    
3522
            s->interlaced_dct=0;
3523
            progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8) 
3524
                              +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
3525

    
3526
            if(progressive_score > 0){
3527
                interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8) 
3528
                                  +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
3529
                if(progressive_score > interlaced_score){
3530
                    s->interlaced_dct=1;
3531
            
3532
                    dct_offset= wrap_y;
3533
                    wrap_y<<=1;
3534
                }
3535
            }
3536
        }
3537
        
3538
        s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
3539
        s->dsp.get_pixels(s->block[1], ptr_y              + 8, wrap_y);
3540
        s->dsp.get_pixels(s->block[2], ptr_y + dct_offset    , wrap_y);
3541
        s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
3542

    
3543
        if(s->flags&CODEC_FLAG_GRAY){
3544
            skip_dct[4]= 1;
3545
            skip_dct[5]= 1;
3546
        }else{
3547
            s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
3548
            s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
3549
        }
3550
    }else{
3551
        op_pixels_func (*op_pix)[4];
3552
        qpel_mc_func (*op_qpix)[16];
3553
        uint8_t *dest_y, *dest_cb, *dest_cr;
3554

    
3555
        dest_y  = s->dest[0];
3556
        dest_cb = s->dest[1];
3557
        dest_cr = s->dest[2];
3558

    
3559
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
3560
            op_pix = s->dsp.put_pixels_tab;
3561
            op_qpix= s->dsp.put_qpel_pixels_tab;
3562
        }else{
3563
            op_pix = s->dsp.put_no_rnd_pixels_tab;
3564
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3565
        }
3566

    
3567
        if (s->mv_dir & MV_DIR_FORWARD) {
3568
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3569
            op_pix = s->dsp.avg_pixels_tab;
3570
            op_qpix= s->dsp.avg_qpel_pixels_tab;
3571
        }
3572
        if (s->mv_dir & MV_DIR_BACKWARD) {
3573
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3574
        }
3575

    
3576
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3577
            int progressive_score, interlaced_score;
3578

    
3579
            s->interlaced_dct=0;
3580
            progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8) 
3581
                              +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
3582
            
3583
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
3584

    
3585
            if(progressive_score>0){
3586
                interlaced_score = s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y*2, 8) 
3587
                                  +s->dsp.ildct_cmp[0](s, dest_y + wrap_y  , ptr_y + wrap_y  , wrap_y*2, 8);
3588
            
3589
                if(progressive_score > interlaced_score){
3590
                    s->interlaced_dct=1;
3591
            
3592
                    dct_offset= wrap_y;
3593
                    wrap_y<<=1;
3594
                }
3595
            }
3596
        }
3597
        
3598
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
3599
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
3600
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
3601
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
3602
        
3603
        if(s->flags&CODEC_FLAG_GRAY){
3604
            skip_dct[4]= 1;
3605
            skip_dct[5]= 1;
3606
        }else{
3607
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
3608
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
3609
        }
3610
        /* pre quantization */         
3611
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
3612
            //FIXME optimize
3613
            if(s->dsp.sad[1](NULL, ptr_y               , dest_y               , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
3614
            if(s->dsp.sad[1](NULL, ptr_y            + 8, dest_y            + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
3615
            if(s->dsp.sad[1](NULL, ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
3616
            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;
3617
            if(s->dsp.sad[1](NULL, ptr_cb              , dest_cb              , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
3618
            if(s->dsp.sad[1](NULL, ptr_cr              , dest_cr              , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
3619
        }
3620
    }
3621

    
3622
    if(s->avctx->quantizer_noise_shaping){
3623
        if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y                 , wrap_y);
3624
        if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y              + 8, wrap_y);
3625
        if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset    , wrap_y);
3626
        if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
3627
        if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb                , wrap_c);
3628
        if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr                , wrap_c);
3629
        memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*6);
3630
    }
3631
            
3632
    /* DCT & quantize */
3633
    assert(s->out_format!=FMT_MJPEG || s->qscale==8);
3634
    {
3635
        for(i=0;i<6;i++) {
3636
            if(!skip_dct[i]){
3637
                int overflow;
3638
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
3639
            // FIXME we could decide to change to quantizer instead of clipping
3640
            // JS: I don't think that would be a good idea it could lower quality instead
3641
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
3642
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
3643
            }else
3644
                s->block_last_index[i]= -1;
3645
        }
3646
        if(s->avctx->quantizer_noise_shaping){
3647
            for(i=0;i<6;i++) {
3648
                if(!skip_dct[i]){
3649
                    s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
3650
                }
3651
            }
3652
        }
3653
        
3654
        if(s->luma_elim_threshold && !s->mb_intra)
3655
            for(i=0; i<4; i++)
3656
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
3657
        if(s->chroma_elim_threshold && !s->mb_intra)
3658
            for(i=4; i<6; i++)
3659
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
3660

    
3661
        if(s->flags & CODEC_FLAG_CBP_RD){
3662
            for(i=0;i<6;i++) {
3663
                if(s->block_last_index[i] == -1)
3664
                    s->coded_score[i]= INT_MAX/256;
3665
            }
3666
        }
3667
    }
3668

    
3669
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
3670
        s->block_last_index[4]=
3671
        s->block_last_index[5]= 0;
3672
        s->block[4][0]=
3673
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
3674
    }
3675

    
3676
    //non c quantize code returns incorrect block_last_index FIXME
3677
    if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
3678
        for(i=0; i<6; i++){
3679
            int j;
3680
            if(s->block_last_index[i]>0){
3681
                for(j=63; j>0; j--){
3682
                    if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
3683
                }
3684
                s->block_last_index[i]= j;
3685
            }
3686
        }
3687
    }
3688

    
3689
    /* huffman encode */
3690
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
3691
    case CODEC_ID_MPEG1VIDEO:
3692
    case CODEC_ID_MPEG2VIDEO:
3693
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
3694
#ifdef CONFIG_RISKY
3695
    case CODEC_ID_MPEG4:
3696
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3697
    case CODEC_ID_MSMPEG4V2:
3698
    case CODEC_ID_MSMPEG4V3:
3699
    case CODEC_ID_WMV1:
3700
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3701
    case CODEC_ID_WMV2:
3702
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
3703
    case CODEC_ID_H263:
3704
    case CODEC_ID_H263P:
3705
    case CODEC_ID_FLV1:
3706
    case CODEC_ID_RV10:
3707
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
3708
#endif
3709
    case CODEC_ID_MJPEG:
3710
        mjpeg_encode_mb(s, s->block); break;
3711
    default:
3712
        assert(0);
3713
    }
3714
}
3715

    
3716
#endif //CONFIG_ENCODERS
3717

    
3718
void ff_mpeg_flush(AVCodecContext *avctx){
3719
    int i;
3720
    MpegEncContext *s = avctx->priv_data;
3721
    
3722
    if(s==NULL || s->picture==NULL) 
3723
        return;
3724
    
3725
    for(i=0; i<MAX_PICTURE_COUNT; i++){
3726
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
3727
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
3728
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
3729
    }
3730
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
3731
    
3732
    s->parse_context.state= -1;
3733
    s->parse_context.frame_start_found= 0;
3734
    s->parse_context.overread= 0;
3735
    s->parse_context.overread_index= 0;
3736
    s->parse_context.index= 0;
3737
    s->parse_context.last_index= 0;
3738
    s->bitstream_buffer_size=0;
3739
}
3740

    
3741
#ifdef CONFIG_ENCODERS
3742
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
3743
{
3744
    const uint16_t *srcw= (uint16_t*)src;
3745
    int words= length>>4;
3746
    int bits= length&15;
3747
    int i;
3748

    
3749
    if(length==0) return;
3750
    
3751
    if(words < 16){
3752
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
3753
    }else if(put_bits_count(pb)&7){
3754
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
3755
    }else{
3756
        for(i=0; put_bits_count(pb)&31; i++)
3757
            put_bits(pb, 8, src[i]);
3758
        flush_put_bits(pb);
3759
        memcpy(pbBufPtr(pb), src+i, 2*words-i);
3760
        skip_put_bytes(pb, 2*words-i);
3761
    }
3762
        
3763
    put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
3764
}
3765

    
3766
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
3767
    int i;
3768

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

    
3771
    /* mpeg1 */
3772
    d->mb_skip_run= s->mb_skip_run;
3773
    for(i=0; i<3; i++)
3774
        d->last_dc[i]= s->last_dc[i];
3775
    
3776
    /* statistics */
3777
    d->mv_bits= s->mv_bits;
3778
    d->i_tex_bits= s->i_tex_bits;
3779
    d->p_tex_bits= s->p_tex_bits;
3780
    d->i_count= s->i_count;
3781
    d->f_count= s->f_count;
3782
    d->b_count= s->b_count;
3783
    d->skip_count= s->skip_count;
3784
    d->misc_bits= s->misc_bits;
3785
    d->last_bits= 0;
3786

    
3787
    d->mb_skiped= 0;
3788
    d->qscale= s->qscale;
3789
    d->dquant= s->dquant;
3790
}
3791

    
3792
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
3793
    int i;
3794

    
3795
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
3796
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
3797
    
3798
    /* mpeg1 */
3799
    d->mb_skip_run= s->mb_skip_run;
3800
    for(i=0; i<3; i++)
3801
        d->last_dc[i]= s->last_dc[i];
3802
    
3803
    /* statistics */
3804
    d->mv_bits= s->mv_bits;
3805
    d->i_tex_bits= s->i_tex_bits;
3806
    d->p_tex_bits= s->p_tex_bits;
3807
    d->i_count= s->i_count;
3808
    d->f_count= s->f_count;
3809
    d->b_count= s->b_count;
3810
    d->skip_count= s->skip_count;
3811
    d->misc_bits= s->misc_bits;
3812

    
3813
    d->mb_intra= s->mb_intra;
3814
    d->mb_skiped= s->mb_skiped;
3815
    d->mv_type= s->mv_type;
3816
    d->mv_dir= s->mv_dir;
3817
    d->pb= s->pb;
3818
    if(s->data_partitioning){
3819
        d->pb2= s->pb2;
3820
        d->tex_pb= s->tex_pb;
3821
    }
3822
    d->block= s->block;
3823
    for(i=0; i<6; i++)
3824
        d->block_last_index[i]= s->block_last_index[i];
3825
    d->interlaced_dct= s->interlaced_dct;
3826
    d->qscale= s->qscale;
3827
}
3828

    
3829
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
3830
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
3831
                           int *dmin, int *next_block, int motion_x, int motion_y)
3832
{
3833
    int score;
3834
    uint8_t *dest_backup[3];
3835
    
3836
    copy_context_before_encode(s, backup, type);
3837

    
3838
    s->block= s->blocks[*next_block];
3839
    s->pb= pb[*next_block];
3840
    if(s->data_partitioning){
3841
        s->pb2   = pb2   [*next_block];
3842
        s->tex_pb= tex_pb[*next_block];
3843
    }
3844
    
3845
    if(*next_block){
3846
        memcpy(dest_backup, s->dest, sizeof(s->dest));
3847
        s->dest[0] = s->rd_scratchpad;
3848
        s->dest[1] = s->rd_scratchpad + 16*s->linesize;
3849
        s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
3850
        assert(s->linesize >= 32); //FIXME
3851
    }
3852

    
3853
    encode_mb(s, motion_x, motion_y);
3854
    
3855
    score= put_bits_count(&s->pb);
3856
    if(s->data_partitioning){
3857
        score+= put_bits_count(&s->pb2);
3858
        score+= put_bits_count(&s->tex_pb);
3859
    }
3860
   
3861
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
3862
        MPV_decode_mb(s, s->block);
3863

    
3864
        score *= s->lambda2;
3865
        score += sse_mb(s) << FF_LAMBDA_SHIFT;
3866
    }
3867
    
3868
    if(*next_block){
3869
        memcpy(s->dest, dest_backup, sizeof(s->dest));
3870
    }
3871

    
3872
    if(score<*dmin){
3873
        *dmin= score;
3874
        *next_block^=1;
3875

    
3876
        copy_context_after_encode(best, s, type);
3877
    }
3878
}
3879
                
3880
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
3881
    uint32_t *sq = squareTbl + 256;
3882
    int acc=0;
3883
    int x,y;
3884
    
3885
    if(w==16 && h==16) 
3886
        return s->dsp.sse[0](NULL, src1, src2, stride, 16);
3887
    else if(w==8 && h==8)
3888
        return s->dsp.sse[1](NULL, src1, src2, stride, 8);
3889
    
3890
    for(y=0; y<h; y++){
3891
        for(x=0; x<w; x++){
3892
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
3893
        } 
3894
    }
3895
    
3896
    assert(acc>=0);
3897
    
3898
    return acc;
3899
}
3900

    
3901
static int sse_mb(MpegEncContext *s){
3902
    int w= 16;
3903
    int h= 16;
3904

    
3905
    if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3906
    if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3907

    
3908
    if(w==16 && h==16)
3909
        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)
3910
               +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)
3911
               +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);
3912
    else
3913
        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)
3914
               +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)
3915
               +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);
3916
}
3917

    
3918
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
3919
    MpegEncContext *s= arg;
3920

    
3921
    
3922
    s->me.pre_pass=1;
3923
    s->me.dia_size= s->avctx->pre_dia_size;
3924
    s->first_slice_line=1;
3925
    for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
3926
        for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
3927
            ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
3928
        }
3929
        s->first_slice_line=0;
3930
    }
3931
    
3932
    s->me.pre_pass=0;
3933
    
3934
    return 0;
3935
}
3936

    
3937
static int estimate_motion_thread(AVCodecContext *c, void *arg){
3938
    MpegEncContext *s= arg;
3939

    
3940
    s->me.dia_size= s->avctx->dia_size;
3941
    s->first_slice_line=1;
3942
    for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
3943
        s->mb_x=0; //for block init below
3944
        ff_init_block_index(s);
3945
        for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
3946
            s->block_index[0]+=2;
3947
            s->block_index[1]+=2;
3948
            s->block_index[2]+=2;
3949
            s->block_index[3]+=2;
3950
            
3951
            /* compute motion vector & mb_type and store in context */
3952
            if(s->pict_type==B_TYPE)
3953
                ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
3954
            else
3955
                ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
3956
        }
3957
        s->first_slice_line=0;
3958
    }
3959
    return 0;
3960
}
3961

    
3962
static int mb_var_thread(AVCodecContext *c, void *arg){
3963
    MpegEncContext *s= arg;
3964
    int mb_x, mb_y;
3965

    
3966
    for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
3967
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3968
            int xx = mb_x * 16;
3969
            int yy = mb_y * 16;
3970
            uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
3971
            int varc;
3972
            int sum = s->dsp.pix_sum(pix, s->linesize);
3973
    
3974
            varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
3975

    
3976
            s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
3977
            s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
3978
            s->me.mb_var_sum_temp    += varc;
3979
        }
3980
    }
3981
    return 0;
3982
}
3983

    
3984
static void write_slice_end(MpegEncContext *s){
3985
    if(s->codec_id==CODEC_ID_MPEG4){
3986
        if(s->partitioned_frame){
3987
            ff_mpeg4_merge_partitions(s);
3988
        }
3989
    
3990
        ff_mpeg4_stuffing(&s->pb);
3991
    }else if(s->out_format == FMT_MJPEG){
3992
        ff_mjpeg_stuffing(&s->pb);
3993
    }
3994

    
3995
    align_put_bits(&s->pb);
3996
    flush_put_bits(&s->pb);
3997
}
3998

    
3999
static int encode_thread(AVCodecContext *c, void *arg){
4000
    MpegEncContext *s= arg;
4001
    int mb_x, mb_y, pdif = 0;
4002
    int i, j;
4003
    MpegEncContext best_s, backup_s;
4004
    uint8_t bit_buf[2][3000];
4005
    uint8_t bit_buf2[2][3000];
4006
    uint8_t bit_buf_tex[2][3000];
4007
    PutBitContext pb[2], pb2[2], tex_pb[2];
4008
//printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4009

    
4010
    for(i=0; i<2; i++){
4011
        init_put_bits(&pb    [i], bit_buf    [i], 3000);
4012
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000);
4013
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000);
4014
    }
4015

    
4016
    s->last_bits= put_bits_count(&s->pb);
4017
    s->mv_bits=0;
4018
    s->misc_bits=0;
4019
    s->i_tex_bits=0;
4020
    s->p_tex_bits=0;
4021
    s->i_count=0;
4022
    s->f_count=0;
4023
    s->b_count=0;
4024
    s->skip_count=0;
4025

    
4026
    for(i=0; i<3; i++){
4027
        /* init last dc values */
4028
        /* note: quant matrix value (8) is implied here */
4029
        s->last_dc[i] = 128 << s->intra_dc_precision;
4030
        
4031
        s->current_picture_ptr->error[i] = 0;
4032
    }
4033
    s->mb_skip_run = 0;
4034
    memset(s->last_mv, 0, sizeof(s->last_mv));
4035
     
4036
    s->last_mv_dir = 0;
4037

    
4038
#ifdef CONFIG_RISKY
4039
    switch(s->codec_id){
4040
    case CODEC_ID_H263:
4041
    case CODEC_ID_H263P:
4042
    case CODEC_ID_FLV1:
4043
        s->gob_index = ff_h263_get_gob_height(s);
4044
        break;
4045
    case CODEC_ID_MPEG4:
4046
        if(s->partitioned_frame)
4047
            ff_mpeg4_init_partitions(s);
4048
        break;
4049
    }
4050
#endif
4051

    
4052
    s->resync_mb_x=0;
4053
    s->resync_mb_y=0; 
4054
    s->first_slice_line = 1;
4055
    s->ptr_lastgob = s->pb.buf;
4056
    for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4057
//    printf("row %d at %X\n", s->mb_y, (int)s);
4058
        s->mb_x=0;
4059
        s->mb_y= mb_y;
4060

    
4061
        ff_set_qscale(s, s->qscale);
4062
        ff_init_block_index(s);
4063
        
4064
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4065
            const int xy= mb_y*s->mb_stride + mb_x;
4066
            int mb_type= s->mb_type[xy];
4067
//            int d;
4068
            int dmin= INT_MAX;
4069
            int dir;
4070

    
4071
            s->mb_x = mb_x;
4072
            ff_update_block_index(s);
4073

    
4074
            /* write gob / video packet header  */
4075
#ifdef CONFIG_RISKY
4076
            if(s->rtp_mode){
4077
                int current_packet_size, is_gob_start;
4078
                
4079
                current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
4080
                
4081
                is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0; 
4082
                
4083
                if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
4084
                
4085
                switch(s->codec_id){
4086
                case CODEC_ID_H263:
4087
                case CODEC_ID_H263P:
4088
                    if(!s->h263_slice_structured)
4089
                        if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
4090
                    break;
4091
                case CODEC_ID_MPEG2VIDEO:
4092
                    if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
4093
                case CODEC_ID_MPEG1VIDEO:
4094
                    if(s->mb_skip_run) is_gob_start=0;
4095
                    break;
4096
                }
4097

    
4098
                if(is_gob_start){
4099
                    if(s->start_mb_y != mb_y || mb_x!=0){
4100
                        write_slice_end(s);
4101

    
4102
                        if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
4103
                            ff_mpeg4_init_partitions(s);
4104
                        }
4105
                    }
4106
                
4107
                    assert((put_bits_count(&s->pb)&7) == 0);
4108
                    current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4109
                    
4110
                    if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
4111
                        int r= put_bits_count(&s->pb)/8 + s->picture_number + s->codec_id + s->mb_x + s->mb_y;
4112
                        int d= 100 / s->avctx->error_rate;
4113
                        if(r % d == 0){
4114
                            current_packet_size=0;
4115
#ifndef ALT_BITSTREAM_WRITER
4116
                            s->pb.buf_ptr= s->ptr_lastgob;
4117
#endif
4118
                            assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
4119
                        }
4120
                    }
4121
        
4122
                    if (s->avctx->rtp_callback)
4123
                        s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, 0);
4124
                    
4125
                    switch(s->codec_id){
4126
                    case CODEC_ID_MPEG4:
4127
                        ff_mpeg4_encode_video_packet_header(s);
4128
                        ff_mpeg4_clean_buffers(s);
4129
                    break;
4130
                    case CODEC_ID_MPEG1VIDEO:
4131
                    case CODEC_ID_MPEG2VIDEO:
4132
                        ff_mpeg1_encode_slice_header(s);
4133
                        ff_mpeg1_clean_buffers(s);
4134
                    break;
4135
                    case CODEC_ID_H263:
4136
                    case CODEC_ID_H263P:
4137
                        h263_encode_gob_header(s, mb_y);                       
4138
                    break;
4139
                    }
4140

    
4141
                    if(s->flags&CODEC_FLAG_PASS1){
4142
                        int bits= put_bits_count(&s->pb);
4143
                        s->misc_bits+= bits - s->last_bits;
4144
                        s->last_bits= bits;
4145
                    }
4146
    
4147
                    s->ptr_lastgob += current_packet_size;
4148
                    s->first_slice_line=1;
4149
                    s->resync_mb_x=mb_x;
4150
                    s->resync_mb_y=mb_y;
4151
                }
4152
            }
4153
#endif
4154

    
4155
            if(  (s->resync_mb_x   == s->mb_x)
4156
               && s->resync_mb_y+1 == s->mb_y){
4157
                s->first_slice_line=0; 
4158
            }
4159

    
4160
            s->mb_skiped=0;
4161
            s->dquant=0; //only for QP_RD
4162

    
4163
            if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible
4164
                int next_block=0;
4165
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
4166

    
4167
                copy_context_before_encode(&backup_s, s, -1);
4168
                backup_s.pb= s->pb;
4169
                best_s.data_partitioning= s->data_partitioning;
4170
                best_s.partitioned_frame= s->partitioned_frame;
4171
                if(s->data_partitioning){
4172
                    backup_s.pb2= s->pb2;
4173
                    backup_s.tex_pb= s->tex_pb;
4174
                }
4175

    
4176
                if(mb_type&CANDIDATE_MB_TYPE_INTER){
4177
                    s->mv_dir = MV_DIR_FORWARD;
4178
                    s->mv_type = MV_TYPE_16X16;
4179
                    s->mb_intra= 0;
4180
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
4181
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
4182
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb, 
4183
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4184
                }
4185
                if(mb_type&CANDIDATE_MB_TYPE_INTER_I){ 
4186
                    s->mv_dir = MV_DIR_FORWARD;
4187
                    s->mv_type = MV_TYPE_FIELD;
4188
                    s->mb_intra= 0;
4189
                    for(i=0; i<2; i++){
4190
                        j= s->field_select[0][i] = s->p_field_select_table[i][xy];
4191
                        s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
4192
                        s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
4193
                    }
4194
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb, 
4195
                                 &dmin, &next_block, 0, 0);
4196
                }
4197
                if(mb_type&CANDIDATE_MB_TYPE_SKIPED){
4198
                    s->mv_dir = MV_DIR_FORWARD;
4199
                    s->mv_type = MV_TYPE_16X16;
4200
                    s->mb_intra= 0;
4201
                    s->mv[0][0][0] = 0;
4202
                    s->mv[0][0][1] = 0;
4203
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPED, pb, pb2, tex_pb, 
4204
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4205
                }
4206
                if(mb_type&CANDIDATE_MB_TYPE_INTER4V){                 
4207
                    s->mv_dir = MV_DIR_FORWARD;
4208
                    s->mv_type = MV_TYPE_8X8;
4209
                    s->mb_intra= 0;
4210
                    for(i=0; i<4; i++){
4211
                        s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
4212
                        s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
4213
                    }
4214
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb, 
4215
                                 &dmin, &next_block, 0, 0);
4216
                }
4217
                if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
4218
                    s->mv_dir = MV_DIR_FORWARD;
4219
                    s->mv_type = MV_TYPE_16X16;
4220
                    s->mb_intra= 0;
4221
                    s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
4222
                    s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
4223
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb, 
4224
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4225
                }
4226
                if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
4227
                    s->mv_dir = MV_DIR_BACKWARD;
4228
                    s->mv_type = MV_TYPE_16X16;
4229
                    s->mb_intra= 0;
4230
                    s->mv[1][0][0] = s->b_back_mv_table[xy][0];
4231
                    s->mv[1][0][1] = s->b_back_mv_table[xy][1];
4232
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb, 
4233
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
4234
                }
4235
                if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
4236
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4237
                    s->mv_type = MV_TYPE_16X16;
4238
                    s->mb_intra= 0;
4239
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
4240
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
4241
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
4242
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
4243
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb, 
4244
                                 &dmin, &next_block, 0, 0);
4245
                }
4246
                if(mb_type&CANDIDATE_MB_TYPE_DIRECT){
4247
                    int mx= s->b_direct_mv_table[xy][0];
4248
                    int my= s->b_direct_mv_table[xy][1];
4249
                    
4250
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4251
                    s->mb_intra= 0;
4252
#ifdef CONFIG_RISKY
4253
                    ff_mpeg4_set_direct_mv(s, mx, my);
4254
#endif
4255
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb, 
4256
                                 &dmin, &next_block, mx, my);
4257
                }
4258
                if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){ 
4259
                    s->mv_dir = MV_DIR_FORWARD;
4260
                    s->mv_type = MV_TYPE_FIELD;
4261
                    s->mb_intra= 0;
4262
                    for(i=0; i<2; i++){
4263
                        j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
4264
                        s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
4265
                        s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
4266
                    }
4267
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb, 
4268
                                 &dmin, &next_block, 0, 0);
4269
                }
4270
                if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){ 
4271
                    s->mv_dir = MV_DIR_BACKWARD;
4272
                    s->mv_type = MV_TYPE_FIELD;
4273
                    s->mb_intra= 0;
4274
                    for(i=0; i<2; i++){
4275
                        j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
4276
                        s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
4277
                        s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
4278
                    }
4279
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb, 
4280
                                 &dmin, &next_block, 0, 0);
4281
                }
4282
                if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){ 
4283
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4284
                    s->mv_type = MV_TYPE_FIELD;
4285
                    s->mb_intra= 0;
4286
                    for(dir=0; dir<2; dir++){
4287
                        for(i=0; i<2; i++){
4288
                            j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
4289
                            s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
4290
                            s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
4291
                        }
4292
                    }
4293
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb, 
4294
                                 &dmin, &next_block, 0, 0);
4295
                }
4296
                if(mb_type&CANDIDATE_MB_TYPE_INTRA){
4297
                    s->mv_dir = 0;
4298
                    s->mv_type = MV_TYPE_16X16;
4299
                    s->mb_intra= 1;
4300
                    s->mv[0][0][0] = 0;
4301
                    s->mv[0][0][1] = 0;
4302
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb, 
4303
                                 &dmin, &next_block, 0, 0);
4304
                    if(s->h263_pred || s->h263_aic){
4305
                        if(best_s.mb_intra)
4306
                            s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
4307
                        else
4308
                            ff_clean_intra_table_entries(s); //old mode?
4309
                    }
4310
                }
4311

    
4312
                if(s->flags & CODEC_FLAG_QP_RD){
4313
                    if(best_s.mv_type==MV_TYPE_16X16 && !(best_s.mv_dir&MV_DIRECT)){
4314
                        const int last_qp= backup_s.qscale;
4315
                        int dquant, dir, qp, dc[6];
4316
                        DCTELEM ac[6][16];
4317
                        const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
4318
                        
4319
                        assert(backup_s.dquant == 0);
4320

    
4321
                        //FIXME intra
4322
                        s->mv_dir= best_s.mv_dir;
4323
                        s->mv_type = MV_TYPE_16X16;
4324
                        s->mb_intra= best_s.mb_intra;
4325
                        s->mv[0][0][0] = best_s.mv[0][0][0];
4326
                        s->mv[0][0][1] = best_s.mv[0][0][1];
4327
                        s->mv[1][0][0] = best_s.mv[1][0][0];
4328
                        s->mv[1][0][1] = best_s.mv[1][0][1];
4329
                        
4330
                        dir= s->pict_type == B_TYPE ? 2 : 1;
4331
                        if(last_qp + dir > s->avctx->qmax) dir= -dir;
4332
                        for(dquant= dir; dquant<=2 && dquant>=-2; dquant += dir){
4333
                            qp= last_qp + dquant;
4334
                            if(qp < s->avctx->qmin || qp > s->avctx->qmax)
4335
                                break;
4336
                            backup_s.dquant= dquant;
4337
                            if(s->mb_intra){
4338
                                for(i=0; i<6; i++){
4339
                                    dc[i]= s->dc_val[0][ s->block_index[i] ];
4340
                                    memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
4341
                                }
4342
                            }
4343

    
4344
                            encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb, 
4345
                                         &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
4346
                            if(best_s.qscale != qp){
4347
                                if(s->mb_intra){
4348
                                    for(i=0; i<6; i++){
4349
                                        s->dc_val[0][ s->block_index[i] ]= dc[i];
4350
                                        memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
4351
                                    }
4352
                                }
4353
                                if(dir > 0 && dquant==dir){
4354
                                    dquant= 0;
4355
                                    dir= -dir;
4356
                                }else
4357
                                    break;
4358
                            }
4359
                        }
4360
                        qp= best_s.qscale;
4361
                        s->current_picture.qscale_table[xy]= qp;
4362
                    }
4363
                }
4364

    
4365
                copy_context_after_encode(s, &best_s, -1);
4366
                
4367
                pb_bits_count= put_bits_count(&s->pb);
4368
                flush_put_bits(&s->pb);
4369
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
4370
                s->pb= backup_s.pb;
4371
                
4372
                if(s->data_partitioning){
4373
                    pb2_bits_count= put_bits_count(&s->pb2);
4374
                    flush_put_bits(&s->pb2);
4375
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
4376
                    s->pb2= backup_s.pb2;
4377
                    
4378
                    tex_pb_bits_count= put_bits_count(&s->tex_pb);
4379
                    flush_put_bits(&s->tex_pb);
4380
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
4381
                    s->tex_pb= backup_s.tex_pb;
4382
                }
4383
                s->last_bits= put_bits_count(&s->pb);
4384
               
4385
#ifdef CONFIG_RISKY
4386
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4387
                    ff_h263_update_motion_val(s);
4388
#endif
4389
        
4390
                if(next_block==0){ //FIXME 16 vs linesize16
4391
                    s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad                     , s->linesize  ,16);
4392
                    s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize    , s->uvlinesize, 8);
4393
                    s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
4394
                }
4395

    
4396
                if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
4397
                    MPV_decode_mb(s, s->block);
4398
            } else {
4399
                int motion_x, motion_y;
4400
                s->mv_type=MV_TYPE_16X16;
4401
                // only one MB-Type possible
4402
                
4403
                switch(mb_type){
4404
                case CANDIDATE_MB_TYPE_INTRA:
4405
                    s->mv_dir = 0;
4406
                    s->mb_intra= 1;
4407
                    motion_x= s->mv[0][0][0] = 0;
4408
                    motion_y= s->mv[0][0][1] = 0;
4409
                    break;
4410
                case CANDIDATE_MB_TYPE_INTER:
4411
                    s->mv_dir = MV_DIR_FORWARD;
4412
                    s->mb_intra= 0;
4413
                    motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
4414
                    motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
4415
                    break;
4416
                case CANDIDATE_MB_TYPE_INTER_I:
4417
                    s->mv_dir = MV_DIR_FORWARD;
4418
                    s->mv_type = MV_TYPE_FIELD;
4419
                    s->mb_intra= 0;
4420
                    for(i=0; i<2; i++){
4421
                        j= s->field_select[0][i] = s->p_field_select_table[i][xy];
4422
                        s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
4423
                        s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
4424
                    }
4425
                    motion_x = motion_y = 0;
4426
                    break;
4427
                case CANDIDATE_MB_TYPE_INTER4V:
4428
                    s->mv_dir = MV_DIR_FORWARD;
4429
                    s->mv_type = MV_TYPE_8X8;
4430
                    s->mb_intra= 0;
4431
                    for(i=0; i<4; i++){
4432
                        s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
4433
                        s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
4434
                    }
4435
                    motion_x= motion_y= 0;
4436
                    break;
4437
                case CANDIDATE_MB_TYPE_DIRECT:
4438
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4439
                    s->mb_intra= 0;
4440
                    motion_x=s->b_direct_mv_table[xy][0];
4441
                    motion_y=s->b_direct_mv_table[xy][1];
4442
#ifdef CONFIG_RISKY
4443
                    ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
4444
#endif
4445
                    break;
4446
                case CANDIDATE_MB_TYPE_BIDIR:
4447
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4448
                    s->mb_intra= 0;
4449
                    motion_x=0;
4450
                    motion_y=0;
4451
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
4452
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
4453
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
4454
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
4455
                    break;
4456
                case CANDIDATE_MB_TYPE_BACKWARD:
4457
                    s->mv_dir = MV_DIR_BACKWARD;
4458
                    s->mb_intra= 0;
4459
                    motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
4460
                    motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
4461
                    break;
4462
                case CANDIDATE_MB_TYPE_FORWARD:
4463
                    s->mv_dir = MV_DIR_FORWARD;
4464
                    s->mb_intra= 0;
4465
                    motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
4466
                    motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
4467
//                    printf(" %d %d ", motion_x, motion_y);
4468
                    break;
4469
                case CANDIDATE_MB_TYPE_FORWARD_I:
4470
                    s->mv_dir = MV_DIR_FORWARD;
4471
                    s->mv_type = MV_TYPE_FIELD;
4472
                    s->mb_intra= 0;
4473
                    for(i=0; i<2; i++){
4474
                        j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
4475
                        s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
4476
                        s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
4477
                    }
4478
                    motion_x=motion_y=0;
4479
                    break;
4480
                case CANDIDATE_MB_TYPE_BACKWARD_I:
4481
                    s->mv_dir = MV_DIR_BACKWARD;
4482
                    s->mv_type = MV_TYPE_FIELD;
4483
                    s->mb_intra= 0;
4484
                    for(i=0; i<2; i++){
4485
                        j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
4486
                        s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
4487
                        s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
4488
                    }
4489
                    motion_x=motion_y=0;
4490
                    break;
4491
                case CANDIDATE_MB_TYPE_BIDIR_I:
4492
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4493
                    s->mv_type = MV_TYPE_FIELD;
4494
                    s->mb_intra= 0;
4495
                    for(dir=0; dir<2; dir++){
4496
                        for(i=0; i<2; i++){
4497
                            j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
4498
                            s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
4499
                            s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
4500
                        }
4501
                    }
4502
                    motion_x=motion_y=0;
4503
                    break;
4504
                default:
4505
                    motion_x=motion_y=0; //gcc warning fix
4506
                    av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
4507
                }
4508

    
4509
                encode_mb(s, motion_x, motion_y);
4510

    
4511
                // RAL: Update last macrobloc type
4512
                s->last_mv_dir = s->mv_dir;
4513
            
4514
#ifdef CONFIG_RISKY
4515
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4516
                    ff_h263_update_motion_val(s);
4517
#endif
4518
                
4519
                MPV_decode_mb(s, s->block);
4520
            }
4521

    
4522
            /* clean the MV table in IPS frames for direct mode in B frames */
4523
            if(s->mb_intra /* && I,P,S_TYPE */){
4524
                s->p_mv_table[xy][0]=0;
4525
                s->p_mv_table[xy][1]=0;
4526
            }
4527
            
4528
            if(s->flags&CODEC_FLAG_PSNR){
4529
                int w= 16;
4530
                int h= 16;
4531

    
4532
                if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4533
                if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4534

    
4535
                s->current_picture_ptr->error[0] += sse(
4536
                    s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
4537
                    s->dest[0], w, h, s->linesize);
4538
                s->current_picture_ptr->error[1] += sse(
4539
                    s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
4540
                    s->dest[1], w>>1, h>>1, s->uvlinesize);
4541
                s->current_picture_ptr->error[2] += sse(
4542
                    s, s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
4543
                    s->dest[2], w>>1, h>>1, s->uvlinesize);
4544
            }
4545
            if(s->loop_filter)
4546
                ff_h263_loop_filter(s);
4547
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
4548
        }
4549
    }
4550

    
4551
#ifdef CONFIG_RISKY
4552
    //not beautifull here but we must write it before flushing so it has to be here
4553
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
4554
        msmpeg4_encode_ext_header(s);
4555
#endif
4556

    
4557
    write_slice_end(s);
4558

    
4559
    /* Send the last GOB if RTP */    
4560
    if (s->avctx->rtp_callback) {
4561
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
4562
        /* Call the RTP callback to send the last GOB */
4563
        emms_c();
4564
        s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, 0);
4565
    }
4566

    
4567
    return 0;
4568
}
4569

    
4570
#define MERGE(field) dst->field += src->field; src->field=0
4571
static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
4572
    MERGE(me.scene_change_score);
4573
    MERGE(me.mc_mb_var_sum_temp);
4574
    MERGE(me.mb_var_sum_temp);
4575
}
4576

    
4577
static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
4578
    int i;
4579

    
4580
    MERGE(dct_count[0]); //note, the other dct vars are not part of the context
4581
    MERGE(dct_count[1]);
4582
    MERGE(mv_bits);
4583
    MERGE(header_bits);
4584
    MERGE(i_tex_bits);
4585
    MERGE(p_tex_bits);
4586
    MERGE(i_count);
4587
    MERGE(f_count);
4588
    MERGE(b_count);
4589
    MERGE(skip_count);
4590
    MERGE(misc_bits);
4591
    MERGE(error_count);
4592
    MERGE(padding_bug_score);
4593

    
4594
    if(dst->avctx->noise_reduction){
4595
        for(i=0; i<64; i++){
4596
            MERGE(dct_error_sum[0][i]);
4597
            MERGE(dct_error_sum[1][i]);
4598
        }
4599
    }
4600
    
4601
    assert(put_bits_count(&src->pb) % 8 ==0);
4602
    assert(put_bits_count(&dst->pb) % 8 ==0);
4603
    ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
4604
    flush_put_bits(&dst->pb);
4605
}
4606

    
4607
static void encode_picture(MpegEncContext *s, int picture_number)
4608
{
4609
    int i;
4610
    int bits;
4611

    
4612
    s->picture_number = picture_number;
4613
    
4614
    /* Reset the average MB variance */
4615
    s->me.mb_var_sum_temp    =
4616
    s->me.mc_mb_var_sum_temp = 0;
4617

    
4618
#ifdef CONFIG_RISKY
4619
    /* we need to initialize some time vars before we can encode b-frames */
4620
    // RAL: Condition added for MPEG1VIDEO
4621
    if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
4622
        ff_set_mpeg4_time(s, s->picture_number);  //FIXME rename and use has_b_frames or similar
4623
#endif
4624
        
4625
    s->me.scene_change_score=0;
4626
    
4627
//    s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration
4628
    
4629
    if(s->pict_type==I_TYPE){
4630
        if(s->msmpeg4_version >= 3) s->no_rounding=1;
4631
        else                        s->no_rounding=0;
4632
    }else if(s->pict_type!=B_TYPE){
4633
        if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
4634
            s->no_rounding ^= 1;          
4635
    }
4636
    
4637
    s->mb_intra=0; //for the rate distoration & bit compare functions
4638
    for(i=1; i<s->avctx->thread_count; i++){
4639
        ff_update_duplicate_context(s->thread_context[i], s);
4640
    }
4641

    
4642
    ff_init_me(s);
4643

    
4644
    /* Estimate motion for every MB */
4645
    if(s->pict_type != I_TYPE){
4646
        if(s->pict_type != B_TYPE && s->avctx->me_threshold==0){
4647
            if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
4648
                s->avctx->execute(s->avctx, pre_estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
4649
            }
4650
        }
4651

    
4652
        s->avctx->execute(s->avctx, estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
4653
    }else /* if(s->pict_type == I_TYPE) */{
4654
        /* I-Frame */
4655
        for(i=0; i<s->mb_stride*s->mb_height; i++)
4656