Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 9ebb8e11

History | View | Annotate | Download (220 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)*4*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 chroma shifts */
625
    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
626
                                                    &(s->chroma_y_shift) );
627

    
628
    /* set default edge pos, will be overriden in decode_header if needed */
629
    s->h_edge_pos= s->mb_width*16;
630
    s->v_edge_pos= s->mb_height*16;
631

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

    
651
    s->avctx->stream_codec_tag=   toupper( s->avctx->stream_codec_tag     &0xFF)          
652
                               + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
653
                               + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16) 
654
                               + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
655

    
656
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
657

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

    
681
        if(s->msmpeg4_version){
682
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
683
        }
684
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
685

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

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

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

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

    
768
    s->context_initialized = 1;
769

    
770
    s->thread_context[0]= s;
771
    for(i=1; i<s->avctx->thread_count; i++){
772
        s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
773
        memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
774
    }
775

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

    
783
    return 0;
784
 fail:
785
    MPV_common_end(s);
786
    return -1;
787
}
788

    
789
/* init common structure for both encoder and decoder */
790
void MPV_common_end(MpegEncContext *s)
791
{
792
    int i, j, k;
793

    
794
    for(i=0; i<s->avctx->thread_count; i++){
795
        free_duplicate_context(s->thread_context[i]);
796
    }
797
    for(i=1; i<s->avctx->thread_count; i++){
798
        av_freep(&s->thread_context[i]);
799
    }
800

    
801
    av_freep(&s->parse_context.buffer);
802
    s->parse_context.buffer_size=0;
803

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

    
853
    if(s->picture){
854
        for(i=0; i<MAX_PICTURE_COUNT; i++){
855
            free_picture(s, &s->picture[i]);
856
        }
857
    }
858
    av_freep(&s->picture);
859
    s->context_initialized = 0;
860
    s->last_picture_ptr=
861
    s->next_picture_ptr=
862
    s->current_picture_ptr= NULL;
863
    s->linesize= s->uvlinesize= 0;
864

    
865
    for(i=0; i<3; i++)
866
        av_freep(&s->visualization_buffer[i]);
867

    
868
    avcodec_default_free_buffers(s->avctx);
869
}
870

    
871
#ifdef CONFIG_ENCODERS
872

    
873
/* init video encoder */
874
int MPV_encode_init(AVCodecContext *avctx)
875
{
876
    MpegEncContext *s = avctx->priv_data;
877
    int i, dummy;
878
    int chroma_h_shift, chroma_v_shift;
879
    
880
    MPV_encode_defaults(s);
881

    
882
    avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME
883

    
884
    s->bit_rate = avctx->bit_rate;
885
    s->width = avctx->width;
886
    s->height = avctx->height;
887
    if(avctx->gop_size > 600){
888
        av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
889
        avctx->gop_size=600;
890
    }
891
    s->gop_size = avctx->gop_size;
892
    s->avctx = avctx;
893
    s->flags= avctx->flags;
894
    s->flags2= avctx->flags2;
895
    s->max_b_frames= avctx->max_b_frames;
896
    s->codec_id= avctx->codec->id;
897
    s->luma_elim_threshold  = avctx->luma_elim_threshold;
898
    s->chroma_elim_threshold= avctx->chroma_elim_threshold;
899
    s->strict_std_compliance= avctx->strict_std_compliance;
900
    s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
901
    s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
902
    s->mpeg_quant= avctx->mpeg_quant;
903
    s->rtp_mode= !!avctx->rtp_payload_size;
904
    s->intra_dc_precision= avctx->intra_dc_precision;
905
    s->user_specified_pts = AV_NOPTS_VALUE;
906

    
907
    if (s->gop_size <= 1) {
908
        s->intra_only = 1;
909
        s->gop_size = 12;
910
    } else {
911
        s->intra_only = 0;
912
    }
913

    
914
    s->me_method = avctx->me_method;
915

    
916
    /* Fixed QSCALE */
917
    s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
918
    
919
    s->adaptive_quant= (   s->avctx->lumi_masking
920
                        || s->avctx->dark_masking
921
                        || s->avctx->temporal_cplx_masking 
922
                        || s->avctx->spatial_cplx_masking
923
                        || s->avctx->p_masking
924
                        || (s->flags&CODEC_FLAG_QP_RD))
925
                       && !s->fixed_qscale;
926
    
927
    s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
928
    s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
929
    s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
930

    
931
    if(avctx->rc_max_rate && !avctx->rc_buffer_size){
932
        av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
933
        return -1;
934
    }    
935

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

    
978
    if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
979
        av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
980
        return -1;
981
    }
982
    
983
    if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
984
        av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
985
        return -1;
986
    }
987

    
988
    if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN)) 
989
       && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
990
        av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
991
        return -1;
992
    }
993
        
994
    if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
995
        av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n");
996
        return -1;
997
    }
998
        
999
    if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1000
        av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1001
        return -1;
1002
    }
1003

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

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

    
1050
    av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1051
    s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1052

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

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

    
1186
    s->encoding = 1;
1187

    
1188
    /* init */
1189
    if (MPV_common_init(s) < 0)
1190
        return -1;
1191

    
1192
    if(s->modified_quant)
1193
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1194
    s->progressive_frame= 
1195
    s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1196
    s->quant_precision=5;
1197
    
1198
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1199
    
1200
#ifdef CONFIG_ENCODERS
1201
#ifdef CONFIG_RISKY
1202
    if (s->out_format == FMT_H263)
1203
        h263_encode_init(s);
1204
    if(s->msmpeg4_version)
1205
        ff_msmpeg4_encode_init(s);
1206
#endif
1207
    if (s->out_format == FMT_MPEG1)
1208
        ff_mpeg1_encode_init(s);
1209
#endif
1210

    
1211
    /* init q matrix */
1212
    for(i=0;i<64;i++) {
1213
        int j= s->dsp.idct_permutation[i];
1214
#ifdef CONFIG_RISKY
1215
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1216
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1217
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1218
        }else if(s->out_format == FMT_H263){
1219
            s->intra_matrix[j] =
1220
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1221
        }else
1222
#endif
1223
        { /* mpeg1/2 */
1224
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1225
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1226
        }
1227
        if(s->avctx->intra_matrix)
1228
            s->intra_matrix[j] = s->avctx->intra_matrix[i];
1229
        if(s->avctx->inter_matrix)
1230
            s->inter_matrix[j] = s->avctx->inter_matrix[i];
1231
    }
1232

    
1233
    /* precompute matrix */
1234
    /* for mjpeg, we do include qscale in the matrix */
1235
    if (s->out_format != FMT_MJPEG) {
1236
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 
1237
                       s->intra_matrix, s->intra_quant_bias, 1, 31);
1238
        convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, 
1239
                       s->inter_matrix, s->inter_quant_bias, 1, 31);
1240
    }
1241

    
1242
    if(ff_rate_control_init(s) < 0)
1243
        return -1;
1244
    
1245
    return 0;
1246
}
1247

    
1248
int MPV_encode_end(AVCodecContext *avctx)
1249
{
1250
    MpegEncContext *s = avctx->priv_data;
1251

    
1252
#ifdef STATS
1253
    print_stats();
1254
#endif
1255

    
1256
    ff_rate_control_uninit(s);
1257

    
1258
    MPV_common_end(s);
1259
    if (s->out_format == FMT_MJPEG)
1260
        mjpeg_close(s);
1261

    
1262
    av_freep(&avctx->extradata);
1263
      
1264
    return 0;
1265
}
1266

    
1267
#endif //CONFIG_ENCODERS
1268

    
1269
void init_rl(RLTable *rl)
1270
{
1271
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1272
    uint8_t index_run[MAX_RUN+1];
1273
    int last, run, level, start, end, i;
1274

    
1275
    /* compute max_level[], max_run[] and index_run[] */
1276
    for(last=0;last<2;last++) {
1277
        if (last == 0) {
1278
            start = 0;
1279
            end = rl->last;
1280
        } else {
1281
            start = rl->last;
1282
            end = rl->n;
1283
        }
1284

    
1285
        memset(max_level, 0, MAX_RUN + 1);
1286
        memset(max_run, 0, MAX_LEVEL + 1);
1287
        memset(index_run, rl->n, MAX_RUN + 1);
1288
        for(i=start;i<end;i++) {
1289
            run = rl->table_run[i];
1290
            level = rl->table_level[i];
1291
            if (index_run[run] == rl->n)
1292
                index_run[run] = i;
1293
            if (level > max_level[run])
1294
                max_level[run] = level;
1295
            if (run > max_run[level])
1296
                max_run[level] = run;
1297
        }
1298
        rl->max_level[last] = av_malloc(MAX_RUN + 1);
1299
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1300
        rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1301
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1302
        rl->index_run[last] = av_malloc(MAX_RUN + 1);
1303
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1304
    }
1305
}
1306

    
1307
/* draw the edges of width 'w' of an image of size width, height */
1308
//FIXME check that this is ok for mpeg4 interlaced
1309
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1310
{
1311
    uint8_t *ptr, *last_line;
1312
    int i;
1313

    
1314
    last_line = buf + (height - 1) * wrap;
1315
    for(i=0;i<w;i++) {
1316
        /* top and bottom */
1317
        memcpy(buf - (i + 1) * wrap, buf, width);
1318
        memcpy(last_line + (i + 1) * wrap, last_line, width);
1319
    }
1320
    /* left and right */
1321
    ptr = buf;
1322
    for(i=0;i<height;i++) {
1323
        memset(ptr - w, ptr[0], w);
1324
        memset(ptr + width, ptr[width-1], w);
1325
        ptr += wrap;
1326
    }
1327
    /* corners */
1328
    for(i=0;i<w;i++) {
1329
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1330
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1331
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1332
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1333
    }
1334
}
1335

    
1336
int ff_find_unused_picture(MpegEncContext *s, int shared){
1337
    int i;
1338
    
1339
    if(shared){
1340
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1341
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1342
        }
1343
    }else{
1344
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1345
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1346
        }
1347
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1348
            if(s->picture[i].data[0]==NULL) return i;
1349
        }
1350
    }
1351

    
1352
    assert(0);
1353
    return -1;
1354
}
1355

    
1356
static void update_noise_reduction(MpegEncContext *s){
1357
    int intra, i;
1358

    
1359
    for(intra=0; intra<2; intra++){
1360
        if(s->dct_count[intra] > (1<<16)){
1361
            for(i=0; i<64; i++){
1362
                s->dct_error_sum[intra][i] >>=1;
1363
            }
1364
            s->dct_count[intra] >>= 1;
1365
        }
1366
        
1367
        for(i=0; i<64; i++){
1368
            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);
1369
        }
1370
    }
1371
}
1372

    
1373
/**
1374
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1375
 */
1376
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1377
{
1378
    int i;
1379
    AVFrame *pic;
1380
    s->mb_skiped = 0;
1381

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

    
1384
    /* mark&release old frames */
1385
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1386
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1387

    
1388
        /* release forgotten pictures */
1389
        /* if(mpeg124/h263) */
1390
        if(!s->encoding){
1391
            for(i=0; i<MAX_PICTURE_COUNT; i++){
1392
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1393
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1394
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
1395
                }
1396
            }
1397
        }
1398
    }
1399
alloc:
1400
    if(!s->encoding){
1401
        /* release non refernce frames */
1402
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1403
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1404
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1405
            }
1406
        }
1407

    
1408
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1409
            pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1410
        else{
1411
            i= ff_find_unused_picture(s, 0);
1412
            pic= (AVFrame*)&s->picture[i];
1413
        }
1414

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

    
1417
        pic->coded_picture_number= s->coded_picture_number++;
1418
        
1419
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1420
            return -1;
1421

    
1422
        s->current_picture_ptr= (Picture*)pic;
1423
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1424
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1425
    }
1426

    
1427
    s->current_picture_ptr->pict_type= s->pict_type;
1428
//    if(s->flags && CODEC_FLAG_QSCALE) 
1429
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1430
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1431

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

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

    
1457
    if(s->picture_structure!=PICT_FRAME){
1458
        int i;
1459
        for(i=0; i<4; i++){
1460
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1461
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1462
            } 
1463
            s->current_picture.linesize[i] *= 2;
1464
            s->last_picture.linesize[i] *=2;
1465
            s->next_picture.linesize[i] *=2;
1466
        }
1467
    }
1468
  }
1469
   
1470
    s->hurry_up= s->avctx->hurry_up;
1471
    s->error_resilience= avctx->error_resilience;
1472

    
1473
    /* set dequantizer, we cant do it during init as it might change for mpeg4
1474
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1475
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1476
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1477
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1478
    }else if(s->out_format == FMT_H263){
1479
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1480
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1481
    }else if(s->out_format == FMT_H261){
1482
        s->dct_unquantize_intra = s->dct_unquantize_h261_intra;
1483
        s->dct_unquantize_inter = s->dct_unquantize_h261_inter;
1484
    }else{
1485
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1486
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1487
    }
1488

    
1489
    if(s->dct_error_sum){
1490
        assert(s->avctx->noise_reduction && s->encoding);
1491

    
1492
        update_noise_reduction(s);
1493
    }
1494
        
1495
#ifdef HAVE_XVMC
1496
    if(s->avctx->xvmc_acceleration)
1497
        return XVMC_field_start(s, avctx);
1498
#endif
1499
    return 0;
1500
}
1501

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

    
1535
    if(s->encoding){
1536
        /* release non refernce frames */
1537
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1538
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1539
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1540
            }
1541
        }
1542
    }
1543
    // clear copies, to avoid confusion
1544
#if 0
1545
    memset(&s->last_picture, 0, sizeof(Picture));
1546
    memset(&s->next_picture, 0, sizeof(Picture));
1547
    memset(&s->current_picture, 0, sizeof(Picture));
