Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ d4c5d2ad

History | View | Annotate | Download (216 KB)

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

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

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

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

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

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

    
77

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

    
81
//#define DEBUG
82

    
83

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
260
#endif //CONFIG_ENCODERS
261

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

    
275
    return 0;
276
}
277

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
555
    s->picture_in_gop_number = 0;
556

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
764
    s->context_initialized = 1;
765

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

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

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

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

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

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

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

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

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

    
864
#ifdef CONFIG_ENCODERS
865

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

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

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

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

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

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

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

    
928
    if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
929
        av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isnt recommanded!\n");
930
    }
931
    
932
    if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
933
        av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
934
        return -1;
935
    }
936
    
937
    if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
938
        av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
939
        return -1;
940
    }
941
        
942
    if(   s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate 
943
       && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
944
       && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
945
        
946
        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");
947
    }
948
       
949
    if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 
950
       && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
951
        av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
952
        return -1;
953
    }
954
        
955
    if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
956
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decission\n");
957
        return -1;
958
    }
959
    
960
    if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
961
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
962
        return -1;
963
    }
964
    
965
    if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
966
        av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
967
        return -1;
968
    }
969

    
970
    if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
971
        av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
972
        return -1;
973
    }
974
    
975
    if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
976
        av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
977
        return -1;
978
    }
979

    
980
    if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN)) 
981
       && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
982
        av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
983
        return -1;
984
    }
985
        
986
    if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
987
        av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n");
988
        return -1;
989
    }
990
        
991
    if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
992
        av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
993
        return -1;
994
    }
995

    
996
    if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
997
        av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
998
        return -1;
999
    }
1000
    
1001
    if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1002
        av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
1003
        return -1;
1004
    }
1005
    
1006
    if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4 
1007
       && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO 
1008
       && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1009
        av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1010
        return -1;
1011
    }
1012
    
1013
    if(s->avctx->thread_count > 1)
1014
        s->rtp_mode= 1;
1015

    
1016
    i= ff_gcd(avctx->frame_rate, avctx->frame_rate_base);
1017
    if(i > 1){
1018
        av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1019
        avctx->frame_rate /= i;
1020
        avctx->frame_rate_base /= i;
1021
//        return -1;
1022
    }
1023
    
1024
    if(s->codec_id==CODEC_ID_MJPEG){
1025
        s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1026
        s->inter_quant_bias= 0;
1027
    }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1028
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1029
        s->inter_quant_bias= 0;
1030
    }else{
1031
        s->intra_quant_bias=0;
1032
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1033
    }
1034
    
1035
    if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1036
        s->intra_quant_bias= avctx->intra_quant_bias;
1037
    if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1038
        s->inter_quant_bias= avctx->inter_quant_bias;
1039
        
1040
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1041

    
1042
    av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1043
    s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1044

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

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

    
1178
    s->encoding = 1;
1179

    
1180
    /* init */
1181
    if (MPV_common_init(s) < 0)
1182
        return -1;
1183

    
1184
    if(s->modified_quant)
1185
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1186
    s->progressive_frame= 
1187
    s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1188
    s->quant_precision=5;
1189
    
1190
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1191
    
1192
#ifdef CONFIG_ENCODERS
1193
#ifdef CONFIG_RISKY
1194
    if (s->out_format == FMT_H263)
1195
        h263_encode_init(s);
1196
    if(s->msmpeg4_version)
1197
        ff_msmpeg4_encode_init(s);
1198
#endif
1199
    if (s->out_format == FMT_MPEG1)
1200
        ff_mpeg1_encode_init(s);
1201
#endif
1202

    
1203
    /* init q matrix */
1204
    for(i=0;i<64;i++) {
1205
        int j= s->dsp.idct_permutation[i];
1206
#ifdef CONFIG_RISKY
1207
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1208
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1209
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1210
        }else if(s->out_format == FMT_H263){
1211
            s->intra_matrix[j] =
1212
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1213
        }else
1214
#endif
1215
        { /* mpeg1/2 */
1216
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1217
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1218
        }
1219
        if(s->avctx->intra_matrix)
1220
            s->intra_matrix[j] = s->avctx->intra_matrix[i];
1221
        if(s->avctx->inter_matrix)
1222
            s->inter_matrix[j] = s->avctx->inter_matrix[i];
1223
    }
1224

    
1225
    /* precompute matrix */
1226
    /* for mjpeg, we do include qscale in the matrix */
1227
    if (s->out_format != FMT_MJPEG) {
1228
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 
1229
                       s->intra_matrix, s->intra_quant_bias, 1, 31);
1230
        convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, 
1231
                       s->inter_matrix, s->inter_quant_bias, 1, 31);
1232
    }
1233

    
1234
    if(ff_rate_control_init(s) < 0)
1235
        return -1;
1236
    
1237
    return 0;
1238
}
1239

    
1240
int MPV_encode_end(AVCodecContext *avctx)
1241
{
1242
    MpegEncContext *s = avctx->priv_data;
1243

    
1244
#ifdef STATS
1245
    print_stats();
1246
#endif
1247

    
1248
    ff_rate_control_uninit(s);
1249

    
1250
    MPV_common_end(s);
1251
    if (s->out_format == FMT_MJPEG)
1252
        mjpeg_close(s);
1253

    
1254
    av_freep(&avctx->extradata);
1255
      
1256
    return 0;
1257
}
1258

    
1259
#endif //CONFIG_ENCODERS
1260

    
1261
void init_rl(RLTable *rl)
1262
{
1263
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1264
    uint8_t index_run[MAX_RUN+1];
1265
    int last, run, level, start, end, i;
1266

    
1267
    /* compute max_level[], max_run[] and index_run[] */
1268
    for(last=0;last<2;last++) {
1269
        if (last == 0) {
1270
            start = 0;
1271
            end = rl->last;
1272
        } else {
1273
            start = rl->last;
1274
            end = rl->n;
1275
        }
1276

    
1277
        memset(max_level, 0, MAX_RUN + 1);
1278
        memset(max_run, 0, MAX_LEVEL + 1);
1279
        memset(index_run, rl->n, MAX_RUN + 1);
1280
        for(i=start;i<end;i++) {
1281
            run = rl->table_run[i];
1282
            level = rl->table_level[i];
1283
            if (index_run[run] == rl->n)
1284
                index_run[run] = i;
1285
            if (level > max_level[run])
1286
                max_level[run] = level;
1287
            if (run > max_run[level])
1288
                max_run[level] = run;
1289
        }
1290
        rl->max_level[last] = av_malloc(MAX_RUN + 1);
1291
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1292
        rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1293
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1294
        rl->index_run[last] = av_malloc(MAX_RUN + 1);
1295
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1296
    }
1297
}
1298

    
1299
/* draw the edges of width 'w' of an image of size width, height */
1300
//FIXME check that this is ok for mpeg4 interlaced
1301
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1302
{
1303
    uint8_t *ptr, *last_line;
1304
    int i;
1305

    
1306
    last_line = buf + (height - 1) * wrap;
1307
    for(i=0;i<w;i++) {
1308
        /* top and bottom */
1309
        memcpy(buf - (i + 1) * wrap, buf, width);
1310
        memcpy(last_line + (i + 1) * wrap, last_line, width);
1311
    }
1312
    /* left and right */
1313
    ptr = buf;
1314
    for(i=0;i<height;i++) {
1315
        memset(ptr - w, ptr[0], w);
1316
        memset(ptr + width, ptr[width-1], w);
1317
        ptr += wrap;
1318
    }
1319
    /* corners */
1320
    for(i=0;i<w;i++) {
1321
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1322
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1323
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1324
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1325
    }
1326
}
1327

    
1328
int ff_find_unused_picture(MpegEncContext *s, int shared){
1329
    int i;
1330
    
1331
    if(shared){
1332
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1333
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1334
        }
1335
    }else{
1336
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1337
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1338
        }
1339
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1340
            if(s->picture[i].data[0]==NULL) return i;
1341
        }
1342
    }
1343

    
1344
    assert(0);
1345
    return -1;
1346
}
1347

    
1348
static void update_noise_reduction(MpegEncContext *s){
1349
    int intra, i;
1350

    
1351
    for(intra=0; intra<2; intra++){
1352
        if(s->dct_count[intra] > (1<<16)){
1353
            for(i=0; i<64; i++){
1354
                s->dct_error_sum[intra][i] >>=1;
1355
            }
1356
            s->dct_count[intra] >>= 1;
1357
        }
1358
        
1359
        for(i=0; i<64; i++){
1360
            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);
1361
        }
1362
    }
1363
}
1364

    
1365
/**
1366
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1367
 */
1368
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1369
{
1370
    int i;
1371
    AVFrame *pic;
1372
    s->mb_skiped = 0;
1373

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

    
1376
    /* mark&release old frames */
1377
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1378
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1379

    
1380
        /* release forgotten pictures */
1381
        /* if(mpeg124/h263) */
1382
        if(!s->encoding){
1383
            for(i=0; i<MAX_PICTURE_COUNT; i++){
1384
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1385
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1386
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
1387
                }
1388
            }
1389
        }
1390
    }
1391
alloc:
1392
    if(!s->encoding){
1393
        /* release non refernce frames */
1394
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1395
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1396
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1397
            }
1398
        }
1399

    
1400
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1401
            pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1402
        else{
1403
            i= ff_find_unused_picture(s, 0);
1404
            pic= (AVFrame*)&s->picture[i];
1405
        }
1406

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

    
1409
        pic->coded_picture_number= s->coded_picture_number++;
1410
        
1411
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1412
            return -1;
1413

    
1414
        s->current_picture_ptr= (Picture*)pic;
1415
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1416
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1417
    }
1418

    
1419
    s->current_picture_ptr->pict_type= s->pict_type;
1420
//    if(s->flags && CODEC_FLAG_QSCALE) 
1421
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1422
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1423

    
1424
    copy_picture(&s->current_picture, s->current_picture_ptr);
1425
  
1426
  if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1427
    if (s->pict_type != B_TYPE) {
1428
        s->last_picture_ptr= s->next_picture_ptr;
1429
        if(!s->dropable)
1430
            s->next_picture_ptr= s->current_picture_ptr;
1431
    }
1432
/*    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,
1433
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL, 
1434
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL, 
1435
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1436
        s->pict_type, s->dropable);*/
1437
    
1438
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1439
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1440
    
1441
    if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1442
        av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1443
        assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1444
        goto alloc;
1445
    }
1446

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

    
1449
    if(s->picture_structure!=PICT_FRAME){
1450
        int i;
1451
        for(i=0; i<4; i++){
1452
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1453
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1454
            } 
1455
            s->current_picture.linesize[i] *= 2;
1456
            s->last_picture.linesize[i] *=2;
1457
            s->next_picture.linesize[i] *=2;
1458
        }
1459
    }
1460
  }
1461
   
1462
    s->hurry_up= s->avctx->hurry_up;
1463
    s->error_resilience= avctx->error_resilience;
