Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 7c4f71c4

History | View | Annotate | Download (214 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 <limits.h>
29
#include <math.h> //for PI
30
#include "avcodec.h"
31
#include "dsputil.h"
32
#include "mpegvideo.h"
33
#include "faandct.h"
34

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

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

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

    
66
#ifdef HAVE_XVMC
67
extern int  XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
68
extern void XVMC_field_end(MpegEncContext *s);
69
extern void XVMC_decode_mb(MpegEncContext *s);
70
#endif
71

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

    
74

    
75
/* enable all paranoid tests for rounding, overflows, etc... */
76
//#define PARANOID
77

    
78
//#define DEBUG
79

    
80

    
81
/* for jpeg fast DCT */
82
#define CONST_BITS 14
83

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

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

    
101
static const uint8_t ff_default_chroma_qscale_table[32]={
102
//  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
103
    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
104
};
105

    
106
#ifdef CONFIG_ENCODERS
107
static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
108
static uint8_t default_fcode_tab[MAX_MV*2+1];
109

    
110
enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
111

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

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

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

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

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

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

    
200
#ifdef CONFIG_ENCODERS
201
void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
202
    int i;
203

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

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

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

    
248
#ifdef CONFIG_ENCODERS
249
    s->fast_dct_quantize= s->dct_quantize;
250

    
251
    if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
252
        s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
253
    }
254

    
255
#endif //CONFIG_ENCODERS
256

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

    
270
    return 0;
271
}
272

    
273
static void copy_picture(Picture *dst, Picture *src){
274
    *dst = *src;
275
    dst->type= FF_BUFFER_TYPE_COPY;
276
}
277

    
278
static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
279
    int i;
280

    
281
    dst->pict_type              = src->pict_type;
282
    dst->quality                = src->quality;
283
    dst->coded_picture_number   = src->coded_picture_number;
284
    dst->display_picture_number = src->display_picture_number;
285
//    dst->reference              = src->reference;
286
    dst->pts                    = src->pts;
287
    dst->interlaced_frame       = src->interlaced_frame;
288
    dst->top_field_first        = src->top_field_first;
289

    
290
    if(s->avctx->me_threshold){
291
        if(!src->motion_val[0])
292
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
293
        if(!src->mb_type)
294
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
295
        if(!src->ref_index[0])
296
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
297
        if(src->motion_subsample_log2 != dst->motion_subsample_log2)
298
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesnt match!\n");
299

    
300
        memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
301
        
302
        for(i=0; i<2; i++){
303
            int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
304
            int height= ((16*s->mb_height)>>src->motion_subsample_log2);
305

    
306
            if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
307
                memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
308
            }
309
            if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
310
                memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
311
            }
312
        }
313
    }
314
}
315

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

    
343
        if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
344
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
345
            return -1;
346
        }
347

    
348
        if(pic->linesize[1] != pic->linesize[2]){
349
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride missmatch)\n");
350
            return -1;
351
        }
352

    
353
        s->linesize  = pic->linesize[0];
354
        s->uvlinesize= pic->linesize[1];
355
    }
356
    
357
    if(pic->qscale_table==NULL){
358
        if (s->encoding) {        
359
            CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
360
            CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
361
            CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
362
        }
363

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

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

    
401
/**
402
 * deallocates a picture
403
 */
404
static void free_picture(MpegEncContext *s, Picture *pic){
405
    int i;
406

    
407
    if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
408
        s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
409
    }
410

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

    
434
static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
435
    int i;
436

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

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

    
456
    for(i=0;i<12;i++){
457
        s->pblocks[i] = (short *)(&s->block[i]);
458
    }
459
    return 0;
460
fail:
461
    return -1; //free() through MPV_common_end()
462
}
463

    
464
static void free_duplicate_context(MpegEncContext *s){
465
    if(s==NULL) return;
466

    
467
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
468
    av_freep(&s->me.scratchpad);
469
    s->rd_scratchpad=   
470
    s->b_scratchpad=    
471
    s->obmc_scratchpad= NULL;
472
    
473
    av_freep(&s->dct_error_sum);
474
    av_freep(&s->me.map);
475
    av_freep(&s->me.score_map);
476
    av_freep(&s->blocks);
477
    s->block= NULL;
478
}
479

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

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

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

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

    
545
    s->coded_picture_number = 0;
546
    s->picture_number = 0;
547
    s->input_picture_number = 0;
548

    
549
    s->picture_in_gop_number = 0;
550

    
551
    s->f_code = 1;
552
    s->b_code = 1;
553
}
554

    
555
/**
556
 * sets the given MpegEncContext to defaults for decoding.
557
 * the changed fields will not depend upon the prior state of the MpegEncContext.
558
 */
559
void MPV_decode_defaults(MpegEncContext *s){
560
    MPV_common_defaults(s);
561
}
562

    
563
/**
564
 * sets the given MpegEncContext to defaults for encoding.
565
 * the changed fields will not depend upon the prior state of the MpegEncContext.
566
 */
567

    
568
#ifdef CONFIG_ENCODERS
569
void MPV_encode_defaults(MpegEncContext *s){
570
    static int done=0;
571
    
572
    MPV_common_defaults(s);
573
    
574
    if(!done){
575
        int i;
576
        done=1;
577

    
578
        default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
579
        memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
580
        memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
581

    
582
        for(i=-16; i<16; i++){
583
            default_fcode_tab[i + MAX_MV]= 1;
584
        }
585
    }
586
    s->me.mv_penalty= default_mv_penalty;
587
    s->fcode_tab= default_fcode_tab;
588
}
589
#endif //CONFIG_ENCODERS
590

    
591
/** 
592
 * init common structure for both encoder and decoder.
593
 * this assumes that some variables like width/height are already set
594
 */
595
int MPV_common_init(MpegEncContext *s)
596
{
597
    int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
598

    
599
    dsputil_init(&s->dsp, s->avctx);
600
    DCT_common_init(s);
601

    
602
    s->flags= s->avctx->flags;
603
    s->flags2= s->avctx->flags2;
604

    
605
    s->mb_width  = (s->width  + 15) / 16;
606
    s->mb_height = (s->height + 15) / 16;
607
    s->mb_stride = s->mb_width + 1;
608
    s->b8_stride = s->mb_width*2 + 1;
609
    s->b4_stride = s->mb_width*4 + 1;
610
    mb_array_size= s->mb_height * s->mb_stride;
611
    mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
612

    
613
    /* set default edge pos, will be overriden in decode_header if needed */
614
    s->h_edge_pos= s->mb_width*16;
615
    s->v_edge_pos= s->mb_height*16;
616

    
617
    s->mb_num = s->mb_width * s->mb_height;
618
    
619
    s->block_wrap[0]=
620
    s->block_wrap[1]=
621
    s->block_wrap[2]=
622
    s->block_wrap[3]= s->b8_stride;
623
    s->block_wrap[4]=
624
    s->block_wrap[5]= s->mb_stride;
625
 
626
    y_size = s->b8_stride * (2 * s->mb_height + 1);
627
    c_size = s->mb_stride * (s->mb_height + 1);
628
    yc_size = y_size + 2 * c_size;
629
    
630
    /* convert fourcc to upper case */
631
    s->avctx->codec_tag=   toupper( s->avctx->codec_tag     &0xFF)          
632
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
633
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16) 
634
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
635

    
636
    s->avctx->stream_codec_tag=   toupper( s->avctx->stream_codec_tag     &0xFF)          
637
                               + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
638
                               + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16) 
639
                               + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
640

    
641
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
642

    
643
    CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
644
    for(y=0; y<s->mb_height; y++){
645
        for(x=0; x<s->mb_width; x++){
646
            s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
647
        }
648
    }
649
    s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
650
    
651
    if (s->encoding) {
652
        /* Allocate MV tables */
653
        CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
654
        CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
655
        CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
656
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
657
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
658
        CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
659
        s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
660
        s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
661
        s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
662
        s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
663
        s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
664
        s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
665

    
666
        if(s->msmpeg4_version){
667
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
668
        }
669
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
670

    
671
        /* Allocate MB type table */
672
        CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint16_t)) //needed for encoding
673
        
674
        CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
675
        
676
        CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
677
        CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
678
        CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
679
        CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
680
        CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
681
        CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
682
        
683
        if(s->avctx->noise_reduction){
684
            CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
685
        }
686
    }
687
    CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
688

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

    
721
        /* cbp, ac_pred, pred_dir */
722
        CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
723
        CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
724
    }
725
    
726
    if (s->h263_pred || s->h263_plus || !s->encoding) {
727
        /* dc values */
728
        //MN: we need these for error resilience of intra-frames
729
        CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
730
        s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
731
        s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
732
        s->dc_val[2] = s->dc_val[1] + c_size;
733
        for(i=0;i<yc_size;i++)
734
            s->dc_val_base[i] = 1024;
735
    }
736

    
737
    /* which mb is a intra block */
738
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
739
    memset(s->mbintra_table, 1, mb_array_size);
740
    
741
    /* init macroblock skip table */
742
    CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
743
    //Note the +1 is for a quicker mpeg4 slice_end detection
744
    CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
745
    
746
    s->parse_context.state= -1;
747
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
748
       s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
749
       s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
750
       s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
751
    }
752

    
753
    s->context_initialized = 1;
754

    
755
    s->thread_context[0]= s;
756
    for(i=1; i<s->avctx->thread_count; i++){
757
        s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
758
        memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
759
    }
760

    
761
    for(i=0; i<s->avctx->thread_count; i++){
762
        if(init_duplicate_context(s->thread_context[i], s) < 0)
763
           goto fail;
764
        s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
765
        s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
766
    }
767

    
768
    return 0;
769
 fail:
770
    MPV_common_end(s);
771
    return -1;
772
}
773

    
774
/* init common structure for both encoder and decoder */
775
void MPV_common_end(MpegEncContext *s)
776
{
777
    int i, j, k;
778

    
779
    for(i=0; i<s->avctx->thread_count; i++){
780
        free_duplicate_context(s->thread_context[i]);
781
    }
782
    for(i=1; i<s->avctx->thread_count; i++){
783
        av_freep(&s->thread_context[i]);
784
    }
785

    
786
    av_freep(&s->parse_context.buffer);
787
    s->parse_context.buffer_size=0;
788

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

    
838
    if(s->picture){
839
        for(i=0; i<MAX_PICTURE_COUNT; i++){
840
            free_picture(s, &s->picture[i]);
841
        }
842
    }
843
    av_freep(&s->picture);
844
    avcodec_default_free_buffers(s->avctx);
845
    s->context_initialized = 0;
846
    s->last_picture_ptr=
847
    s->next_picture_ptr=
848
    s->current_picture_ptr= NULL;
849

    
850
    for(i=0; i<3; i++)
851
        av_freep(&s->visualization_buffer[i]);
852
}
853

    
854
#ifdef CONFIG_ENCODERS
855

    
856
/* init video encoder */
857
int MPV_encode_init(AVCodecContext *avctx)
858
{
859
    MpegEncContext *s = avctx->priv_data;
860
    int i, dummy;
861
    int chroma_h_shift, chroma_v_shift;
862
    
863
    MPV_encode_defaults(s);
864

    
865
    avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME
866

    
867
    s->bit_rate = avctx->bit_rate;
868
    s->width = avctx->width;
869
    s->height = avctx->height;
870
    if(avctx->gop_size > 600){
871
        av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
872
        avctx->gop_size=600;
873
    }
874
    s->gop_size = avctx->gop_size;
875
    s->avctx = avctx;
876
    s->flags= avctx->flags;
877
    s->flags2= avctx->flags2;
878
    s->max_b_frames= avctx->max_b_frames;
879
    s->codec_id= avctx->codec->id;
880
    s->luma_elim_threshold  = avctx->luma_elim_threshold;
881
    s->chroma_elim_threshold= avctx->chroma_elim_threshold;
882
    s->strict_std_compliance= avctx->strict_std_compliance;
883
    s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
884
    s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
885
    s->mpeg_quant= avctx->mpeg_quant;
886
    s->rtp_mode= !!avctx->rtp_payload_size;
887

    
888
    if (s->gop_size <= 1) {
889
        s->intra_only = 1;
890
        s->gop_size = 12;
891
    } else {
892
        s->intra_only = 0;
893
    }
894

    
895
    s->me_method = avctx->me_method;
896

    
897
    /* Fixed QSCALE */
898
    s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
899
    
900
    s->adaptive_quant= (   s->avctx->lumi_masking
901
                        || s->avctx->dark_masking
902
                        || s->avctx->temporal_cplx_masking 
903
                        || s->avctx->spatial_cplx_masking
904
                        || s->avctx->p_masking
905
                        || (s->flags&CODEC_FLAG_QP_RD))
906
                       && !s->fixed_qscale;
907
    
908
    s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
909
    s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
910
    s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
911

    
912
    if(avctx->rc_max_rate && !avctx->rc_buffer_size){
913
        av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
914
        return -1;
915
    }    
916

    
917
    if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
918
        av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isnt recommanded!\n");
919
    }
920
    
921
    if(   s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate 
922
       && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
923
       && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
924
        
925
        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");
926
    }
927
       
928
    if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 
929
       && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
930
        av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
931
        return -1;
932
    }
933
        
934
    if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
935
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decission\n");
936
        return -1;
937
    }
938
    
939
    if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
940
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
941
        return -1;
942
    }
943
    
944
    if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
945
        av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
946
        return -1;
947
    }
948

    
949
    if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
950
        av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
951
        return -1;
952
    }
953
    
954
    if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
955
        av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
956
        return -1;
957
    }
958
    
959
    if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
960
        av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n");
961
        return -1;
962
    }
963
        
964
    if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
965
        av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
966
        return -1;
967
    }
968

    
969
    if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
970
        av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
971
        return -1;
972
    }
973
    
974
    if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
975
        av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
976
        return -1;
977
    }
978
    
979
    if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4 
980
       && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO 
981
       && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
982
        av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