1548
#endif
1549
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1550
}
1551

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

    
1601
/**
1602
 * draws an arrow from (ex, ey) -> (sx, sy).
1603
 * @param w width of the image
1604
 * @param h height of the image
1605
 * @param stride stride/linesize of the image
1606
 * @param color color of the arrow
1607
 */
1608
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1609
    int dx,dy;
1610

    
1611
    sx= clip(sx, -100, w+100);
1612
    sy= clip(sy, -100, h+100);
1613
    ex= clip(ex, -100, w+100);
1614
    ey= clip(ey, -100, h+100);
1615
    
1616
    dx= ex - sx;
1617
    dy= ey - sy;
1618
    
1619
    if(dx*dx + dy*dy > 3*3){
1620
        int rx=  dx + dy;
1621
        int ry= -dx + dy;
1622
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1623
        
1624
        //FIXME subpixel accuracy
1625
        rx= ROUNDED_DIV(rx*3<<4, length);
1626
        ry= ROUNDED_DIV(ry*3<<4, length);
1627
        
1628
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1629
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1630
    }
1631
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1632
}
1633

    
1634
/**
1635
 * prints debuging info for the given picture.
1636
 */
1637
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1638

    
1639
    if(!pict || !pict->mb_type) return;
1640

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

    
1717
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1718
        const int shift= 1 + s->quarter_sample;
1719
        int mb_y;
1720
        uint8_t *ptr;
1721
        int i;
1722
        int h_chroma_shift, v_chroma_shift;
1723
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1724

    
1725
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1726
        for(i=0; i<3; i++){
1727
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*s->height:pict->linesize[i]*s->height >> v_chroma_shift);
1728
            pict->data[i]= s->visualization_buffer[i];
1729
        }
1730
        pict->type= FF_BUFFER_TYPE_COPY;
1731
        ptr= pict->data[0];
1732

    
1733
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1734
            int mb_x;
1735
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1736
                const int mb_index= mb_x + mb_y*s->mb_stride;
1737
                if((s->avctx->debug_mv) && pict->motion_val){
1738
                  int type;
1739
                  for(type=0; type<3; type++){
1740
                    int direction = 0;
1741
                    switch (type) {
1742
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1743
                                continue;
1744
                              direction = 0;
1745
                              break;
1746
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1747
                                continue;
1748
                              direction = 0;
1749
                              break;
1750
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1751
                                continue;
1752
                              direction = 1;
1753
                              break;
1754
                    }
1755
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1756
                        continue;
1757

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

    
1809
                    
1810
                    u=v=128;
1811
                    if(IS_PCM(mb_type)){
1812
                        COLOR(120,48)
1813
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1814
                        COLOR(30,48)
1815
                    }else if(IS_INTRA4x4(mb_type)){
1816
                        COLOR(90,48)
1817
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1818
//                        COLOR(120,48)
1819
                    }else if(IS_DIRECT(mb_type)){
1820
                        COLOR(150,48)
1821
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1822
                        COLOR(170,48)
1823
                    }else if(IS_GMC(mb_type)){
1824
                        COLOR(190,48)
1825
                    }else if(IS_SKIP(mb_type)){
1826
//                        COLOR(180,48)
1827
                    }else if(!USES_LIST(mb_type, 1)){
1828
                        COLOR(240,48)
1829
                    }else if(!USES_LIST(mb_type, 0)){
1830
                        COLOR(0,48)
1831
                    }else{
1832
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1833
                        COLOR(300,48)
1834
                    }
1835

    
1836
                    u*= 0x0101010101010101ULL;
1837
                    v*= 0x0101010101010101ULL;
1838
                    for(y=0; y<8; y++){
1839
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1840
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1841
                    }
1842

    
1843
                    //segmentation
1844
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1845
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1846
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1847
                    }
1848
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1849
                        for(y=0; y<16; y++)
1850
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1851
                    }
1852
                        
1853
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1854
                        // hmm
1855
                    }
1856
                }
1857
                s->mbskip_table[mb_index]=0;
1858
            }
1859
        }
1860
    }
1861
}
1862

    
1863
#ifdef CONFIG_ENCODERS
1864

    
1865
static int get_sae(uint8_t *src, int ref, int stride){
1866
    int x,y;
1867
    int acc=0;
1868
    
1869
    for(y=0; y<16; y++){
1870
        for(x=0; x<16; x++){
1871
            acc+= ABS(src[x+y*stride] - ref);
1872
        }
1873
    }
1874
    
1875
    return acc;
1876
}
1877

    
1878
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1879
    int x, y, w, h;
1880
    int acc=0;
1881
    
1882
    w= s->width &~15;
1883
    h= s->height&~15;
1884
    
1885
    for(y=0; y<h; y+=16){
1886
        for(x=0; x<w; x+=16){
1887
            int offset= x + y*stride;
1888
            int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1889
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1890
            int sae = get_sae(src + offset, mean, stride);
1891
            
1892
            acc+= sae + 500 < sad;
1893
        }
1894
    }
1895
    return acc;
1896
}
1897

    
1898

    
1899
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1900
    AVFrame *pic=NULL;
1901
    int i;
1902
    const int encoding_delay= s->max_b_frames;
1903
    int direct=1;
1904
    
1905
  if(pic_arg){
1906
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1907
    if(pic_arg->linesize[0] != s->linesize) direct=0;
1908
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1909
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1910
  
1911
//    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1912
    
1913
    if(direct){
1914
        i= ff_find_unused_picture(s, 1);
1915

    
1916
        pic= (AVFrame*)&s->picture[i];
1917
        pic->reference= 3;
1918
    
1919
        for(i=0; i<4; i++){
1920
            pic->data[i]= pic_arg->data[i];
1921
            pic->linesize[i]= pic_arg->linesize[i];
1922
        }
1923
        alloc_picture(s, (Picture*)pic, 1);
1924
    }else{
1925
        int offset= 16;
1926
        i= ff_find_unused_picture(s, 0);
1927

    
1928
        pic= (AVFrame*)&s->picture[i];
1929
        pic->reference= 3;
1930

    
1931
        alloc_picture(s, (Picture*)pic, 0);
1932

    
1933
        if(   pic->data[0] + offset == pic_arg->data[0] 
1934
           && pic->data[1] + offset == pic_arg->data[1]
1935
           && pic->data[2] + offset == pic_arg->data[2]){
1936
       // empty
1937
        }else{
1938
            int h_chroma_shift, v_chroma_shift;
1939
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1940
        
1941
            for(i=0; i<3; i++){
1942
                int src_stride= pic_arg->linesize[i];
1943
                int dst_stride= i ? s->uvlinesize : s->linesize;
1944
                int h_shift= i ? h_chroma_shift : 0;
1945
                int v_shift= i ? v_chroma_shift : 0;
1946
                int w= s->width >>h_shift;
1947
                int h= s->height>>v_shift;
1948
                uint8_t *src= pic_arg->data[i];
1949
                uint8_t *dst= pic->data[i] + offset;
1950
            
1951
                if(src_stride==dst_stride)
1952
                    memcpy(dst, src, src_stride*h);
1953
                else{
1954
                    while(h--){
1955
                        memcpy(dst, src, w);
1956
                        dst += dst_stride;
1957
                        src += src_stride;
1958
                    }
1959
                }
1960
            }
1961
        }
1962
    }
1963
    copy_picture_attributes(s, pic, pic_arg);
1964
    
1965
    pic->display_picture_number= s->input_picture_number++;
1966
 
1967
    if(pic->pts != AV_NOPTS_VALUE){ 
1968
        if(s->user_specified_pts != AV_NOPTS_VALUE){
1969
            int64_t time= av_rescale(pic->pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
1970
            int64_t last= av_rescale(s->user_specified_pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
1971
        
1972
            if(time <= last){            
1973
                av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%Ld, last=%Ld\n", pic->pts, s->user_specified_pts);
1974
                return -1;
1975
            }
1976
        }
1977
    }else{
1978
        if(s->user_specified_pts != AV_NOPTS_VALUE){
1979
            pic->pts= s->user_specified_pts + AV_TIME_BASE*(int64_t)s->avctx->frame_rate_base / s->avctx->frame_rate;
1980
            av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%Ld)\n", pic->pts);
1981
        }else{
1982
            pic->pts= av_rescale(pic->display_picture_number*(int64_t)s->avctx->frame_rate_base, AV_TIME_BASE, s->avctx->frame_rate);
1983
        }
1984
    }
1985
    s->user_specified_pts= pic->pts;
1986
  }
1987
  
1988
    /* shift buffer entries */
1989
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1990
        s->input_picture[i-1]= s->input_picture[i];
1991
        
1992
    s->input_picture[encoding_delay]= (Picture*)pic;
1993

    
1994
    return 0;
1995
}
1996

    
1997
static void select_input_picture(MpegEncContext *s){
1998
    int i;
1999

    
2000
    for(i=1; i<MAX_PICTURE_COUNT; i++)
2001
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2002
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2003

    
2004
    /* set next picture types & ordering */
2005
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2006
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2007
            s->reordered_input_picture[0]= s->input_picture[0];
2008
            s->reordered_input_picture[0]->pict_type= I_TYPE;
2009
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2010
        }else{
2011
            int b_frames;
2012
            
2013
            if(s->flags&CODEC_FLAG_PASS2){
2014
                for(i=0; i<s->max_b_frames+1; i++){
2015
                    int pict_num= s->input_picture[0]->display_picture_number + i;
2016
                    int pict_type= s->rc_context.entry[pict_num].new_pict_type;
2017
                    s->input_picture[i]->pict_type= pict_type;
2018
                    
2019
                    if(i + 1 >= s->rc_context.num_entries) break;
2020
                }
2021
            }
2022

    
2023
            if(s->input_picture[0]->pict_type){
2024
                /* user selected pict_type */
2025
                for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
2026
                    if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
2027
                }
2028
            
2029
                if(b_frames > s->max_b_frames){
2030
                    av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
2031
                    b_frames = s->max_b_frames;
2032
                }
2033
            }else if(s->avctx->b_frame_strategy==0){
2034
                b_frames= s->max_b_frames;
2035
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
2036
            }else if(s->avctx->b_frame_strategy==1){
2037
                for(i=1; i<s->max_b_frames+1; i++){
2038
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2039
                        s->input_picture[i]->b_frame_score= 
2040
                            get_intra_count(s, s->input_picture[i  ]->data[0], 
2041
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
2042
                    }
2043
                }
2044
                for(i=0; i<s->max_b_frames; i++){
2045
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2046
                }
2047
                                
2048
                b_frames= FFMAX(0, i-1);
2049
                
2050
                /* reset scores */
2051
                for(i=0; i<b_frames+1; i++){
2052
                    s->input_picture[i]->b_frame_score=0;
2053
                }
2054
            }else{
2055
                av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2056
                b_frames=0;
2057
            }
2058

    
2059
            emms_c();
2060
//static int b_count=0;
2061
//b_count+= b_frames;
2062
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2063
            if(s->picture_in_gop_number + b_frames >= s->gop_size){
2064
                if(s->flags & CODEC_FLAG_CLOSED_GOP)
2065
                    b_frames=0;
2066
                s->input_picture[b_frames]->pict_type= I_TYPE;
2067
            }
2068
            
2069
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2070
               && b_frames
2071
               && s->input_picture[b_frames]->pict_type== I_TYPE)
2072
                b_frames--;
2073

    
2074
            s->reordered_input_picture[0]= s->input_picture[b_frames];
2075
            if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2076
                s->reordered_input_picture[0]->pict_type= P_TYPE;
2077
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2078
            for(i=0; i<b_frames; i++){
2079
                s->reordered_input_picture[i+1]= s->input_picture[i];
2080
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2081
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2082
            }
2083
        }
2084
    }
2085
    
2086
    if(s->reordered_input_picture[0]){
2087
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2088

    
2089
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2090

    
2091
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2092
            // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2093
        
2094
            int i= ff_find_unused_picture(s, 0);
2095
            Picture *pic= &s->picture[i];
2096

    
2097
            /* mark us unused / free shared pic */
2098
            for(i=0; i<4; i++)
2099
                s->reordered_input_picture[0]->data[i]= NULL;
2100
            s->reordered_input_picture[0]->type= 0;
2101
            
2102
            pic->reference              = s->reordered_input_picture[0]->reference;
2103
            
2104
            alloc_picture(s, pic, 0);
2105

    
2106
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2107

    
2108
            s->current_picture_ptr= pic;
2109
        }else{
2110
            // input is not a shared pix -> reuse buffer for current_pix
2111

    
2112
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
2113
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2114
            
2115
            s->current_picture_ptr= s->reordered_input_picture[0];
2116
            for(i=0; i<4; i++){
2117
                s->new_picture.data[i]+=16;
2118
            }
2119
        }
2120
        copy_picture(&s->current_picture, s->current_picture_ptr);
2121
    
2122
        s->picture_number= s->new_picture.display_picture_number;
2123
//printf("dpn:%d\n", s->picture_number);
2124
    }else{
2125
       memset(&s->new_picture, 0, sizeof(Picture));
2126
    }
2127
}
2128

    
2129
int MPV_encode_picture(AVCodecContext *avctx,
2130
                       unsigned char *buf, int buf_size, void *data)