1464

    
1465
    /* set dequantizer, we cant do it during init as it might change for mpeg4
1466
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1467
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1468
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1469
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1470
    }else if(s->out_format == FMT_H263){
1471
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1472
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1473
    }else if(s->out_format == FMT_H261){
1474
        s->dct_unquantize_intra = s->dct_unquantize_h261_intra;
1475
        s->dct_unquantize_inter = s->dct_unquantize_h261_inter;
1476
    }else{
1477
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1478
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1479
    }
1480

    
1481
    if(s->dct_error_sum){
1482
        assert(s->avctx->noise_reduction && s->encoding);
1483

    
1484
        update_noise_reduction(s);
1485
    }
1486
        
1487
#ifdef HAVE_XVMC
1488
    if(s->avctx->xvmc_acceleration)
1489
        return XVMC_field_start(s, avctx);
1490
#endif
1491
    return 0;
1492
}
1493

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

    
1527
    if(s->encoding){
1528
        /* release non refernce frames */
1529
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1530
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1531
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1532
            }
1533
        }
1534
    }
1535
    // clear copies, to avoid confusion
1536
#if 0
1537
    memset(&s->last_picture, 0, sizeof(Picture));
1538
    memset(&s->next_picture, 0, sizeof(Picture));
1539
    memset(&s->current_picture, 0, sizeof(Picture));
1540
#endif
1541
}
1542

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

    
1592
/**
1593
 * draws an arrow from (ex, ey) -> (sx, sy).
1594
 * @param w width of the image
1595
 * @param h height of the image
1596
 * @param stride stride/linesize of the image
1597
 * @param color color of the arrow
1598
 */
1599
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1600
    int dx,dy;
1601

    
1602
    sx= clip(sx, -100, w+100);
1603
    sy= clip(sy, -100, h+100);
1604
    ex= clip(ex, -100, w+100);
1605
    ey= clip(ey, -100, h+100);
1606
    
1607
    dx= ex - sx;
1608
    dy= ey - sy;
1609
    
1610
    if(dx*dx + dy*dy > 3*3){
1611
        int rx=  dx + dy;
1612
        int ry= -dx + dy;
1613
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1614
        
1615
        //FIXME subpixel accuracy
1616
        rx= ROUNDED_DIV(rx*3<<4, length);
1617
        ry= ROUNDED_DIV(ry*3<<4, length);
1618
        
1619
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1620
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1621
    }
1622
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1623
}
1624

    
1625
/**
1626
 * prints debuging info for the given picture.
1627
 */
1628
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1629

    
1630
    if(!pict || !pict->mb_type) return;
1631

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

    
1708
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1709
        const int shift= 1 + s->quarter_sample;
1710
        int mb_y;
1711
        uint8_t *ptr;
1712
        int i;
1713
        int h_chroma_shift, v_chroma_shift;
1714
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1715

    
1716
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1717
        for(i=0; i<3; i++){
1718
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*s->height:pict->linesize[i]*s->height >> v_chroma_shift);
1719
            pict->data[i]= s->visualization_buffer[i];
1720
        }
1721
        pict->type= FF_BUFFER_TYPE_COPY;
1722
        ptr= pict->data[0];
1723

    
1724
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1725
            int mb_x;
1726
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1727
                const int mb_index= mb_x + mb_y*s->mb_stride;
1728
                if((s->avctx->debug_mv) && pict->motion_val){
1729
                  int type;
1730
                  for(type=0; type<3; type++){
1731
                    int direction = 0;
1732
                    switch (type) {
1733
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1734
                                continue;
1735
                              direction = 0;
1736
                              break;
1737
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1738
                                continue;
1739
                              direction = 0;
1740
                              break;
1741
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1742
                                continue;
1743
                              direction = 1;
1744
                              break;
1745
                    }
1746
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1747
                        continue;
1748

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

    
1800
                    
1801
                    u=v=128;
1802
                    if(IS_PCM(mb_type)){
1803
                        COLOR(120,48)
1804
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1805
                        COLOR(30,48)
1806
                    }else if(IS_INTRA4x4(mb_type)){
1807
                        COLOR(90,48)
1808
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1809
//                        COLOR(120,48)
1810
                    }else if(IS_DIRECT(mb_type)){
1811
                        COLOR(150,48)
1812
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1813
                        COLOR(170,48)
1814
                    }else if(IS_GMC(mb_type)){
1815
                        COLOR(190,48)
1816
                    }else if(IS_SKIP(mb_type)){
1817
//                        COLOR(180,48)
1818
                    }else if(!USES_LIST(mb_type, 1)){
1819
                        COLOR(240,48)
1820
                    }else if(!USES_LIST(mb_type, 0)){
1821
                        COLOR(0,48)
1822
                    }else{
1823
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1824
                        COLOR(300,48)
1825
                    }
1826

    
1827
                    u*= 0x0101010101010101ULL;
1828
                    v*= 0x0101010101010101ULL;
1829
                    for(y=0; y<8; y++){
1830
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1831
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1832
                    }
1833

    
1834
                    //segmentation
1835
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1836
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1837
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1838
                    }
1839
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1840
                        for(y=0; y<16; y++)
1841
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1842
                    }
1843
                        
1844
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1845
                        // hmm
1846
                    }
1847
                }
1848
                s->mbskip_table[mb_index]=0;
1849
            }
1850
        }
1851
    }
1852
}
1853

    
1854
#ifdef CONFIG_ENCODERS
1855

    
1856
static int get_sae(uint8_t *src, int ref, int stride){
1857
    int x,y;
1858
    int acc=0;
1859
    
1860
    for(y=0; y<16; y++){
1861
        for(x=0; x<16; x++){
1862
            acc+= ABS(src[x+y*stride] - ref);
1863
        }
1864
    }
1865
    
1866
    return acc;
1867
}
1868

    
1869
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1870
    int x, y, w, h;
1871
    int acc=0;
1872
    
1873
    w= s->width &~15;
1874
    h= s->height&~15;
1875
    
1876
    for(y=0; y<h; y+=16){
1877
        for(x=0; x<w; x+=16){
1878
            int offset= x + y*stride;
1879
            int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1880
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1881
            int sae = get_sae(src + offset, mean, stride);
1882
            
1883
            acc+= sae + 500 < sad;
1884
        }
1885
    }
1886
    return acc;
1887
}
1888

    
1889

    
1890
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1891
    AVFrame *pic=NULL;
1892
    int i;
1893
    const int encoding_delay= s->max_b_frames;
1894
    int direct=1;
1895
    
1896
  if(pic_arg){
1897
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1898
    if(pic_arg->linesize[0] != s->linesize) direct=0;
1899
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1900
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1901
  
1902
//    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1903
    
1904
    if(direct){
1905
        i= ff_find_unused_picture(s, 1);
1906

    
1907
        pic= (AVFrame*)&s->picture[i];
1908
        pic->reference= 3;
1909
    
1910
        for(i=0; i<4; i++){
1911
            pic->data[i]= pic_arg->data[i];
1912
            pic->linesize[i]= pic_arg->linesize[i];
1913
        }
1914
        alloc_picture(s, (Picture*)pic, 1);
1915
    }else{
1916
        int offset= 16;
1917
        i= ff_find_unused_picture(s, 0);
1918

    
1919
        pic= (AVFrame*)&s->picture[i];
1920
        pic->reference= 3;
1921

    
1922
        alloc_picture(s, (Picture*)pic, 0);
1923

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

    
1975
    return 0;
1976
}
1977

    
1978
static void select_input_picture(MpegEncContext *s){
1979
    int i;
1980

    
1981
    for(i=1; i<MAX_PICTURE_COUNT; i++)
1982
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1983
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1984

    
1985
    /* set next picture types & ordering */
1986
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1987
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
1988
            s->reordered_input_picture[0]= s->input_picture[0];
1989
            s->reordered_input_picture[0]->pict_type= I_TYPE;
1990
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
1991
        }else{
1992
            int b_frames;
1993
            
1994
            if(s->flags&CODEC_FLAG_PASS2){
1995
                for(i=0; i<s->max_b_frames+1; i++){
1996
                    int pict_num= s->input_picture[0]->display_picture_number + i;
1997
                    int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1998
                    s->input_picture[i]->pict_type= pict_type;
1999
                    
2000
                    if(i + 1 >= s->rc_context.num_entries) break;
2001
                }
2002
            }
2003

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

    
2040
            emms_c();
2041
//static int b_count=0;
2042
//b_count+= b_frames;
2043
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2044
            if(s->picture_in_gop_number + b_frames >= s->gop_size){
2045
                if(s->flags & CODEC_FLAG_CLOSED_GOP)
2046
                    b_frames=0;
2047
                s->input_picture[b_frames]->pict_type= I_TYPE;
2048
            }
2049
            
2050
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2051
               && b_frames
2052
               && s->input_picture[b_frames]->pict_type== I_TYPE)
2053
                b_frames--;
2054

    
2055
            s->reordered_input_picture[0]= s->input_picture[b_frames];
2056
            if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2057
                s->reordered_input_picture[0]->pict_type= P_TYPE;
2058
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2059
            for(i=0; i<b_frames; i++){
2060
                s->reordered_input_picture[i+1]= s->input_picture[i];
2061
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2062
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2063
            }
2064
        }
2065
    }
2066
    
2067
    if(s->reordered_input_picture[0]){
2068
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2069

    
2070
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2071

    
2072
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2073
            // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2074
        
2075
            int i= ff_find_unused_picture(s, 0);
2076
            Picture *pic= &s->picture[i];
2077

    
2078
            /* mark us unused / free shared pic */
2079
            for(i=0; i<4; i++)
2080
                s->reordered_input_picture[0]->data[i]= NULL;
2081
            s->reordered_input_picture[0]->type= 0;
2082
            
2083
            pic->reference              = s->reordered_input_picture[0]->reference;
2084
            
2085
            alloc_picture(s, pic, 0);
2086

    
2087
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2088

    
2089
            s->current_picture_ptr= pic;
2090
        }else{
2091
            // input is not a shared pix -> reuse buffer for current_pix
2092

    
2093
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
2094
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2095
            
2096
            s->current_picture_ptr= s->reordered_input_picture[0];
2097
            for(i=0; i<4; i++){
2098
                s->new_picture.data[i]+=16;
2099
            }
2100
        }
2101
        copy_picture(&s->current_picture, s->current_picture_ptr);
2102
    
2103
        s->picture_number= s->new_picture.display_picture_number;
2104
//printf("dpn:%d\n", s->picture_number);
2105
    }else{
2106
       memset(&s->new_picture, 0, sizeof(Picture));
2107
    }
2108
}
2109

    
2110
int MPV_encode_picture(AVCodecContext *avctx,
2111
                       unsigned char *buf, int buf_size, void *data)