983
        return -1;
984
    }
985
    
986
    if(s->avctx->thread_count > MAX_THREADS || 16*s->avctx->thread_count > s->height){
987
        av_log(avctx, AV_LOG_ERROR, "too many threads\n");
988
        return -1;
989
    }
990
    
991
    if(s->avctx->thread_count > 1)
992
        s->rtp_mode= 1;
993

    
994
    i= ff_gcd(avctx->frame_rate, avctx->frame_rate_base);
995
    if(i > 1){
996
        av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
997
        avctx->frame_rate /= i;
998
        avctx->frame_rate_base /= i;
999
//        return -1;
1000
    }
1001
    
1002
    if(s->codec_id==CODEC_ID_MJPEG){
1003
        s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1004
        s->inter_quant_bias= 0;
1005
    }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1006
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1007
        s->inter_quant_bias= 0;
1008
    }else{
1009
        s->intra_quant_bias=0;
1010
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1011
    }
1012
    
1013
    if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1014
        s->intra_quant_bias= avctx->intra_quant_bias;
1015
    if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1016
        s->inter_quant_bias= avctx->inter_quant_bias;
1017
        
1018
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1019

    
1020
    av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1021
    s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1022

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

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

    
1154
    s->encoding = 1;
1155

    
1156
    /* init */
1157
    if (MPV_common_init(s) < 0)
1158
        return -1;
1159

    
1160
    if(s->modified_quant)
1161
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1162
    s->progressive_frame= 
1163
    s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1164
    s->quant_precision=5;
1165
    
1166
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1167
    
1168
    ff_init_me(s);
1169

    
1170
#ifdef CONFIG_ENCODERS
1171
#ifdef CONFIG_RISKY
1172
    if (s->out_format == FMT_H263)
1173
        h263_encode_init(s);
1174
    if(s->msmpeg4_version)
1175
        ff_msmpeg4_encode_init(s);
1176
#endif
1177
    if (s->out_format == FMT_MPEG1)
1178
        ff_mpeg1_encode_init(s);
1179
#endif
1180

    
1181
    /* init q matrix */
1182
    for(i=0;i<64;i++) {
1183
        int j= s->dsp.idct_permutation[i];
1184
#ifdef CONFIG_RISKY
1185
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1186
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1187
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1188
        }else if(s->out_format == FMT_H263){
1189
            s->intra_matrix[j] =
1190
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1191
        }else
1192
#endif
1193
        { /* mpeg1/2 */
1194
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1195
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1196
        }
1197
        if(s->avctx->intra_matrix)
1198
            s->intra_matrix[j] = s->avctx->intra_matrix[i];
1199
        if(s->avctx->inter_matrix)
1200
            s->inter_matrix[j] = s->avctx->inter_matrix[i];
1201
    }
1202

    
1203
    /* precompute matrix */
1204
    /* for mjpeg, we do include qscale in the matrix */
1205
    if (s->out_format != FMT_MJPEG) {
1206
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 
1207
                       s->intra_matrix, s->intra_quant_bias, 1, 31);
1208
        convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, 
1209
                       s->inter_matrix, s->inter_quant_bias, 1, 31);
1210
    }
1211

    
1212
    if(ff_rate_control_init(s) < 0)
1213
        return -1;
1214
    
1215
    return 0;
1216
}
1217

    
1218
int MPV_encode_end(AVCodecContext *avctx)
1219
{
1220
    MpegEncContext *s = avctx->priv_data;
1221

    
1222
#ifdef STATS
1223
    print_stats();
1224
#endif
1225

    
1226
    ff_rate_control_uninit(s);
1227

    
1228
    MPV_common_end(s);
1229
    if (s->out_format == FMT_MJPEG)
1230
        mjpeg_close(s);
1231

    
1232
    av_freep(&avctx->extradata);
1233
      
1234
    return 0;
1235
}
1236

    
1237
#endif //CONFIG_ENCODERS
1238

    
1239
void init_rl(RLTable *rl)
1240
{
1241
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1242
    uint8_t index_run[MAX_RUN+1];
1243
    int last, run, level, start, end, i;
1244

    
1245
    /* compute max_level[], max_run[] and index_run[] */
1246
    for(last=0;last<2;last++) {
1247
        if (last == 0) {
1248
            start = 0;
1249
            end = rl->last;
1250
        } else {
1251
            start = rl->last;
1252
            end = rl->n;
1253
        }
1254

    
1255
        memset(max_level, 0, MAX_RUN + 1);
1256
        memset(max_run, 0, MAX_LEVEL + 1);
1257
        memset(index_run, rl->n, MAX_RUN + 1);
1258
        for(i=start;i<end;i++) {
1259
            run = rl->table_run[i];
1260
            level = rl->table_level[i];
1261
            if (index_run[run] == rl->n)
1262
                index_run[run] = i;
1263
            if (level > max_level[run])
1264
                max_level[run] = level;
1265
            if (run > max_run[level])
1266
                max_run[level] = run;
1267
        }
1268
        rl->max_level[last] = av_malloc(MAX_RUN + 1);
1269
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1270
        rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1271
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1272
        rl->index_run[last] = av_malloc(MAX_RUN + 1);
1273
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1274
    }
1275
}
1276

    
1277
/* draw the edges of width 'w' of an image of size width, height */
1278
//FIXME check that this is ok for mpeg4 interlaced
1279
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1280
{
1281
    uint8_t *ptr, *last_line;
1282
    int i;
1283

    
1284
    last_line = buf + (height - 1) * wrap;
1285
    for(i=0;i<w;i++) {
1286
        /* top and bottom */
1287
        memcpy(buf - (i + 1) * wrap, buf, width);
1288
        memcpy(last_line + (i + 1) * wrap, last_line, width);
1289
    }
1290
    /* left and right */
1291
    ptr = buf;
1292
    for(i=0;i<height;i++) {
1293
        memset(ptr - w, ptr[0], w);
1294
        memset(ptr + width, ptr[width-1], w);
1295
        ptr += wrap;
1296
    }
1297
    /* corners */
1298
    for(i=0;i<w;i++) {
1299
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1300
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1301
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1302
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1303
    }
1304
}
1305

    
1306
int ff_find_unused_picture(MpegEncContext *s, int shared){
1307
    int i;
1308
    
1309
    if(shared){
1310
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1311
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1312
        }
1313
    }else{
1314
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1315
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1316
        }
1317
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1318
            if(s->picture[i].data[0]==NULL) return i;
1319
        }
1320
    }
1321

    
1322
    assert(0);
1323
    return -1;
1324
}
1325

    
1326
static void update_noise_reduction(MpegEncContext *s){
1327
    int intra, i;
1328

    
1329
    for(intra=0; intra<2; intra++){
1330
        if(s->dct_count[intra] > (1<<16)){
1331
            for(i=0; i<64; i++){
1332
                s->dct_error_sum[intra][i] >>=1;
1333
            }
1334
            s->dct_count[intra] >>= 1;
1335
        }
1336
        
1337
        for(i=0; i<64; i++){
1338
            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);
1339
        }
1340
    }
1341
}
1342

    
1343
/**
1344
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1345
 */
1346
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1347
{
1348
    int i;
1349
    AVFrame *pic;
1350
    s->mb_skiped = 0;
1351

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

    
1354
    /* mark&release old frames */
1355
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1356
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1357

    
1358
        /* release forgotten pictures */
1359
        /* if(mpeg124/h263) */
1360
        if(!s->encoding){
1361
            for(i=0; i<MAX_PICTURE_COUNT; i++){
1362
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1363
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1364
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
1365
                }
1366
            }
1367
        }
1368
    }
1369
alloc:
1370
    if(!s->encoding){
1371
        /* release non refernce frames */
1372
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1373
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1374
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1375
            }
1376
        }
1377

    
1378
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1379
            pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1380
        else{
1381
            i= ff_find_unused_picture(s, 0);
1382
            pic= (AVFrame*)&s->picture[i];
1383
        }
1384

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

    
1387
        pic->coded_picture_number= s->coded_picture_number++;
1388
        
1389
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1390
            return -1;
1391

    
1392
        s->current_picture_ptr= (Picture*)pic;
1393
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1394
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1395
    }
1396

    
1397
    s->current_picture_ptr->pict_type= s->pict_type;
1398
//    if(s->flags && CODEC_FLAG_QSCALE) 
1399
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1400
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1401

    
1402
    copy_picture(&s->current_picture, s->current_picture_ptr);
1403
  
1404
  if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1405
    if (s->pict_type != B_TYPE) {
1406
        s->last_picture_ptr= s->next_picture_ptr;
1407
        if(!s->dropable)
1408
            s->next_picture_ptr= s->current_picture_ptr;
1409
    }
1410
/*    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,
1411
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL, 
1412
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL, 
1413
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1414
        s->pict_type, s->dropable);*/
1415
    
1416
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1417
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1418
    
1419
    if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1420
        av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1421
        assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1422
        goto alloc;
1423
    }
1424

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

    
1427
    if(s->picture_structure!=PICT_FRAME){
1428
        int i;
1429
        for(i=0; i<4; i++){
1430
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1431
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1432
            } 
1433
            s->current_picture.linesize[i] *= 2;
1434
            s->last_picture.linesize[i] *=2;
1435
            s->next_picture.linesize[i] *=2;
1436
        }
1437
    }
1438
  }
1439
   
1440
    s->hurry_up= s->avctx->hurry_up;
1441
    s->error_resilience= avctx->error_resilience;
1442

    
1443
    /* set dequantizer, we cant do it during init as it might change for mpeg4
1444
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1445
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1446
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1447
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1448
    }else if(s->out_format == FMT_H263){
1449
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1450
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1451
    }else{
1452
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1453
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1454
    }
1455

    
1456
    if(s->dct_error_sum){
1457
        assert(s->avctx->noise_reduction && s->encoding);
1458

    
1459
        update_noise_reduction(s);
1460
    }
1461
        
1462
#ifdef HAVE_XVMC
1463
    if(s->avctx->xvmc_acceleration)
1464
        return XVMC_field_start(s, avctx);
1465
#endif
1466
    return 0;
1467
}
1468

    
1469
/* generic function for encode/decode called after a frame has been coded/decoded */
1470
void MPV_frame_end(MpegEncContext *s)
1471
{
1472
    int i;
1473
    /* draw edge for correct motion prediction if outside */
1474
#ifdef HAVE_XVMC
1475
//just to make sure that all data is rendered.
1476
    if(s->avctx->xvmc_acceleration){
1477
        XVMC_field_end(s);
1478
    }else
1479
#endif
1480
    if(s->unrestricted_mv && s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1481
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1482
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1483
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1484
    }
1485
    emms_c();
1486
    
1487
    s->last_pict_type    = s->pict_type;
1488
    if(s->pict_type!=B_TYPE){
1489
        s->last_non_b_pict_type= s->pict_type;
1490
    }
1491
#if 0
1492
        /* copy back current_picture variables */
1493
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1494
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1495
            s->picture[i]= s->current_picture;
1496
            break;
1497
        }    
1498
    }
1499
    assert(i<MAX_PICTURE_COUNT);
1500
#endif    
1501

    
1502
    if(s->encoding){
1503
        /* release non refernce frames */
1504
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1505
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1506
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1507
            }
1508
        }
1509
    }
1510
    // clear copies, to avoid confusion
1511
#if 0
1512
    memset(&s->last_picture, 0, sizeof(Picture));
1513
    memset(&s->next_picture, 0, sizeof(Picture));
1514
    memset(&s->current_picture, 0, sizeof(Picture));
1515
#endif
1516
}
1517

    
1518
/**
1519
 * draws an line from (ex, ey) -> (sx, sy).
1520
 * @param w width of the image
1521
 * @param h height of the image
1522
 * @param stride stride/linesize of the image
1523
 * @param color color of the arrow
1524
 */
1525
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1526
    int t, x, y, fr, f;
1527
    
1528
    sx= clip(sx, 0, w-1);
1529
    sy= clip(sy, 0, h-1);
1530
    ex= clip(ex, 0, w-1);
1531
    ey= clip(ey, 0, h-1);
1532
    
1533
    buf[sy*stride + sx]+= color;
1534
    
1535
    if(ABS(ex - sx) > ABS(ey - sy)){
1536
        if(sx > ex){
1537
            t=sx; sx=ex; ex=t;
1538
            t=sy; sy=ey; ey=t;
1539
        }
1540
        buf+= sx + sy*stride;
1541
        ex-= sx;
1542
        f= ((ey-sy)<<16)/ex;
1543
        for(x= 0; x <= ex; x++){
1544
            y = (x*f)>>16;
1545
            fr= (x*f)&0xFFFF;
1546
            buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1547
            buf[(y+1)*stride + x]+= (color*         fr )>>16;
1548
        }
1549
    }else{
1550
        if(sy > ey){
1551
            t=sx; sx=ex; ex=t;
1552
            t=sy; sy=ey; ey=t;
1553
        }
1554
        buf+= sx + sy*stride;
1555
        ey-= sy;
1556
        if(ey) f= ((ex-sx)<<16)/ey;
1557
        else   f= 0;
1558
        for(y= 0; y <= ey; y++){
1559
            x = (y*f)>>16;
1560
            fr= (y*f)&0xFFFF;
1561
            buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;;
1562
            buf[y*stride + x+1]+= (color*         fr )>>16;;
1563
        }
1564
    }
1565
}
1566

    
1567
/**
1568
 * draws an arrow from (ex, ey) -> (sx, sy).
1569
 * @param w width of the image
1570
 * @param h height of the image
1571
 * @param stride stride/linesize of the image
1572
 * @param color color of the arrow
1573
 */
1574
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1575
    int dx,dy;
1576

    
1577
    sx= clip(sx, -100, w+100);
1578
    sy= clip(sy, -100, h+100);
1579
    ex= clip(ex, -100, w+100);
1580
    ey= clip(ey, -100, h+100);
1581
    
1582
    dx= ex - sx;
1583
    dy= ey - sy;
1584
    