2131
{
2132
    MpegEncContext *s = avctx->priv_data;
2133
    AVFrame *pic_arg = data;
2134
    int i, stuffing_count;
2135

    
2136
    if(avctx->pix_fmt != PIX_FMT_YUV420P){
2137
        av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2138
        return -1;
2139
    }
2140
    
2141
    for(i=0; i<avctx->thread_count; i++){
2142
        int start_y= s->thread_context[i]->start_mb_y;
2143
        int   end_y= s->thread_context[i]->  end_mb_y;
2144
        int h= s->mb_height;
2145
        uint8_t *start= buf + buf_size*start_y/h;
2146
        uint8_t *end  = buf + buf_size*  end_y/h;
2147

    
2148
        init_put_bits(&s->thread_context[i]->pb, start, end - start);
2149
    }
2150

    
2151
    s->picture_in_gop_number++;
2152

    
2153
    if(load_input_picture(s, pic_arg) < 0)
2154
        return -1;
2155
    
2156
    select_input_picture(s);
2157
    
2158
    /* output? */
2159
    if(s->new_picture.data[0]){
2160
        s->pict_type= s->new_picture.pict_type;
2161
//emms_c();
2162
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2163
        MPV_frame_start(s, avctx);
2164

    
2165
        encode_picture(s, s->picture_number);
2166
        
2167
        avctx->real_pict_num  = s->picture_number;
2168
        avctx->header_bits = s->header_bits;
2169
        avctx->mv_bits     = s->mv_bits;
2170
        avctx->misc_bits   = s->misc_bits;
2171
        avctx->i_tex_bits  = s->i_tex_bits;
2172
        avctx->p_tex_bits  = s->p_tex_bits;
2173
        avctx->i_count     = s->i_count;
2174
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2175
        avctx->skip_count  = s->skip_count;
2176

    
2177
        MPV_frame_end(s);
2178

    
2179
        if (s->out_format == FMT_MJPEG)
2180
            mjpeg_picture_trailer(s);
2181
        
2182
        if(s->flags&CODEC_FLAG_PASS1)
2183
            ff_write_pass1_stats(s);
2184

    
2185
        for(i=0; i<4; i++){
2186
            avctx->error[i] += s->current_picture_ptr->error[i];
2187
        }
2188

    
2189
        flush_put_bits(&s->pb);
2190
        s->frame_bits  = put_bits_count(&s->pb);
2191

    
2192
        stuffing_count= ff_vbv_update(s, s->frame_bits);
2193
        if(stuffing_count){
2194
            switch(s->codec_id){
2195
            case CODEC_ID_MPEG1VIDEO:
2196
            case CODEC_ID_MPEG2VIDEO:
2197
                while(stuffing_count--){
2198
                    put_bits(&s->pb, 8, 0);
2199
                }
2200
            break;
2201
            case CODEC_ID_MPEG4:
2202
                put_bits(&s->pb, 16, 0);
2203
                put_bits(&s->pb, 16, 0x1C3);
2204
                stuffing_count -= 4;
2205
                while(stuffing_count--){
2206
                    put_bits(&s->pb, 8, 0xFF);
2207
                }
2208
            break;
2209
            default:
2210
                av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2211
            }
2212
            flush_put_bits(&s->pb);
2213
            s->frame_bits  = put_bits_count(&s->pb);
2214
        }
2215

    
2216
        /* update mpeg1/2 vbv_delay for CBR */    
2217
        if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2218
           && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2219
            int vbv_delay;
2220

    
2221
            assert(s->repeat_first_field==0);
2222
            
2223
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2224
            assert(vbv_delay < 0xFFFF);
2225

    
2226
            s->vbv_delay_ptr[0] &= 0xF8;
2227
            s->vbv_delay_ptr[0] |= vbv_delay>>13;
2228
            s->vbv_delay_ptr[1]  = vbv_delay>>5;
2229
            s->vbv_delay_ptr[2] &= 0x07;
2230
            s->vbv_delay_ptr[2] |= vbv_delay<<3;
2231
        }
2232
        s->total_bits += s->frame_bits;
2233
        avctx->frame_bits  = s->frame_bits;
2234
    }else{
2235
        assert((pbBufPtr(&s->pb) == s->pb.buf));
2236
        s->frame_bits=0;
2237
    }
2238
    assert((s->frame_bits&7)==0);
2239
    
2240
    return s->frame_bits/8;
2241
}
2242

    
2243
#endif //CONFIG_ENCODERS
2244

    
2245
static inline void gmc1_motion(MpegEncContext *s,
2246
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2247
                               uint8_t **ref_picture)
2248
{
2249
    uint8_t *ptr;
2250
    int offset, src_x, src_y, linesize, uvlinesize;
2251
    int motion_x, motion_y;
2252
    int emu=0;
2253

    
2254
    motion_x= s->sprite_offset[0][0];
2255
    motion_y= s->sprite_offset[0][1];
2256
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2257
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2258
    motion_x<<=(3-s->sprite_warping_accuracy);
2259
    motion_y<<=(3-s->sprite_warping_accuracy);
2260
    src_x = clip(src_x, -16, s->width);
2261
    if (src_x == s->width)
2262
        motion_x =0;
2263
    src_y = clip(src_y, -16, s->height);
2264
    if (src_y == s->height)
2265
        motion_y =0;
2266

    
2267
    linesize = s->linesize;
2268
    uvlinesize = s->uvlinesize;
2269
    
2270
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2271

    
2272
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2273
        if(   (unsigned)src_x >= s->h_edge_pos - 17
2274
           || (unsigned)src_y >= s->v_edge_pos - 17){
2275
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2276
            ptr= s->edge_emu_buffer;
2277
        }
2278
    }
2279
    
2280
    if((motion_x|motion_y)&7){
2281
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2282
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2283
    }else{
2284
        int dxy;
2285
        
2286
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2287
        if (s->no_rounding){
2288
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2289
        }else{
2290
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2291
        }
2292
    }
2293
    
2294
    if(s->flags&CODEC_FLAG_GRAY) return;
2295

    
2296
    motion_x= s->sprite_offset[1][0];
2297
    motion_y= s->sprite_offset[1][1];
2298
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2299
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2300
    motion_x<<=(3-s->sprite_warping_accuracy);
2301
    motion_y<<=(3-s->sprite_warping_accuracy);
2302
    src_x = clip(src_x, -8, s->width>>1);
2303
    if (src_x == s->width>>1)
2304
        motion_x =0;
2305
    src_y = clip(src_y, -8, s->height>>1);
2306
    if (src_y == s->height>>1)
2307
        motion_y =0;
2308

    
2309
    offset = (src_y * uvlinesize) + src_x;
2310
    ptr = ref_picture[1] + offset;
2311
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2312
        if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2313
           || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2314
            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);
2315
            ptr= s->edge_emu_buffer;
2316
            emu=1;
2317
        }
2318
    }
2319
    s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2320
    
2321
    ptr = ref_picture[2] + offset;
2322
    if(emu){
2323
        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);
2324
        ptr= s->edge_emu_buffer;
2325
    }
2326
    s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2327
    
2328
    return;
2329
}
2330

    
2331
static inline void gmc_motion(MpegEncContext *s,
2332
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2333
                               uint8_t **ref_picture)
2334
{
2335
    uint8_t *ptr;
2336
    int linesize, uvlinesize;
2337
    const int a= s->sprite_warping_accuracy;
2338
    int ox, oy;
2339

    
2340
    linesize = s->linesize;
2341
    uvlinesize = s->uvlinesize;
2342

    
2343
    ptr = ref_picture[0];
2344

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

    
2348
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2349
           ox, 
2350
           oy, 
2351
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2352
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2353
           a+1, (1<<(2*a+1)) - s->no_rounding,
2354
           s->h_edge_pos, s->v_edge_pos);
2355
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2356
           ox + s->sprite_delta[0][0]*8, 
2357
           oy + s->sprite_delta[1][0]*8, 
2358
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2359
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2360
           a+1, (1<<(2*a+1)) - s->no_rounding,
2361
           s->h_edge_pos, s->v_edge_pos);
2362

    
2363
    if(s->flags&CODEC_FLAG_GRAY) return;
2364

    
2365
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2366
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2367

    
2368
    ptr = ref_picture[1];
2369
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2370
           ox, 
2371
           oy, 
2372
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2373
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2374
           a+1, (1<<(2*a+1)) - s->no_rounding,
2375
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2376
    
2377
    ptr = ref_picture[2];
2378
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2379
           ox, 
2380
           oy, 
2381
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2382
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2383
           a+1, (1<<(2*a+1)) - s->no_rounding,
2384
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2385
}
2386

    
2387
/**
2388
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2389
 * @param buf destination buffer
2390
 * @param src source buffer
2391
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2392
 * @param block_w width of block
2393
 * @param block_h height of block
2394
 * @param src_x x coordinate of the top left sample of the block in the source buffer
2395
 * @param src_y y coordinate of the top left sample of the block in the source buffer
2396
 * @param w width of the source buffer
2397
 * @param h height of the source buffer
2398
 */
2399
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
2400
                                    int src_x, int src_y, int w, int h){
2401
    int x, y;
2402
    int start_y, start_x, end_y, end_x;
2403

    
2404
    if(src_y>= h){
2405
        src+= (h-1-src_y)*linesize;
2406
        src_y=h-1;
2407
    }else if(src_y<=-block_h){
2408
        src+= (1-block_h-src_y)*linesize;
2409
        src_y=1-block_h;
2410
    }
2411
    if(src_x>= w){
2412
        src+= (w-1-src_x);
2413
        src_x=w-1;
2414
    }else if(src_x<=-block_w){
2415
        src+= (1-block_w-src_x);
2416
        src_x=1-block_w;
2417
    }
2418

    
2419
    start_y= FFMAX(0, -src_y);
2420
    start_x= FFMAX(0, -src_x);
2421
    end_y= FFMIN(block_h, h-src_y);
2422
    end_x= FFMIN(block_w, w-src_x);
2423

    
2424
    // copy existing part
2425
    for(y=start_y; y<end_y; y++){
2426
        for(x=start_x; x<end_x; x++){
2427
            buf[x + y*linesize]= src[x + y*linesize];
2428
        }
2429
    }
2430

    
2431
    //top
2432
    for(y=0; y<start_y; y++){
2433
        for(x=start_x; x<end_x; x++){
2434
            buf[x + y*linesize]= buf[x + start_y*linesize];
2435
        }
2436
    }
2437

    
2438
    //bottom
2439
    for(y=end_y; y<block_h; y++){
2440
        for(x=start_x; x<end_x; x++){
2441
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2442
        }
2443
    }
2444
                                    
2445
    for(y=0; y<block_h; y++){
2446
       //left
2447
        for(x=0; x<start_x; x++){
2448
            buf[x + y*linesize]= buf[start_x + y*linesize];
2449
        }
2450
       
2451
       //right
2452
        for(x=end_x; x<block_w; x++){
2453
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2454
        }
2455
    }
2456
}
2457

    
2458
static inline int hpel_motion(MpegEncContext *s, 
2459
                                  uint8_t *dest, uint8_t *src,
2460
                                  int field_based, int field_select,
2461
                                  int src_x, int src_y,
2462
                                  int width, int height, int stride,
2463
                                  int h_edge_pos, int v_edge_pos,
2464
                                  int w, int h, op_pixels_func *pix_op,
2465
                                  int motion_x, int motion_y)
2466
{
2467
    int dxy;
2468
    int emu=0;
2469

    
2470
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2471
    src_x += motion_x >> 1;
2472
    src_y += motion_y >> 1;
2473
                
2474
    /* WARNING: do no forget half pels */
2475
    src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2476
    if (src_x == width)
2477
        dxy &= ~1;
2478
    src_y = clip(src_y, -16, height);
2479
    if (src_y == height)
2480
        dxy &= ~2;
2481
    src += src_y * stride + src_x;
2482

    
2483
    if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2484
        if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2485
           || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2486
            ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2487
                             src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2488
            src= s->edge_emu_buffer;
2489
            emu=1;
2490
        }
2491
    }
2492
    if(field_select)
2493
        src += s->linesize;
2494
    pix_op[dxy](dest, src, stride, h);
2495
    return emu;
2496
}
2497

    
2498
/* apply one mpeg motion vector to the three components */
2499
static always_inline void mpeg_motion(MpegEncContext *s,
2500
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2501
                               int field_based, int bottom_field, int field_select,
2502
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2503
                               int motion_x, int motion_y, int h)
2504
{
2505
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2506
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2507
    
2508
#if 0    
2509
if(s->quarter_sample)
2510
{
2511
    motion_x>>=1;
2512
    motion_y>>=1;
2513
}
2514
#endif
2515

    
2516
    v_edge_pos = s->v_edge_pos >> field_based;
2517
    linesize   = s->current_picture.linesize[0] << field_based;
2518
    uvlinesize = s->current_picture.linesize[1] << field_based;
2519

    
2520
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2521
    src_x = s->mb_x* 16               + (motion_x >> 1);
2522
    src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2523

    
2524
    if (s->out_format == FMT_H263) {
2525
        if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2526
            mx = (motion_x>>1)|(motion_x&1);
2527
            my = motion_y >>1;
2528
            uvdxy = ((my & 1) << 1) | (mx & 1);
2529
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2530
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2531
        }else{
2532
            uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2533
            uvsrc_x = src_x>>1;
2534
            uvsrc_y = src_y>>1;
2535
        }
2536
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2537
        mx = motion_x / 4;
2538
        my = motion_y / 4;
2539
        uvdxy = 0;
2540
        uvsrc_x = s->mb_x*8 + mx;
2541
        uvsrc_y = s->mb_y*8 + my;
2542
    } else {
2543
        if(s->chroma_y_shift){
2544
            mx = motion_x / 2;
2545
            my = motion_y / 2;
2546
            uvdxy = ((my & 1) << 1) | (mx & 1);
2547
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2548
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2549
        } else {
2550
            if(s->chroma_x_shift){
2551
            //Chroma422
2552
                mx = motion_x / 2;
2553
                uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2554
                uvsrc_x = s->mb_x* 8           + (mx >> 1);
2555
                uvsrc_y = src_y;
2556
            } else {
2557
            //Chroma444
2558
                uvdxy = dxy;
2559
                uvsrc_x = src_x;
2560
                uvsrc_y = src_y;
2561
            }
2562
        }
2563
    }
2564

    
2565
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2566
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2567
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2568

    
2569
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2570
       || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
2571
            if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2572
               s->codec_id == CODEC_ID_MPEG1VIDEO){
2573
                av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2574
                return ;
2575
            }
2576
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2577
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2578
            ptr_y = s->edge_emu_buffer;