2112
{
2113
    MpegEncContext *s = avctx->priv_data;
2114
    AVFrame *pic_arg = data;
2115
    int i, stuffing_count;
2116

    
2117
    if(avctx->pix_fmt != PIX_FMT_YUV420P){
2118
        av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2119
        return -1;
2120
    }
2121
    
2122
    for(i=0; i<avctx->thread_count; i++){
2123
        int start_y= s->thread_context[i]->start_mb_y;
2124
        int   end_y= s->thread_context[i]->  end_mb_y;
2125
        int h= s->mb_height;
2126
        uint8_t *start= buf + buf_size*start_y/h;
2127
        uint8_t *end  = buf + buf_size*  end_y/h;
2128

    
2129
        init_put_bits(&s->thread_context[i]->pb, start, end - start);
2130
    }
2131

    
2132
    s->picture_in_gop_number++;
2133

    
2134
    load_input_picture(s, pic_arg);
2135
    
2136
    select_input_picture(s);
2137
    
2138
    /* output? */
2139
    if(s->new_picture.data[0]){
2140
        s->pict_type= s->new_picture.pict_type;
2141
//emms_c();
2142
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2143
        MPV_frame_start(s, avctx);
2144

    
2145
        encode_picture(s, s->picture_number);
2146
        
2147
        avctx->real_pict_num  = s->picture_number;
2148
        avctx->header_bits = s->header_bits;
2149
        avctx->mv_bits     = s->mv_bits;
2150
        avctx->misc_bits   = s->misc_bits;
2151
        avctx->i_tex_bits  = s->i_tex_bits;
2152
        avctx->p_tex_bits  = s->p_tex_bits;
2153
        avctx->i_count     = s->i_count;
2154
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2155
        avctx->skip_count  = s->skip_count;
2156

    
2157
        MPV_frame_end(s);
2158

    
2159
        if (s->out_format == FMT_MJPEG)
2160
            mjpeg_picture_trailer(s);
2161
        
2162
        if(s->flags&CODEC_FLAG_PASS1)
2163
            ff_write_pass1_stats(s);
2164

    
2165
        for(i=0; i<4; i++){
2166
            avctx->error[i] += s->current_picture_ptr->error[i];
2167
        }
2168

    
2169
        flush_put_bits(&s->pb);
2170
        s->frame_bits  = put_bits_count(&s->pb);
2171

    
2172
        stuffing_count= ff_vbv_update(s, s->frame_bits);
2173
        if(stuffing_count){
2174
            switch(s->codec_id){
2175
            case CODEC_ID_MPEG1VIDEO:
2176
            case CODEC_ID_MPEG2VIDEO:
2177
                while(stuffing_count--){
2178
                    put_bits(&s->pb, 8, 0);
2179
                }
2180
            break;
2181
            case CODEC_ID_MPEG4:
2182
                put_bits(&s->pb, 16, 0);
2183
                put_bits(&s->pb, 16, 0x1C3);
2184
                stuffing_count -= 4;
2185
                while(stuffing_count--){
2186
                    put_bits(&s->pb, 8, 0xFF);
2187
                }
2188
            break;
2189
            default:
2190
                av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2191
            }
2192
            flush_put_bits(&s->pb);
2193
            s->frame_bits  = put_bits_count(&s->pb);
2194
        }
2195

    
2196
        /* update mpeg1/2 vbv_delay for CBR */    
2197
        if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2198
           && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2199
            int vbv_delay;
2200

    
2201
            assert(s->repeat_first_field==0);
2202
            
2203
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2204
            assert(vbv_delay < 0xFFFF);
2205

    
2206
            s->vbv_delay_ptr[0] &= 0xF8;
2207
            s->vbv_delay_ptr[0] |= vbv_delay>>13;
2208
            s->vbv_delay_ptr[1]  = vbv_delay>>5;
2209
            s->vbv_delay_ptr[2] &= 0x07;
2210
            s->vbv_delay_ptr[2] |= vbv_delay<<3;
2211
        }
2212
        s->total_bits += s->frame_bits;
2213
        avctx->frame_bits  = s->frame_bits;
2214
    }else{
2215
        assert((pbBufPtr(&s->pb) == s->pb.buf));
2216
        s->frame_bits=0;
2217
    }
2218
    assert((s->frame_bits&7)==0);
2219
    
2220
    return s->frame_bits/8;
2221
}
2222

    
2223
#endif //CONFIG_ENCODERS
2224

    
2225
static inline void gmc1_motion(MpegEncContext *s,
2226
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2227
                               uint8_t **ref_picture)
2228
{
2229
    uint8_t *ptr;
2230
    int offset, src_x, src_y, linesize, uvlinesize;
2231
    int motion_x, motion_y;
2232
    int emu=0;
2233

    
2234
    motion_x= s->sprite_offset[0][0];
2235
    motion_y= s->sprite_offset[0][1];
2236
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2237
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2238
    motion_x<<=(3-s->sprite_warping_accuracy);
2239
    motion_y<<=(3-s->sprite_warping_accuracy);
2240
    src_x = clip(src_x, -16, s->width);
2241
    if (src_x == s->width)
2242
        motion_x =0;
2243
    src_y = clip(src_y, -16, s->height);
2244
    if (src_y == s->height)
2245
        motion_y =0;
2246

    
2247
    linesize = s->linesize;
2248
    uvlinesize = s->uvlinesize;
2249
    
2250
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2251

    
2252
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2253
        if(   (unsigned)src_x >= s->h_edge_pos - 17
2254
           || (unsigned)src_y >= s->v_edge_pos - 17){
2255
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2256
            ptr= s->edge_emu_buffer;
2257
        }
2258
    }
2259
    
2260
    if((motion_x|motion_y)&7){
2261
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2262
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2263
    }else{
2264
        int dxy;
2265
        
2266
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2267
        if (s->no_rounding){
2268
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2269
        }else{
2270
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2271
        }
2272
    }
2273
    
2274
    if(s->flags&CODEC_FLAG_GRAY) return;
2275

    
2276
    motion_x= s->sprite_offset[1][0];
2277
    motion_y= s->sprite_offset[1][1];
2278
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2279
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2280
    motion_x<<=(3-s->sprite_warping_accuracy);
2281
    motion_y<<=(3-s->sprite_warping_accuracy);
2282
    src_x = clip(src_x, -8, s->width>>1);
2283
    if (src_x == s->width>>1)
2284
        motion_x =0;
2285
    src_y = clip(src_y, -8, s->height>>1);
2286
    if (src_y == s->height>>1)
2287
        motion_y =0;
2288

    
2289
    offset = (src_y * uvlinesize) + src_x;
2290
    ptr = ref_picture[1] + offset;
2291
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2292
        if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2293
           || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2294
            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);
2295
            ptr= s->edge_emu_buffer;
2296
            emu=1;
2297
        }
2298
    }
2299
    s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2300
    
2301
    ptr = ref_picture[2] + offset;
2302
    if(emu){
2303
        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);
2304
        ptr= s->edge_emu_buffer;
2305
    }
2306
    s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2307
    
2308
    return;
2309
}
2310

    
2311
static inline void gmc_motion(MpegEncContext *s,
2312
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2313
                               uint8_t **ref_picture)
2314
{
2315
    uint8_t *ptr;
2316
    int linesize, uvlinesize;
2317
    const int a= s->sprite_warping_accuracy;
2318
    int ox, oy;
2319

    
2320
    linesize = s->linesize;
2321
    uvlinesize = s->uvlinesize;
2322

    
2323
    ptr = ref_picture[0];
2324

    
2325
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2326
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2327

    
2328
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2329
           ox, 
2330
           oy, 
2331
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2332
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2333
           a+1, (1<<(2*a+1)) - s->no_rounding,
2334
           s->h_edge_pos, s->v_edge_pos);
2335
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2336
           ox + s->sprite_delta[0][0]*8, 
2337
           oy + s->sprite_delta[1][0]*8, 
2338
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2339
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2340
           a+1, (1<<(2*a+1)) - s->no_rounding,
2341
           s->h_edge_pos, s->v_edge_pos);
2342

    
2343
    if(s->flags&CODEC_FLAG_GRAY) return;
2344

    
2345
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2346
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2347

    
2348
    ptr = ref_picture[1];
2349
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2350
           ox, 
2351
           oy, 
2352
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2353
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2354
           a+1, (1<<(2*a+1)) - s->no_rounding,
2355
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2356
    
2357
    ptr = ref_picture[2];
2358
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2359
           ox, 
2360
           oy, 
2361
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2362
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2363
           a+1, (1<<(2*a+1)) - s->no_rounding,
2364
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2365
}
2366

    
2367
/**
2368
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2369
 * @param buf destination buffer
2370
 * @param src source buffer
2371
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2372
 * @param block_w width of block
2373
 * @param block_h height of block
2374
 * @param src_x x coordinate of the top left sample of the block in the source buffer
2375
 * @param src_y y coordinate of the top left sample of the block in the source buffer
2376
 * @param w width of the source buffer
2377
 * @param h height of the source buffer
2378
 */
2379
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
2380
                                    int src_x, int src_y, int w, int h){
2381
    int x, y;
2382
    int start_y, start_x, end_y, end_x;
2383

    
2384
    if(src_y>= h){
2385
        src+= (h-1-src_y)*linesize;
2386
        src_y=h-1;
2387
    }else if(src_y<=-block_h){
2388
        src+= (1-block_h-src_y)*linesize;
2389
        src_y=1-block_h;
2390
    }
2391
    if(src_x>= w){
2392
        src+= (w-1-src_x);
2393
        src_x=w-1;
2394
    }else if(src_x<=-block_w){
2395
        src+= (1-block_w-src_x);
2396
        src_x=1-block_w;
2397
    }
2398

    
2399
    start_y= FFMAX(0, -src_y);
2400
    start_x= FFMAX(0, -src_x);
2401
    end_y= FFMIN(block_h, h-src_y);
2402
    end_x= FFMIN(block_w, w-src_x);
2403

    
2404
    // copy existing part
2405
    for(y=start_y; y<end_y; y++){
2406
        for(x=start_x; x<end_x; x++){
2407
            buf[x + y*linesize]= src[x + y*linesize];
2408
        }
2409
    }
2410

    
2411
    //top
2412
    for(y=0; y<start_y; y++){
2413
        for(x=start_x; x<end_x; x++){
2414
            buf[x + y*linesize]= buf[x + start_y*linesize];
2415
        }
2416
    }
2417

    
2418
    //bottom
2419
    for(y=end_y; y<block_h; y++){
2420
        for(x=start_x; x<end_x; x++){
2421
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2422
        }
2423
    }
2424
                                    
2425
    for(y=0; y<block_h; y++){
2426
       //left
2427
        for(x=0; x<start_x; x++){
2428
            buf[x + y*linesize]= buf[start_x + y*linesize];
2429
        }
2430
       
2431
       //right
2432
        for(x=end_x; x<block_w; x++){
2433
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2434
        }
2435
    }
2436
}
2437

    
2438
static inline int hpel_motion(MpegEncContext *s, 
2439
                                  uint8_t *dest, uint8_t *src,
2440
                                  int field_based, int field_select,
2441
                                  int src_x, int src_y,
2442
                                  int width, int height, int stride,
2443
                                  int h_edge_pos, int v_edge_pos,
2444
                                  int w, int h, op_pixels_func *pix_op,
2445
                                  int motion_x, int motion_y)
2446
{
2447
    int dxy;
2448
    int emu=0;
2449

    
2450
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2451
    src_x += motion_x >> 1;
2452
    src_y += motion_y >> 1;
2453
                
2454
    /* WARNING: do no forget half pels */
2455
    src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2456
    if (src_x == width)
2457
        dxy &= ~1;
2458
    src_y = clip(src_y, -16, height);
2459
    if (src_y == height)
2460
        dxy &= ~2;
2461
    src += src_y * stride + src_x;
2462

    
2463
    if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2464
        if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2465
           || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2466
            ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2467
                             src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2468
            src= s->edge_emu_buffer;
2469
            emu=1;
2470
        }
2471
    }
2472
    if(field_select)
2473
        src += s->linesize;
2474
    pix_op[dxy](dest, src, stride, h);
2475
    return emu;