1585
    if(dx*dx + dy*dy > 3*3){
1586
        int rx=  dx + dy;
1587
        int ry= -dx + dy;
1588
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1589
        
1590
        //FIXME subpixel accuracy
1591
        rx= ROUNDED_DIV(rx*3<<4, length);
1592
        ry= ROUNDED_DIV(ry*3<<4, length);
1593
        
1594
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1595
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1596
    }
1597
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1598
}
1599

    
1600
/**
1601
 * prints debuging info for the given picture.
1602
 */
1603
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1604

    
1605
    if(!pict || !pict->mb_type) return;
1606

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

    
1683
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1684
        const int shift= 1 + s->quarter_sample;
1685
        int mb_y;
1686
        uint8_t *ptr;
1687
        int i;
1688
        int h_chroma_shift, v_chroma_shift;
1689
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1690

    
1691
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1692
        for(i=0; i<3; i++){
1693
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*s->height:pict->linesize[i]*s->height >> v_chroma_shift);
1694
            pict->data[i]= s->visualization_buffer[i];
1695
        }
1696
        pict->type= FF_BUFFER_TYPE_COPY;
1697
        ptr= pict->data[0];
1698

    
1699
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1700
            int mb_x;
1701
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1702
                const int mb_index= mb_x + mb_y*s->mb_stride;
1703
                if((s->avctx->debug_mv) && pict->motion_val){
1704
                  int type;
1705
                  for(type=0; type<3; type++){
1706
                    int direction;
1707
                    switch (type) {
1708
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1709
                                continue;
1710
                              direction = 0;
1711
                              break;
1712
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1713
                                continue;
1714
                              direction = 0;
1715
                              break;
1716
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1717
                                continue;
1718
                              direction = 1;
1719
                              break;
1720
                    }
1721
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1722
                        continue;
1723

    
1724
                    //FIXME for h264
1725
                    if(IS_8X8(pict->mb_type[mb_index])){
1726
                      int i;
1727
                      for(i=0; i<4; i++){
1728
                        int sx= mb_x*16 + 4 + 8*(i&1);
1729
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1730
                        int xy= mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*s->b8_stride;
1731
                        int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1732
                        int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1733
                        draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1734
                      }
1735
                    }else if(IS_16X8(pict->mb_type[mb_index])){
1736
                      int i;
1737
                      for(i=0; i<2; i++){
1738
                        int sx=mb_x*16 + 8;
1739
                        int sy=mb_y*16 + 4 + 8*i;
1740
                        int xy= mb_x*2 + (mb_y*2 + i)*s->b8_stride;
1741
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1742
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1743
                        
1744
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1745
                            my*=2;
1746
                        
1747
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, s->width, s->height, s->linesize, 100);
1748
                      }
1749
                    }else{
1750
                      int sx= mb_x*16 + 8;
1751
                      int sy= mb_y*16 + 8;
1752
                      int xy= mb_x*2 + mb_y*2*s->b8_stride;
1753
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1754
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1755
                      draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1756
                    }
1757
                  }                  
1758
                }
1759
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1760
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1761
                    int y;
1762
                    for(y=0; y<8; y++){
1763
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1764
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1765
                    }
1766
                }
1767
                if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1768
                    int mb_type= pict->mb_type[mb_index];
1769
                    uint64_t u,v;
1770
                    int y;
1771
#define COLOR(theta, r)\
1772
u= (int)(128 + r*cos(theta*3.141592/180));\
1773
v= (int)(128 + r*sin(theta*3.141592/180));
1774

    
1775
                    
1776
                    u=v=128;
1777
                    if(IS_PCM(mb_type)){
1778
                        COLOR(120,48)
1779
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1780
                        COLOR(30,48)
1781
                    }else if(IS_INTRA4x4(mb_type)){
1782
                        COLOR(90,48)
1783
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1784
//                        COLOR(120,48)
1785
                    }else if(IS_DIRECT(mb_type)){
1786
                        COLOR(150,48)
1787
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1788
                        COLOR(170,48)
1789
                    }else if(IS_GMC(mb_type)){
1790
                        COLOR(190,48)
1791
                    }else if(IS_SKIP(mb_type)){
1792
//                        COLOR(180,48)
1793
                    }else if(!USES_LIST(mb_type, 1)){
1794
                        COLOR(240,48)
1795
                    }else if(!USES_LIST(mb_type, 0)){
1796
                        COLOR(0,48)
1797
                    }else{
1798
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1799
                        COLOR(300,48)
1800
                    }
1801

    
1802
                    u*= 0x0101010101010101ULL;
1803
                    v*= 0x0101010101010101ULL;
1804
                    for(y=0; y<8; y++){
1805
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1806
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1807
                    }
1808

    
1809
                    //segmentation
1810
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1811
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1812
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1813
                    }
1814
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1815
                        for(y=0; y<16; y++)
1816
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1817
                    }
1818
                        
1819
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1820
                        // hmm
1821
                    }
1822
                }
1823
                s->mbskip_table[mb_index]=0;
1824
            }
1825
        }
1826
    }
1827
}
1828

    
1829
#ifdef CONFIG_ENCODERS
1830

    
1831
static int get_sae(uint8_t *src, int ref, int stride){
1832
    int x,y;
1833
    int acc=0;
1834
    
1835
    for(y=0; y<16; y++){
1836
        for(x=0; x<16; x++){
1837
            acc+= ABS(src[x+y*stride] - ref);
1838
        }
1839
    }
1840
    
1841
    return acc;
1842
}
1843

    
1844
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1845
    int x, y, w, h;
1846
    int acc=0;
1847
    
1848
    w= s->width &~15;
1849
    h= s->height&~15;
1850
    
1851
    for(y=0; y<h; y+=16){
1852
        for(x=0; x<w; x+=16){
1853
            int offset= x + y*stride;
1854
            int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1855
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1856
            int sae = get_sae(src + offset, mean, stride);
1857
            
1858
            acc+= sae + 500 < sad;
1859
        }
1860
    }
1861
    return acc;
1862
}
1863

    
1864

    
1865
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1866
    AVFrame *pic=NULL;
1867
    int i;
1868
    const int encoding_delay= s->max_b_frames;
1869
    int direct=1;
1870
    
1871
  if(pic_arg){
1872
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1873
    if(pic_arg->linesize[0] != s->linesize) direct=0;
1874
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1875
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1876
  
1877
//    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1878
    
1879
    if(direct){
1880
        i= ff_find_unused_picture(s, 1);
1881

    
1882
        pic= (AVFrame*)&s->picture[i];
1883
        pic->reference= 3;
1884
    
1885
        for(i=0; i<4; i++){
1886
            pic->data[i]= pic_arg->data[i];
1887
            pic->linesize[i]= pic_arg->linesize[i];
1888
        }
1889
        alloc_picture(s, (Picture*)pic, 1);
1890
    }else{
1891
        int offset= 16;
1892
        i= ff_find_unused_picture(s, 0);
1893

    
1894
        pic= (AVFrame*)&s->picture[i];
1895
        pic->reference= 3;
1896

    
1897
        alloc_picture(s, (Picture*)pic, 0);
1898

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

    
1950
    return 0;
1951
}
1952

    
1953
static void select_input_picture(MpegEncContext *s){
1954
    int i;
1955

    
1956
    for(i=1; i<MAX_PICTURE_COUNT; i++)
1957
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1958
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1959

    
1960
    /* set next picture types & ordering */
1961
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1962
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
1963
            s->reordered_input_picture[0]= s->input_picture[0];
1964
            s->reordered_input_picture[0]->pict_type= I_TYPE;
1965
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
1966
        }else{
1967
            int b_frames;
1968
            
1969
            if(s->flags&CODEC_FLAG_PASS2){
1970
                for(i=0; i<s->max_b_frames+1; i++){
1971
                    int pict_num= s->input_picture[0]->display_picture_number + i;
1972
                    int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1973
                    s->input_picture[i]->pict_type= pict_type;
1974
                    
1975
                    if(i + 1 >= s->rc_context.num_entries) break;
1976
                }
1977
            }
1978

    
1979
            if(s->input_picture[0]->pict_type){
1980
                /* user selected pict_type */
1981
                for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
1982
                    if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
1983
                }
1984
            
1985
                if(b_frames > s->max_b_frames){
1986
                    av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
1987
                    b_frames = s->max_b_frames;
1988
                }
1989
            }else if(s->avctx->b_frame_strategy==0){
1990
                b_frames= s->max_b_frames;
1991
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
1992
            }else if(s->avctx->b_frame_strategy==1){
1993
                for(i=1; i<s->max_b_frames+1; i++){
1994
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
1995
                        s->input_picture[i]->b_frame_score= 
1996
                            get_intra_count(s, s->input_picture[i  ]->data[0], 
1997
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
1998
                    }
1999
                }
2000
                for(i=0; i<s->max_b_frames; i++){
2001
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2002
                }
2003
                                
2004
                b_frames= FFMAX(0, i-1);
2005
                
2006
                /* reset scores */
2007
                for(i=0; i<b_frames+1; i++){
2008
                    s->input_picture[i]->b_frame_score=0;
2009
                }
2010
            }else{
2011
                av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2012
                b_frames=0;
2013
            }
2014

    
2015
            emms_c();
2016
//static int b_count=0;
2017
//b_count+= b_frames;
2018
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2019
            if(s->picture_in_gop_number + b_frames >= s->gop_size){
2020
                if(s->flags & CODEC_FLAG_CLOSED_GOP)
2021
                    b_frames=0;
2022
                s->input_picture[b_frames]->pict_type= I_TYPE;
2023
            }
2024
            
2025
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2026
               && b_frames
2027
               && s->input_picture[b_frames]->pict_type== I_TYPE)
2028
                b_frames--;
2029

    
2030
            s->reordered_input_picture[0]= s->input_picture[b_frames];
2031
            if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2032
                s->reordered_input_picture[0]->pict_type= P_TYPE;
2033
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2034
            for(i=0; i<b_frames; i++){
2035
                s->reordered_input_picture[i+1]= s->input_picture[i];
2036
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2037
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2038
            }
2039
        }
2040
    }
2041
    
2042
    if(s->reordered_input_picture[0]){
2043
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2044

    
2045
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2046

    
2047
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2048
            // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2049
        
2050
            int i= ff_find_unused_picture(s, 0);
2051
            Picture *pic= &s->picture[i];
2052

    
2053
            /* mark us unused / free shared pic */
2054
            for(i=0; i<4; i++)
2055
                s->reordered_input_picture[0]->data[i]= NULL;
2056
            s->reordered_input_picture[0]->type= 0;
2057
            
2058
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2059
            pic->reference              = s->reordered_input_picture[0]->reference;
2060
            
2061
            alloc_picture(s, pic, 0);
2062

    
2063
            s->current_picture_ptr= pic;
2064
        }else{
2065
            // input is not a shared pix -> reuse buffer for current_pix
2066

    
2067
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
2068
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2069
            
2070
            s->current_picture_ptr= s->reordered_input_picture[0];
2071
            for(i=0; i<4; i++){
2072
                s->new_picture.data[i]+=16;
2073
            }
2074
        }
2075
        copy_picture(&s->current_picture, s->current_picture_ptr);
2076
    
2077
        s->picture_number= s->new_picture.display_picture_number;
2078
//printf("dpn:%d\n", s->picture_number);
2079
    }else{
2080
       memset(&s->new_picture, 0, sizeof(Picture));
2081
    }
2082
}
2083

    
2084
int MPV_encode_picture(AVCodecContext *avctx,
2085
                       unsigned char *buf, int buf_size, void *data)
2086
{
2087
    MpegEncContext *s = avctx->priv_data;
2088
    AVFrame *pic_arg = data;
2089
    int i, stuffing_count;
2090

    
2091
    if(avctx->pix_fmt != PIX_FMT_YUV420P){
2092
        av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2093
        return -1;
2094
    }
2095
    
2096
    for(i=0; i<avctx->thread_count; i++){
2097
        int start_y= s->thread_context[i]->start_mb_y;
2098
        int   end_y= s->thread_context[i]->  end_mb_y;
2099
        int h= s->mb_height;
2100
        uint8_t *start= buf + buf_size*start_y/h;
2101
        uint8_t *end  = buf + buf_size*  end_y/h;
2102

    
2103
        init_put_bits(&s->thread_context[i]->pb, start, end - start);
2104
    }
2105

    
2106
    s->picture_in_gop_number++;
2107

    
2108
    load_input_picture(s, pic_arg);
2109
    
2110
    select_input_picture(s);
2111
    
2112
    /* output? */
2113
    if(s->new_picture.data[0]){
2114
        s->pict_type= s->new_picture.pict_type;
2115
//emms_c();
2116
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2117
        MPV_frame_start(s, avctx);
2118

    
2119
        encode_picture(s, s->picture_number);
2120
        
2121
        avctx->real_pict_num  = s->picture_number;
2122
        avctx->header_bits = s->header_bits;
2123
        avctx->mv_bits     = s->mv_bits;
2124
        avctx->misc_bits   = s->misc_bits;
2125
        avctx->i_tex_bits  = s->i_tex_bits;
2126
        avctx->p_tex_bits  = s->p_tex_bits;
2127
        avctx->i_count     = s->i_count;
2128
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2129
        avctx->skip_count  = s->skip_count;
2130

    
2131
        MPV_frame_end(s);
2132

    
2133
        if (s->out_format == FMT_MJPEG)
2134
            mjpeg_picture_trailer(s);
2135
        
2136
        if(s->flags&CODEC_FLAG_PASS1)
2137
            ff_write_pass1_stats(s);
2138

    
2139
        for(i=0; i<4; i++){
2140
            avctx->error[i] += s->current_picture_ptr->error[i];
2141
        }
2142

    
2143
        flush_put_bits(&s->pb);
2144
        s->frame_bits  = put_bits_count(&s->pb);
2145

    
2146
        stuffing_count= ff_vbv_update(s, s->frame_bits);
2147
        if(stuffing_count){
2148
            switch(s->codec_id){
2149
            case CODEC_ID_MPEG1VIDEO:
2150
            case CODEC_ID_MPEG2VIDEO:
2151
                while(stuffing_count--){
2152
                    put_bits(&s->pb, 8, 0);
2153
                }
2154
            break;
2155
            case CODEC_ID_MPEG4:
2156
                put_bits(&s->pb, 16, 0);
2157
                put_bits(&s->pb, 16, 0x1C3);
2158
                stuffing_count -= 4;
2159
                while(stuffing_count--){
2160
                    put_bits(&s->pb, 8, 0xFF);
2161
                }
2162
            break;
2163
            default:
2164
                av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2165
            }
2166
            flush_put_bits(&s->pb);
2167
            s->frame_bits  = put_bits_count(&s->pb);
2168
        }
2169

    
2170
        /* update mpeg1/2 vbv_delay for CBR */    
2171
        if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2172
           && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2173
            int vbv_delay;
2174

    
2175
            assert(s->repeat_first_field==0);
2176
            
2177
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2178
            assert(vbv_delay < 0xFFFF);
2179

    
2180
            s->vbv_delay_ptr[0] &= 0xF8;
2181
            s->vbv_delay_ptr[0] |= vbv_delay>>13;
2182
            s->vbv_delay_ptr[1]  = vbv_delay>>5;
2183
            s->vbv_delay_ptr[2] &= 0x07;
2184
            s->vbv_delay_ptr[2] |= vbv_delay<<3;
2185
        }
2186
        s->total_bits += s->frame_bits;
2187
        avctx->frame_bits  = s->frame_bits;
2188
    }else{
2189
        assert((pbBufPtr(&s->pb) == s->pb.buf));
2190
        s->frame_bits=0;
2191
    }