2579
            if(!(s->flags&CODEC_FLAG_GRAY)){
2580
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2581
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2582
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2583
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2584
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2585
                ptr_cb= uvbuf;
2586
                ptr_cr= uvbuf+16;
2587
            }
2588
    }
2589

    
2590
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2591
        dest_y += s->linesize;
2592
        dest_cb+= s->uvlinesize;
2593
        dest_cr+= s->uvlinesize;
2594
    }
2595

    
2596
    if(field_select){
2597
        ptr_y += s->linesize;
2598
        ptr_cb+= s->uvlinesize;
2599
        ptr_cr+= s->uvlinesize;
2600
    }
2601

    
2602
    pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2603
    
2604
    if(!(s->flags&CODEC_FLAG_GRAY)){
2605
        pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2606
        pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2607
    }
2608
}
2609
//FIXME move to dsputil, avg variant, 16x16 version
2610
static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2611
    int x;
2612
    uint8_t * const top   = src[1];
2613
    uint8_t * const left  = src[2];
2614
    uint8_t * const mid   = src[0];
2615
    uint8_t * const right = src[3];
2616
    uint8_t * const bottom= src[4];
2617
#define OBMC_FILTER(x, t, l, m, r, b)\
2618
    dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2619
#define OBMC_FILTER4(x, t, l, m, r, b)\
2620
    OBMC_FILTER(x         , t, l, m, r, b);\
2621
    OBMC_FILTER(x+1       , t, l, m, r, b);\
2622
    OBMC_FILTER(x  +stride, t, l, m, r, b);\
2623
    OBMC_FILTER(x+1+stride, t, l, m, r, b);
2624
    
2625
    x=0;
2626
    OBMC_FILTER (x  , 2, 2, 4, 0, 0);
2627
    OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2628
    OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2629
    OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2630
    OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2631
    OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2632
    x+= stride;
2633
    OBMC_FILTER (x  , 1, 2, 5, 0, 0);
2634
    OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2635
    OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2636
    OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2637
    x+= stride;
2638
    OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
2639
    OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2640
    OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2641
    OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2642
    x+= 2*stride;
2643
    OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
2644
    OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2645
    OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2646
    OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2647
    x+= 2*stride;
2648
    OBMC_FILTER (x  , 0, 2, 5, 0, 1);
2649
    OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2650
    OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2651
    OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2652
    OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2653
    OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2654
    x+= stride;
2655
    OBMC_FILTER (x  , 0, 2, 4, 0, 2);
2656
    OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2657
    OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2658
    OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2659
}
2660

    
2661
/* obmc for 1 8x8 luma block */
2662
static inline void obmc_motion(MpegEncContext *s,
2663
                               uint8_t *dest, uint8_t *src,
2664
                               int src_x, int src_y,
2665
                               op_pixels_func *pix_op,
2666
                               int16_t mv[5][2]/* mid top left right bottom*/)
2667
#define MID    0
2668
{
2669
    int i;
2670
    uint8_t *ptr[5];
2671
    
2672
    assert(s->quarter_sample==0);
2673
    
2674
    for(i=0; i<5; i++){
2675
        if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2676
            ptr[i]= ptr[MID];
2677
        }else{
2678
            ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
2679
            hpel_motion(s, ptr[i], src, 0, 0,
2680
                        src_x, src_y,
2681
                        s->width, s->height, s->linesize,
2682
                        s->h_edge_pos, s->v_edge_pos,
2683
                        8, 8, pix_op,
2684
                        mv[i][0], mv[i][1]);
2685
        }
2686
    }
2687

    
2688
    put_obmc(dest, ptr, s->linesize);                
2689
}
2690

    
2691
static inline void qpel_motion(MpegEncContext *s,
2692
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2693
                               int field_based, int bottom_field, int field_select,
2694
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2695
                               qpel_mc_func (*qpix_op)[16],
2696
                               int motion_x, int motion_y, int h)
2697
{
2698
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2699
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
2700

    
2701
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2702
    src_x = s->mb_x *  16                 + (motion_x >> 2);
2703
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2704

    
2705
    v_edge_pos = s->v_edge_pos >> field_based;
2706
    linesize = s->linesize << field_based;
2707
    uvlinesize = s->uvlinesize << field_based;
2708
    
2709
    if(field_based){
2710
        mx= motion_x/2;
2711
        my= motion_y>>1;
2712
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2713
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
2714
        mx= (motion_x>>1) + rtab[motion_x&7];
2715
        my= (motion_y>>1) + rtab[motion_y&7];
2716
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2717
        mx= (motion_x>>1)|(motion_x&1);
2718
        my= (motion_y>>1)|(motion_y&1);
2719
    }else{
2720
        mx= motion_x/2;
2721
        my= motion_y/2;
2722
    }
2723
    mx= (mx>>1)|(mx&1);
2724
    my= (my>>1)|(my&1);
2725

    
2726
    uvdxy= (mx&1) | ((my&1)<<1);
2727
    mx>>=1;
2728
    my>>=1;
2729

    
2730
    uvsrc_x = s->mb_x *  8                 + mx;
2731
    uvsrc_y = s->mb_y * (8 >> field_based) + my;
2732

    
2733
    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
2734
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2735
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2736

    
2737
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 
2738
       || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
2739
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, 
2740
                         src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2741
        ptr_y= s->edge_emu_buffer;
2742
        if(!(s->flags&CODEC_FLAG_GRAY)){
2743
            uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
2744
            ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based, 
2745
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2746
            ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based, 
2747
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2748
            ptr_cb= uvbuf;
2749
            ptr_cr= uvbuf + 16;
2750
        }
2751
    }
2752

    
2753
    if(!field_based)
2754
        qpix_op[0][dxy](dest_y, ptr_y, linesize);
2755
    else{
2756
        if(bottom_field){
2757
            dest_y += s->linesize;
2758
            dest_cb+= s->uvlinesize;
2759
            dest_cr+= s->uvlinesize;
2760
        }
2761

    
2762
        if(field_select){
2763
            ptr_y  += s->linesize;
2764
            ptr_cb += s->uvlinesize;
2765
            ptr_cr += s->uvlinesize;
2766
        }
2767
        //damn interlaced mode
2768
        //FIXME boundary mirroring is not exactly correct here
2769
        qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
2770
        qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
2771
    }
2772
    if(!(s->flags&CODEC_FLAG_GRAY)){
2773
        pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
2774
        pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
2775
    }
2776
}
2777

    
2778
inline int ff_h263_round_chroma(int x){
2779
    if (x >= 0)
2780
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2781
    else {
2782
        x = -x;
2783
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2784
    }
2785
}
2786

    
2787
/**
2788
 * h263 chorma 4mv motion compensation.
2789
 */
2790
static inline void chroma_4mv_motion(MpegEncContext *s,
2791
                                     uint8_t *dest_cb, uint8_t *dest_cr,
2792
                                     uint8_t **ref_picture,
2793
                                     op_pixels_func *pix_op,
2794
                                     int mx, int my){
2795
    int dxy, emu=0, src_x, src_y, offset;
2796
    uint8_t *ptr;
2797
    
2798
    /* In case of 8X8, we construct a single chroma motion vector
2799
       with a special rounding */
2800
    mx= ff_h263_round_chroma(mx);
2801
    my= ff_h263_round_chroma(my);
2802
    
2803
    dxy = ((my & 1) << 1) | (mx & 1);
2804
    mx >>= 1;
2805
    my >>= 1;
2806

    
2807
    src_x = s->mb_x * 8 + mx;
2808
    src_y = s->mb_y * 8 + my;
2809
    src_x = clip(src_x, -8, s->width/2);
2810
    if (src_x == s->width/2)
2811
        dxy &= ~1;
2812
    src_y = clip(src_y, -8, s->height/2);
2813
    if (src_y == s->height/2)
2814
        dxy &= ~2;
2815
    
2816
    offset = (src_y * (s->uvlinesize)) + src_x;
2817
    ptr = ref_picture[1] + offset;
2818
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2819
        if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
2820
           || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
2821
            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);
2822
            ptr= s->edge_emu_buffer;
2823
            emu=1;
2824
        }
2825
    }
2826
    pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
2827

    
2828
    ptr = ref_picture[2] + offset;
2829
    if(emu){
2830
        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);
2831
        ptr= s->edge_emu_buffer;
2832
    }
2833
    pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
2834
}
2835

    
2836
/**
2837
 * motion compesation of a single macroblock
2838
 * @param s context
2839
 * @param dest_y luma destination pointer
2840
 * @param dest_cb chroma cb/u destination pointer
2841
 * @param dest_cr chroma cr/v destination pointer
2842
 * @param dir direction (0->forward, 1->backward)
2843
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2844
 * @param pic_op halfpel motion compensation function (average or put normally)
2845
 * @param pic_op qpel motion compensation function (average or put normally)
2846
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2847
 */
2848
static inline void MPV_motion(MpegEncContext *s, 
2849
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2850
                              int dir, uint8_t **ref_picture, 
2851
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
2852
{
2853
    int dxy, mx, my, src_x, src_y, motion_x, motion_y;
2854
    int mb_x, mb_y, i;
2855
    uint8_t *ptr, *dest;
2856

    
2857
    mb_x = s->mb_x;
2858
    mb_y = s->mb_y;
2859

    
2860
    if(s->obmc && s->pict_type != B_TYPE){
2861
        int16_t mv_cache[4][4][2];
2862
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
2863
        const int mot_stride= s->b8_stride;
2864
        const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
2865

    
2866
        assert(!s->mb_skiped);
2867
                
2868
        memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
2869
        memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2870
        memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2871

    
2872
        if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
2873
            memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
2874
        }else{
2875
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
2876
        }
2877

    
2878
        if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
2879
            *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
2880
            *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
2881
        }else{
2882
            *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
2883
            *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
2884
        }
2885

    
2886
        if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
2887
            *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
2888
            *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
2889
        }else{
2890
            *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
2891
            *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
2892
        }
2893
        
2894
        mx = 0;
2895
        my = 0;