2476
}
2477

    
2478
/* apply one mpeg motion vector to the three components */
2479
static inline void mpeg_motion(MpegEncContext *s,
2480
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2481
                               int field_based, int bottom_field, int field_select,
2482
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2483
                               int motion_x, int motion_y, int h)
2484
{
2485
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2486
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2487
    
2488
#if 0    
2489
if(s->quarter_sample)
2490
{
2491
    motion_x>>=1;
2492
    motion_y>>=1;
2493
}
2494
#endif
2495

    
2496
    v_edge_pos = s->v_edge_pos >> field_based;
2497
    linesize   = s->current_picture.linesize[0] << field_based;
2498
    uvlinesize = s->current_picture.linesize[1] << field_based;
2499

    
2500
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2501
    src_x = s->mb_x* 16               + (motion_x >> 1);
2502
    src_y = s->mb_y*(16>>field_based) + (motion_y >> 1);
2503

    
2504
    if (s->out_format == FMT_H263) {
2505
        if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2506
            mx = (motion_x>>1)|(motion_x&1);
2507
            my = motion_y >>1;
2508
            uvdxy = ((my & 1) << 1) | (mx & 1);
2509
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2510
            uvsrc_y = s->mb_y*(8>>field_based) + (my >> 1);
2511
        }else{
2512
            uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2513
            uvsrc_x = src_x>>1;
2514
            uvsrc_y = src_y>>1;
2515
        }
2516
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2517
        mx = motion_x / 4;
2518
        my = motion_y / 4;
2519
        uvdxy = 0;
2520
        uvsrc_x = s->mb_x*8 + mx;
2521
        uvsrc_y = s->mb_y*8 + my;
2522
    } else {
2523
        mx = motion_x / 2;
2524
        my = motion_y / 2;
2525
        uvdxy = ((my & 1) << 1) | (mx & 1);
2526
        uvsrc_x = s->mb_x* 8               + (mx >> 1);
2527
        uvsrc_y = s->mb_y*(8>>field_based) + (my >> 1);
2528
    }
2529

    
2530
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2531
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2532
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2533

    
2534
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2535
       || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
2536
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2537
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2538
            ptr_y = s->edge_emu_buffer;
2539
            if(!(s->flags&CODEC_FLAG_GRAY)){
2540
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2541
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2542
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2543
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2544
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2545
                ptr_cb= uvbuf;
2546
                ptr_cr= uvbuf+16;
2547
            }
2548
    }
2549

    
2550
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2551
        dest_y += s->linesize;
2552
        dest_cb+= s->uvlinesize;
2553
        dest_cr+= s->uvlinesize;
2554
    }
2555

    
2556
    if(field_select){
2557
        ptr_y += s->linesize;
2558
        ptr_cb+= s->uvlinesize;
2559
        ptr_cr+= s->uvlinesize;
2560
    }
2561

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

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

    
2648
    put_obmc(dest, ptr, s->linesize);                
2649
}
2650

    
2651
static inline void qpel_motion(MpegEncContext *s,
2652
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2653
                               int field_based, int bottom_field, int field_select,
2654
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2655
                               qpel_mc_func (*qpix_op)[16],
2656
                               int motion_x, int motion_y, int h)
2657
{
2658
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2659
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
2660

    
2661
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2662
    src_x = s->mb_x *  16                 + (motion_x >> 2);
2663
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2664

    
2665
    v_edge_pos = s->v_edge_pos >> field_based;
2666
    linesize = s->linesize << field_based;
2667
    uvlinesize = s->uvlinesize << field_based;
2668
    
2669
    if(field_based){
2670
        mx= motion_x/2;
2671
        my= motion_y>>1;
2672
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2673
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
2674
        mx= (motion_x>>1) + rtab[motion_x&7];
2675
        my= (motion_y>>1) + rtab[motion_y&7];
2676
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2677
        mx= (motion_x>>1)|(motion_x&1);
2678
        my= (motion_y>>1)|(motion_y&1);
2679
    }else{
2680
        mx= motion_x/2;
2681
        my= motion_y/2;
2682
    }
2683
    mx= (mx>>1)|(mx&1);
2684
    my= (my>>1)|(my&1);
2685

    
2686
    uvdxy= (mx&1) | ((my&1)<<1);
2687
    mx>>=1;
2688
    my>>=1;
2689

    
2690
    uvsrc_x = s->mb_x *  8                 + mx;
2691
    uvsrc_y = s->mb_y * (8 >> field_based) + my;
2692

    
2693
    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
2694
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2695
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2696

    
2697
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 
2698
       || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
2699
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, 
2700
                         src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2701
        ptr_y= s->edge_emu_buffer;
2702
        if(!(s->flags&CODEC_FLAG_GRAY)){
2703
            uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
2704
            ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based, 
2705
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2706
            ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based, 
2707
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2708
            ptr_cb= uvbuf;
2709
            ptr_cr= uvbuf + 16;
2710
        }
2711
    }
2712

    
2713
    if(!field_based)
2714
        qpix_op[0][dxy](dest_y, ptr_y, linesize);
2715
    else{
2716
        if(bottom_field){
2717
            dest_y += s->linesize;
2718
            dest_cb+= s->uvlinesize;
2719
            dest_cr+= s->uvlinesize;
2720
        }
2721

    
2722
        if(field_select){
2723
            ptr_y  += s->linesize;
2724
            ptr_cb += s->uvlinesize;
2725
            ptr_cr += s->uvlinesize;
2726
        }
2727
        //damn interlaced mode
2728
        //FIXME boundary mirroring is not exactly correct here
2729
        qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
2730
        qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
2731
    }
2732
    if(!(s->flags&CODEC_FLAG_GRAY)){
2733
        pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
2734
        pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
2735
    }
2736
}
2737

    
2738
inline int ff_h263_round_chroma(int x){
2739
    if (x >= 0)
2740
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2741
    else {
2742
        x = -x;
2743
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2744
    }
2745
}
2746

    
2747
/**
2748
 * h263 chorma 4mv motion compensation.
2749
 */
2750
static inline void chroma_4mv_motion(MpegEncContext *s,
2751
                                     uint8_t *dest_cb, uint8_t *dest_cr,
2752
                                     uint8_t **ref_picture,
2753
                                     op_pixels_func *pix_op,
2754
                                     int mx, int my){
2755
    int dxy, emu=0, src_x, src_y, offset;
2756
    uint8_t *ptr;
2757
    
2758
    /* In case of 8X8, we construct a single chroma motion vector
2759
       with a special rounding */
2760
    mx= ff_h263_round_chroma(mx);
2761
    my= ff_h263_round_chroma(my);
2762
    
2763
    dxy = ((my & 1) << 1) | (mx & 1);
2764
    mx >>= 1;
2765
    my >>= 1;
2766

    
2767
    src_x = s->mb_x * 8 + mx;
2768
    src_y = s->mb_y * 8 + my;
2769
    src_x = clip(src_x, -8, s->width/2);
2770
    if (src_x == s->width/2)
2771
        dxy &= ~1;
2772
    src_y = clip(src_y, -8, s->height/2);
2773
    if (src_y == s->height/2)
2774
        dxy &= ~2;
2775
    
2776
    offset = (src_y * (s->uvlinesize)) + src_x;
2777
    ptr = ref_picture[1] + offset;
2778
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2779
        if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
2780
           || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
2781
            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);
2782
            ptr= s->edge_emu_buffer;
2783
            emu=1;
2784
        }
2785
    }
2786
    pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
2787

    
2788
    ptr = ref_picture[2] + offset;
2789
    if(emu){
2790
        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);
2791
        ptr= s->edge_emu_buffer;
2792
    }
2793
    pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
2794
}
2795

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

    
2817
    mb_x = s->mb_x;
2818
    mb_y = s->mb_y;
2819

    
2820
    if(s->obmc && s->pict_type != B_TYPE){
2821
        int16_t mv_cache[4][4][2];
2822
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
2823
        const int mot_stride= s->b8_stride;
2824
        const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
2825

    
2826
        assert(!s->mb_skiped);
2827
                
2828
        memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
2829
        memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2830
        memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2831

    
2832
        if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
2833
            memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
2834
        }else{
2835
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
2836
        }
2837

    
2838
        if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
2839
            *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
2840
            *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
2841
        }else{
2842
            *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
2843
            *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
2844
        }
2845

    
2846
        if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
2847
            *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
2848
            *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
2849
        }else{
2850
            *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
2851
            *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
2852
        }
2853
        
2854
        mx = 0;
2855
        my = 0;
2856
        for(i=0;i<4;i++) {
2857
            const int x= (i&1)+1;
2858
            const int y= (i>>1)+1;
2859
            int16_t mv[5][2]= {
2860
                {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
2861
                {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
2862
                {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
2863
                {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
2864
                {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
2865
            //FIXME cleanup
2866
            obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2867
                        ref_picture[0],
2868
                        mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2869
                        pix_op[1],
2870
                        mv);
2871

    
2872
            mx += mv[0][0];
2873
            my += mv[0][1];
2874
        }
2875
        if(!(s->flags&CODEC_FLAG_GRAY))
2876
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2877

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

    
2918
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2919
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
2920
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
2921
                    
2922
                /* WARNING: do no forget half pels */
2923
                src_x = clip(src_x, -16, s->width);
2924
                if (src_x == s->width)
2925
                    dxy &= ~3;
2926
                src_y = clip(src_y, -16, s->height);
2927
                if (src_y == s->height)
2928
                    dxy &= ~12;
2929
                    
2930
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2931
                if(s->flags&CODEC_FLAG_EMU_EDGE){
2932
                    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8 
2933
                       || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
2934
                        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);
2935
                        ptr= s->edge_emu_buffer;
2936
                    }
2937
                }
2938
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2939
                qpix_op[1][dxy](dest, ptr, s->linesize);
2940

    
2941
                mx += s->mv[dir][i][0]/2;
2942
                my += s->mv[dir][i][1]/2;
2943
            }
2944
        }else{
2945
            for(i=0;i<4;i++) {
2946
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2947
                            ref_picture[0], 0, 0,
2948
                            mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2949
                            s->width, s->height, s->linesize,
2950
                            s->h_edge_pos, s->v_edge_pos,
2951
                            8, 8, pix_op[1],
2952
                            s->mv[dir][i][0], s->mv[dir][i][1]);
2953

    
2954
                mx += s->mv[dir][i][0];
2955
                my += s->mv[dir][i][1];
2956
            }
2957
        }
2958

    
2959
        if(!(s->flags&CODEC_FLAG_GRAY))
2960
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2961
        break;
2962
    case MV_TYPE_FIELD:
2963
        if (s->picture_structure == PICT_FRAME) {
2964
            if(s->quarter_sample){
2965
                for(i=0; i<2; i++){
2966
                    qpel_motion(s, dest_y, dest_cb, dest_cr,
2967
                                1, i, s->field_select[dir][i],
2968
                                ref_picture, pix_op, qpix_op,
2969
                                s->mv[dir][i][0], s->mv[dir][i][1], 8);
2970
                }
2971
            }else{
2972
                /* top field */       
2973
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
2974
                            1, 0, s->field_select[dir][0],
2975
                            ref_picture, pix_op,
2976
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
2977
                /* bottom field */
2978
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
2979
                            1, 1, s->field_select[dir][1],
2980
                            ref_picture, pix_op,
2981
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
2982
            }
2983
        } else {
2984
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
2985
                ref_picture= s->current_picture_ptr->data;
2986
            } 