2192
    assert((s->frame_bits&7)==0);
2193
    
2194
    return s->frame_bits/8;
2195
}
2196

    
2197
#endif //CONFIG_ENCODERS
2198

    
2199
static inline void gmc1_motion(MpegEncContext *s,
2200
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2201
                               uint8_t **ref_picture)
2202
{
2203
    uint8_t *ptr;
2204
    int offset, src_x, src_y, linesize, uvlinesize;
2205
    int motion_x, motion_y;
2206
    int emu=0;
2207

    
2208
    motion_x= s->sprite_offset[0][0];
2209
    motion_y= s->sprite_offset[0][1];
2210
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2211
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2212
    motion_x<<=(3-s->sprite_warping_accuracy);
2213
    motion_y<<=(3-s->sprite_warping_accuracy);
2214
    src_x = clip(src_x, -16, s->width);
2215
    if (src_x == s->width)
2216
        motion_x =0;
2217
    src_y = clip(src_y, -16, s->height);
2218
    if (src_y == s->height)
2219
        motion_y =0;
2220

    
2221
    linesize = s->linesize;
2222
    uvlinesize = s->uvlinesize;
2223
    
2224
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2225

    
2226
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2227
        if(   (unsigned)src_x >= s->h_edge_pos - 17
2228
           || (unsigned)src_y >= s->v_edge_pos - 17){
2229
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2230
            ptr= s->edge_emu_buffer;
2231
        }
2232
    }
2233
    
2234
    if((motion_x|motion_y)&7){
2235
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2236
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2237
    }else{
2238
        int dxy;
2239
        
2240
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2241
        if (s->no_rounding){
2242
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2243
        }else{
2244
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2245
        }
2246
    }
2247
    
2248
    if(s->flags&CODEC_FLAG_GRAY) return;
2249

    
2250
    motion_x= s->sprite_offset[1][0];
2251
    motion_y= s->sprite_offset[1][1];
2252
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2253
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2254
    motion_x<<=(3-s->sprite_warping_accuracy);
2255
    motion_y<<=(3-s->sprite_warping_accuracy);
2256
    src_x = clip(src_x, -8, s->width>>1);
2257
    if (src_x == s->width>>1)
2258
        motion_x =0;
2259
    src_y = clip(src_y, -8, s->height>>1);
2260
    if (src_y == s->height>>1)
2261
        motion_y =0;
2262

    
2263
    offset = (src_y * uvlinesize) + src_x;
2264
    ptr = ref_picture[1] + offset;
2265
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2266
        if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2267
           || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2268
            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);
2269
            ptr= s->edge_emu_buffer;
2270
            emu=1;
2271
        }
2272
    }
2273
    s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2274
    
2275
    ptr = ref_picture[2] + offset;
2276
    if(emu){
2277
        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);
2278
        ptr= s->edge_emu_buffer;
2279
    }
2280
    s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2281
    
2282
    return;
2283
}
2284

    
2285
static inline void gmc_motion(MpegEncContext *s,
2286
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2287
                               uint8_t **ref_picture)
2288
{
2289
    uint8_t *ptr;
2290
    int linesize, uvlinesize;
2291
    const int a= s->sprite_warping_accuracy;
2292
    int ox, oy;
2293

    
2294
    linesize = s->linesize;
2295
    uvlinesize = s->uvlinesize;
2296

    
2297
    ptr = ref_picture[0];
2298

    
2299
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2300
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2301

    
2302
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2303
           ox, 
2304
           oy, 
2305
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2306
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2307
           a+1, (1<<(2*a+1)) - s->no_rounding,
2308
           s->h_edge_pos, s->v_edge_pos);
2309
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2310
           ox + s->sprite_delta[0][0]*8, 
2311
           oy + s->sprite_delta[1][0]*8, 
2312
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2313
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2314
           a+1, (1<<(2*a+1)) - s->no_rounding,
2315
           s->h_edge_pos, s->v_edge_pos);
2316

    
2317
    if(s->flags&CODEC_FLAG_GRAY) return;
2318

    
2319
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2320
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2321

    
2322
    ptr = ref_picture[1];
2323
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2324
           ox, 
2325
           oy, 
2326
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2327
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2328
           a+1, (1<<(2*a+1)) - s->no_rounding,
2329
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2330
    
2331
    ptr = ref_picture[2];
2332
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2333
           ox, 
2334
           oy, 
2335
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2336
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2337
           a+1, (1<<(2*a+1)) - s->no_rounding,
2338
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2339
}
2340

    
2341
/**
2342
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2343
 * @param buf destination buffer
2344
 * @param src source buffer
2345
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2346
 * @param block_w width of block
2347
 * @param block_h height of block
2348
 * @param src_x x coordinate of the top left sample of the block in the source buffer
2349
 * @param src_y y coordinate of the top left sample of the block in the source buffer
2350
 * @param w width of the source buffer
2351
 * @param h height of the source buffer
2352
 */
2353
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
2354
                                    int src_x, int src_y, int w, int h){
2355
    int x, y;
2356
    int start_y, start_x, end_y, end_x;
2357

    
2358
    if(src_y>= h){
2359
        src+= (h-1-src_y)*linesize;
2360
        src_y=h-1;
2361
    }else if(src_y<=-block_h){
2362
        src+= (1-block_h-src_y)*linesize;
2363
        src_y=1-block_h;
2364
    }
2365
    if(src_x>= w){
2366
        src+= (w-1-src_x);
2367
        src_x=w-1;
2368
    }else if(src_x<=-block_w){
2369
        src+= (1-block_w-src_x);
2370
        src_x=1-block_w;
2371
    }
2372

    
2373
    start_y= FFMAX(0, -src_y);
2374
    start_x= FFMAX(0, -src_x);
2375
    end_y= FFMIN(block_h, h-src_y);
2376
    end_x= FFMIN(block_w, w-src_x);
2377

    
2378
    // copy existing part
2379
    for(y=start_y; y<end_y; y++){
2380
        for(x=start_x; x<end_x; x++){
2381
            buf[x + y*linesize]= src[x + y*linesize];
2382
        }
2383
    }
2384

    
2385
    //top
2386
    for(y=0; y<start_y; y++){
2387
        for(x=start_x; x<end_x; x++){
2388
            buf[x + y*linesize]= buf[x + start_y*linesize];
2389
        }
2390
    }
2391

    
2392
    //bottom
2393
    for(y=end_y; y<block_h; y++){
2394
        for(x=start_x; x<end_x; x++){
2395
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2396
        }
2397
    }
2398
                                    
2399
    for(y=0; y<block_h; y++){
2400
       //left
2401
        for(x=0; x<start_x; x++){
2402
            buf[x + y*linesize]= buf[start_x + y*linesize];
2403
        }
2404
       
2405
       //right
2406
        for(x=end_x; x<block_w; x++){
2407
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2408
        }
2409
    }
2410
}
2411

    
2412
static inline int hpel_motion(MpegEncContext *s, 
2413
                                  uint8_t *dest, uint8_t *src,
2414
                                  int field_based, int field_select,
2415
                                  int src_x, int src_y,
2416
                                  int width, int height, int stride,
2417
                                  int h_edge_pos, int v_edge_pos,
2418
                                  int w, int h, op_pixels_func *pix_op,
2419
                                  int motion_x, int motion_y)
2420
{
2421
    int dxy;
2422
    int emu=0;
2423

    
2424
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2425
    src_x += motion_x >> 1;
2426
    src_y += motion_y >> 1;
2427
                
2428
    /* WARNING: do no forget half pels */
2429
    src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2430
    if (src_x == width)
2431
        dxy &= ~1;
2432
    src_y = clip(src_y, -16, height);
2433
    if (src_y == height)
2434
        dxy &= ~2;
2435
    src += src_y * stride + src_x;
2436

    
2437
    if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2438
        if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2439
           || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2440
            ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2441
                             src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2442
            src= s->edge_emu_buffer;
2443
            emu=1;
2444
        }
2445
    }
2446
    if(field_select)
2447
        src += s->linesize;
2448
    pix_op[dxy](dest, src, stride, h);
2449
    return emu;
2450
}
2451

    
2452
/* apply one mpeg motion vector to the three components */
2453
static inline void mpeg_motion(MpegEncContext *s,
2454
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2455
                               int field_based, int bottom_field, int field_select,
2456
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2457
                               int motion_x, int motion_y, int h)
2458
{
2459
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2460
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2461
    
2462
#if 0    
2463
if(s->quarter_sample)
2464
{
2465
    motion_x>>=1;
2466
    motion_y>>=1;
2467
}
2468
#endif
2469

    
2470
    v_edge_pos = s->v_edge_pos >> field_based;
2471
    linesize   = s->current_picture.linesize[0] << field_based;
2472
    uvlinesize = s->current_picture.linesize[1] << field_based;
2473

    
2474
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2475
    src_x = s->mb_x* 16               + (motion_x >> 1);
2476
    src_y = s->mb_y*(16>>field_based) + (motion_y >> 1);
2477

    
2478
    if (s->out_format == FMT_H263) {
2479
        if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2480
            mx = (motion_x>>1)|(motion_x&1);
2481
            my = motion_y >>1;
2482
            uvdxy = ((my & 1) << 1) | (mx & 1);
2483
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2484
            uvsrc_y = s->mb_y*(8>>field_based) + (my >> 1);
2485
        }else{
2486
            uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2487
            uvsrc_x = src_x>>1;
2488
            uvsrc_y = src_y>>1;
2489
        }
2490
    } else {
2491
        mx = motion_x / 2;
2492
        my = motion_y / 2;
2493
        uvdxy = ((my & 1) << 1) | (mx & 1);
2494
        uvsrc_x = s->mb_x* 8               + (mx >> 1);
2495
        uvsrc_y = s->mb_y*(8>>field_based) + (my >> 1);
2496
    }
2497

    
2498
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2499
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2500
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2501

    
2502
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2503
       || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
2504
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2505
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2506
            ptr_y = s->edge_emu_buffer;
2507
            if(!(s->flags&CODEC_FLAG_GRAY)){
2508
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2509
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2510
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2511
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2512
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2513
                ptr_cb= uvbuf;
2514
                ptr_cr= uvbuf+16;
2515
            }
2516
    }
2517

    
2518
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2519
        dest_y += s->linesize;
2520
        dest_cb+= s->uvlinesize;
2521
        dest_cr+= s->uvlinesize;
2522
    }
2523

    
2524
    if(field_select){
2525
        ptr_y += s->linesize;
2526
        ptr_cb+= s->uvlinesize;
2527
        ptr_cr+= s->uvlinesize;
2528
    }
2529

    
2530
    pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2531
    
2532
    if(!(s->flags&CODEC_FLAG_GRAY)){
2533
        pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
2534
        pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
2535
    }
2536
}
2537
//FIXME move to dsputil, avg variant, 16x16 version
2538
static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2539
    int x;
2540
    uint8_t * const top   = src[1];
2541
    uint8_t * const left  = src[2];
2542
    uint8_t * const mid   = src[0];
2543
    uint8_t * const right = src[3];
2544
    uint8_t * const bottom= src[4];
2545
#define OBMC_FILTER(x, t, l, m, r, b)\
2546
    dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2547
#define OBMC_FILTER4(x, t, l, m, r, b)\
2548
    OBMC_FILTER(x         , t, l, m, r, b);\
2549
    OBMC_FILTER(x+1       , t, l, m, r, b);\
2550
    OBMC_FILTER(x  +stride, t, l, m, r, b);\
2551
    OBMC_FILTER(x+1+stride, t, l, m, r, b);
2552
    
2553
    x=0;
2554
    OBMC_FILTER (x  , 2, 2, 4, 0, 0);
2555
    OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2556
    OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2557
    OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2558
    OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2559
    OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2560
    x+= stride;
2561
    OBMC_FILTER (x  , 1, 2, 5, 0, 0);
2562
    OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2563
    OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2564
    OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2565
    x+= stride;
2566
    OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
2567
    OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2568
    OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2569
    OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2570
    x+= 2*stride;
2571
    OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
2572
    OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2573
    OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2574
    OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2575
    x+= 2*stride;
2576
    OBMC_FILTER (x  , 0, 2, 5, 0, 1);
2577
    OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2578
    OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2579
    OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2580
    OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2581
    OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2582
    x+= stride;