2896
        for(i=0;i<4;i++) {
2897
            const int x= (i&1)+1;
2898
            const int y= (i>>1)+1;
2899
            int16_t mv[5][2]= {
2900
                {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
2901
                {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
2902
                {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
2903
                {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
2904
                {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
2905
            //FIXME cleanup
2906
            obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2907
                        ref_picture[0],
2908
                        mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2909
                        pix_op[1],
2910
                        mv);
2911

    
2912
            mx += mv[0][0];
2913
            my += mv[0][1];
2914
        }
2915
        if(!(s->flags&CODEC_FLAG_GRAY))
2916
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2917

    
2918
        return;
2919
    }
2920
   
2921
    switch(s->mv_type) {
2922
    case MV_TYPE_16X16:
2923
#ifdef CONFIG_RISKY
2924
        if(s->mcsel){
2925
            if(s->real_sprite_warping_points==1){
2926
                gmc1_motion(s, dest_y, dest_cb, dest_cr,
2927
                            ref_picture);
2928
            }else{
2929
                gmc_motion(s, dest_y, dest_cb, dest_cr,
2930
                            ref_picture);
2931
            }
2932
        }else if(s->quarter_sample){
2933
            qpel_motion(s, dest_y, dest_cb, dest_cr, 
2934
                        0, 0, 0,
2935
                        ref_picture, pix_op, qpix_op,
2936
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2937
        }else if(s->mspel){
2938
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
2939
                        ref_picture, pix_op,
2940
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2941
        }else
2942
#endif
2943
        {
2944
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 
2945
                        0, 0, 0,
2946
                        ref_picture, pix_op,
2947
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2948
        }           
2949
        break;
2950
    case MV_TYPE_8X8:
2951
        mx = 0;
2952
        my = 0;
2953
        if(s->quarter_sample){
2954
            for(i=0;i<4;i++) {
2955
                motion_x = s->mv[dir][i][0];
2956
                motion_y = s->mv[dir][i][1];
2957

    
2958
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2959
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
2960
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
2961
                    
2962
                /* WARNING: do no forget half pels */
2963
                src_x = clip(src_x, -16, s->width);
2964
                if (src_x == s->width)
2965
                    dxy &= ~3;
2966
                src_y = clip(src_y, -16, s->height);
2967
                if (src_y == s->height)
2968
                    dxy &= ~12;
2969
                    
2970
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2971
                if(s->flags&CODEC_FLAG_EMU_EDGE){
2972
                    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8 
2973
                       || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
2974
                        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);
2975
                        ptr= s->edge_emu_buffer;
2976
                    }
2977
                }
2978
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2979
                qpix_op[1][dxy](dest, ptr, s->linesize);
2980

    
2981
                mx += s->mv[dir][i][0]/2;
2982
                my += s->mv[dir][i][1]/2;
2983
            }
2984
        }else{
2985
            for(i=0;i<4;i++) {
2986
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2987
                            ref_picture[0], 0, 0,
2988
                            mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2989
                            s->width, s->height, s->linesize,
2990
                            s->h_edge_pos, s->v_edge_pos,
2991
                            8, 8, pix_op[1],
2992
                            s->mv[dir][i][0], s->mv[dir][i][1]);
2993

    
2994
                mx += s->mv[dir][i][0];
2995
                my += s->mv[dir][i][1];
2996
            }
2997
        }
2998

    
2999
        if(!(s->flags&CODEC_FLAG_GRAY))
3000
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3001
        break;
3002
    case MV_TYPE_FIELD:
3003
        if (s->picture_structure == PICT_FRAME) {
3004
            if(s->quarter_sample){
3005
                for(i=0; i<2; i++){
3006
                    qpel_motion(s, dest_y, dest_cb, dest_cr,
3007
                                1, i, s->field_select[dir][i],
3008
                                ref_picture, pix_op, qpix_op,
3009
                                s->mv[dir][i][0], s->mv[dir][i][1], 8);
3010
                }
3011
            }else{
3012
                /* top field */       
3013
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3014
                            1, 0, s->field_select[dir][0],
3015
                            ref_picture, pix_op,
3016
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
3017
                /* bottom field */
3018
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3019
                            1, 1, s->field_select[dir][1],
3020
                            ref_picture, pix_op,
3021
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
3022
            }
3023
        } else {
3024
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3025
                ref_picture= s->current_picture_ptr->data;
3026
            } 
3027

    
3028
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3029
                        0, 0, s->field_select[dir][0],
3030
                        ref_picture, pix_op,
3031
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3032
        }
3033
        break;
3034
    case MV_TYPE_16X8:
3035
        for(i=0; i<2; i++){
3036
            uint8_t ** ref2picture;
3037

    
3038
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3039
                ref2picture= ref_picture;
3040
            }else{
3041
                ref2picture= s->current_picture_ptr->data;
3042
            } 
3043

    
3044
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3045
                        0, 0, s->field_select[dir][i],
3046
                        ref2picture, pix_op,
3047
                        s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3048
                
3049
            dest_y += 16*s->linesize;
3050
            dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3051
            dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3052
        }        
3053
        break;
3054
    case MV_TYPE_DMV:
3055
        if(s->picture_structure == PICT_FRAME){
3056
            for(i=0; i<2; i++){
3057
                int j;
3058
                for(j=0; j<2; j++){
3059
                    mpeg_motion(s, dest_y, dest_cb, dest_cr,
3060
                                1, j, j^i,
3061
                                ref_picture, pix_op,
3062
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3063
                }
3064
                pix_op = s->dsp.avg_pixels_tab; 
3065
            }
3066
        }else{
3067
            for(i=0; i<2; i++){
3068
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3069
                            0, 0, s->picture_structure != i+1,
3070
                            ref_picture, pix_op,
3071
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3072

    
3073
                // after put we make avg of the same block
3074
                pix_op=s->dsp.avg_pixels_tab; 
3075

    
3076
                //opposite parity is always in the same frame if this is second field
3077
                if(!s->first_field){
3078
                    ref_picture = s->current_picture_ptr->data;    
3079
                }
3080
            }
3081
        }
3082
    break;
3083
    default: assert(0);
3084
    }
3085
}
3086

    
3087

    
3088
/* put block[] to dest[] */
3089
static inline void put_dct(MpegEncContext *s, 
3090
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3091
{
3092
    s->dct_unquantize_intra(s, block, i, qscale);
3093
    s->dsp.idct_put (dest, line_size, block);
3094
}
3095

    
3096
/* add block[] to dest[] */
3097
static inline void add_dct(MpegEncContext *s, 
3098
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
3099
{
3100
    if (s->block_last_index[i] >= 0) {
3101
        s->dsp.idct_add (dest, line_size, block);
3102
    }
3103
}
3104

    
3105
static inline void add_dequant_dct(MpegEncContext *s, 
3106
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3107
{
3108
    if (s->block_last_index[i] >= 0) {
3109
        s->dct_unquantize_inter(s, block, i, qscale);
3110

    
3111
        s->dsp.idct_add (dest, line_size, block);
3112
    }
3113
}
3114

    
3115
/**
3116
 * cleans dc, ac, coded_block for the current non intra MB
3117
 */
3118
void ff_clean_intra_table_entries(MpegEncContext *s)
3119
{
3120
    int wrap = s->b8_stride;
3121
    int xy = s->block_index[0];
3122
    
3123
    s->dc_val[0][xy           ] = 
3124
    s->dc_val[0][xy + 1       ] = 
3125
    s->dc_val[0][xy     + wrap] =
3126
    s->dc_val[0][xy + 1 + wrap] = 1024;
3127
    /* ac pred */
3128
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
3129
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3130
    if (s->msmpeg4_version>=3) {
3131
        s->coded_block[xy           ] =
3132
        s->coded_block[xy + 1       ] =
3133
        s->coded_block[xy     + wrap] =
3134
        s->coded_block[xy + 1 + wrap] = 0;
3135
    }
3136
    /* chroma */
3137
    wrap = s->mb_stride;
3138
    xy = s->mb_x + s->mb_y * wrap;
3139
    s->dc_val[1][xy] =
3140
    s->dc_val[2][xy] = 1024;
3141
    /* ac pred */
3142
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3143
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3144
    
3145
    s->mbintra_table[xy]= 0;
3146
}
3147

    
3148
/* generic function called after a macroblock has been parsed by the
3149
   decoder or after it has been encoded by the encoder.
3150

3151
   Important variables used:
3152
   s->mb_intra : true if intra macroblock
3153
   s->mv_dir   : motion vector direction
3154
   s->mv_type  : motion vector type
3155
   s->mv       : motion vector
3156
   s->interlaced_dct : true if interlaced dct used (mpeg2)
3157
 */
3158
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64])
3159
{
3160
    int mb_x, mb_y;
3161
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3162
#ifdef HAVE_XVMC
3163
    if(s->avctx->xvmc_acceleration){
3164
        XVMC_decode_mb(s);//xvmc uses pblocks
3165
        return;
3166
    }
3167
#endif
3168

    
3169
    mb_x = s->mb_x;
3170
    mb_y = s->mb_y;
3171

    
3172
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3173
       /* save DCT coefficients */
3174
       int i,j;
3175
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3176
       for(i=0; i<6; i++)
3177
           for(j=0; j<64; j++)
3178
               *dct++ = block[i][s->dsp.idct_permutation[j]];
3179
    }
3180

    
3181
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3182

    
3183
    /* update DC predictors for P macroblocks */
3184
    if (!s->mb_intra) {
3185
        if (s->h263_pred || s->h263_aic) {
3186
            if(s->mbintra_table[mb_xy])
3187
                ff_clean_intra_table_entries(s);
3188
        } else {
3189
            s->last_dc[0] =
3190
            s->last_dc[1] =
3191
            s->last_dc[2] = 128 << s->intra_dc_precision;
3192
        }
3193
    }
3194
    else if (s->h263_pred || s->h263_aic)
3195
        s->mbintra_table[mb_xy]=1;
3196

    
3197
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3198
        uint8_t *dest_y, *dest_cb, *dest_cr;
3199
        int dct_linesize, dct_offset;
3200
        op_pixels_func (*op_pix)[4];
3201
        qpel_mc_func (*op_qpix)[16];
3202
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3203
        const int uvlinesize= s->current_picture.linesize[1];
3204
        const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band;
3205

    
3206
        /* avoid copy if macroblock skipped in last frame too */
3207
        /* skip only during decoding as we might trash the buffers during encoding a bit */
3208
        if(!s->encoding){
3209
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3210
            const int age= s->current_picture.age;
3211

    
3212
            assert(age);
3213

    
3214
            if (s->mb_skiped) {
3215
                s->mb_skiped= 0;
3216
                assert(s->pict_type!=I_TYPE);
3217
 
3218
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
3219
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3220

    
3221
                /* if previous was skipped too, then nothing to do !  */
3222
                if (*mbskip_ptr >= age && s->current_picture.reference){
3223
                    return;
3224
                }
3225
            } else if(!s->current_picture.reference){
3226
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3227
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3228
            } else{
3229
                *mbskip_ptr = 0; /* not skipped */
3230
            }
3231
        }
3232

    
3233
        dct_linesize = linesize << s->interlaced_dct;
3234
        dct_offset =(s->interlaced_dct)? linesize : linesize*8;
3235

    
3236
        if(readable){
3237
            dest_y=  s->dest[0];
3238
            dest_cb= s->dest[1];
3239
            dest_cr= s->dest[2];
3240
        }else{
3241
            dest_y = s->b_scratchpad;
3242
            dest_cb= s->b_scratchpad+16*linesize;
3243
            dest_cr= s->b_scratchpad+32*linesize;
3244
        }
3245
        if (!s->mb_intra) {
3246
            /* motion handling */
3247
            /* decoding or more than one mb_type (MC was allready done otherwise) */
3248
            if(!s->encoding){
3249
                if ((!s->no_rounding) || s->pict_type==B_TYPE){                
3250
                    op_pix = s->dsp.put_pixels_tab;
3251
                    op_qpix= s->dsp.put_qpel_pixels_tab;
3252
                }else{
3253
                    op_pix = s->dsp.put_no_rnd_pixels_tab;
3254
                    op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3255
                }
3256

    
3257
                if (s->mv_dir & MV_DIR_FORWARD) {
3258
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3259
                    op_pix = s->dsp.avg_pixels_tab;
3260
                    op_qpix= s->dsp.avg_qpel_pixels_tab;
3261
                }
3262
                if (s->mv_dir & MV_DIR_BACKWARD) {
3263
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3264
                }
3265
            }
3266

    
3267
            /* skip dequant / idct if we are really late ;) */
3268
            if(s->hurry_up>1) return;
3269

    
3270
            /* add dct residue */
3271
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3272
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3273
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
3274
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
3275
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
3276
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
3277

    
3278
                if(!(s->flags&CODEC_FLAG_GRAY)){
3279
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3280
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3281
                }
3282
            } else if(s->codec_id != CODEC_ID_WMV2){
3283
                add_dct(s, block[0], 0, dest_y, dct_linesize);
3284
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
3285
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
3286
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
3287

    
3288
                if(!(s->flags&CODEC_FLAG_GRAY)){
3289
                    if(s->chroma_y_shift){//Chroma420
3290
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
3291
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
3292
                    }else{
3293
                        //chroma422
3294
                        dct_linesize = uvlinesize << s->interlaced_dct;
3295
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3296

    
3297
                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
3298
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
3299
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
3300
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
3301
                        if(!s->chroma_x_shift){//Chroma444
3302
                            add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
3303
                            add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
3304
                            add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
3305
                            add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
3306
                        }
3307
                    }
3308
                }//fi gray
3309
            }
3310
#ifdef CONFIG_RISKY
3311
            else{
3312
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3313
            }
3314
#endif
3315
        } else {
3316
            /* dct only in intra block */
3317
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3318
                put_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
3319
                put_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
3320
                put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
3321
                put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
3322

    
3323
                if(!(s->flags&CODEC_FLAG_GRAY)){
3324
                    put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3325
                    put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3326
                }
3327
            }else{
3328
                s->dsp.idct_put(dest_y                 , dct_linesize, block[0]);
3329
                s->dsp.idct_put(dest_y              + 8, dct_linesize, block[1]);
3330
                s->dsp.idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
3331
                s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
3332

    
3333
                if(!(s->flags&CODEC_FLAG_GRAY)){
3334
                    if(s->chroma_y_shift){
3335
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3336
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3337
                    }else{
3338

    
3339
                        dct_linesize = uvlinesize << s->interlaced_dct;
3340
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3341

    
3342
                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
3343
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
3344
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
3345
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
3346
                        if(!s->chroma_x_shift){//Chroma444
3347
                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
3348
                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
3349
                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
3350
                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
3351
                        }
3352
                    }
3353
                }//gray
3354
            }
3355
        }
3356
        if(!readable){
3357
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3358
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
3359
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
3360
        }
3361
    }
3362
}
3363

    
3364
#ifdef CONFIG_ENCODERS
3365

    
3366
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3367
{
3368
    static const char tab[64]=
3369
        {3,2,2,1,1,1,1,1,
3370
         1,1,1,1,1,1,1,1,
3371
         1,1,1,1,1,1,1,1,
3372
         0,0,0,0,0,0,0,0,
3373
         0,0,0,0,0,0,0,0,
3374
         0,0,0,0,0,0,0,0,
3375
         0,0,0,0,0,0,0,0,
3376
         0,0,0,0,0,0,0,0};
3377
    int score=0;
3378
    int run=0;
3379
    int i;
3380
    DCTELEM *block= s->block[n];
3381
    const int last_index= s->block_last_index[n];
3382
    int skip_dc;
3383

    
3384
    if(threshold<0){
3385
        skip_dc=0;
3386
        threshold= -threshold;
3387
    }else
3388
        skip_dc=1;
3389

    
3390
    /* are all which we could set to zero are allready zero? */
3391
    if(last_index<=skip_dc - 1) return;
3392

    
3393
    for(i=0; i<=last_index; i++){
3394
        const int j = s->intra_scantable.permutated[i];
3395
        const int level = ABS(block[j]);
3396
        if(level==1){
3397
            if(skip_dc && i==0) continue;
3398
            score+= tab[run];
3399
            run=0;
3400
        }else if(level>1){
3401
            return;
3402
        }else{
3403
            run++;
3404
        }
3405
    }
3406
    if(score >= threshold) return;
3407
    for(i=skip_dc; i<=last_index; i++){
3408
        const int j = s->intra_scantable.permutated[i];
3409
        block[j]=0;
3410
    }
3411
    if(block[0]) s->block_last_index[n]= 0;
3412
    else         s->block_last_index[n]= -1;
3413
}
3414

    
3415
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
3416
{
3417
    int i;
3418
    const int maxlevel= s->max_qcoeff;
3419
    const int minlevel= s->min_qcoeff;
3420
    int overflow=0;
3421
    
3422
    if(s->mb_intra){
3423
        i=1; //skip clipping of intra dc
3424
    }else
3425
        i=0;
3426
    
3427
    for(;i<=last_index; i++){
3428
        const int j= s->intra_scantable.permutated[i];
3429
        int level = block[j];
3430
       
3431
        if     (level>maxlevel){
3432
            level=maxlevel;
3433
            overflow++;
3434
        }else if(level<minlevel){
3435
            level=minlevel;
3436
            overflow++;
3437
        }
3438
        
3439
        block[j]= level;
3440
    }
3441
    
3442
    if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
3443
        av_log(s->avctx, AV_LOG_INFO, "warning, cliping %d dct coefficents to %d..%d\n", overflow, minlevel, maxlevel);
3444
}
3445

    
3446
#endif //CONFIG_ENCODERS
3447

    
3448
/**
3449
 *
3450
 * @param h is the normal height, this will be reduced automatically if needed for the last row
3451
 */