2987

    
2988
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
2989
                        0, 0, s->field_select[dir][0],
2990
                        ref_picture, pix_op,
2991
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2992
        }
2993
        break;
2994
    case MV_TYPE_16X8:
2995
        for(i=0; i<2; i++){
2996
            uint8_t ** ref2picture;
2997

    
2998
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
2999
                ref2picture= ref_picture;
3000
            }else{
3001
                ref2picture= s->current_picture_ptr->data;
3002
            } 
3003

    
3004
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3005
                        0, 0, s->field_select[dir][i],
3006
                        ref2picture, pix_op,
3007
                        s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3008
                
3009
            dest_y += 16*s->linesize;
3010
            dest_cb+=  8*s->uvlinesize;
3011
            dest_cr+=  8*s->uvlinesize;
3012
        }        
3013
        break;
3014
    case MV_TYPE_DMV:
3015
        if(s->picture_structure == PICT_FRAME){
3016
            for(i=0; i<2; i++){
3017
                int j;
3018
                for(j=0; j<2; j++){
3019
                    mpeg_motion(s, dest_y, dest_cb, dest_cr,
3020
                                1, j, j^i,
3021
                                ref_picture, pix_op,
3022
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3023
                }
3024
                pix_op = s->dsp.avg_pixels_tab; 
3025
            }
3026
        }else{
3027
            for(i=0; i<2; i++){
3028
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3029
                            0, 0, s->picture_structure != i+1,
3030
                            ref_picture, pix_op,
3031
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3032

    
3033
                // after put we make avg of the same block
3034
                pix_op=s->dsp.avg_pixels_tab; 
3035

    
3036
                //opposite parity is always in the same frame if this is second field
3037
                if(!s->first_field){
3038
                    ref_picture = s->current_picture_ptr->data;    
3039
                }
3040
            }
3041
        }
3042
    break;
3043
    default: assert(0);
3044
    }
3045
}
3046

    
3047

    
3048
/* put block[] to dest[] */
3049
static inline void put_dct(MpegEncContext *s, 
3050
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3051
{
3052
    s->dct_unquantize_intra(s, block, i, qscale);
3053
    s->dsp.idct_put (dest, line_size, block);
3054
}
3055

    
3056
/* add block[] to dest[] */
3057
static inline void add_dct(MpegEncContext *s, 
3058
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
3059
{
3060
    if (s->block_last_index[i] >= 0) {
3061
        s->dsp.idct_add (dest, line_size, block);
3062
    }
3063
}
3064

    
3065
static inline void add_dequant_dct(MpegEncContext *s, 
3066
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3067
{
3068
    if (s->block_last_index[i] >= 0) {
3069
        s->dct_unquantize_inter(s, block, i, qscale);
3070

    
3071
        s->dsp.idct_add (dest, line_size, block);
3072
    }
3073
}
3074

    
3075
/**
3076
 * cleans dc, ac, coded_block for the current non intra MB
3077
 */
3078
void ff_clean_intra_table_entries(MpegEncContext *s)
3079
{
3080
    int wrap = s->b8_stride;
3081
    int xy = s->block_index[0];
3082
    
3083
    s->dc_val[0][xy           ] = 
3084
    s->dc_val[0][xy + 1       ] = 
3085
    s->dc_val[0][xy     + wrap] =
3086
    s->dc_val[0][xy + 1 + wrap] = 1024;
3087
    /* ac pred */
3088
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
3089
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3090
    if (s->msmpeg4_version>=3) {
3091
        s->coded_block[xy           ] =
3092
        s->coded_block[xy + 1       ] =
3093
        s->coded_block[xy     + wrap] =
3094
        s->coded_block[xy + 1 + wrap] = 0;
3095
    }
3096
    /* chroma */
3097
    wrap = s->mb_stride;
3098
    xy = s->mb_x + s->mb_y * wrap;
3099
    s->dc_val[1][xy] =
3100
    s->dc_val[2][xy] = 1024;
3101
    /* ac pred */
3102
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3103
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3104
    
3105
    s->mbintra_table[xy]= 0;
3106
}
3107

    
3108
/* generic function called after a macroblock has been parsed by the
3109
   decoder or after it has been encoded by the encoder.
3110

3111
   Important variables used:
3112
   s->mb_intra : true if intra macroblock
3113
   s->mv_dir   : motion vector direction
3114
   s->mv_type  : motion vector type
3115
   s->mv       : motion vector
3116
   s->interlaced_dct : true if interlaced dct used (mpeg2)
3117
 */
3118
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
3119
{
3120
    int mb_x, mb_y;
3121
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3122
#ifdef HAVE_XVMC
3123
    if(s->avctx->xvmc_acceleration){
3124
        XVMC_decode_mb(s);//xvmc uses pblocks
3125
        return;
3126
    }
3127
#endif
3128

    
3129
    mb_x = s->mb_x;
3130
    mb_y = s->mb_y;
3131

    
3132
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3133
       /* save DCT coefficients */
3134
       int i,j;
3135
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3136
       for(i=0; i<6; i++)
3137
           for(j=0; j<64; j++)
3138
               *dct++ = block[i][s->dsp.idct_permutation[j]];
3139
    }
3140

    
3141
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3142

    
3143
    /* update DC predictors for P macroblocks */
3144
    if (!s->mb_intra) {
3145
        if (s->h263_pred || s->h263_aic) {
3146
            if(s->mbintra_table[mb_xy])
3147
                ff_clean_intra_table_entries(s);
3148
        } else {
3149
            s->last_dc[0] =
3150
            s->last_dc[1] =
3151
            s->last_dc[2] = 128 << s->intra_dc_precision;
3152
        }
3153
    }
3154
    else if (s->h263_pred || s->h263_aic)
3155
        s->mbintra_table[mb_xy]=1;
3156

    
3157
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3158
        uint8_t *dest_y, *dest_cb, *dest_cr;
3159
        int dct_linesize, dct_offset;
3160
        op_pixels_func (*op_pix)[4];
3161
        qpel_mc_func (*op_qpix)[16];
3162
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3163
        const int uvlinesize= s->current_picture.linesize[1];
3164
        const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band;
3165

    
3166
        /* avoid copy if macroblock skipped in last frame too */
3167
        /* skip only during decoding as we might trash the buffers during encoding a bit */
3168
        if(!s->encoding){
3169
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3170
            const int age= s->current_picture.age;
3171

    
3172
            assert(age);
3173

    
3174
            if (s->mb_skiped) {
3175
                s->mb_skiped= 0;
3176
                assert(s->pict_type!=I_TYPE);
3177
 
3178
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
3179
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3180

    
3181
                /* if previous was skipped too, then nothing to do !  */
3182
                if (*mbskip_ptr >= age && s->current_picture.reference){
3183
                    return;
3184
                }
3185
            } else if(!s->current_picture.reference){
3186
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3187
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3188
            } else{
3189
                *mbskip_ptr = 0; /* not skipped */
3190
            }
3191
        }
3192

    
3193
        if (s->interlaced_dct) {
3194
            dct_linesize = linesize * 2;
3195
            dct_offset = linesize;
3196
        } else {
3197
            dct_linesize = linesize;
3198
            dct_offset = linesize * 8;
3199
        }
3200
        if(readable){
3201
            dest_y=  s->dest[0];
3202
            dest_cb= s->dest[1];
3203
            dest_cr= s->dest[2];
3204
        }else{
3205
            dest_y = s->b_scratchpad;
3206
            dest_cb= s->b_scratchpad+16*linesize;
3207
            dest_cr= s->b_scratchpad+16*linesize+8;
3208
        }
3209
        if (!s->mb_intra) {
3210
            /* motion handling */
3211
            /* decoding or more than one mb_type (MC was allready done otherwise) */
3212
            if(!s->encoding){
3213
                if ((!s->no_rounding) || s->pict_type==B_TYPE){                
3214
                    op_pix = s->dsp.put_pixels_tab;
3215
                    op_qpix= s->dsp.put_qpel_pixels_tab;
3216
                }else{
3217
                    op_pix = s->dsp.put_no_rnd_pixels_tab;
3218
                    op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3219
                }
3220

    
3221
                if (s->mv_dir & MV_DIR_FORWARD) {
3222
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3223
                    op_pix = s->dsp.avg_pixels_tab;
3224
                    op_qpix= s->dsp.avg_qpel_pixels_tab;
3225
                }
3226
                if (s->mv_dir & MV_DIR_BACKWARD) {
3227
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3228
                }
3229
            }
3230

    
3231
            /* skip dequant / idct if we are really late ;) */
3232
            if(s->hurry_up>1) return;
3233

    
3234
            /* add dct residue */
3235
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3236
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3237
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
3238
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
3239
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
3240
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
3241

    
3242
                if(!(s->flags&CODEC_FLAG_GRAY)){
3243
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3244
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3245
                }
3246
            } else if(s->codec_id != CODEC_ID_WMV2){
3247
                add_dct(s, block[0], 0, dest_y, dct_linesize);
3248
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
3249
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
3250
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
3251

    
3252
                if(!(s->flags&CODEC_FLAG_GRAY)){
3253
                    add_dct(s, block[4], 4, dest_cb, uvlinesize);
3254
                    add_dct(s, block[5], 5, dest_cr, uvlinesize);
3255
                }
3256
            } 
3257
#ifdef CONFIG_RISKY
3258
            else{
3259
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3260
            }
3261
#endif
3262
        } else {
3263
            /* dct only in intra block */
3264
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3265
                put_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
3266
                put_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
3267
                put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
3268
                put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
3269

    
3270
                if(!(s->flags&CODEC_FLAG_GRAY)){
3271
                    put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3272
                    put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3273
                }
3274
            }else{
3275
                s->dsp.idct_put(dest_y                 , dct_linesize, block[0]);
3276
                s->dsp.idct_put(dest_y              + 8, dct_linesize, block[1]);
3277
                s->dsp.idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
3278
                s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
3279

    
3280
                if(!(s->flags&CODEC_FLAG_GRAY)){
3281
                    s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3282
                    s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3283
                }
3284
            }
3285
        }
3286
        if(!readable){
3287
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3288
            s->dsp.put_pixels_tab[1][0](s->dest[1], dest_cb, uvlinesize, 8);
3289
            s->dsp.put_pixels_tab[1][0](s->dest[2], dest_cr, uvlinesize, 8);
3290
        }
3291
    }