2583
    OBMC_FILTER (x  , 0, 2, 4, 0, 2);
2584
    OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2585
    OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2586
    OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2587
}
2588

    
2589
/* obmc for 1 8x8 luma block */
2590
static inline void obmc_motion(MpegEncContext *s,
2591
                               uint8_t *dest, uint8_t *src,
2592
                               int src_x, int src_y,
2593
                               op_pixels_func *pix_op,
2594
                               int16_t mv[5][2]/* mid top left right bottom*/)
2595
#define MID    0
2596
{
2597
    int i;
2598
    uint8_t *ptr[5];
2599
    
2600
    assert(s->quarter_sample==0);
2601
    
2602
    for(i=0; i<5; i++){
2603
        if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2604
            ptr[i]= ptr[MID];
2605
        }else{
2606
            ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
2607
            hpel_motion(s, ptr[i], src, 0, 0,
2608
                        src_x, src_y,
2609
                        s->width, s->height, s->linesize,
2610
                        s->h_edge_pos, s->v_edge_pos,
2611
                        8, 8, pix_op,
2612
                        mv[i][0], mv[i][1]);
2613
        }
2614
    }
2615

    
2616
    put_obmc(dest, ptr, s->linesize);                
2617
}
2618

    
2619
static inline void qpel_motion(MpegEncContext *s,
2620
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2621
                               int field_based, int bottom_field, int field_select,
2622
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2623
                               qpel_mc_func (*qpix_op)[16],
2624
                               int motion_x, int motion_y, int h)
2625
{
2626
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2627
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
2628

    
2629
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2630
    src_x = s->mb_x *  16                 + (motion_x >> 2);
2631
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2632

    
2633
    v_edge_pos = s->v_edge_pos >> field_based;
2634
    linesize = s->linesize << field_based;
2635
    uvlinesize = s->uvlinesize << field_based;
2636
    
2637
    if(field_based){
2638
        mx= motion_x/2;
2639
        my= motion_y>>1;
2640
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2641
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
2642
        mx= (motion_x>>1) + rtab[motion_x&7];
2643
        my= (motion_y>>1) + rtab[motion_y&7];
2644
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2645
        mx= (motion_x>>1)|(motion_x&1);
2646
        my= (motion_y>>1)|(motion_y&1);
2647
    }else{
2648
        mx= motion_x/2;
2649
        my= motion_y/2;
2650
    }
2651
    mx= (mx>>1)|(mx&1);
2652
    my= (my>>1)|(my&1);
2653

    
2654
    uvdxy= (mx&1) | ((my&1)<<1);
2655
    mx>>=1;
2656
    my>>=1;
2657

    
2658
    uvsrc_x = s->mb_x *  8                 + mx;
2659
    uvsrc_y = s->mb_y * (8 >> field_based) + my;
2660

    
2661
    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
2662
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2663
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2664

    
2665
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 
2666
       || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
2667
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, 
2668
                         src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2669
        ptr_y= s->edge_emu_buffer;
2670
        if(!(s->flags&CODEC_FLAG_GRAY)){
2671
            uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
2672
            ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based, 
2673
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2674
            ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based, 
2675
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2676
            ptr_cb= uvbuf;
2677
            ptr_cr= uvbuf + 16;
2678
        }
2679
    }
2680

    
2681
    if(!field_based)
2682
        qpix_op[0][dxy](dest_y, ptr_y, linesize);
2683
    else{
2684
        if(bottom_field){
2685
            dest_y += s->linesize;
2686
            dest_cb+= s->uvlinesize;
2687
            dest_cr+= s->uvlinesize;
2688
        }
2689

    
2690
        if(field_select){
2691
            ptr_y  += s->linesize;
2692
            ptr_cb += s->uvlinesize;
2693
            ptr_cr += s->uvlinesize;
2694
        }
2695
        //damn interlaced mode
2696
        //FIXME boundary mirroring is not exactly correct here
2697
        qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
2698
        qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
2699
    }
2700
    if(!(s->flags&CODEC_FLAG_GRAY)){
2701
        pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
2702
        pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
2703
    }
2704
}
2705

    
2706
inline int ff_h263_round_chroma(int x){
2707
    if (x >= 0)
2708
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2709
    else {
2710
        x = -x;
2711
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2712
    }
2713
}
2714

    
2715
/**
2716
 * h263 chorma 4mv motion compensation.
2717
 */
2718
static inline void chroma_4mv_motion(MpegEncContext *s,
2719
                                     uint8_t *dest_cb, uint8_t *dest_cr,
2720
                                     uint8_t **ref_picture,
2721
                                     op_pixels_func *pix_op,
2722
                                     int mx, int my){
2723
    int dxy, emu=0, src_x, src_y, offset;
2724
    uint8_t *ptr;
2725
    
2726
    /* In case of 8X8, we construct a single chroma motion vector
2727
       with a special rounding */
2728
    mx= ff_h263_round_chroma(mx);
2729
    my= ff_h263_round_chroma(my);
2730
    
2731
    dxy = ((my & 1) << 1) | (mx & 1);
2732
    mx >>= 1;
2733
    my >>= 1;
2734

    
2735
    src_x = s->mb_x * 8 + mx;
2736
    src_y = s->mb_y * 8 + my;
2737
    src_x = clip(src_x, -8, s->width/2);
2738
    if (src_x == s->width/2)
2739
        dxy &= ~1;
2740
    src_y = clip(src_y, -8, s->height/2);
2741
    if (src_y == s->height/2)
2742
        dxy &= ~2;
2743
    
2744
    offset = (src_y * (s->uvlinesize)) + src_x;
2745
    ptr = ref_picture[1] + offset;
2746
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2747
        if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
2748
           || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
2749
            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);
2750
            ptr= s->edge_emu_buffer;
2751
            emu=1;
2752
        }
2753
    }
2754
    pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
2755

    
2756
    ptr = ref_picture[2] + offset;
2757
    if(emu){
2758
        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);
2759
        ptr= s->edge_emu_buffer;
2760
    }
2761
    pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
2762
}
2763

    
2764
/**
2765
 * motion compesation of a single macroblock
2766
 * @param s context
2767
 * @param dest_y luma destination pointer
2768
 * @param dest_cb chroma cb/u destination pointer
2769
 * @param dest_cr chroma cr/v destination pointer
2770
 * @param dir direction (0->forward, 1->backward)
2771
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2772
 * @param pic_op halfpel motion compensation function (average or put normally)
2773
 * @param pic_op qpel motion compensation function (average or put normally)
2774
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2775
 */
2776
static inline void MPV_motion(MpegEncContext *s, 
2777
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2778
                              int dir, uint8_t **ref_picture, 
2779
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
2780
{
2781
    int dxy, mx, my, src_x, src_y, motion_x, motion_y;
2782
    int mb_x, mb_y, i;
2783
    uint8_t *ptr, *dest;
2784

    
2785
    mb_x = s->mb_x;
2786
    mb_y = s->mb_y;
2787

    
2788
    if(s->obmc && s->pict_type != B_TYPE){
2789
        int16_t mv_cache[4][4][2];
2790
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
2791
        const int mot_stride= s->b8_stride;
2792
        const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
2793

    
2794
        assert(!s->mb_skiped);
2795
                
2796
        memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
2797
        memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2798
        memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2799

    
2800
        if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
2801
            memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
2802
        }else{
2803
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
2804
        }
2805

    
2806
        if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
2807
            *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
2808
            *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
2809
        }else{
2810
            *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
2811
            *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
2812
        }
2813

    
2814
        if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
2815
            *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
2816
            *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
2817
        }else{
2818
            *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
2819
            *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
2820
        }
2821
        
2822
        mx = 0;
2823
        my = 0;