3452
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3453
    if (s->avctx->draw_horiz_band) {
3454
        AVFrame *src;
3455
        int offset[4];
3456
        
3457
        if(s->picture_structure != PICT_FRAME){
3458
            h <<= 1;
3459
            y <<= 1;
3460
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3461
        }
3462

    
3463
        h= FFMIN(h, s->height - y);
3464

    
3465
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) 
3466
            src= (AVFrame*)s->current_picture_ptr;
3467
        else if(s->last_picture_ptr)
3468
            src= (AVFrame*)s->last_picture_ptr;
3469
        else
3470
            return;
3471
            
3472
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3473
            offset[0]=
3474
            offset[1]=
3475
            offset[2]=
3476
            offset[3]= 0;
3477
        }else{
3478
            offset[0]= y * s->linesize;;
3479
            offset[1]= 
3480
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
3481
            offset[3]= 0;
3482
        }
3483

    
3484
        emms_c();
3485

    
3486
        s->avctx->draw_horiz_band(s->avctx, src, offset,
3487
                                  y, s->picture_structure, h);
3488
    }
3489
}
3490

    
3491
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3492
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3493
    const int uvlinesize= s->current_picture.linesize[1];
3494
        
3495
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
3496
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
3497
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
3498
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3499
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3500
    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;
3501
    //block_index is not used by mpeg2, so it is not affected by chroma_format
3502

    
3503
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << 4);
3504
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (4 - s->chroma_x_shift));
3505
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (4 - s->chroma_x_shift));
3506

    
3507
    if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
3508
    {
3509
        s->dest[0] += s->mb_y *   linesize << 4;
3510
        s->dest[1] += s->mb_y * uvlinesize << (4 - s->chroma_y_shift);
3511
        s->dest[2] += s->mb_y * uvlinesize << (4 - s->chroma_y_shift);
3512
    }
3513
}
3514

    
3515
#ifdef CONFIG_ENCODERS
3516

    
3517
static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
3518
    int x, y;
3519
//FIXME optimize
3520
    for(y=0; y<8; y++){
3521
        for(x=0; x<8; x++){
3522
            int x2, y2;
3523
            int sum=0;
3524
            int sqr=0;
3525
            int count=0;
3526

    
3527
            for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
3528
                for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
3529
                    int v= ptr[x2 + y2*stride];
3530
                    sum += v;
3531
                    sqr += v*v;
3532
                    count++;
3533
                }
3534
            }
3535
            weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
3536
        }
3537
    }
3538
}
3539

    
3540
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
3541
{
3542
    int16_t weight[6][64];
3543
    DCTELEM orig[6][64];
3544
    const int mb_x= s->mb_x;
3545
    const int mb_y= s->mb_y;
3546
    int i;
3547
    int skip_dct[6];
3548
    int dct_offset   = s->linesize*8; //default for progressive frames
3549
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3550
    int wrap_y, wrap_c;
3551
    
3552
    for(i=0; i<6; i++) skip_dct[i]=0;
3553
    
3554
    if(s->adaptive_quant){
3555
        const int last_qp= s->qscale;
3556
        const int mb_xy= mb_x + mb_y*s->mb_stride;
3557

    
3558
        s->lambda= s->lambda_table[mb_xy];
3559
        update_qscale(s);
3560
    
3561
        if(!(s->flags&CODEC_FLAG_QP_RD)){
3562
            s->dquant= s->qscale - last_qp;
3563

    
3564
            if(s->out_format==FMT_H263){
3565
                s->dquant= clip(s->dquant, -2, 2); //FIXME RD
3566
            
3567
                if(s->codec_id==CODEC_ID_MPEG4){        
3568
                    if(!s->mb_intra){
3569
                        if(s->pict_type == B_TYPE){
3570
                            if(s->dquant&1) 
3571
                                s->dquant= (s->dquant/2)*2;
3572
                            if(s->mv_dir&MV_DIRECT)
3573
                                s->dquant= 0;
3574
                        }
3575
                        if(s->mv_type==MV_TYPE_8X8)
3576
                            s->dquant=0;
3577
                    }
3578
                }
3579
            }
3580
        }
3581
        ff_set_qscale(s, last_qp + s->dquant);
3582
    }else if(s->flags&CODEC_FLAG_QP_RD)
3583
        ff_set_qscale(s, s->qscale + s->dquant);
3584

    
3585
    wrap_y = s->linesize;
3586
    wrap_c = s->uvlinesize;
3587
    ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
3588
    ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
3589
    ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3590

    
3591
    if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
3592
        uint8_t *ebuf= s->edge_emu_buffer + 32;
3593
        ff_emulated_edge_mc(ebuf            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
3594
        ptr_y= ebuf;
3595
        ff_emulated_edge_mc(ebuf+18*wrap_y  , ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3596
        ptr_cb= ebuf+18*wrap_y;
3597
        ff_emulated_edge_mc(ebuf+18*wrap_y+8, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3598
        ptr_cr= ebuf+18*wrap_y+8;
3599
    }
3600

    
3601
    if (s->mb_intra) {
3602
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3603
            int progressive_score, interlaced_score;
3604

    
3605
            s->interlaced_dct=0;
3606
            progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8) 
3607
                              +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
3608

    
3609
            if(progressive_score > 0){
3610
                interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8) 
3611
                                  +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
3612
                if(progressive_score > interlaced_score){
3613
                    s->interlaced_dct=1;
3614
            
3615
                    dct_offset= wrap_y;
3616
                    wrap_y<<=1;
3617
                }
3618
            }
3619
        }
3620
        
3621
        s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
3622
        s->dsp.get_pixels(s->block[1], ptr_y              + 8, wrap_y);
3623
        s->dsp.get_pixels(s->block[2], ptr_y + dct_offset    , wrap_y);
3624
        s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
3625

    
3626
        if(s->flags&CODEC_FLAG_GRAY){
3627
            skip_dct[4]= 1;
3628
            skip_dct[5]= 1;
3629
        }else{
3630
            s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
3631
            s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
3632
        }
3633
    }else{
3634
        op_pixels_func (*op_pix)[4];
3635
        qpel_mc_func (*op_qpix)[16];
3636
        uint8_t *dest_y, *dest_cb, *dest_cr;
3637

    
3638
        dest_y  = s->dest[0];
3639
        dest_cb = s->dest[1];
3640
        dest_cr = s->dest[2];
3641

    
3642
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
3643
            op_pix = s->dsp.put_pixels_tab;
3644
            op_qpix= s->dsp.put_qpel_pixels_tab;
3645
        }else{
3646
            op_pix = s->dsp.put_no_rnd_pixels_tab;
3647
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3648
        }
3649

    
3650
        if (s->mv_dir & MV_DIR_FORWARD) {
3651
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3652
            op_pix = s->dsp.avg_pixels_tab;
3653
            op_qpix= s->dsp.avg_qpel_pixels_tab;
3654
        }
3655
        if (s->mv_dir & MV_DIR_BACKWARD) {
3656
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3657
        }
3658

    
3659
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3660
            int progressive_score, interlaced_score;
3661

    
3662
            s->interlaced_dct=0;
3663
            progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8) 
3664
                              +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
3665
            
3666
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
3667

    
3668
            if(progressive_score>0){
3669
                interlaced_score = s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y*2, 8) 
3670
                                  +s->dsp.ildct_cmp[0](s, dest_y + wrap_y  , ptr_y + wrap_y  , wrap_y*2, 8);
3671
            
3672
                if(progressive_score > interlaced_score){
3673
                    s->interlaced_dct=1;
3674
            
3675
                    dct_offset= wrap_y;
3676
                    wrap_y<<=1;
3677
                }
3678
            }
3679
        }
3680
        
3681
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
3682
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
3683
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
3684
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
3685
        
3686
        if(s->flags&CODEC_FLAG_GRAY){
3687
            skip_dct[4]= 1;
3688
            skip_dct[5]= 1;
3689
        }else{
3690
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
3691
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
3692
        }
3693
        /* pre quantization */         
3694
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
3695
            //FIXME optimize
3696
            if(s->dsp.sad[1](NULL, ptr_y               , dest_y               , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
3697
            if(s->dsp.sad[1](NULL, ptr_y            + 8, dest_y            + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
3698
            if(s->dsp.sad[1](NULL, ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
3699
            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;
3700
            if(s->dsp.sad[1](NULL, ptr_cb              , dest_cb              , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
3701
            if(s->dsp.sad[1](NULL, ptr_cr              , dest_cr              , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
3702
        }
3703
    }
3704

    
3705
    if(s->avctx->quantizer_noise_shaping){
3706
        if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y                 , wrap_y);
3707
        if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y              + 8, wrap_y);
3708
        if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset    , wrap_y);
3709
        if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
3710
        if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb                , wrap_c);
3711
        if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr                , wrap_c);
3712
        memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*6);
3713
    }
3714
            
3715
    /* DCT & quantize */
3716
    assert(s->out_format!=FMT_MJPEG || s->qscale==8);
3717
    {
3718
        for(i=0;i<6;i++) {
3719
            if(!skip_dct[i]){
3720
                int overflow;
3721
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
3722
            // FIXME we could decide to change to quantizer instead of clipping
3723
            // JS: I don't think that would be a good idea it could lower quality instead
3724
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
3725
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
3726
            }else
3727
                s->block_last_index[i]= -1;
3728
        }
3729
        if(s->avctx->quantizer_noise_shaping){
3730
            for(i=0;i<6;i++) {
3731
                if(!skip_dct[i]){
3732
                    s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
3733
                }
3734
            }
3735
        }
3736
        
3737
        if(s->luma_elim_threshold && !s->mb_intra)
3738
            for(i=0; i<4; i++)
3739
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
3740
        if(s->chroma_elim_threshold && !s->mb_intra)
3741
            for(i=4; i<6; i++)
3742
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
3743

    
3744
        if(s->flags & CODEC_FLAG_CBP_RD){
3745
            for(i=0;i<6;i++) {
3746
                if(s->block_last_index[i] == -1)
3747
                    s->coded_score[i]= INT_MAX/256;
3748
            }
3749
        }
3750
    }
3751

    
3752
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
3753
        s->block_last_index[4]=
3754
        s->block_last_index[5]= 0;
3755
        s->block[4][0]=
3756
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
3757
    }
3758

    
3759
    //non c quantize code returns incorrect block_last_index FIXME
3760
    if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
3761
        for(i=0; i<6; i++){
3762
            int j;
3763
            if(s->block_last_index[i]>0){
3764
                for(j=63; j>0; j--){
3765
                    if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
3766
                }
3767
                s->block_last_index[i]= j;
3768
            }
3769
        }
3770
    }
3771

    
3772
    /* huffman encode */
3773
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
3774
    case CODEC_ID_MPEG1VIDEO:
3775
    case CODEC_ID_MPEG2VIDEO:
3776
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
3777
#ifdef CONFIG_RISKY
3778
    case CODEC_ID_MPEG4:
3779
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3780
    case CODEC_ID_MSMPEG4V2:
3781
    case CODEC_ID_MSMPEG4V3:
3782
    case CODEC_ID_WMV1:
3783
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3784
    case CODEC_ID_WMV2:
3785
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
3786
    case CODEC_ID_H263:
3787
    case CODEC_ID_H263P:
3788
    case CODEC_ID_FLV1:
3789
    case CODEC_ID_RV10:
3790
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
3791
#endif
3792
    case CODEC_ID_MJPEG:
3793
        mjpeg_encode_mb(s, s->block); break;
3794
    default:
3795
        assert(0);
3796
    }
3797
}
3798

    
3799
#endif //CONFIG_ENCODERS
3800

    
3801
void ff_mpeg_flush(AVCodecContext *avctx){
3802
    int i;
3803
    MpegEncContext *s = avctx->priv_data;
3804
    
3805
    if(s==NULL || s->picture==NULL) 
3806
        return;
3807
    
3808
    for(i=0; i<MAX_PICTURE_COUNT; i++){
3809
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
3810
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
3811
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
3812
    }
3813
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
3814
    
3815
    s->parse_context.state= -1;
3816
    s->parse_context.frame_start_found= 0;
3817
    s->parse_context.overread= 0;
3818
    s->parse_context.overread_index= 0;
3819
    s->parse_context.index= 0;
3820
    s->parse_context.last_index= 0;
3821
    s->bitstream_buffer_size=0;
3822
}
3823

    
3824
#ifdef CONFIG_ENCODERS
3825
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
3826
{
3827
    const uint16_t *srcw= (uint16_t*)src;
3828
    int words= length>>4;
3829
    int bits= length&15;
3830
    int i;
3831

    
3832
    if(length==0) return;
3833
    
3834
    if(words < 16){
3835
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
3836
    }else if(put_bits_count(pb)&7){
3837
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
3838
    }else{
3839
        for(i=0; put_bits_count(pb)&31; i++)
3840
            put_bits(pb, 8, src[i]);
3841
        flush_put_bits(pb);
3842
        memcpy(pbBufPtr(pb), src+i, 2*words-i);
3843
        skip_put_bytes(pb, 2*words-i);
3844
    }
3845
        
3846
    put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
3847
}
3848

    
3849
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
3850
    int i;
3851

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

    
3854
    /* mpeg1 */
3855
    d->mb_skip_run= s->mb_skip_run;
3856
    for(i=0; i<3; i++)
3857
        d->last_dc[i]= s->last_dc[i];
3858
    
3859
    /* statistics */
3860
    d->mv_bits= s->mv_bits;
3861
    d->i_tex_bits= s->i_tex_bits;
3862
    d->p_tex_bits= s->p_tex_bits;
3863
    d->i_count= s->i_count;
3864
    d->f_count= s->f_count;
3865
    d->b_count= s->b_count;
3866
    d->skip_count= s->skip_count;
3867
    d->misc_bits= s->misc_bits;
3868
    d->last_bits= 0;