3292
}
3293

    
3294
#ifdef CONFIG_ENCODERS
3295

    
3296
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3297
{
3298
    static const char tab[64]=
3299
        {3,2,2,1,1,1,1,1,
3300
         1,1,1,1,1,1,1,1,
3301
         1,1,1,1,1,1,1,1,
3302
         0,0,0,0,0,0,0,0,
3303
         0,0,0,0,0,0,0,0,
3304
         0,0,0,0,0,0,0,0,
3305
         0,0,0,0,0,0,0,0,
3306
         0,0,0,0,0,0,0,0};
3307
    int score=0;
3308
    int run=0;
3309
    int i;
3310
    DCTELEM *block= s->block[n];
3311
    const int last_index= s->block_last_index[n];
3312
    int skip_dc;
3313

    
3314
    if(threshold<0){
3315
        skip_dc=0;
3316
        threshold= -threshold;
3317
    }else
3318
        skip_dc=1;
3319

    
3320
    /* are all which we could set to zero are allready zero? */
3321
    if(last_index<=skip_dc - 1) return;
3322

    
3323
    for(i=0; i<=last_index; i++){
3324
        const int j = s->intra_scantable.permutated[i];
3325
        const int level = ABS(block[j]);
3326
        if(level==1){
3327
            if(skip_dc && i==0) continue;
3328
            score+= tab[run];
3329
            run=0;
3330
        }else if(level>1){
3331
            return;
3332
        }else{
3333
            run++;
3334
        }
3335
    }
3336
    if(score >= threshold) return;
3337
    for(i=skip_dc; i<=last_index; i++){
3338
        const int j = s->intra_scantable.permutated[i];
3339
        block[j]=0;
3340
    }
3341
    if(block[0]) s->block_last_index[n]= 0;
3342
    else         s->block_last_index[n]= -1;
3343
}
3344

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

    
3376
#endif //CONFIG_ENCODERS
3377

    
3378
/**
3379
 *
3380
 * @param h is the normal height, this will be reduced automatically if needed for the last row
3381
 */
3382
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3383
    if (s->avctx->draw_horiz_band) {
3384
        AVFrame *src;
3385
        int offset[4];
3386
        
3387
        if(s->picture_structure != PICT_FRAME){
3388
            h <<= 1;
3389
            y <<= 1;
3390
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3391
        }
3392

    
3393
        h= FFMIN(h, s->height - y);
3394

    
3395
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) 
3396
            src= (AVFrame*)s->current_picture_ptr;
3397
        else if(s->last_picture_ptr)
3398
            src= (AVFrame*)s->last_picture_ptr;
3399
        else
3400
            return;
3401
            
3402
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3403
            offset[0]=
3404
            offset[1]=
3405
            offset[2]=
3406
            offset[3]= 0;
3407
        }else{
3408
            offset[0]= y * s->linesize;;
3409
            offset[1]= 
3410
            offset[2]= (y>>1) * s->uvlinesize;;
3411
            offset[3]= 0;
3412
        }
3413

    
3414
        emms_c();
3415

    
3416
        s->avctx->draw_horiz_band(s->avctx, src, offset,
3417
                                  y, s->picture_structure, h);
3418
    }
3419
}
3420

    
3421
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3422
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3423
    const int uvlinesize= s->current_picture.linesize[1];
3424
        
3425
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
3426
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
3427
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
3428
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3429
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3430
    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;
3431
    
3432
    if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){
3433
        s->dest[0] = s->current_picture.data[0] + s->mb_x * 16 - 16;
3434
        s->dest[1] = s->current_picture.data[1] + s->mb_x * 8 - 8;
3435
        s->dest[2] = s->current_picture.data[2] + s->mb_x * 8 - 8;
3436
    }else{
3437
        s->dest[0] = s->current_picture.data[0] + (s->mb_y * 16* linesize  ) + s->mb_x * 16 - 16;
3438
        s->dest[1] = s->current_picture.data[1] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
3439
        s->dest[2] = s->current_picture.data[2] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
3440
    }    
3441
}
3442

    
3443
#ifdef CONFIG_ENCODERS
3444

    
3445
static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
3446
    int x, y;
3447
//FIXME optimize
3448
    for(y=0; y<8; y++){
3449
        for(x=0; x<8; x++){
3450
            int x2, y2;
3451
            int sum=0;
3452
            int sqr=0;
3453
            int count=0;
3454

    
3455
            for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
3456
                for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
3457
                    int v= ptr[x2 + y2*stride];
3458
                    sum += v;
3459
                    sqr += v*v;
3460
                    count++;
3461
                }
3462
            }
3463
            weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
3464
        }
3465
    }
3466
}
3467

    
3468
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
3469
{
3470
    int16_t weight[6][64];
3471
    DCTELEM orig[6][64];
3472
    const int mb_x= s->mb_x;
3473
    const int mb_y= s->mb_y;
3474
    int i;
3475
    int skip_dct[6];
3476
    int dct_offset   = s->linesize*8; //default for progressive frames
3477
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3478
    int wrap_y, wrap_c;
3479
    
3480
    for(i=0; i<6; i++) skip_dct[i]=0;
3481
    
3482
    if(s->adaptive_quant){
3483
        const int last_qp= s->qscale;
3484
        const int mb_xy= mb_x + mb_y*s->mb_stride;
3485

    
3486
        s->lambda= s->lambda_table[mb_xy];
3487
        update_qscale(s);
3488
    
3489
        if(!(s->flags&CODEC_FLAG_QP_RD)){
3490
            s->dquant= s->qscale - last_qp;
3491

    
3492
            if(s->out_format==FMT_H263){
3493
                s->dquant= clip(s->dquant, -2, 2); //FIXME RD
3494
            
3495
                if(s->codec_id==CODEC_ID_MPEG4){        
3496
                    if(!s->mb_intra){
3497
                        if(s->pict_type == B_TYPE){
3498
                            if(s->dquant&1) 
3499
                                s->dquant= (s->dquant/2)*2;
3500
                            if(s->mv_dir&MV_DIRECT)
3501
                                s->dquant= 0;
3502
                        }
3503
                        if(s->mv_type==MV_TYPE_8X8)
3504
                            s->dquant=0;
3505
                    }
3506
                }
3507
            }
3508
        }
3509
        ff_set_qscale(s, last_qp + s->dquant);
3510
    }else if(s->flags&CODEC_FLAG_QP_RD)
3511
        ff_set_qscale(s, s->qscale + s->dquant);
3512

    
3513
    wrap_y = s->linesize;
3514
    wrap_c = s->uvlinesize;
3515
    ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
3516
    ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
3517
    ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3518

    
3519
    if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
3520
        ff_emulated_edge_mc(s->edge_emu_buffer            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
3521
        ptr_y= s->edge_emu_buffer;
3522
        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);
3523
        ptr_cb= s->edge_emu_buffer+18*wrap_y;
3524
        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);
3525
        ptr_cr= s->edge_emu_buffer+18*wrap_y+9;
3526
    }
3527

    
3528
    if (s->mb_intra) {
3529
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3530
            int progressive_score, interlaced_score;
3531

    
3532
            s->interlaced_dct=0;
3533
            progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8) 
3534
                              +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
3535

    
3536
            if(progressive_score > 0){
3537
                interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8) 
3538
                                  +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
3539
                if(progressive_score > interlaced_score){
3540
                    s->interlaced_dct=1;
3541
            
3542
                    dct_offset= wrap_y;
3543
                    wrap_y<<=1;
3544
                }
3545
            }
3546
        }
3547
        
3548
        s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
3549
        s->dsp.get_pixels(s->block[1], ptr_y              + 8, wrap_y);
3550
        s->dsp.get_pixels(s->block[2], ptr_y + dct_offset    , wrap_y);
3551
        s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
3552

    
3553
        if(s->flags&CODEC_FLAG_GRAY){
3554
            skip_dct[4]= 1;
3555
            skip_dct[5]= 1;
3556
        }else{
3557
            s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
3558
            s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
3559
        }
3560
    }else{
3561
        op_pixels_func (*op_pix)[4];
3562
        qpel_mc_func (*op_qpix)[16];
3563
        uint8_t *dest_y, *dest_cb, *dest_cr;
3564

    
3565
        dest_y  = s->dest[0];
3566
        dest_cb = s->dest[1];
3567
        dest_cr = s->dest[2];
3568

    
3569
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
3570
            op_pix = s->dsp.put_pixels_tab;
3571
            op_qpix= s->dsp.put_qpel_pixels_tab;
3572
        }else{
3573
            op_pix = s->dsp.put_no_rnd_pixels_tab;
3574
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3575
        }
3576

    
3577
        if (s->mv_dir & MV_DIR_FORWARD) {
3578
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3579
            op_pix = s->dsp.avg_pixels_tab;
3580
            op_qpix= s->dsp.avg_qpel_pixels_tab;
3581
        }
3582
        if (s->mv_dir & MV_DIR_BACKWARD) {
3583
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3584
        }
3585

    
3586
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3587
            int progressive_score, interlaced_score;
3588

    
3589
            s->interlaced_dct=0;
3590
            progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8) 
3591
                              +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
3592
            
3593
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
3594

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

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

    
3671
        if(s->flags & CODEC_FLAG_CBP_RD){
3672
            for(i=0;i<6;i++) {
3673
                if(s->block_last_index[i] == -1)
3674
                    s->coded_score[i]= INT_MAX/256;
3675
            }
3676
        }
3677
    }
3678

    
3679
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
3680
        s->block_last_index[4]=
3681
        s->block_last_index[5]= 0;
3682
        s->block[4][0]=
3683
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
3684
    }
3685

    
3686
    //non c quantize code returns incorrect block_last_index FIXME
3687
    if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
3688
        for(i=0; i<6; i++){
3689
            int j;
3690
            if(s->block_last_index[i]>0){
3691
                for(j=63; j>0; j--){
3692
                    if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
3693
                }
3694
                s->block_last_index[i]= j;
3695
            }
3696
        }
3697
    }
3698

    
3699
    /* huffman encode */
3700
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
3701
    case CODEC_ID_MPEG1VIDEO:
3702
    case CODEC_ID_MPEG2VIDEO:
3703
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
3704
#ifdef CONFIG_RISKY
3705
    case CODEC_ID_MPEG4:
3706
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3707
    case CODEC_ID_MSMPEG4V2:
3708
    case CODEC_ID_MSMPEG4V3:
3709
    case CODEC_ID_WMV1:
3710
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3711
    case CODEC_ID_WMV2:
3712
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
3713
    case CODEC_ID_H263:
3714
    case CODEC_ID_H263P:
3715
    case CODEC_ID_FLV1:
3716
    case CODEC_ID_RV10:
3717
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
3718
#endif
3719
    case CODEC_ID_MJPEG:
3720
        mjpeg_encode_mb(s, s->block); break;
3721
    default:
3722
        assert(0);
3723
    }
3724
}
3725

    
3726
#endif //CONFIG_ENCODERS
3727

    
3728
void ff_mpeg_flush(AVCodecContext *avctx){
3729
    int i;
3730
    MpegEncContext *s = avctx->priv_data;
3731
    
3732
    if(s==NULL || s->picture==NULL) 
3733
        return;
3734
    
3735
    for(i=0; i<MAX_PICTURE_COUNT; i++){
3736
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
3737
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
3738
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
3739
    }
3740
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
3741
    
3742
    s->parse_context.state= -1;
3743
    s->parse_context.frame_start_found= 0;
3744
    s->parse_context.overread= 0;
3745
    s->parse_context.overread_index= 0;
3746
    s->parse_context.index= 0;
3747
    s->parse_context.last_index= 0;
3748
    s->bitstream_buffer_size=0;
3749
}
3750

    
3751
#ifdef CONFIG_ENCODERS
3752
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
3753
{
3754
    const uint16_t *srcw= (uint16_t*)src;
3755
    int words= length>>4;
3756
    int bits= length&15;
3757
    int i;
3758

    
3759
    if(length==0) return;
3760
    
3761
    if(words < 16){
3762
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
3763
    }else if(put_bits_count(pb)&7){
3764
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
3765
    }else{
3766
        for(i=0; put_bits_count(pb)&31; i++)
3767
            put_bits(pb, 8, src[i]);
3768
        flush_put_bits(pb);
3769
        memcpy(pbBufPtr(pb), src+i, 2*words-i);
3770
        skip_put_bytes(pb, 2*words-i);
3771
    }
3772
        
3773
    put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
3774
}
3775

    
3776
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
3777
    int i;