2824
        for(i=0;i<4;i++) {
2825
            const int x= (i&1)+1;
2826
            const int y= (i>>1)+1;
2827
            int16_t mv[5][2]= {
2828
                {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
2829
                {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
2830
                {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
2831
                {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
2832
                {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
2833
            //FIXME cleanup
2834
            obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2835
                        ref_picture[0],
2836
                        mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2837
                        pix_op[1],
2838
                        mv);
2839

    
2840
            mx += mv[0][0];
2841
            my += mv[0][1];
2842
        }
2843
        if(!(s->flags&CODEC_FLAG_GRAY))
2844
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2845

    
2846
        return;
2847
    }
2848
   
2849
    switch(s->mv_type) {
2850
    case MV_TYPE_16X16:
2851
#ifdef CONFIG_RISKY
2852
        if(s->mcsel){
2853
            if(s->real_sprite_warping_points==1){
2854
                gmc1_motion(s, dest_y, dest_cb, dest_cr,
2855
                            ref_picture);
2856
            }else{
2857
                gmc_motion(s, dest_y, dest_cb, dest_cr,
2858
                            ref_picture);
2859
            }
2860
        }else if(s->quarter_sample){
2861
            qpel_motion(s, dest_y, dest_cb, dest_cr, 
2862
                        0, 0, 0,
2863
                        ref_picture, pix_op, qpix_op,
2864
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2865
        }else if(s->mspel){
2866
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
2867
                        ref_picture, pix_op,
2868
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2869
        }else
2870
#endif
2871
        {
2872
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 
2873
                        0, 0, 0,
2874
                        ref_picture, pix_op,
2875
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2876
        }           
2877
        break;
2878
    case MV_TYPE_8X8:
2879
        mx = 0;
2880
        my = 0;
2881
        if(s->quarter_sample){
2882
            for(i=0;i<4;i++) {
2883
                motion_x = s->mv[dir][i][0];
2884
                motion_y = s->mv[dir][i][1];
2885

    
2886
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2887
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
2888
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
2889
                    
2890
                /* WARNING: do no forget half pels */
2891
                src_x = clip(src_x, -16, s->width);
2892
                if (src_x == s->width)
2893
                    dxy &= ~3;
2894
                src_y = clip(src_y, -16, s->height);
2895
                if (src_y == s->height)
2896
                    dxy &= ~12;
2897
                    
2898
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2899
                if(s->flags&CODEC_FLAG_EMU_EDGE){
2900
                    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8 
2901
                       || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
2902
                        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);
2903
                        ptr= s->edge_emu_buffer;
2904
                    }
2905
                }
2906
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2907
                qpix_op[1][dxy](dest, ptr, s->linesize);
2908

    
2909
                mx += s->mv[dir][i][0]/2;
2910
                my += s->mv[dir][i][1]/2;
2911
            }
2912
        }else{
2913
            for(i=0;i<4;i++) {
2914
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2915
                            ref_picture[0], 0, 0,
2916
                            mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2917
                            s->width, s->height, s->linesize,
2918
                            s->h_edge_pos, s->v_edge_pos,
2919
                            8, 8, pix_op[1],
2920
                            s->mv[dir][i][0], s->mv[dir][i][1]);
2921

    
2922
                mx += s->mv[dir][i][0];
2923
                my += s->mv[dir][i][1];
2924
            }
2925
        }
2926

    
2927
        if(!(s->flags&CODEC_FLAG_GRAY))
2928
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2929
        break;
2930
    case MV_TYPE_FIELD:
2931
        if (s->picture_structure == PICT_FRAME) {
2932
            if(s->quarter_sample){
2933
                for(i=0; i<2; i++){
2934
                    qpel_motion(s, dest_y, dest_cb, dest_cr,
2935
                                1, i, s->field_select[dir][i],
2936
                                ref_picture, pix_op, qpix_op,
2937
                                s->mv[dir][i][0], s->mv[dir][i][1], 8);
2938
                }
2939
            }else{
2940
                /* top field */       
2941
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
2942
                            1, 0, s->field_select[dir][0],
2943
                            ref_picture, pix_op,
2944
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
2945
                /* bottom field */
2946
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
2947
                            1, 1, s->field_select[dir][1],
2948
                            ref_picture, pix_op,
2949
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
2950
            }
2951
        } else {
2952
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
2953
                ref_picture= s->current_picture_ptr->data;
2954
            } 
2955

    
2956
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
2957
                        0, 0, s->field_select[dir][0],
2958
                        ref_picture, pix_op,
2959
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2960
        }
2961
        break;
2962
    case MV_TYPE_16X8:
2963
        for(i=0; i<2; i++){
2964
            uint8_t ** ref2picture;
2965

    
2966
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
2967
                ref2picture= ref_picture;
2968
            }else{
2969
                ref2picture= s->current_picture_ptr->data;
2970
            } 
2971

    
2972
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 
2973
                        0, 0, s->field_select[dir][i],
2974
                        ref2picture, pix_op,
2975
                        s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
2976
                
2977
            dest_y += 16*s->linesize;
2978
            dest_cb+=  8*s->uvlinesize;
2979
            dest_cr+=  8*s->uvlinesize;
2980
        }        
2981
        break;
2982
    case MV_TYPE_DMV:
2983
        if(s->picture_structure == PICT_FRAME){
2984
            for(i=0; i<2; i++){
2985
                int j;
2986
                for(j=0; j<2; j++){
2987
                    mpeg_motion(s, dest_y, dest_cb, dest_cr,
2988
                                1, j, j^i,
2989
                                ref_picture, pix_op,
2990
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
2991
                }
2992
                pix_op = s->dsp.avg_pixels_tab; 
2993
            }
2994
        }else{
2995
            for(i=0; i<2; i++){
2996
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 
2997
                            0, 0, s->picture_structure != i+1,
2998
                            ref_picture, pix_op,
2999
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3000

    
3001
                // after put we make avg of the same block
3002
                pix_op=s->dsp.avg_pixels_tab; 
3003

    
3004
                //opposite parity is always in the same frame if this is second field
3005
                if(!s->first_field){
3006
                    ref_picture = s->current_picture_ptr->data;    
3007
                }
3008
            }
3009
        }
3010
    break;
3011
    default: assert(0);
3012
    }
3013
}
3014

    
3015

    
3016
/* put block[] to dest[] */
3017
static inline void put_dct(MpegEncContext *s, 
3018
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3019
{
3020
    s->dct_unquantize_intra(s, block, i, qscale);
3021
    s->dsp.idct_put (dest, line_size, block);
3022
}
3023

    
3024
/* add block[] to dest[] */
3025
static inline void add_dct(MpegEncContext *s, 
3026
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
3027
{
3028
    if (s->block_last_index[i] >= 0) {
3029
        s->dsp.idct_add (dest, line_size, block);
3030
    }
3031
}
3032

    
3033
static inline void add_dequant_dct(MpegEncContext *s, 
3034
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3035
{
3036
    if (s->block_last_index[i] >= 0) {
3037
        s->dct_unquantize_inter(s, block, i, qscale);
3038

    
3039
        s->dsp.idct_add (dest, line_size, block);
3040
    }
3041
}
3042

    
3043
/**
3044
 * cleans dc, ac, coded_block for the current non intra MB
3045
 */
3046
void ff_clean_intra_table_entries(MpegEncContext *s)
3047
{
3048
    int wrap = s->b8_stride;
3049
    int xy = s->block_index[0];
3050
    
3051
    s->dc_val[0][xy           ] = 
3052
    s->dc_val[0][xy + 1       ] = 
3053
    s->dc_val[0][xy     + wrap] =
3054
    s->dc_val[0][xy + 1 + wrap] = 1024;
3055
    /* ac pred */
3056
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
3057
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3058
    if (s->msmpeg4_version>=3) {
3059
        s->coded_block[xy           ] =
3060
        s->coded_block[xy + 1       ] =
3061
        s->coded_block[xy     + wrap] =
3062
        s->coded_block[xy + 1 + wrap] = 0;
3063
    }
3064
    /* chroma */
3065
    wrap = s->mb_stride;
3066
    xy = s->mb_x + s->mb_y * wrap;
3067
    s->dc_val[1][xy] =
3068
    s->dc_val[2][xy] = 1024;
3069
    /* ac pred */
3070
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3071
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3072
    
3073
    s->mbintra_table[xy]= 0;
3074
}
3075

    
3076
/* generic function called after a macroblock has been parsed by the
3077
   decoder or after it has been encoded by the encoder.
3078

3079
   Important variables used:
3080
   s->mb_intra : true if intra macroblock
3081
   s->mv_dir   : motion vector direction
3082
   s->mv_type  : motion vector type
3083
   s->mv       : motion vector
3084
   s->interlaced_dct : true if interlaced dct used (mpeg2)
3085
 */
3086
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
3087
{
3088
    int mb_x, mb_y;
3089
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3090
#ifdef HAVE_XVMC
3091
    if(s->avctx->xvmc_acceleration){
3092
        XVMC_decode_mb(s);//xvmc uses pblocks
3093
        return;
3094
    }
3095
#endif
3096

    
3097
    mb_x = s->mb_x;
3098
    mb_y = s->mb_y;
3099

    
3100
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3101
       /* save DCT coefficients */
3102
       int i,j;
3103
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3104
       for(i=0; i<6; i++)
3105
           for(j=0; j<64; j++)
3106
               *dct++ = block[i][s->dsp.idct_permutation[j]];
3107
    }
3108

    
3109
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3110

    
3111
    /* update DC predictors for P macroblocks */
3112
    if (!s->mb_intra) {
3113
        if (s->h263_pred || s->h263_aic) {
3114
            if(s->mbintra_table[mb_xy])
3115
                ff_clean_intra_table_entries(s);
3116
        } else {
3117
            s->last_dc[0] =
3118
            s->last_dc[1] =
3119
            s->last_dc[2] = 128 << s->intra_dc_precision;
3120
        }
3121
    }
3122
    else if (s->h263_pred || s->h263_aic)
3123
        s->mbintra_table[mb_xy]=1;
3124

    
3125
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3126
        uint8_t *dest_y, *dest_cb, *dest_cr;
3127
        int dct_linesize, dct_offset;
3128
        op_pixels_func (*op_pix)[4];
3129
        qpel_mc_func (*op_qpix)[16];
3130
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3131
        const int uvlinesize= s->current_picture.linesize[1];
3132
        const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band;
3133

    
3134
        /* avoid copy if macroblock skipped in last frame too */
3135
        /* skip only during decoding as we might trash the buffers during encoding a bit */
3136
        if(!s->encoding){
3137
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3138
            const int age= s->current_picture.age;
3139

    
3140
            assert(age);
3141

    
3142
            if (s->mb_skiped) {
3143
                s->mb_skiped= 0;
3144
                assert(s->pict_type!=I_TYPE);
3145
 
3146
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
3147
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3148

    
3149
                /* if previous was skipped too, then nothing to do !  */
3150
                if (*mbskip_ptr >= age && s->current_picture.reference){
3151
                    return;
3152
                }
3153
            } else if(!s->current_picture.reference){
3154
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3155
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3156
            } else{
3157
                *mbskip_ptr = 0; /* not skipped */
3158
            }
3159
        }
3160

    
3161
        if (s->interlaced_dct) {
3162
            dct_linesize = linesize * 2;
3163
            dct_offset = linesize;
3164
        } else {
3165
            dct_linesize = linesize;
3166
            dct_offset = linesize * 8;
3167
        }
3168
        if(readable){
3169
            dest_y=  s->dest[0];
3170
            dest_cb= s->dest[1];
3171
            dest_cr= s->dest[2];
3172
        }else{
3173
            dest_y = s->b_scratchpad;
3174
            dest_cb= s->b_scratchpad+16*linesize;
3175
            dest_cr= s->b_scratchpad+16*linesize+8;
3176
        }
3177
        if (!s->mb_intra) {
3178
            /* motion handling */
3179
            /* decoding or more than one mb_type (MC was allready done otherwise) */
3180
            if(!s->encoding){
3181
                if ((!s->no_rounding) || s->pict_type==B_TYPE){                
3182
                    op_pix = s->dsp.put_pixels_tab;
3183
                    op_qpix= s->dsp.put_qpel_pixels_tab;
3184
                }else{
3185
                    op_pix = s->dsp.put_no_rnd_pixels_tab;
3186
                    op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3187
                }
3188

    
3189
                if (s->mv_dir & MV_DIR_FORWARD) {
3190
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3191
                    op_pix = s->dsp.avg_pixels_tab;
3192
                    op_qpix= s->dsp.avg_qpel_pixels_tab;
3193
                }
3194
                if (s->mv_dir & MV_DIR_BACKWARD) {
3195
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3196
                }
3197
            }
3198

    
3199
            /* skip dequant / idct if we are really late ;) */
3200
            if(s->hurry_up>1) return;
3201

    
3202
            /* add dct residue */
3203
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3204
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3205
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
3206
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
3207
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
3208
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
3209

    
3210
                if(!(s->flags&CODEC_FLAG_GRAY)){
3211
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3212
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3213
                }
3214
            } else if(s->codec_id != CODEC_ID_WMV2){
3215
                add_dct(s, block[0], 0, dest_y, dct_linesize);
3216
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
3217
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
3218
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
3219

    
3220
                if(!(s->flags&CODEC_FLAG_GRAY)){
3221
                    add_dct(s, block[4], 4, dest_cb, uvlinesize);
3222
                    add_dct(s, block[5], 5, dest_cr, uvlinesize);
3223
                }
3224
            } 
3225
#ifdef CONFIG_RISKY
3226
            else{
3227
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3228
            }
3229
#endif
3230
        } else {
3231
            /* dct only in intra block */
3232
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3233
                put_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
3234
                put_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
3235
                put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
3236
                put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
3237

    
3238
                if(!(s->flags&CODEC_FLAG_GRAY)){
3239
                    put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3240
                    put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3241
                }
3242
            }else{
3243
                s->dsp.idct_put(dest_y                 , dct_linesize, block[0]);
3244
                s->dsp.idct_put(dest_y              + 8, dct_linesize, block[1]);
3245
                s->dsp.idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
3246
                s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
3247

    
3248
                if(!(s->flags&CODEC_FLAG_GRAY)){
3249
                    s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3250
                    s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3251
                }
3252
            }
3253
        }
3254
        if(!readable){
3255
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3256
            s->dsp.put_pixels_tab[1][0](s->dest[1], dest_cb, uvlinesize, 8);
3257
            s->dsp.put_pixels_tab[1][0](s->dest[2], dest_cr, uvlinesize, 8);
3258
        }
3259
    }
3260
}
3261

    
3262
#ifdef CONFIG_ENCODERS
3263

    
3264
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3265
{
3266
    static const char tab[64]=
3267
        {3,2,2,1,1,1,1,1,
3268
         1,1,1,1,1,1,1,1,
3269
         1,1,1,1,1,1,1,1,
3270
         0,0,0,0,0,0,0,0,
3271
         0,0,0,0,0,0,0,0,
3272
         0,0,0,0,0,0,0,0,
3273
         0,0,0,0,0,0,0,0,
3274
         0,0,0,0,0,0,0,0};
3275
    int score=0;
3276
    int run=0;
3277
    int i;
3278
    DCTELEM *block= s->block[n];
3279
    const int last_index= s->block_last_index[n];
3280
    int skip_dc;
3281

    
3282
    if(threshold<0){
3283
        skip_dc=0;
3284
        threshold= -threshold;
3285
    }else
3286
        skip_dc=1;
3287

    
3288
    /* are all which we could set to zero are allready zero? */
3289
    if(last_index<=skip_dc - 1) return;
3290

    
3291
    for(i=0; i<=last_index; i++){
3292
        const int j = s->intra_scantable.permutated[i];
3293
        const int level = ABS(block[j]);
3294
        if(level==1){
3295
            if(skip_dc && i==0) continue;
3296
            score+= tab[run];
3297
            run=0;
3298
        }else if(level>1){
3299
            return;
3300
        }else{
3301
            run++;
3302
        }
3303
    }
3304
    if(score >= threshold) return;
3305
    for(i=skip_dc; i<=last_index; i++){
3306
        const int j = s->intra_scantable.permutated[i];
3307
        block[j]=0;
3308
    }
3309
    if(block[0]) s->block_last_index[n]= 0;
3310
    else         s->block_last_index[n]= -1;
3311
}
3312

    
3313
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
3314
{
3315
    int i;
3316
    const int maxlevel= s->max_qcoeff;
3317
    const int minlevel= s->min_qcoeff;
3318
    int overflow=0;
3319
    
3320
    if(s->mb_intra){
3321
        i=1; //skip clipping of intra dc
3322
    }else
3323
        i=0;
3324
    
3325
    for(;i<=last_index; i++){
3326
        const int j= s->intra_scantable.permutated[i];
3327
        int level = block[j];
3328
       
3329
        if     (level>maxlevel){
3330
            level=maxlevel;
3331
            overflow++;
3332
        }else if(level<minlevel){
3333
            level=minlevel;
3334
            overflow++;
3335
        }
3336
        
3337
        block[j]= level;
3338
    }
3339
    
3340
    if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
3341
        av_log(s->avctx, AV_LOG_INFO, "warning, cliping %d dct coefficents to %d..%d\n", overflow, minlevel, maxlevel);
3342
}
3343

    
3344
#endif //CONFIG_ENCODERS
3345

    
3346
/**
3347
 *
3348
 * @param h is the normal height, this will be reduced automatically if needed for the last row
3349
 */
3350
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3351
    if (s->avctx->draw_horiz_band) {
3352
        AVFrame *src;
3353
        int offset[4];
3354
        
3355
        if(s->picture_structure != PICT_FRAME){
3356
            h <<= 1;
3357
            y <<= 1;
3358
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3359
        }
3360

    
3361
        h= FFMIN(h, s->height - y);
3362

    
3363
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) 
3364
            src= (AVFrame*)s->current_picture_ptr;
3365
        else if(s->last_picture_ptr)
3366
            src= (AVFrame*)s->last_picture_ptr;
3367
        else
3368
            return;
3369
            
3370
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3371
            offset[0]=
3372
            offset[1]=
3373
            offset[2]=
3374
            offset[3]= 0;
3375
        }else{
3376
            offset[0]= y * s->linesize;;
3377
            offset[1]= 
3378
            offset[2]= (y>>1) * s->uvlinesize;;
3379
            offset[3]= 0;
3380
        }
3381

    
3382
        emms_c();
3383

    
3384
        s->avctx->draw_horiz_band(s->avctx, src, offset,
3385
                                  y, s->picture_structure, h);
3386
    }
3387
}
3388

    
3389
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3390
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3391
    const int uvlinesize= s->current_picture.linesize[1];
3392
        
3393
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
3394
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
3395
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
3396
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3397
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3398
    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;
3399
    
3400
    if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){
3401
        s->dest[0] = s->current_picture.data[0] + s->mb_x * 16 - 16;
3402
        s->dest[1] = s->current_picture.data[1] + s->mb_x * 8 - 8;
3403
        s->dest[2] = s->current_picture.data[2] + s->mb_x * 8 - 8;
3404
    }else{
3405
        s->dest[0] = s->current_picture.data[0] + (s->mb_y * 16* linesize  ) + s->mb_x * 16 - 16;
3406
        s->dest[1] = s->current_picture.data[1] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
3407
        s->dest[2] = s->current_picture.data[2] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
3408
    }    
3409
}
3410

    
3411
#ifdef CONFIG_ENCODERS
3412

    
3413
static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
3414
    int x, y;
3415
//FIXME optimize
3416
    for(y=0; y<8; y++){
3417
        for(x=0; x<8; x++){
3418
            int x2, y2;
3419
            int sum=0;
3420
            int sqr=0;
3421
            int count=0;
3422

    
3423
            for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
3424
                for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
3425
                    int v= ptr[x2 + y2*stride];
3426
                    sum += v;
3427
                    sqr += v*v;
3428
                    count++;
3429
                }
3430
            }
3431
            weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
3432
        }
3433
    }