3869

    
3870
    d->mb_skiped= 0;
3871
    d->qscale= s->qscale;
3872
    d->dquant= s->dquant;
3873
}
3874

    
3875
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
3876
    int i;
3877

    
3878
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
3879
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
3880
    
3881
    /* mpeg1 */
3882
    d->mb_skip_run= s->mb_skip_run;
3883
    for(i=0; i<3; i++)
3884
        d->last_dc[i]= s->last_dc[i];
3885
    
3886
    /* statistics */
3887
    d->mv_bits= s->mv_bits;
3888
    d->i_tex_bits= s->i_tex_bits;
3889
    d->p_tex_bits= s->p_tex_bits;
3890
    d->i_count= s->i_count;
3891
    d->f_count= s->f_count;
3892
    d->b_count= s->b_count;
3893
    d->skip_count= s->skip_count;
3894
    d->misc_bits= s->misc_bits;
3895

    
3896
    d->mb_intra= s->mb_intra;
3897
    d->mb_skiped= s->mb_skiped;
3898
    d->mv_type= s->mv_type;
3899
    d->mv_dir= s->mv_dir;
3900
    d->pb= s->pb;
3901
    if(s->data_partitioning){
3902
        d->pb2= s->pb2;
3903
        d->tex_pb= s->tex_pb;
3904
    }
3905
    d->block= s->block;
3906
    for(i=0; i<6; i++)
3907
        d->block_last_index[i]= s->block_last_index[i];
3908
    d->interlaced_dct= s->interlaced_dct;
3909
    d->qscale= s->qscale;
3910
}
3911

    
3912
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
3913
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
3914
                           int *dmin, int *next_block, int motion_x, int motion_y)
3915
{
3916
    int score;
3917
    uint8_t *dest_backup[3];
3918
    
3919
    copy_context_before_encode(s, backup, type);
3920

    
3921
    s->block= s->blocks[*next_block];
3922
    s->pb= pb[*next_block];
3923
    if(s->data_partitioning){
3924
        s->pb2   = pb2   [*next_block];
3925
        s->tex_pb= tex_pb[*next_block];
3926
    }
3927
    
3928
    if(*next_block){
3929
        memcpy(dest_backup, s->dest, sizeof(s->dest));
3930
        s->dest[0] = s->rd_scratchpad;
3931
        s->dest[1] = s->rd_scratchpad + 16*s->linesize;
3932
        s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
3933
        assert(s->linesize >= 32); //FIXME
3934
    }
3935

    
3936
    encode_mb(s, motion_x, motion_y);
3937
    
3938
    score= put_bits_count(&s->pb);
3939
    if(s->data_partitioning){
3940
        score+= put_bits_count(&s->pb2);
3941
        score+= put_bits_count(&s->tex_pb);
3942
    }
3943
   
3944
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
3945
        MPV_decode_mb(s, s->block);
3946

    
3947
        score *= s->lambda2;
3948
        score += sse_mb(s) << FF_LAMBDA_SHIFT;
3949
    }
3950
    
3951
    if(*next_block){
3952
        memcpy(s->dest, dest_backup, sizeof(s->dest));
3953
    }
3954

    
3955
    if(score<*dmin){
3956
        *dmin= score;
3957
        *next_block^=1;
3958

    
3959
        copy_context_after_encode(best, s, type);
3960
    }
3961
}
3962
                
3963
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
3964
    uint32_t *sq = squareTbl + 256;
3965
    int acc=0;
3966
    int x,y;
3967
    
3968
    if(w==16 && h==16) 
3969
        return s->dsp.sse[0](NULL, src1, src2, stride, 16);
3970
    else if(w==8 && h==8)
3971
        return s->dsp.sse[1](NULL, src1, src2, stride, 8);
3972
    
3973
    for(y=0; y<h; y++){
3974
        for(x=0; x<w; x++){
3975
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
3976
        } 
3977
    }
3978
    
3979
    assert(acc>=0);
3980
    
3981
    return acc;
3982
}
3983

    
3984
static int sse_mb(MpegEncContext *s){
3985
    int w= 16;
3986
    int h= 16;
3987

    
3988
    if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3989
    if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3990

    
3991
    if(w==16 && h==16)
3992
      if(s->avctx->mb_cmp == FF_CMP_NSSE){
3993
        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)
3994
               +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)
3995
               +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);
3996
      }else{
3997
        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)
3998
               +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)
3999
               +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);
4000
      }
4001
    else
4002
        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)
4003
               +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)
4004
               +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);
4005
}
4006

    
4007
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
4008
    MpegEncContext *s= arg;
4009

    
4010
    
4011
    s->me.pre_pass=1;
4012
    s->me.dia_size= s->avctx->pre_dia_size;
4013
    s->first_slice_line=1;
4014
    for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
4015
        for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
4016
            ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4017
        }
4018
        s->first_slice_line=0;
4019
    }
4020
    
4021
    s->me.pre_pass=0;
4022
    
4023
    return 0;
4024
}
4025

    
4026
static int estimate_motion_thread(AVCodecContext *c, void *arg){
4027
    MpegEncContext *s= arg;
4028

    
4029
    s->me.dia_size= s->avctx->dia_size;
4030
    s->first_slice_line=1;
4031
    for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4032
        s->mb_x=0; //for block init below
4033
        ff_init_block_index(s);
4034
        for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
4035
            s->block_index[0]+=2;
4036
            s->block_index[1]+=2;
4037
            s->block_index[2]+=2;
4038
            s->block_index[3]+=2;
4039
            
4040
            /* compute motion vector & mb_type and store in context */
4041
            if(s->pict_type==B_TYPE)
4042
                ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
4043
            else
4044
                ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4045
        }
4046
        s->first_slice_line=0;
4047
    }
4048
    return 0;
4049
}
4050

    
4051
static int mb_var_thread(AVCodecContext *c, void *arg){
4052
    MpegEncContext *s= arg;
4053
    int mb_x, mb_y;
4054

    
4055
    for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4056
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4057
            int xx = mb_x * 16;
4058
            int yy = mb_y * 16;
4059
            uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
4060
            int varc;
4061
            int sum = s->dsp.pix_sum(pix, s->linesize);
4062
    
4063
            varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
4064

    
4065
            s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
4066
            s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
4067
            s->me.mb_var_sum_temp    += varc;
4068
        }
4069
    }
4070
    return 0;
4071
}
4072

    
4073
static void write_slice_end(MpegEncContext *s){
4074
    if(s->codec_id==CODEC_ID_MPEG4){
4075
        if(s->partitioned_frame){
4076
            ff_mpeg4_merge_partitions(s);
4077
        }
4078
    
4079
        ff_mpeg4_stuffing(&s->pb);
4080
    }else if(s->out_format == FMT_MJPEG){
4081
        ff_mjpeg_stuffing(&s->pb);
4082
    }
4083

    
4084
    align_put_bits(&s->pb);
4085
    flush_put_bits(&s->pb);
4086
}
4087

    
4088
static int encode_thread(AVCodecContext *c, void *arg){
4089
    MpegEncContext *s= arg;
4090
    int mb_x, mb_y, pdif = 0;
4091
    int i, j;
4092
    MpegEncContext best_s, backup_s;
4093
    uint8_t bit_buf[2][3000];
4094
    uint8_t bit_buf2[2][3000];
4095
    uint8_t bit_buf_tex[2][3000];
4096
    PutBitContext pb[2], pb2[2], tex_pb[2];
4097
//printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4098

    
4099
    for(i=0; i<2; i++){
4100
        init_put_bits(&pb    [i], bit_buf    [i], 3000);
4101
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000);
4102
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000);
4103
    }
4104

    
4105
    s->last_bits= put_bits_count(&s->pb);
4106
    s->mv_bits=0;
4107
    s->misc_bits=0;
4108
    s->i_tex_bits=0;
4109
    s->p_tex_bits=0;
4110
    s->i_count=0;
4111
    s->f_count=0;
4112
    s->b_count=0;
4113
    s->skip_count=0;
4114

    
4115
    for(i=0; i<3; i++){
4116
        /* init last dc values */
4117
        /* note: quant matrix value (8) is implied here */
4118
        s->last_dc[i] = 128 << s->intra_dc_precision;
4119
        
4120
        s->current_picture_ptr->error[i] = 0;
4121
    }
4122
    s->mb_skip_run = 0;
4123
    memset(s->last_mv, 0, sizeof(s->last_mv));
4124
     
4125
    s->last_mv_dir = 0;
4126

    
4127
#ifdef CONFIG_RISKY
4128
    switch(s->codec_id){
4129
    case CODEC_ID_H263:
4130
    case CODEC_ID_H263P:
4131
    case CODEC_ID_FLV1:
4132
        s->gob_index = ff_h263_get_gob_height(s);
4133
        break;
4134
    case CODEC_ID_MPEG4:
4135
        if(s->partitioned_frame)
4136
            ff_mpeg4_init_partitions(s);
4137
        break;
4138
    }
4139
#endif
4140

    
4141
    s->resync_mb_x=0;
4142
    s->resync_mb_y=0; 
4143
    s->first_slice_line = 1;
4144
    s->ptr_lastgob = s->pb.buf;
4145
    for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4146
//    printf("row %d at %X\n", s->mb_y, (int)s);
4147
        s->mb_x=0;
4148
        s->mb_y= mb_y;
4149

    
4150
        ff_set_qscale(s, s->qscale);
4151
        ff_init_block_index(s);
4152
        
4153
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4154
            const int xy= mb_y*s->mb_stride + mb_x;
4155
            int mb_type= s->mb_type[xy];
4156
//            int d;
4157
            int dmin= INT_MAX;
4158
            int dir;
4159

    
4160
            s->mb_x = mb_x;
4161
            ff_update_block_index(s);
4162

    
4163
            /* write gob / video packet header  */
4164
#ifdef CONFIG_RISKY
4165
            if(s->rtp_mode){
4166
                int current_packet_size, is_gob_start;
4167
                
4168
                current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
4169
                
4170
                is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0; 
4171
                
4172
                if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
4173
                
4174
                switch(s->codec_id){
4175
                case CODEC_ID_H263:
4176
                case CODEC_ID_H263P:
4177
                    if(!s->h263_slice_structured)
4178
                        if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
4179
                    break;
4180
                case CODEC_ID_MPEG2VIDEO:
4181
                    if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
4182
                case CODEC_ID_MPEG1VIDEO:
4183
                    if(s->mb_skip_run) is_gob_start=0;
4184
                    break;
4185
                }
4186

    
4187
                if(is_gob_start){
4188
                    if(s->start_mb_y != mb_y || mb_x!=0){
4189
                        write_slice_end(s);
4190

    
4191
                        if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
4192
                            ff_mpeg4_init_partitions(s);
4193
                        }
4194
                    }
4195
                
4196
                    assert((put_bits_count(&s->pb)&7) == 0);
4197
                    current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4198
                    
4199
                    if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
4200
                        int r= put_bits_count(&s->pb)/8 + s->picture_number + s->codec_id + s->mb_x + s->mb_y;
4201
                        int d= 100 / s->avctx->error_rate;
4202
                        if(r % d == 0){
4203
                            current_packet_size=0;
4204
#ifndef ALT_BITSTREAM_WRITER
4205
                            s->pb.buf_ptr= s->ptr_lastgob;
4206
#endif
4207
                            assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
4208
                        }
4209
                    }
4210
        
4211
                    if (s->avctx->rtp_callback)
4212
                        s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, 0);
4213
                    
4214
                    switch(s->codec_id){
4215
                    case CODEC_ID_MPEG4:
4216
                        ff_mpeg4_encode_video_packet_header(s);
4217
                        ff_mpeg4_clean_buffers(s);
4218
                    break;
4219
                    case CODEC_ID_MPEG1VIDEO:
4220
                    case CODEC_ID_MPEG2VIDEO:
4221
                        ff_mpeg1_encode_slice_header(s);
4222
                        ff_mpeg1_clean_buffers(s);
4223
                    break;
4224
                    case CODEC_ID_H263:
4225
                    case CODEC_ID_H263P:
4226
                        h263_encode_gob_header(s, mb_y);                       
4227
                    break;
4228
                    }
4229

    
4230
                    if(s->flags&CODEC_FLAG_PASS1){
4231
                        int bits= put_bits_count(&s->pb);
4232
                        s->misc_bits+= bits - s->last_bits;
4233
                        s->last_bits= bits;
4234
                    }
4235
    
4236
                    s->ptr_lastgob += current_packet_size;
4237
                    s->first_slice_line=1;
4238
                    s->resync_mb_x=mb_x;
4239
                    s->resync_mb_y=mb_y;
4240
                }
4241
            }
4242
#endif
4243

    
4244
            if(  (s->resync_mb_x   == s->mb_x)
4245
               && s->resync_mb_y+1 == s->mb_y){
4246
                s->first_slice_line=0; 
4247
            }
4248

    
4249
            s->mb_skiped=0;
4250
            s->dquant=0; //only for QP_RD
4251

    
4252
            if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD
4253
                int next_block=0;
4254
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
4255

    
4256
                copy_context_before_encode(&backup_s, s, -1);
4257
                backup_s.pb= s->pb;
4258
                best_s.data_partitioning= s->data_partitioning;
4259
                best_s.partitioned_frame= s->partitioned_frame;
4260
                if(s->data_partitioning){
4261
                    backup_s.pb2= s->pb2;
4262
                    backup_s.tex_pb= s->tex_pb;
4263
                }
4264

    
4265
                if(mb_type&CANDIDATE_MB_TYPE_INTER){
4266
                    s->mv_dir = MV_DIR_FORWARD;
4267
                    s->mv_type = MV_TYPE_16X16;
4268
                    s->mb_intra= 0;
4269
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
4270
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
4271
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb, 
4272
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4273
                }
4274
                if(mb_type&CANDIDATE_MB_TYPE_INTER_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->p_field_select_table[i][xy];
4280
                        s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
4281
                        s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
4282
                    }