3778

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

    
3781
    /* mpeg1 */
3782
    d->mb_skip_run= s->mb_skip_run;
3783
    for(i=0; i<3; i++)
3784
        d->last_dc[i]= s->last_dc[i];
3785
    
3786
    /* statistics */
3787
    d->mv_bits= s->mv_bits;
3788
    d->i_tex_bits= s->i_tex_bits;
3789
    d->p_tex_bits= s->p_tex_bits;
3790
    d->i_count= s->i_count;
3791
    d->f_count= s->f_count;
3792
    d->b_count= s->b_count;
3793
    d->skip_count= s->skip_count;
3794
    d->misc_bits= s->misc_bits;
3795
    d->last_bits= 0;
3796

    
3797
    d->mb_skiped= 0;
3798
    d->qscale= s->qscale;
3799
    d->dquant= s->dquant;
3800
}
3801

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

    
3805
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
3806
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
3807
    
3808
    /* mpeg1 */
3809
    d->mb_skip_run= s->mb_skip_run;
3810
    for(i=0; i<3; i++)
3811
        d->last_dc[i]= s->last_dc[i];
3812
    
3813
    /* statistics */
3814
    d->mv_bits= s->mv_bits;
3815
    d->i_tex_bits= s->i_tex_bits;
3816
    d->p_tex_bits= s->p_tex_bits;
3817
    d->i_count= s->i_count;
3818
    d->f_count= s->f_count;
3819
    d->b_count= s->b_count;
3820
    d->skip_count= s->skip_count;
3821
    d->misc_bits= s->misc_bits;
3822

    
3823
    d->mb_intra= s->mb_intra;
3824
    d->mb_skiped= s->mb_skiped;
3825
    d->mv_type= s->mv_type;
3826
    d->mv_dir= s->mv_dir;
3827
    d->pb= s->pb;
3828
    if(s->data_partitioning){
3829
        d->pb2= s->pb2;
3830
        d->tex_pb= s->tex_pb;
3831
    }
3832
    d->block= s->block;
3833
    for(i=0; i<6; i++)
3834
        d->block_last_index[i]= s->block_last_index[i];
3835
    d->interlaced_dct= s->interlaced_dct;
3836
    d->qscale= s->qscale;
3837
}
3838

    
3839
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
3840
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
3841
                           int *dmin, int *next_block, int motion_x, int motion_y)
3842
{
3843
    int score;
3844
    uint8_t *dest_backup[3];
3845
    
3846
    copy_context_before_encode(s, backup, type);
3847

    
3848
    s->block= s->blocks[*next_block];
3849
    s->pb= pb[*next_block];
3850
    if(s->data_partitioning){
3851
        s->pb2   = pb2   [*next_block];
3852
        s->tex_pb= tex_pb[*next_block];
3853
    }
3854
    
3855
    if(*next_block){
3856
        memcpy(dest_backup, s->dest, sizeof(s->dest));
3857
        s->dest[0] = s->rd_scratchpad;
3858
        s->dest[1] = s->rd_scratchpad + 16*s->linesize;
3859
        s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
3860
        assert(s->linesize >= 32); //FIXME
3861
    }
3862

    
3863
    encode_mb(s, motion_x, motion_y);
3864
    
3865
    score= put_bits_count(&s->pb);
3866
    if(s->data_partitioning){
3867
        score+= put_bits_count(&s->pb2);
3868
        score+= put_bits_count(&s->tex_pb);
3869
    }
3870
   
3871
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
3872
        MPV_decode_mb(s, s->block);
3873

    
3874
        score *= s->lambda2;
3875
        score += sse_mb(s) << FF_LAMBDA_SHIFT;
3876
    }
3877
    
3878
    if(*next_block){
3879
        memcpy(s->dest, dest_backup, sizeof(s->dest));
3880
    }
3881

    
3882
    if(score<*dmin){
3883
        *dmin= score;
3884
        *next_block^=1;
3885

    
3886
        copy_context_after_encode(best, s, type);
3887
    }
3888
}
3889
                
3890
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
3891
    uint32_t *sq = squareTbl + 256;
3892
    int acc=0;
3893
    int x,y;
3894
    
3895
    if(w==16 && h==16) 
3896
        return s->dsp.sse[0](NULL, src1, src2, stride, 16);
3897
    else if(w==8 && h==8)
3898
        return s->dsp.sse[1](NULL, src1, src2, stride, 8);
3899
    
3900
    for(y=0; y<h; y++){
3901
        for(x=0; x<w; x++){
3902
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
3903
        } 
3904
    }
3905
    
3906
    assert(acc>=0);
3907
    
3908
    return acc;
3909
}
3910

    
3911
static int sse_mb(MpegEncContext *s){
3912
    int w= 16;
3913
    int h= 16;
3914

    
3915
    if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3916
    if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3917

    
3918
    if(w==16 && h==16)
3919
      if(s->avctx->mb_cmp == FF_CMP_NSSE){
3920
        return  s->dsp.nsse[0](s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16)
3921
               +s->dsp.nsse[1](s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8)
3922
               +s->dsp.nsse[1](s, s->new_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
3923
      }else{
3924
        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)
3925
               +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)
3926
               +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);
3927
      }
3928
    else
3929
        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)
3930
               +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)
3931
               +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);
3932
}
3933

    
3934
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
3935
    MpegEncContext *s= arg;
3936

    
3937
    
3938
    s->me.pre_pass=1;
3939
    s->me.dia_size= s->avctx->pre_dia_size;
3940
    s->first_slice_line=1;
3941
    for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
3942
        for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
3943
            ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
3944
        }
3945
        s->first_slice_line=0;
3946
    }
3947
    
3948
    s->me.pre_pass=0;
3949
    
3950
    return 0;
3951
}
3952

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

    
3956
    s->me.dia_size= s->avctx->dia_size;
3957
    s->first_slice_line=1;
3958
    for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
3959
        s->mb_x=0; //for block init below
3960
        ff_init_block_index(s);
3961
        for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
3962
            s->block_index[0]+=2;
3963
            s->block_index[1]+=2;
3964
            s->block_index[2]+=2;
3965
            s->block_index[3]+=2;
3966
            
3967
            /* compute motion vector & mb_type and store in context */
3968
            if(s->pict_type==B_TYPE)
3969
                ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
3970
            else
3971
                ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
3972
        }
3973
        s->first_slice_line=0;
3974
    }
3975
    return 0;
3976
}
3977

    
3978
static int mb_var_thread(AVCodecContext *c, void *arg){
3979
    MpegEncContext *s= arg;
3980
    int mb_x, mb_y;
3981

    
3982
    for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
3983
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3984
            int xx = mb_x * 16;
3985
            int yy = mb_y * 16;
3986
            uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
3987
            int varc;
3988
            int sum = s->dsp.pix_sum(pix, s->linesize);
3989
    
3990
            varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
3991

    
3992
            s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
3993
            s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
3994
            s->me.mb_var_sum_temp    += varc;
3995
        }
3996
    }
3997
    return 0;
3998
}
3999

    
4000
static void write_slice_end(MpegEncContext *s){
4001
    if(s->codec_id==CODEC_ID_MPEG4){
4002
        if(s->partitioned_frame){
4003
            ff_mpeg4_merge_partitions(s);
4004
        }
4005
    
4006
        ff_mpeg4_stuffing(&s->pb);
4007
    }else if(s->out_format == FMT_MJPEG){
4008
        ff_mjpeg_stuffing(&s->pb);
4009
    }
4010

    
4011
    align_put_bits(&s->pb);
4012
    flush_put_bits(&s->pb);
4013
}
4014

    
4015
static int encode_thread(AVCodecContext *c, void *arg){
4016
    MpegEncContext *s= arg;
4017
    int mb_x, mb_y, pdif = 0;
4018
    int i, j;
4019
    MpegEncContext best_s, backup_s;
4020
    uint8_t bit_buf[2][3000];
4021
    uint8_t bit_buf2[2][3000];
4022
    uint8_t bit_buf_tex[2][3000];
4023
    PutBitContext pb[2], pb2[2], tex_pb[2];
4024
//printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4025

    
4026
    for(i=0; i<2; i++){
4027
        init_put_bits(&pb    [i], bit_buf    [i], 3000);
4028
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000);
4029
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000);
4030
    }
4031

    
4032
    s->last_bits= put_bits_count(&s->pb);
4033
    s->mv_bits=0;
4034
    s->misc_bits=0;
4035
    s->i_tex_bits=0;
4036
    s->p_tex_bits=0;
4037
    s->i_count=0;
4038
    s->f_count=0;
4039
    s->b_count=0;
4040
    s->skip_count=0;
4041

    
4042
    for(i=0; i<3; i++){
4043
        /* init last dc values */
4044
        /* note: quant matrix value (8) is implied here */
4045
        s->last_dc[i] = 128 << s->intra_dc_precision;
4046
        
4047
        s->current_picture_ptr->error[i] = 0;
4048
    }
4049
    s->mb_skip_run = 0;
4050
    memset(s->last_mv, 0, sizeof(s->last_mv));
4051
     
4052
    s->last_mv_dir = 0;
4053

    
4054
#ifdef CONFIG_RISKY
4055
    switch(s->codec_id){
4056
    case CODEC_ID_H263:
4057
    case CODEC_ID_H263P:
4058
    case CODEC_ID_FLV1:
4059
        s->gob_index = ff_h263_get_gob_height(s);
4060
        break;
4061
    case CODEC_ID_MPEG4:
4062
        if(s->partitioned_frame)
4063
            ff_mpeg4_init_partitions(s);
4064
        break;
4065
    }
4066
#endif
4067

    
4068
    s->resync_mb_x=0;
4069
    s->resync_mb_y=0; 
4070
    s->first_slice_line = 1;
4071
    s->ptr_lastgob = s->pb.buf;
4072
    for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4073
//    printf("row %d at %X\n", s->mb_y, (int)s);
4074
        s->mb_x=0;
4075
        s->mb_y= mb_y;
4076

    
4077
        ff_set_qscale(s, s->qscale);
4078
        ff_init_block_index(s);
4079
        
4080
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4081
            const int xy= mb_y*s->mb_stride + mb_x;
4082
            int mb_type= s->mb_type[xy];
4083
//            int d;
4084
            int dmin= INT_MAX;
4085
            int dir;
4086

    
4087
            s->mb_x = mb_x;
4088
            ff_update_block_index(s);
4089

    
4090
            /* write gob / video packet header  */