3434
}
3435

    
3436
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
3437
{
3438
    int16_t weight[6][64];
3439
    DCTELEM orig[6][64];
3440
    const int mb_x= s->mb_x;
3441
    const int mb_y= s->mb_y;
3442
    int i;
3443
    int skip_dct[6];
3444
    int dct_offset   = s->linesize*8; //default for progressive frames
3445
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3446
    int wrap_y, wrap_c;
3447
    
3448
    for(i=0; i<6; i++) skip_dct[i]=0;
3449
    
3450
    if(s->adaptive_quant){
3451
        const int last_qp= s->qscale;
3452
        const int mb_xy= mb_x + mb_y*s->mb_stride;
3453

    
3454
        s->lambda= s->lambda_table[mb_xy];
3455
        update_qscale(s);
3456
    
3457
        if(!(s->flags&CODEC_FLAG_QP_RD)){
3458
            s->dquant= s->qscale - last_qp;
3459

    
3460
            if(s->out_format==FMT_H263){
3461
                s->dquant= clip(s->dquant, -2, 2); //FIXME RD
3462
            
3463
                if(s->codec_id==CODEC_ID_MPEG4){        
3464
                    if(!s->mb_intra){
3465
                        if(s->pict_type == B_TYPE){
3466
                            if(s->dquant&1) 
3467
                                s->dquant= (s->dquant/2)*2;
3468
                            if(s->mv_dir&MV_DIRECT)
3469
                                s->dquant= 0;
3470
                        }
3471
                        if(s->mv_type==MV_TYPE_8X8)
3472
                            s->dquant=0;
3473
                    }
3474
                }
3475
            }
3476
        }
3477
        ff_set_qscale(s, last_qp + s->dquant);
3478
    }
3479

    
3480
    wrap_y = s->linesize;
3481
    wrap_c = s->uvlinesize;
3482
    ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
3483
    ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
3484
    ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3485

    
3486
    if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
3487
        ff_emulated_edge_mc(s->edge_emu_buffer            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
3488
        ptr_y= s->edge_emu_buffer;
3489
        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);
3490
        ptr_cb= s->edge_emu_buffer+18*wrap_y;
3491
        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);
3492
        ptr_cr= s->edge_emu_buffer+18*wrap_y+9;
3493
    }
3494

    
3495
    if (s->mb_intra) {
3496
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3497
            int progressive_score, interlaced_score;
3498

    
3499
            s->interlaced_dct=0;
3500
            progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8) 
3501
                              +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
3502

    
3503
            if(progressive_score > 0){
3504
                interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8) 
3505
                                  +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
3506
                if(progressive_score > interlaced_score){
3507
                    s->interlaced_dct=1;
3508
            
3509
                    dct_offset= wrap_y;
3510
                    wrap_y<<=1;
3511
                }
3512
            }
3513
        }
3514
        
3515
        s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
3516
        s->dsp.get_pixels(s->block[1], ptr_y              + 8, wrap_y);
3517
        s->dsp.get_pixels(s->block[2], ptr_y + dct_offset    , wrap_y);
3518
        s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
3519

    
3520
        if(s->flags&CODEC_FLAG_GRAY){
3521
            skip_dct[4]= 1;
3522
            skip_dct[5]= 1;
3523
        }else{
3524
            s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
3525
            s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
3526
        }
3527
    }else{
3528
        op_pixels_func (*op_pix)[4];
3529
        qpel_mc_func (*op_qpix)[16];
3530
        uint8_t *dest_y, *dest_cb, *dest_cr;
3531

    
3532
        dest_y  = s->dest[0];
3533
        dest_cb = s->dest[1];
3534
        dest_cr = s->dest[2];
3535

    
3536
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
3537
            op_pix = s->dsp.put_pixels_tab;
3538
            op_qpix= s->dsp.put_qpel_pixels_tab;
3539
        }else{
3540
            op_pix = s->dsp.put_no_rnd_pixels_tab;
3541
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3542
        }
3543

    
3544
        if (s->mv_dir & MV_DIR_FORWARD) {
3545
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3546
            op_pix = s->dsp.avg_pixels_tab;
3547
            op_qpix= s->dsp.avg_qpel_pixels_tab;
3548
        }
3549
        if (s->mv_dir & MV_DIR_BACKWARD) {
3550
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3551
        }
3552

    
3553
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3554
            int progressive_score, interlaced_score;
3555

    
3556
            s->interlaced_dct=0;
3557
            progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8) 
3558
                              +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
3559
            
3560
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
3561

    
3562
            if(progressive_score>0){
3563
                interlaced_score = s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y*2, 8) 
3564
                                  +s->dsp.ildct_cmp[0](s, dest_y + wrap_y  , ptr_y + wrap_y  , wrap_y*2, 8);
3565
            
3566
                if(progressive_score > interlaced_score){
3567
                    s->interlaced_dct=1;
3568
            
3569
                    dct_offset= wrap_y;
3570
                    wrap_y<<=1;
3571
                }
3572
            }
3573
        }
3574
        
3575
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
3576
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
3577
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
3578
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
3579
        
3580
        if(s->flags&CODEC_FLAG_GRAY){
3581
            skip_dct[4]= 1;
3582
            skip_dct[5]= 1;
3583
        }else{
3584
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
3585
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
3586
        }
3587
        /* pre quantization */         
3588
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
3589
            //FIXME optimize
3590
            if(s->dsp.sad[1](NULL, ptr_y               , dest_y               , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
3591
            if(s->dsp.sad[1](NULL, ptr_y            + 8, dest_y            + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
3592
            if(s->dsp.sad[1](NULL, ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
3593
            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;
3594
            if(s->dsp.sad[1](NULL, ptr_cb              , dest_cb              , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
3595
            if(s->dsp.sad[1](NULL, ptr_cr              , dest_cr              , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
3596
        }
3597
    }
3598

    
3599
    if(s->avctx->quantizer_noise_shaping){
3600
        if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y                 , wrap_y);
3601
        if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y              + 8, wrap_y);
3602
        if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset    , wrap_y);
3603
        if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
3604
        if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb                , wrap_c);
3605
        if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr                , wrap_c);
3606
        memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*6);
3607
    }
3608
            
3609
    /* DCT & quantize */
3610
    assert(s->out_format!=FMT_MJPEG || s->qscale==8);
3611
    {
3612
        for(i=0;i<6;i++) {
3613
            if(!skip_dct[i]){
3614
                int overflow;
3615
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
3616
            // FIXME we could decide to change to quantizer instead of clipping
3617
            // JS: I don't think that would be a good idea it could lower quality instead
3618
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
3619
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
3620
            }else
3621
                s->block_last_index[i]= -1;
3622
        }
3623
        if(s->avctx->quantizer_noise_shaping){
3624
            for(i=0;i<6;i++) {
3625
                if(!skip_dct[i]){
3626
                    s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
3627
                }
3628
            }
3629
        }
3630
        
3631
        if(s->luma_elim_threshold && !s->mb_intra)
3632
            for(i=0; i<4; i++)
3633
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
3634
        if(s->chroma_elim_threshold && !s->mb_intra)
3635
            for(i=4; i<6; i++)
3636
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
3637

    
3638
        if(s->flags & CODEC_FLAG_CBP_RD){
3639
            for(i=0;i<6;i++) {
3640
                if(s->block_last_index[i] == -1)
3641
                    s->coded_score[i]= INT_MAX/256;
3642
            }
3643
        }
3644
    }
3645

    
3646
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
3647
        s->block_last_index[4]=
3648
        s->block_last_index[5]= 0;
3649
        s->block[4][0]=
3650
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
3651
    }
3652

    
3653
    //non c quantize code returns incorrect block_last_index FIXME
3654
    if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
3655
        for(i=0; i<6; i++){
3656
            int j;
3657
            if(s->block_last_index[i]>0){
3658
                for(j=63; j>0; j--){
3659
                    if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
3660
                }
3661
                s->block_last_index[i]= j;
3662
            }
3663
        }
3664
    }
3665

    
3666
    /* huffman encode */
3667
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
3668
    case CODEC_ID_MPEG1VIDEO:
3669
    case CODEC_ID_MPEG2VIDEO:
3670
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
3671
#ifdef CONFIG_RISKY
3672
    case CODEC_ID_MPEG4:
3673
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3674
    case CODEC_ID_MSMPEG4V2:
3675
    case CODEC_ID_MSMPEG4V3:
3676
    case CODEC_ID_WMV1:
3677
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3678
    case CODEC_ID_WMV2:
3679
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
3680
    case CODEC_ID_H263:
3681
    case CODEC_ID_H263P:
3682
    case CODEC_ID_FLV1:
3683
    case CODEC_ID_RV10:
3684
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
3685
#endif
3686
    case CODEC_ID_MJPEG:
3687
        mjpeg_encode_mb(s, s->block); break;
3688
    default:
3689
        assert(0);
3690
    }
3691
}
3692

    
3693
#endif //CONFIG_ENCODERS
3694

    
3695
/**
3696
 * combines the (truncated) bitstream to a complete frame
3697
 * @returns -1 if no complete frame could be created
3698
 */
3699
int ff_combine_frame( MpegEncContext *s, int next, uint8_t **buf, int *buf_size){
3700
    ParseContext *pc= &s->parse_context;
3701

    
3702
#if 0
3703
    if(pc->overread){
3704
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
3705
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
3706
    }
3707
#endif
3708

    
3709
    /* copy overreaded byes from last frame into buffer */
3710
    for(; pc->overread>0; pc->overread--){
3711
        pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
3712
    }
3713
    
3714
    pc->last_index= pc->index;
3715

    
3716
    /* copy into buffer end return */
3717
    if(next == END_NOT_FOUND){
3718
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
3719

    
3720
        memcpy(&pc->buffer[pc->index], *buf, *buf_size);
3721
        pc->index += *buf_size;
3722
        return -1;
3723
    }
3724

    
3725
    *buf_size=
3726
    pc->overread_index= pc->index + next;
3727
    
3728
    /* append to buffer */
3729
    if(pc->index){
3730
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
3731

    
3732
        memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
3733
        pc->index = 0;
3734
        *buf= pc->buffer;
3735
    }
3736

    
3737
    /* store overread bytes */
3738
    for(;next < 0; next++){
3739
        pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
3740
        pc->overread++;
3741
    }
3742

    
3743
#if 0
3744
    if(pc->overread){
3745
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
3746
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
3747
    }
3748
#endif
3749

    
3750
    return 0;
3751
}
3752

    
3753
void ff_mpeg_flush(AVCodecContext *avctx){
3754
    int i;
3755
    MpegEncContext *s = avctx->priv_data;
3756
    
3757
    if(s==NULL || s->picture==NULL) 
3758
        return;
3759
    
3760
    for(i=0; i<MAX_PICTURE_COUNT; i++){
3761
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
3762
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
3763
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
3764
    }
3765
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
3766
    
3767
    s->parse_context.state= -1;
3768
    s->parse_context.frame_start_found= 0;
3769
    s->parse_context.overread= 0;
3770
    s->parse_context.overread_index= 0;
3771
    s->parse_context.index= 0;
3772
    s->parse_context.last_index= 0;
3773
    s->bitstream_buffer_size=0;
3774
}
3775

    
3776
#ifdef CONFIG_ENCODERS
3777
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
3778
{
3779
    const uint16_t *srcw= (uint16_t*)src;
3780
    int words= length>>4;
3781
    int bits= length&15;
3782
    int i;
3783

    
3784
    if(length==0) return;
3785
    
3786
    if(words < 16){
3787
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
3788
    }else if(put_bits_count(pb)&7){
3789
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
3790
    }else{
3791
        for(i=0; put_bits_count(pb)&31; i++)
3792
            put_bits(pb, 8, src[i]);
3793
        flush_put_bits(pb);
3794
        memcpy(pbBufPtr(pb), src+i, 2*words-i);
3795
        skip_put_bytes(pb, 2*words-i);
3796
    }
3797
        
3798
    put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
3799
}
3800

    
3801
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
3802
    int i;
3803

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

    
3806
    /* mpeg1 */
3807
    d->mb_skip_run= s->mb_skip_run;
3808
    for(i=0; i<3; i++)
3809
        d->last_dc[i]= s->last_dc[i];
3810
    
3811
    /* statistics */
3812
    d->mv_bits= s->mv_bits;
3813
    d->i_tex_bits= s->i_tex_bits;
3814
    d->p_tex_bits= s->p_tex_bits;
3815
    d->i_count= s->i_count;
3816
    d->f_count= s->f_count;
3817
    d->b_count= s->b_count;
3818
    d->skip_count= s->skip_count;
3819
    d->misc_bits= s->misc_bits;
3820
    d->last_bits= 0;
3821

    
3822
    d->mb_skiped= 0;
3823
    d->qscale= s->qscale;
3824
    d->dquant= s->dquant;
3825
}
3826

    
3827
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
3828
    int i;
3829

    
3830
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
3831
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
3832
    
3833
    /* mpeg1 */
3834
    d->mb_skip_run= s->mb_skip_run;
3835
    for(i=0; i<3; i++)
3836
        d->last_dc[i]= s->last_dc[i];
3837
    
3838
    /* statistics */
3839
    d->mv_bits= s->mv_bits;
3840
    d->i_tex_bits= s->i_tex_bits;
3841
    d->p_tex_bits= s->p_tex_bits;
3842
    d->i_count= s->i_count;
3843
    d->f_count= s->f_count;
3844
    d->b_count= s->b_count;
3845
    d->skip_count= s->skip_count;
3846
    d->misc_bits= s->misc_bits;
3847

    
3848
    d->mb_intra= s->mb_intra;
3849
    d->mb_skiped= s->mb_skiped;
3850
    d->mv_type= s->mv_type;
3851
    d->mv_dir= s->mv_dir;
3852
    d->pb= s->pb;
3853
    if(s->data_partitioning){
3854
        d->pb2= s->pb2;
3855
        d->tex_pb= s->tex_pb;
3856
    }
3857
    d->block= s->block;
3858
    for(i=0; i<6; i++)
3859
        d->block_last_index[i]= s->block_last_index[i];