4283
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb, 
4284
                                 &dmin, &next_block, 0, 0);
4285
                }
4286
                if(mb_type&CANDIDATE_MB_TYPE_SKIPED){
4287
                    s->mv_dir = MV_DIR_FORWARD;
4288
                    s->mv_type = MV_TYPE_16X16;
4289
                    s->mb_intra= 0;
4290
                    s->mv[0][0][0] = 0;
4291
                    s->mv[0][0][1] = 0;
4292
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPED, pb, pb2, tex_pb, 
4293
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4294
                }
4295
                if(mb_type&CANDIDATE_MB_TYPE_INTER4V){                 
4296
                    s->mv_dir = MV_DIR_FORWARD;
4297
                    s->mv_type = MV_TYPE_8X8;
4298
                    s->mb_intra= 0;
4299
                    for(i=0; i<4; i++){
4300
                        s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
4301
                        s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
4302
                    }
4303
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb, 
4304
                                 &dmin, &next_block, 0, 0);
4305
                }
4306
                if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
4307
                    s->mv_dir = MV_DIR_FORWARD;
4308
                    s->mv_type = MV_TYPE_16X16;
4309
                    s->mb_intra= 0;
4310
                    s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
4311
                    s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
4312
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb, 
4313
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4314
                }
4315
                if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
4316
                    s->mv_dir = MV_DIR_BACKWARD;
4317
                    s->mv_type = MV_TYPE_16X16;
4318
                    s->mb_intra= 0;
4319
                    s->mv[1][0][0] = s->b_back_mv_table[xy][0];
4320
                    s->mv[1][0][1] = s->b_back_mv_table[xy][1];
4321
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb, 
4322
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
4323
                }
4324
                if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
4325
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4326
                    s->mv_type = MV_TYPE_16X16;
4327
                    s->mb_intra= 0;
4328
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
4329
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
4330
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
4331
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
4332
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb, 
4333
                                 &dmin, &next_block, 0, 0);
4334
                }
4335
                if(mb_type&CANDIDATE_MB_TYPE_DIRECT){
4336
                    int mx= s->b_direct_mv_table[xy][0];
4337
                    int my= s->b_direct_mv_table[xy][1];
4338
                    
4339
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4340
                    s->mb_intra= 0;
4341
#ifdef CONFIG_RISKY
4342
                    ff_mpeg4_set_direct_mv(s, mx, my);
4343
#endif
4344
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb, 
4345
                                 &dmin, &next_block, mx, my);
4346
                }
4347
                if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){ 
4348
                    s->mv_dir = MV_DIR_FORWARD;
4349
                    s->mv_type = MV_TYPE_FIELD;
4350
                    s->mb_intra= 0;
4351
                    for(i=0; i<2; i++){
4352
                        j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
4353
                        s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
4354
                        s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
4355
                    }
4356
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb, 
4357
                                 &dmin, &next_block, 0, 0);
4358
                }
4359
                if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){ 
4360
                    s->mv_dir = MV_DIR_BACKWARD;
4361
                    s->mv_type = MV_TYPE_FIELD;
4362
                    s->mb_intra= 0;
4363
                    for(i=0; i<2; i++){
4364
                        j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
4365
                        s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
4366
                        s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
4367
                    }
4368
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb, 
4369
                                 &dmin, &next_block, 0, 0);
4370
                }
4371
                if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){ 
4372
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4373
                    s->mv_type = MV_TYPE_FIELD;
4374
                    s->mb_intra= 0;
4375
                    for(dir=0; dir<2; dir++){
4376
                        for(i=0; i<2; i++){
4377
                            j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
4378
                            s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
4379
                            s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
4380
                        }
4381
                    }
4382
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb, 
4383
                                 &dmin, &next_block, 0, 0);
4384
                }
4385
                if(mb_type&CANDIDATE_MB_TYPE_INTRA){
4386
                    s->mv_dir = 0;
4387
                    s->mv_type = MV_TYPE_16X16;
4388
                    s->mb_intra= 1;
4389
                    s->mv[0][0][0] = 0;
4390
                    s->mv[0][0][1] = 0;
4391
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb, 
4392
                                 &dmin, &next_block, 0, 0);
4393
                    if(s->h263_pred || s->h263_aic){
4394
                        if(best_s.mb_intra)
4395
                            s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
4396
                        else
4397
                            ff_clean_intra_table_entries(s); //old mode?
4398
                    }
4399
                }
4400

    
4401
                if(s->flags & CODEC_FLAG_QP_RD){
4402
                    if(best_s.mv_type==MV_TYPE_16X16 && !(best_s.mv_dir&MV_DIRECT)){
4403
                        const int last_qp= backup_s.qscale;
4404
                        int dquant, dir, qp, dc[6];
4405
                        DCTELEM ac[6][16];
4406
                        const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
4407
                        
4408
                        assert(backup_s.dquant == 0);
4409

    
4410
                        //FIXME intra
4411
                        s->mv_dir= best_s.mv_dir;
4412
                        s->mv_type = MV_TYPE_16X16;
4413
                        s->mb_intra= best_s.mb_intra;
4414
                        s->mv[0][0][0] = best_s.mv[0][0][0];
4415
                        s->mv[0][0][1] = best_s.mv[0][0][1];
4416
                        s->mv[1][0][0] = best_s.mv[1][0][0];
4417
                        s->mv[1][0][1] = best_s.mv[1][0][1];
4418
                        
4419
                        dir= s->pict_type == B_TYPE ? 2 : 1;
4420
                        if(last_qp + dir > s->avctx->qmax) dir= -dir;
4421
                        for(dquant= dir; dquant<=2 && dquant>=-2; dquant += dir){
4422
                            qp= last_qp + dquant;
4423
                            if(qp < s->avctx->qmin || qp > s->avctx->qmax)
4424
                                break;
4425
                            backup_s.dquant= dquant;
4426
                            if(s->mb_intra && s->dc_val[0]){
4427
                                for(i=0; i<6; i++){
4428
                                    dc[i]= s->dc_val[0][ s->block_index[i] ];
4429
                                    memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
4430
                                }
4431
                            }
4432

    
4433
                            encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb, 
4434
                                         &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
4435
                            if(best_s.qscale != qp){
4436
                                if(s->mb_intra && s->dc_val[0]){
4437
                                    for(i=0; i<6; i++){
4438
                                        s->dc_val[0][ s->block_index[i] ]= dc[i];
4439
                                        memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
4440
                                    }
4441
                                }
4442
                                if(dir > 0 && dquant==dir){
4443
                                    dquant= 0;
4444
                                    dir= -dir;
4445
                                }else
4446
                                    break;
4447
                            }
4448
                        }
4449
                        qp= best_s.qscale;
4450
                        s->current_picture.qscale_table[xy]= qp;
4451
                    }
4452
                }
4453

    
4454
                copy_context_after_encode(s, &best_s, -1);
4455
                
4456
                pb_bits_count= put_bits_count(&s->pb);
4457
                flush_put_bits(&s->pb);
4458
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
4459
                s->pb= backup_s.pb;
4460
                
4461
                if(s->data_partitioning){
4462
                    pb2_bits_count= put_bits_count(&s->pb2);
4463
                    flush_put_bits(&s->pb2);
4464
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
4465
                    s->pb2= backup_s.pb2;
4466
                    
4467
                    tex_pb_bits_count= put_bits_count(&s->tex_pb);
4468
                    flush_put_bits(&s->tex_pb);
4469
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
4470
                    s->tex_pb= backup_s.tex_pb;
4471
                }
4472
                s->last_bits= put_bits_count(&s->pb);
4473
               
4474
#ifdef CONFIG_RISKY
4475
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4476
                    ff_h263_update_motion_val(s);
4477
#endif
4478
        
4479
                if(next_block==0){ //FIXME 16 vs linesize16
4480
                    s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad                     , s->linesize  ,16);
4481
                    s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize    , s->uvlinesize, 8);
4482
                    s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
4483
                }
4484

    
4485
                if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
4486
                    MPV_decode_mb(s, s->block);
4487
            } else {
4488
                int motion_x, motion_y;
4489
                s->mv_type=MV_TYPE_16X16;
4490
                // only one MB-Type possible
4491
                
4492
                switch(mb_type){
4493
                case CANDIDATE_MB_TYPE_INTRA:
4494
                    s->mv_dir = 0;
4495
                    s->mb_intra= 1;
4496
                    motion_x= s->mv[0][0][0] = 0;
4497
                    motion_y= s->mv[0][0][1] = 0;
4498
                    break;
4499
                case CANDIDATE_MB_TYPE_INTER:
4500
                    s->mv_dir = MV_DIR_FORWARD;
4501
                    s->mb_intra= 0;
4502
                    motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
4503
                    motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
4504
                    break;
4505
                case CANDIDATE_MB_TYPE_INTER_I:
4506
                    s->mv_dir = MV_DIR_FORWARD;
4507
                    s->mv_type = MV_TYPE_FIELD;
4508
                    s->mb_intra= 0;
4509
                    for(i=0; i<2; i++){
4510
                        j= s->field_select[0][i] = s->p_field_select_table[i][xy];
4511
                        s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
4512
                        s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
4513
                    }
4514
                    motion_x = motion_y = 0;
4515
                    break;
4516
                case CANDIDATE_MB_TYPE_INTER4V:
4517
                    s->mv_dir = MV_DIR_FORWARD;
4518
                    s->mv_type = MV_TYPE_8X8;
4519
                    s->mb_intra= 0;
4520
                    for(i=0; i<4; i++){
4521
                        s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
4522
                        s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
4523
                    }
4524
                    motion_x= motion_y= 0;
4525
                    break;
4526
                case CANDIDATE_MB_TYPE_DIRECT:
4527
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4528
                    s->mb_intra= 0;
4529
                    motion_x=s->b_direct_mv_table[xy][0];
4530
                    motion_y=s->b_direct_mv_table[xy][1];
4531
#ifdef CONFIG_RISKY
4532
                    ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
4533
#endif
4534
                    break;
4535
                case CANDIDATE_MB_TYPE_BIDIR:
4536
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4537
                    s->mb_intra= 0;
4538
                    motion_x=0;
4539
                    motion_y=0;
4540
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
4541
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
4542
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
4543
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
4544
                    break;
4545
                case CANDIDATE_MB_TYPE_BACKWARD:
4546
                    s->mv_dir = MV_DIR_BACKWARD;
4547
                    s->mb_intra= 0;
4548
                    motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
4549
                    motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
4550
                    break;
4551
                case CANDIDATE_MB_TYPE_FORWARD:
4552
                    s->mv_dir = MV_DIR_FORWARD;
4553
                    s->mb_intra= 0;
4554
                    motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
4555
                    motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
4556
//                    printf(" %d %d ", motion_x, motion_y);
4557
                    break;
4558
                case CANDIDATE_MB_TYPE_FORWARD_I:
4559
                    s->mv_dir = MV_DIR_FORWARD;
4560
                    s->mv_type = MV_TYPE_FIELD;
4561
                    s->mb_intra= 0;
4562
                    for(i=0; i<2; i++){
4563
                        j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
4564
                        s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
4565
                        s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
4566
                    }
4567
                    motion_x=motion_y=0;
4568
                    break;
4569
                case CANDIDATE_MB_TYPE_BACKWARD_I:
4570
                    s->mv_dir = MV_DIR_BACKWARD;
4571
                    s->mv_type = MV_TYPE_FIELD;
4572
                    s->mb_intra= 0;
4573
                    for(i=0; i<2; i++){
4574
                        j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
4575
                        s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
4576
                        s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
4577
                    }
4578
                    motion_x=motion_y=0;
4579
                    break;
4580
                case CANDIDATE_MB_TYPE_BIDIR_I:
4581
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4582
                    s->mv_type = MV_TYPE_FIELD;
4583
                    s->mb_intra= 0;
4584
                    for(dir=0; dir<2; dir++){
4585
                        for(i=0; i<2; i++){
4586
                            j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
4587
                            s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
4588
                            s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
4589
                        }
4590
                    }
4591
                    motion_x=motion_y=0;
4592
                    break;
4593
                default:
4594
                    motion_x=motion_y=0; //gcc warning fix
4595
                    av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
4596
                }
4597

    
4598
                encode_mb(s, motion_x, motion_y);
4599

    
4600
                // RAL: Update last macrobloc type
4601
                s->last_mv_dir = s->mv_dir;
4602
            
4603
#ifdef CONFIG_RISKY
4604
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4605
                    ff_h263_update_motion_val(s);
4606
#endif
4607
                
4608
                MPV_decode_mb(s, s->block);
4609
            }
4610

    
4611
            /* clean the MV table in IPS frames for direct mode in B frames */
4612
            if(s->mb_intra /* && I,P,S_TYPE */){
4613
                s->p_mv_table[xy][0]=0;
4614
                s->p_mv_table[xy][1]=0;
4615
            }
4616
            
4617
            if(s->flags&CODEC_FLAG_PSNR){
4618
                int w= 16;
4619
                int h= 16;
4620

    
4621
                if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4622
                if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4623

    
4624
                s->current_picture_ptr->error[0] += sse(
4625
                    s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
4626
                    s->dest[0], w, h, s->linesize);
4627
                s->current_picture_ptr->error[1] += sse(
4628
                    s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
4629
                    s->dest[1], w>>1, h>>1, s->uvlinesize);
4630
                s->current_picture_ptr->error[2] += sse(
4631
                    s, s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
4632
                    s->dest[2], w>>1, h>>1, s->uvlinesize);
4633
            }
4634
            if(s->loop_filter)
4635
                ff_h263_loop_filter(s);
4636
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
4637
        }
4638
    }
4639

    
4640
#ifdef CONFIG_RISKY
4641
    //not beautifull here but we must write it before flushing so it has to be here
4642
    if (s->msmpeg4_version &