4091
#ifdef CONFIG_RISKY
4092
            if(s->rtp_mode){
4093
                int current_packet_size, is_gob_start;
4094
                
4095
                current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
4096
                
4097
                is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0; 
4098
                
4099
                if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
4100
                
4101
                switch(s->codec_id){
4102
                case CODEC_ID_H263:
4103
                case CODEC_ID_H263P:
4104
                    if(!s->h263_slice_structured)
4105
                        if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
4106
                    break;
4107
                case CODEC_ID_MPEG2VIDEO:
4108
                    if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
4109
                case CODEC_ID_MPEG1VIDEO:
4110
                    if(s->mb_skip_run) is_gob_start=0;
4111
                    break;
4112
                }
4113

    
4114
                if(is_gob_start){
4115
                    if(s->start_mb_y != mb_y || mb_x!=0){
4116
                        write_slice_end(s);
4117

    
4118
                        if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
4119
                            ff_mpeg4_init_partitions(s);
4120
                        }
4121
                    }
4122
                
4123
                    assert((put_bits_count(&s->pb)&7) == 0);
4124
                    current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4125
                    
4126
                    if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
4127
                        int r= put_bits_count(&s->pb)/8 + s->picture_number + s->codec_id + s->mb_x + s->mb_y;
4128
                        int d= 100 / s->avctx->error_rate;
4129
                        if(r % d == 0){
4130
                            current_packet_size=0;
4131
#ifndef ALT_BITSTREAM_WRITER
4132
                            s->pb.buf_ptr= s->ptr_lastgob;
4133
#endif
4134
                            assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
4135
                        }
4136
                    }
4137
        
4138
                    if (s->avctx->rtp_callback)
4139
                        s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, 0);
4140
                    
4141
                    switch(s->codec_id){
4142
                    case CODEC_ID_MPEG4:
4143
                        ff_mpeg4_encode_video_packet_header(s);
4144
                        ff_mpeg4_clean_buffers(s);
4145
                    break;
4146
                    case CODEC_ID_MPEG1VIDEO:
4147
                    case CODEC_ID_MPEG2VIDEO:
4148
                        ff_mpeg1_encode_slice_header(s);
4149
                        ff_mpeg1_clean_buffers(s);
4150
                    break;
4151
                    case CODEC_ID_H263:
4152
                    case CODEC_ID_H263P:
4153
                        h263_encode_gob_header(s, mb_y);                       
4154
                    break;
4155
                    }
4156

    
4157
                    if(s->flags&CODEC_FLAG_PASS1){
4158
                        int bits= put_bits_count(&s->pb);
4159
                        s->misc_bits+= bits - s->last_bits;
4160
                        s->last_bits= bits;
4161
                    }
4162
    
4163
                    s->ptr_lastgob += current_packet_size;
4164
                    s->first_slice_line=1;
4165
                    s->resync_mb_x=mb_x;
4166
                    s->resync_mb_y=mb_y;
4167
                }
4168
            }
4169
#endif
4170

    
4171
            if(  (s->resync_mb_x   == s->mb_x)
4172
               && s->resync_mb_y+1 == s->mb_y){
4173
                s->first_slice_line=0; 
4174
            }
4175

    
4176
            s->mb_skiped=0;
4177
            s->dquant=0; //only for QP_RD
4178

    
4179
            if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible
4180
                int next_block=0;
4181
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
4182

    
4183
                copy_context_before_encode(&backup_s, s, -1);
4184
                backup_s.pb= s->pb;
4185
                best_s.data_partitioning= s->data_partitioning;
4186
                best_s.partitioned_frame= s->partitioned_frame;
4187
                if(s->data_partitioning){
4188
                    backup_s.pb2= s->pb2;
4189
                    backup_s.tex_pb= s->tex_pb;
4190
                }
4191

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

    
4328
                if(s->flags & CODEC_FLAG_QP_RD){
4329
                    if(best_s.mv_type==MV_TYPE_16X16 && !(best_s.mv_dir&MV_DIRECT)){
4330
                        const int last_qp= backup_s.qscale;
4331
                        int dquant, dir, qp, dc[6];
4332
                        DCTELEM ac[6][16];
4333
                        const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
4334
                        
4335
                        assert(backup_s.dquant == 0);
4336

    
4337
                        //FIXME intra
4338
                        s->mv_dir= best_s.mv_dir;
4339
                        s->mv_type = MV_TYPE_16X16;
4340
                        s->mb_intra= best_s.mb_intra;
4341
                        s->mv[0][0][0] = best_s.mv[0][0][0];
4342
                        s->mv[0][0][1] = best_s.mv[0][0][1];
4343
                        s->mv[1][0][0] = best_s.mv[1][0][0];
4344
                        s->mv[1][0][1] = best_s.mv[1][0][1];
4345
                        
4346
                        dir= s->pict_type == B_TYPE ? 2 : 1;
4347
                        if(last_qp + dir > s->avctx->qmax) dir= -dir;
4348
                        for(dquant= dir; dquant<=2 && dquant>=-2; dquant += dir){
4349
                            qp= last_qp + dquant;
4350
                            if(qp < s->avctx->qmin || qp > s->avctx->qmax)
4351
                                break;
4352
                            backup_s.dquant= dquant;
4353
                            if(s->mb_intra){
4354
                                for(i=0; i<6; i++){
4355
                                    dc[i]= s->dc_val[0][ s->block_index[i] ];
4356
                                    memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
4357
                                }
4358
                            }
4359

    
4360
                            encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb, 
4361
                                         &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
4362
                            if(best_s.qscale != qp){
4363
                                if(s->mb_intra){
4364
                                    for(i=0; i<6; i++){
4365
                                        s->dc_val[0][ s->block_index[i] ]= dc[i];
4366
                                        memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
4367
                                    }
4368
                                }
4369
                                if(dir > 0 && dquant==dir){
4370
                                    dquant= 0;
4371
                                    dir= -dir;
4372
                                }else
4373
                                    break;
4374
                            }
4375
                        }
4376
                        qp= best_s.qscale;
4377
                        s->current_picture.qscale_table[xy]= qp;
4378
                    }
4379
                }
4380

    
4381
                copy_context_after_encode(s, &best_s, -1);
4382
                
4383
                pb_bits_count= put_bits_count(&s->pb);
4384
                flush_put_bits(&s->pb);
4385
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
4386
                s->pb= backup_s.pb;
4387
                
4388
                if(s->data_partitioning){
4389
                    pb2_bits_count= put_bits_count(&s->pb2);
4390
                    flush_put_bits(&s->pb2);
4391
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
4392
                    s->pb2= backup_s.pb2;
4393
                    
4394
                    tex_pb_bits_count= put_bits_count(&s->tex_pb);
4395
                    flush_put_bits(&s->tex_pb);
4396
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
4397
                    s->tex_pb= backup_s.tex_pb;
4398
                }
4399
                s->last_bits= put_bits_count(&s->pb);
4400
               
4401
#ifdef CONFIG_RISKY
4402
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4403
                    ff_h263_update_motion_val(s);
4404
#endif
4405
        
4406
                if(next_block==0){ //FIXME 16 vs linesize16
4407
                    s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad                     , s->linesize  ,16);
4408
                    s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize    , s->uvlinesize, 8);
4409
                    s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
4410
                }
4411

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

    
4525
                encode_mb(s, motion_x, motion_y);
4526

    
4527
                // RAL: Update last macrobloc type
4528
                s->last_mv_dir = s->mv_dir;
4529
            
4530
#ifdef CONFIG_RISKY
4531
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4532
                    ff_h263_update_motion_val(s);
4533
#endif
4534
                
4535
                MPV_decode_mb(s, s->block);
4536
            }
4537

    
4538
            /* clean the MV table in IPS frames for direct mode in B frames */
4539
            if(s->mb_intra /* && I,P,S_TYPE */){
4540
                s->p_mv_table[xy][0]=0;
4541
                s->p_mv_table[xy][1]=0;
4542
            }
4543
            
4544
            if(s->flags&CODEC_FLAG_PSNR){
4545
                int w= 16;
4546
                int h= 16;
4547

    
4548
                if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4549
                if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4550

    
4551
                s->current_picture_ptr->error[0] += sse(
4552
                    s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
4553
                    s->dest[0], w, h, s->linesize);
4554
                s->current_picture_ptr->error[1] += sse(
4555
                    s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
4556
                    s->dest[1], w>>1, h>>1, s->uvlinesize);
4557
                s->current_picture_ptr->error[2] += sse(
4558
                    s, s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
4559
                    s->dest[2], w>>1, h>>1, s->uvlinesize);
4560
            }
4561
            if(s->loop_filter)
4562
                ff_h263_loop_filter(s);
4563
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
4564
        }
4565
    }
4566

    
4567
#ifdef CONFIG_RISKY
4568
    //not beautifull here but we must write it before flushing so it has to be here
4569
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
4570
        msmpeg4_encode_ext_header(s);
4571
#endif
4572

    
4573
    write_slice_end(s);
4574

    
4575
    /* Send the last GOB if RTP */    
4576
    if (s->avctx->rtp_callback) {
4577
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
4578
        /* Call the RTP callback to send the last GOB */
4579
        emms_c();
4580
        s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, 0);
4581
    }
4582

    
4583
    return 0;
4584
}
4585

    
4586
#define MERGE(field) dst->field += src->field; src->field=0
4587
static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
4588
    MERGE(me.scene_change_score);
4589
    MERGE(me.mc_mb_var_sum_temp);
4590
    MERGE(me.mb_var_sum_temp);
4591
}
4592

    
4593
static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
4594
    int i;
4595

    
4596
    MERGE(dct_count[0]); //note, the other dct vars are not part of the context
4597
    MERGE(dct_count[1]);
4598
    MERGE(mv_bits);
4599
    MERGE(header_bits);
4600
    MERGE(i_tex_bits);
4601
    MERGE(p_tex_bits);
4602
    MERGE(i_count);
4603
    MERGE(f_count);
4604
    MERGE(b_count);
4605
    MERGE(skip_count);
4606
    MERGE(misc_bits);
4607
    MERGE(error_count);
4608
    MERGE(padding_bug_score);
4609

    
4610
    if(dst->avctx->noise_reduction){
4611
        for(i=0; i<64; i++){
4612
            MERGE(dct_error_sum[0][i]);
4613
            MERGE(dct_error_sum[1][i]);
4614
        }
4615
    }
4616
    
4617
    assert(put_bits_count(&src->pb) % 8 ==0);
4618
    assert(put_bits_count(&dst->pb) % 8 ==0);
4619
    ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
4620
    flush_put_bits(&dst->pb);
4621
}
4622

    
4623
static void encode_picture(MpegEncContext *s, int picture_number)
4624
{
4625
    int i;
4626
    int bits;
4627

    
4628
    s->picture_number = picture_number;
4629
    
4630
    /* Reset the average MB variance */
4631
    s->me.mb_var_sum_temp    =
4632
    s->me.mc_mb_var_sum_temp = 0;
4633

    
4634
#ifdef CONFIG_RISKY
4635
    /* we need to initialize some time vars before we can encode b-frames */
4636
    // RAL: Condition added for MPEG1VIDEO
4637
    if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
4638
        ff_set_mpeg4_time(s, s->picture_number);  //FIXME rename and use has_b_frames or similar
4639
#endif
4640
        
4641
    s->me.scene_change_score=0;
4642
    
4643
//    s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration
4644
    
4645
    if(s->pict_type==I_TYPE){
4646
        if(s->msmpeg4_version >= 3) s->no_rounding=1;
4647
        else                        s->no_rounding=0;
4648
    }else if(s->pict_type!=B_TYPE){
4649
        if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
4650
            s->no_rounding ^= 1;          
4651
    }
4652
    
4653
    s->mb_intra=0;