3860
    d->interlaced_dct= s->interlaced_dct;
3861
    d->qscale= s->qscale;
3862
}
3863

    
3864
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
3865
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
3866
                           int *dmin, int *next_block, int motion_x, int motion_y)
3867
{
3868
    int score;
3869
    uint8_t *dest_backup[3];
3870
    
3871
    copy_context_before_encode(s, backup, type);
3872

    
3873
    s->block= s->blocks[*next_block];
3874
    s->pb= pb[*next_block];
3875
    if(s->data_partitioning){
3876
        s->pb2   = pb2   [*next_block];
3877
        s->tex_pb= tex_pb[*next_block];
3878
    }
3879
    
3880
    if(*next_block){
3881
        memcpy(dest_backup, s->dest, sizeof(s->dest));
3882
        s->dest[0] = s->rd_scratchpad;
3883
        s->dest[1] = s->rd_scratchpad + 16*s->linesize;
3884
        s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
3885
        assert(s->linesize >= 32); //FIXME
3886
    }
3887

    
3888
    encode_mb(s, motion_x, motion_y);
3889
    
3890
    score= put_bits_count(&s->pb);
3891
    if(s->data_partitioning){
3892
        score+= put_bits_count(&s->pb2);
3893
        score+= put_bits_count(&s->tex_pb);
3894
    }
3895
   
3896
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
3897
        MPV_decode_mb(s, s->block);
3898

    
3899
        score *= s->lambda2;
3900
        score += sse_mb(s) << FF_LAMBDA_SHIFT;
3901
    }
3902
    
3903
    if(*next_block){
3904
        memcpy(s->dest, dest_backup, sizeof(s->dest));
3905
    }
3906

    
3907
    if(score<*dmin){
3908
        *dmin= score;
3909
        *next_block^=1;
3910

    
3911
        copy_context_after_encode(best, s, type);
3912
    }
3913
}
3914
                
3915
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
3916
    uint32_t *sq = squareTbl + 256;
3917
    int acc=0;
3918
    int x,y;
3919
    
3920
    if(w==16 && h==16) 
3921
        return s->dsp.sse[0](NULL, src1, src2, stride, 16);
3922
    else if(w==8 && h==8)
3923
        return s->dsp.sse[1](NULL, src1, src2, stride, 8);
3924
    
3925
    for(y=0; y<h; y++){
3926
        for(x=0; x<w; x++){
3927
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
3928
        } 
3929
    }
3930
    
3931
    assert(acc>=0);
3932
    
3933
    return acc;
3934
}
3935

    
3936
static int sse_mb(MpegEncContext *s){
3937
    int w= 16;
3938
    int h= 16;
3939

    
3940
    if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3941
    if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3942

    
3943
    if(w==16 && h==16)
3944
        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)
3945
               +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)
3946
               +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);
3947
    else
3948
        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)
3949
               +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)
3950
               +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);
3951
}
3952

    
3953
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
3954
    MpegEncContext *s= arg;
3955

    
3956
    
3957
    s->me.pre_pass=1;
3958
    s->me.dia_size= s->avctx->pre_dia_size;
3959
    s->first_slice_line=1;
3960
    for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
3961
        for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
3962
            ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
3963
        }
3964
        s->first_slice_line=0;
3965
    }
3966
    
3967
    s->me.pre_pass=0;
3968
    
3969
    return 0;
3970
}
3971

    
3972
static int estimate_motion_thread(AVCodecContext *c, void *arg){
3973
    MpegEncContext *s= arg;
3974

    
3975
    s->me.dia_size= s->avctx->dia_size;
3976
    s->first_slice_line=1;
3977
    for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
3978
        s->mb_x=0; //for block init below
3979
        ff_init_block_index(s);
3980
        for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
3981
            s->block_index[0]+=2;
3982
            s->block_index[1]+=2;
3983
            s->block_index[2]+=2;
3984
            s->block_index[3]+=2;
3985
            
3986
            /* compute motion vector & mb_type and store in context */
3987
            if(s->pict_type==B_TYPE)
3988
                ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
3989
            else
3990
                ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
3991
        }
3992
        s->first_slice_line=0;
3993
    }
3994
    return 0;
3995
}
3996

    
3997
static int mb_var_thread(AVCodecContext *c, void *arg){
3998
    MpegEncContext *s= arg;
3999
    int mb_x, mb_y;
4000

    
4001
    for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4002
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4003
            int xx = mb_x * 16;
4004
            int yy = mb_y * 16;
4005
            uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
4006
            int varc;
4007
            int sum = s->dsp.pix_sum(pix, s->linesize);
4008
    
4009
            varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
4010

    
4011
            s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
4012
            s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
4013
            s->mb_var_sum_temp    += varc;
4014
        }
4015
    }
4016
    return 0;
4017
}
4018

    
4019
static void write_slice_end(MpegEncContext *s){
4020
    if(s->codec_id==CODEC_ID_MPEG4){
4021
        if(s->partitioned_frame){
4022
            ff_mpeg4_merge_partitions(s);
4023
        }
4024
    
4025
        ff_mpeg4_stuffing(&s->pb);
4026
    }else if(s->out_format == FMT_MJPEG){
4027
        ff_mjpeg_stuffing(&s->pb);
4028
    }
4029

    
4030
    align_put_bits(&s->pb);
4031
    flush_put_bits(&s->pb);
4032
}
4033

    
4034
static int encode_thread(AVCodecContext *c, void *arg){
4035
    MpegEncContext *s= arg;
4036
    int mb_x, mb_y, pdif = 0;
4037
    int i, j;
4038
    MpegEncContext best_s, backup_s;
4039
    uint8_t bit_buf[2][3000];
4040
    uint8_t bit_buf2[2][3000];
4041
    uint8_t bit_buf_tex[2][3000];
4042
    PutBitContext pb[2], pb2[2], tex_pb[2];
4043
//printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4044

    
4045
    for(i=0; i<2; i++){
4046
        init_put_bits(&pb    [i], bit_buf    [i], 3000);
4047
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000);
4048
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000);
4049
    }
4050

    
4051
    s->last_bits= put_bits_count(&s->pb);
4052
    s->mv_bits=0;
4053
    s->misc_bits=0;
4054
    s->i_tex_bits=0;
4055
    s->p_tex_bits=0;
4056
    s->i_count=0;
4057
    s->f_count=0;
4058
    s->b_count=0;
4059
    s->skip_count=0;
4060

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

    
4073
#ifdef CONFIG_RISKY
4074
    switch(s->codec_id){
4075
    case CODEC_ID_H263:
4076
    case CODEC_ID_H263P:
4077
    case CODEC_ID_FLV1:
4078
        s->gob_index = ff_h263_get_gob_height(s);
4079
        break;
4080
    case CODEC_ID_MPEG4:
4081
        if(s->partitioned_frame)
4082
            ff_mpeg4_init_partitions(s);
4083
        break;
4084
    }
4085
#endif
4086

    
4087
    s->resync_mb_x=0;
4088
    s->resync_mb_y=0; 
4089
    s->first_slice_line = 1;
4090
    s->ptr_lastgob = s->pb.buf;
4091
    for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4092
//    printf("row %d at %X\n", s->mb_y, (int)s);
4093
        s->mb_x=0;
4094
        s->mb_y= mb_y;
4095

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

    
4106
            s->mb_x = mb_x;
4107
            ff_update_block_index(s);
4108

    
4109
            /* write gob / video packet header  */
4110
#ifdef CONFIG_RISKY
4111
            if(s->rtp_mode){
4112
                int current_packet_size, is_gob_start;
4113
                
4114
                current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
4115
                
4116
                is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0; 
4117
                
4118
                if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
4119
                
4120
                switch(s->codec_id){
4121
                case CODEC_ID_H263:
4122
                case CODEC_ID_H263P:
4123
                    if(!s->h263_slice_structured)
4124
                        if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
4125
                    break;
4126
                case CODEC_ID_MPEG2VIDEO:
4127
                    if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
4128
                case CODEC_ID_MPEG1VIDEO:
4129
                    if(s->mb_skip_run) is_gob_start=0;
4130
                    break;
4131
                }
4132

    
4133
                if(is_gob_start){
4134
                    if(s->start_mb_y != mb_y || mb_x!=0){
4135
                        write_slice_end(s);
4136

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

    
4176
                    if(s->flags&CODEC_FLAG_PASS1){
4177
                        int bits= put_bits_count(&s->pb);
4178
                        s->misc_bits+= bits - s->last_bits;
4179
                        s->last_bits= bits;
4180
                    }
4181
    
4182
                    s->ptr_lastgob += current_packet_size;
4183
                    s->first_slice_line=1;
4184
                    s->resync_mb_x=mb_x;
4185
                    s->resync_mb_y=mb_y;
4186
                }
4187
            }
4188
#endif
4189

    
4190
            if(  (s->resync_mb_x   == s->mb_x)
4191
               && s->resync_mb_y+1 == s->mb_y){
4192
                s->first_slice_line=0; 
4193
            }
4194

    
4195
            s->mb_skiped=0;
4196
            s->dquant=0; //only for QP_RD
4197

    
4198
            if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible
4199
                int next_block=0;
4200
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
4201

    
4202
                copy_context_before_encode(&backup_s, s, -1);
4203
                backup_s.pb= s->pb;
4204
                best_s.data_partitioning= s->data_partitioning;
4205
                best_s.partitioned_frame= s->partitioned_frame;
4206
                if(s->data_partitioning){
4207
                    backup_s.pb2= s->pb2;
4208
                    backup_s.tex_pb= s->tex_pb;
4209
                }
4210

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

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

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

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

    
4400
                copy_context_after_encode(s, &best_s, -1);
4401
                
4402
                pb_bits_count= put_bits_count(&s->pb);
4403
                flush_put_bits(&s->pb);
4404
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
4405
                s->pb= backup_s.pb;
4406
                
4407
                if(s->data_partitioning){
4408
                    pb2_bits_count= put_bits_count(&s->pb2);
4409
                    flush_put_bits(&s->pb2);
4410
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
4411
                    s->pb2= backup_s.pb2;
4412
                    
4413
                    tex_pb_bits_count= put_bits_count(&s->tex_pb);
4414
                    flush_put_bits(&s->tex_pb);
4415
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
4416
                    s->tex_pb= backup_s.tex_pb;
4417
                }
4418
                s->last_bits= put_bits_count(&s->pb);
4419
               
4420
#ifdef CONFIG_RISKY
4421
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4422
                    ff_h263_update_motion_val(s);
4423
#endif
4424
        
4425
                if(next_block==0){ //FIXME 16 vs linesize16
4426
                    s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad                     , s->linesize  ,16);
4427
                    s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize    , s->uvlinesize, 8);
4428
                    s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
4429
                }
4430

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

    
4544
                encode_mb(s, motion_x, motion_y);
4545

    
4546
                // RAL: Update last macrobloc type
4547
                s->last_mv_dir = s->mv_dir;
4548
            
4549
#ifdef CONFIG_RISKY
4550
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4551
                    ff_h263_update_motion_val(s);
4552
#endif
4553
                
4554
                MPV_decode_mb(s, s->block);
4555
            }
4556

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

    
4567
                if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4568
                if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4569

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

    
4586
#ifdef CONFIG_RISKY
4587
    //not beautifull here but we must write it before flushing so it has to be here
4588
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
4589
        msmpeg4_encode_ext_header(s);
4590
#endif
4591

    
4592
    write_slice_end(s);
4593

    
4594
    /* Send the last GOB if RTP */    
4595
    if (s->avctx->rtp_callback) {
4596
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
4597
        /* Call the RTP callback to send the last GOB */
4598
        emms_c();
4599
        s->avctx->rtp_callback(s->ptr_lastgob, pdif, 0);
4600
    }
4601

    
4602
    return 0;
4603
}
4604

    
4605
#define MERGE(field) dst->field += src->field; src->field=0
4606
static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
4607
    MERGE(scene_change_score);
4608
    MERGE(mc_mb_var_sum_temp);
4609
    MERGE(mb_var_sum_temp);
4610
}
4611

    
4612
static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
4613
    int i;
4614

    
4615
    MERGE(dct_count[0]); //note, the other dct vars are not part of the context
4616
    MERGE(dct_count[1]);
4617
    MERGE(mv_bits);
4618
    MERGE(header_bits);
4619
    MERGE(i_tex_bits);
4620
    MERGE(p_tex_bits);
4621
    MERGE(i_count);
4622
    MERGE(f_count);
4623
    MERGE(b_count);
4624
    MERGE(skip_count);
4625
    MERGE(misc_bits);
4626
    MERGE(error_count);
4627
    MERGE(padding_bug_score);
4628

    
4629
    if(dst->avctx->noise_reduction){
4630
        for(i=0; i<64; i++){
4631
            MERGE(dct_error_sum[0][i]);
4632
            MERGE(dct_error_sum[1][i]);
4633
        }
4634
    }
4635
    
4636
    assert(put_bits_count(&src->pb) % 8 ==0);
4637
    assert(put_bits_count(&dst->pb) % 8 ==0);
4638
    ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
4639
    flush_put_bits(&dst->pb);
4640
}
4641

    
4642
static void encode_picture(MpegEncContext *s, int picture_number)
4643
{
4644
    int i, j;
4645
    int bits;
4646

    
4647
    s->picture_number = picture_number;
4648
    
4649
    /* Reset the average MB variance */
4650
    s->mb_var_sum_temp    =
4651
    s->mc_mb_var_sum_temp = 0;
4652

    
4653
#ifdef CONFIG_RISKY
4654
    /* we need to initialize some time vars before we can encode b-frames */
4655
    // RAL: Condition added for MPEG1VIDEO
4656
    if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
4657
        ff_set_mpeg4_time(s, s->picture_number);  //FIXME rename and use has_b_frames or similar
4658
#endif
4659
        
4660
    s->scene_change_score=0;
4661
    
4662
    s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration
4663
    
4664
    if(s->pict_type==I_TYPE){
4665
        if(