Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ d32064c0

History | View | Annotate | Download (219 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

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

    
868
#ifdef CONFIG_ENCODERS
869

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

    
879
    avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME
880

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

    
903
    if (s->gop_size <= 1) {
904
        s->intra_only = 1;
905
        s->gop_size = 12;
906
    } else {
907
        s->intra_only = 0;
908
    }
909

    
910
    s->me_method = avctx->me_method;
911

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

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

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

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

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

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

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

    
1046
    av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1047
    s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1048

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

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

    
1182
    s->encoding = 1;
1183

    
1184
    /* init */
1185
    if (MPV_common_init(s) < 0)
1186
        return -1;
1187

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

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

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

    
1238
    if(ff_rate_control_init(s) < 0)
1239
        return -1;
1240
    
1241
    return 0;
1242
}
1243

    
1244
int MPV_encode_end(AVCodecContext *avctx)
1245
{
1246
    MpegEncContext *s = avctx->priv_data;
1247

    
1248
#ifdef STATS
1249
    print_stats();
1250
#endif
1251

    
1252
    ff_rate_control_uninit(s);
1253

    
1254
    MPV_common_end(s);
1255
    if (s->out_format == FMT_MJPEG)
1256
        mjpeg_close(s);
1257

    
1258
    av_freep(&avctx->extradata);
1259
      
1260
    return 0;
1261
}
1262

    
1263
#endif //CONFIG_ENCODERS
1264

    
1265
void init_rl(RLTable *rl)
1266
{
1267
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1268
    uint8_t index_run[MAX_RUN+1];
1269
    int last, run, level, start, end, i;
1270

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

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

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

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

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

    
1348
    assert(0);
1349
    return -1;
1350
}
1351

    
1352
static void update_noise_reduction(MpegEncContext *s){
1353
    int intra, i;
1354

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

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

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

    
1380
    /* mark&release old frames */
1381
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1382
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1383

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

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

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

    
1413
        pic->coded_picture_number= s->coded_picture_number++;
1414
        
1415
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1416
            return -1;
1417

    
1418
        s->current_picture_ptr= (Picture*)pic;
1419
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1420
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1421
    }
1422

    
1423
    s->current_picture_ptr->pict_type= s->pict_type;
1424
//    if(s->flags && CODEC_FLAG_QSCALE) 
1425
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1426
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1427

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

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

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

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

    
1485
    if(s->dct_error_sum){
1486
        assert(s->avctx->noise_reduction && s->encoding);
1487

    
1488
        update_noise_reduction(s);
1489
    }
1490
        
1491
#ifdef HAVE_XVMC
1492
    if(s->avctx->xvmc_acceleration)
1493
        return XVMC_field_start(s, avctx);
1494
#endif
1495
    return 0;
1496
}
1497

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

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

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

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

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

    
1630
/**
1631
 * prints debuging info for the given picture.
1632
 */
1633
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1634

    
1635
    if(!pict || !pict->mb_type) return;
1636

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

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

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

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

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

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

    
1832
                    u*= 0x0101010101010101ULL;
1833
                    v*= 0x0101010101010101ULL;
1834
                    for(y=0; y<8; y++){
1835
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1836
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1837
                    }
1838

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

    
1859
#ifdef CONFIG_ENCODERS
1860

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

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

    
1894

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

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

    
1924
        pic= (AVFrame*)&s->picture[i];
1925
        pic->reference= 3;
1926

    
1927
        alloc_picture(s, (Picture*)pic, 0);
1928

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

    
1980
    return 0;
1981
}
1982

    
1983
static void select_input_picture(MpegEncContext *s){
1984
    int i;
1985

    
1986
    for(i=1; i<MAX_PICTURE_COUNT; i++)
1987
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1988
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1989

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

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

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

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

    
2075
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2076

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

    
2083
            /* mark us unused / free shared pic */
2084
            for(i=0; i<4; i++)
2085
                s->reordered_input_picture[0]->data[i]= NULL;
2086
            s->reordered_input_picture[0]->type= 0;
2087
            
2088
            pic->reference              = s->reordered_input_picture[0]->reference;
2089
            
2090
            alloc_picture(s, pic, 0);
2091

    
2092
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2093

    
2094
            s->current_picture_ptr= pic;
2095
        }else{
2096
            // input is not a shared pix -> reuse buffer for current_pix
2097

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

    
2115
int MPV_encode_picture(AVCodecContext *avctx,
2116
                       unsigned char *buf, int buf_size, void *data)
2117
{
2118
    MpegEncContext *s = avctx->priv_data;
2119
    AVFrame *pic_arg = data;
2120
    int i, stuffing_count;
2121

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

    
2134
        init_put_bits(&s->thread_context[i]->pb, start, end - start);
2135
    }
2136

    
2137
    s->picture_in_gop_number++;
2138

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

    
2150
        encode_picture(s, s->picture_number);
2151
        
2152
        avctx->real_pict_num  = s->picture_number;
2153
        avctx->header_bits = s->header_bits;
2154
        avctx->mv_bits     = s->mv_bits;
2155
        avctx->misc_bits   = s->misc_bits;
2156
        avctx->i_tex_bits  = s->i_tex_bits;
2157
        avctx->p_tex_bits  = s->p_tex_bits;
2158
        avctx->i_count     = s->i_count;
2159
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2160
        avctx->skip_count  = s->skip_count;
2161

    
2162
        MPV_frame_end(s);
2163

    
2164
        if (s->out_format == FMT_MJPEG)
2165
            mjpeg_picture_trailer(s);
2166
        
2167
        if(s->flags&CODEC_FLAG_PASS1)
2168
            ff_write_pass1_stats(s);
2169

    
2170
        for(i=0; i<4; i++){
2171
            avctx->error[i] += s->current_picture_ptr->error[i];
2172
        }
2173

    
2174
        flush_put_bits(&s->pb);
2175
        s->frame_bits  = put_bits_count(&s->pb);
2176

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

    
2201
        /* update mpeg1/2 vbv_delay for CBR */    
2202
        if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2203
           && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2204
            int vbv_delay;
2205

    
2206
            assert(s->repeat_first_field==0);
2207
            
2208
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2209
            assert(vbv_delay < 0xFFFF);
2210

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

    
2228
#endif //CONFIG_ENCODERS
2229

    
2230
static inline void gmc1_motion(MpegEncContext *s,
2231
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2232
                               uint8_t **ref_picture)
2233
{
2234
    uint8_t *ptr;
2235
    int offset, src_x, src_y, linesize, uvlinesize;
2236
    int motion_x, motion_y;
2237
    int emu=0;
2238

    
2239
    motion_x= s->sprite_offset[0][0];
2240
    motion_y= s->sprite_offset[0][1];
2241
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2242
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2243
    motion_x<<=(3-s->sprite_warping_accuracy);
2244
    motion_y<<=(3-s->sprite_warping_accuracy);
2245
    src_x = clip(src_x, -16, s->width);
2246
    if (src_x == s->width)
2247
        motion_x =0;
2248
    src_y = clip(src_y, -16, s->height);
2249
    if (src_y == s->height)
2250
        motion_y =0;
2251

    
2252
    linesize = s->linesize;
2253
    uvlinesize = s->uvlinesize;
2254
    
2255
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2256

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

    
2281
    motion_x= s->sprite_offset[1][0];
2282
    motion_y= s->sprite_offset[1][1];
2283
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2284
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2285
    motion_x<<=(3-s->sprite_warping_accuracy);
2286
    motion_y<<=(3-s->sprite_warping_accuracy);
2287
    src_x = clip(src_x, -8, s->width>>1);
2288
    if (src_x == s->width>>1)
2289
        motion_x =0;
2290
    src_y = clip(src_y, -8, s->height>>1);
2291
    if (src_y == s->height>>1)
2292
        motion_y =0;
2293

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

    
2316
static inline void gmc_motion(MpegEncContext *s,
2317
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2318
                               uint8_t **ref_picture)
2319
{
2320
    uint8_t *ptr;
2321
    int linesize, uvlinesize;
2322
    const int a= s->sprite_warping_accuracy;
2323
    int ox, oy;
2324

    
2325
    linesize = s->linesize;
2326
    uvlinesize = s->uvlinesize;
2327

    
2328
    ptr = ref_picture[0];
2329

    
2330
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2331
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2332

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

    
2348
    if(s->flags&CODEC_FLAG_GRAY) return;
2349

    
2350
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2351
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2352

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

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

    
2389
    if(src_y>= h){
2390
        src+= (h-1-src_y)*linesize;
2391
        src_y=h-1;
2392
    }else if(src_y<=-block_h){
2393
        src+= (1-block_h-src_y)*linesize;
2394
        src_y=1-block_h;
2395
    }
2396
    if(src_x>= w){
2397
        src+= (w-1-src_x);
2398
        src_x=w-1;
2399
    }else if(src_x<=-block_w){
2400
        src+= (1-block_w-src_x);
2401
        src_x=1-block_w;
2402
    }
2403

    
2404
    start_y= FFMAX(0, -src_y);
2405
    start_x= FFMAX(0, -src_x);
2406
    end_y= FFMIN(block_h, h-src_y);
2407
    end_x= FFMIN(block_w, w-src_x);
2408

    
2409
    // copy existing part
2410
    for(y=start_y; y<end_y; y++){
2411
        for(x=start_x; x<end_x; x++){
2412
            buf[x + y*linesize]= src[x + y*linesize];
2413
        }
2414
    }
2415

    
2416
    //top
2417
    for(y=0; y<start_y; y++){
2418
        for(x=start_x; x<end_x; x++){
2419
            buf[x + y*linesize]= buf[x + start_y*linesize];
2420
        }
2421
    }
2422

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

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

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

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

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

    
2501
    v_edge_pos = s->v_edge_pos >> field_based;
2502
    linesize   = s->current_picture.linesize[0] << field_based;
2503
    uvlinesize = s->current_picture.linesize[1] << field_based;
2504

    
2505
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2506
    src_x = s->mb_x* 16               + (motion_x >> 1);
2507
    src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2508

    
2509
    if (s->out_format == FMT_H263) {
2510
        if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2511
            mx = (motion_x>>1)|(motion_x&1);
2512
            my = motion_y >>1;
2513
            uvdxy = ((my & 1) << 1) | (mx & 1);
2514
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2515
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2516
        }else{
2517
            uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2518
            uvsrc_x = src_x>>1;
2519
            uvsrc_y = src_y>>1;
2520
        }
2521
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2522
        mx = motion_x / 4;
2523
        my = motion_y / 4;
2524
        uvdxy = 0;
2525
        uvsrc_x = s->mb_x*8 + mx;
2526
        uvsrc_y = s->mb_y*8 + my;
2527
    } else {
2528
        if(s->chroma_y_shift){
2529
            mx = motion_x / 2;
2530
            my = motion_y / 2;
2531
            uvdxy = ((my & 1) << 1) | (mx & 1);
2532
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2533
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2534
        } else {
2535
            if(s->chroma_x_shift){
2536
            //Chroma422
2537
                mx = motion_x / 2;
2538
                uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2539
                uvsrc_x = s->mb_x* 8           + (mx >> 1);
2540
                uvsrc_y = src_y;
2541
            } else {
2542
            //Chroma444
2543
                uvdxy = dxy;
2544
                uvsrc_x = src_x;
2545
                uvsrc_y = src_y;
2546
            }
2547
        }
2548
    }
2549

    
2550
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2551
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2552
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2553

    
2554
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2555
       || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
2556
            if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2557
               s->codec_id == CODEC_ID_MPEG1VIDEO){
2558
                av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2559
                return ;
2560
            }
2561
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2562
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2563
            ptr_y = s->edge_emu_buffer;
2564
            if(!(s->flags&CODEC_FLAG_GRAY)){
2565
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2566
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2567
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2568
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2569
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2570
                ptr_cb= uvbuf;
2571
                ptr_cr= uvbuf+16;
2572
            }
2573
    }
2574

    
2575
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2576
        dest_y += s->linesize;
2577
        dest_cb+= s->uvlinesize;
2578
        dest_cr+= s->uvlinesize;
2579
    }
2580

    
2581
    if(field_select){
2582
        ptr_y += s->linesize;
2583
        ptr_cb+= s->uvlinesize;
2584
        ptr_cr+= s->uvlinesize;
2585
    }
2586

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

    
2646
/* obmc for 1 8x8 luma block */
2647
static inline void obmc_motion(MpegEncContext *s,
2648
                               uint8_t *dest, uint8_t *src,
2649
                               int src_x, int src_y,
2650
                               op_pixels_func *pix_op,
2651
                               int16_t mv[5][2]/* mid top left right bottom*/)
2652
#define MID    0
2653
{
2654
    int i;
2655
    uint8_t *ptr[5];
2656
    
2657
    assert(s->quarter_sample==0);
2658
    
2659
    for(i=0; i<5; i++){
2660
        if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2661
            ptr[i]= ptr[MID];
2662
        }else{
2663
            ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
2664
            hpel_motion(s, ptr[i], src, 0, 0,
2665
                        src_x, src_y,
2666
                        s->width, s->height, s->linesize,
2667
                        s->h_edge_pos, s->v_edge_pos,
2668
                        8, 8, pix_op,
2669
                        mv[i][0], mv[i][1]);
2670
        }
2671
    }
2672

    
2673
    put_obmc(dest, ptr, s->linesize);                
2674
}
2675

    
2676
static inline void qpel_motion(MpegEncContext *s,
2677
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2678
                               int field_based, int bottom_field, int field_select,
2679
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2680
                               qpel_mc_func (*qpix_op)[16],
2681
                               int motion_x, int motion_y, int h)
2682
{
2683
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2684
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
2685

    
2686
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2687
    src_x = s->mb_x *  16                 + (motion_x >> 2);
2688
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2689

    
2690
    v_edge_pos = s->v_edge_pos >> field_based;
2691
    linesize = s->linesize << field_based;
2692
    uvlinesize = s->uvlinesize << field_based;
2693
    
2694
    if(field_based){
2695
        mx= motion_x/2;
2696
        my= motion_y>>1;
2697
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2698
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
2699
        mx= (motion_x>>1) + rtab[motion_x&7];
2700
        my= (motion_y>>1) + rtab[motion_y&7];
2701
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2702
        mx= (motion_x>>1)|(motion_x&1);
2703
        my= (motion_y>>1)|(motion_y&1);
2704
    }else{
2705
        mx= motion_x/2;
2706
        my= motion_y/2;
2707
    }
2708
    mx= (mx>>1)|(mx&1);
2709
    my= (my>>1)|(my&1);
2710

    
2711
    uvdxy= (mx&1) | ((my&1)<<1);
2712
    mx>>=1;
2713
    my>>=1;
2714

    
2715
    uvsrc_x = s->mb_x *  8                 + mx;
2716
    uvsrc_y = s->mb_y * (8 >> field_based) + my;
2717

    
2718
    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
2719
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2720
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2721

    
2722
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 
2723
       || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
2724
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, 
2725
                         src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2726
        ptr_y= s->edge_emu_buffer;
2727
        if(!(s->flags&CODEC_FLAG_GRAY)){
2728
            uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
2729
            ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based, 
2730
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2731
            ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based, 
2732
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2733
            ptr_cb= uvbuf;
2734
            ptr_cr= uvbuf + 16;
2735
        }
2736
    }
2737

    
2738
    if(!field_based)
2739
        qpix_op[0][dxy](dest_y, ptr_y, linesize);
2740
    else{
2741
        if(bottom_field){
2742
            dest_y += s->linesize;
2743
            dest_cb+= s->uvlinesize;
2744
            dest_cr+= s->uvlinesize;
2745
        }
2746

    
2747
        if(field_select){
2748
            ptr_y  += s->linesize;
2749
            ptr_cb += s->uvlinesize;
2750
            ptr_cr += s->uvlinesize;
2751
        }
2752
        //damn interlaced mode
2753
        //FIXME boundary mirroring is not exactly correct here
2754
        qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
2755
        qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
2756
    }
2757
    if(!(s->flags&CODEC_FLAG_GRAY)){
2758
        pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
2759
        pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
2760
    }
2761
}
2762

    
2763
inline int ff_h263_round_chroma(int x){
2764
    if (x >= 0)
2765
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2766
    else {
2767
        x = -x;
2768
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2769
    }
2770
}
2771

    
2772
/**
2773
 * h263 chorma 4mv motion compensation.
2774
 */
2775
static inline void chroma_4mv_motion(MpegEncContext *s,
2776
                                     uint8_t *dest_cb, uint8_t *dest_cr,
2777
                                     uint8_t **ref_picture,
2778
                                     op_pixels_func *pix_op,
2779
                                     int mx, int my){
2780
    int dxy, emu=0, src_x, src_y, offset;
2781
    uint8_t *ptr;
2782
    
2783
    /* In case of 8X8, we construct a single chroma motion vector
2784
       with a special rounding */
2785
    mx= ff_h263_round_chroma(mx);
2786
    my= ff_h263_round_chroma(my);
2787
    
2788
    dxy = ((my & 1) << 1) | (mx & 1);
2789
    mx >>= 1;
2790
    my >>= 1;
2791

    
2792
    src_x = s->mb_x * 8 + mx;
2793
    src_y = s->mb_y * 8 + my;
2794
    src_x = clip(src_x, -8, s->width/2);
2795
    if (src_x == s->width/2)
2796
        dxy &= ~1;
2797
    src_y = clip(src_y, -8, s->height/2);
2798
    if (src_y == s->height/2)
2799
        dxy &= ~2;
2800
    
2801
    offset = (src_y * (s->uvlinesize)) + src_x;
2802
    ptr = ref_picture[1] + offset;
2803
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2804
        if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
2805
           || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
2806
            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);
2807
            ptr= s->edge_emu_buffer;
2808
            emu=1;
2809
        }
2810
    }
2811
    pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
2812

    
2813
    ptr = ref_picture[2] + offset;
2814
    if(emu){
2815
        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);
2816
        ptr= s->edge_emu_buffer;
2817
    }
2818
    pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
2819
}
2820

    
2821
/**
2822
 * motion compesation of a single macroblock
2823
 * @param s context
2824
 * @param dest_y luma destination pointer
2825
 * @param dest_cb chroma cb/u destination pointer
2826
 * @param dest_cr chroma cr/v destination pointer
2827
 * @param dir direction (0->forward, 1->backward)
2828
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2829
 * @param pic_op halfpel motion compensation function (average or put normally)
2830
 * @param pic_op qpel motion compensation function (average or put normally)
2831
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2832
 */
2833
static inline void MPV_motion(MpegEncContext *s, 
2834
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2835
                              int dir, uint8_t **ref_picture, 
2836
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
2837
{
2838
    int dxy, mx, my, src_x, src_y, motion_x, motion_y;
2839
    int mb_x, mb_y, i;
2840
    uint8_t *ptr, *dest;
2841

    
2842
    mb_x = s->mb_x;
2843
    mb_y = s->mb_y;
2844

    
2845
    if(s->obmc && s->pict_type != B_TYPE){
2846
        int16_t mv_cache[4][4][2];
2847
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
2848
        const int mot_stride= s->b8_stride;
2849
        const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
2850

    
2851
        assert(!s->mb_skiped);
2852
                
2853
        memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
2854
        memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2855
        memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2856

    
2857
        if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
2858
            memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
2859
        }else{
2860
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
2861
        }
2862

    
2863
        if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
2864
            *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
2865
            *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
2866
        }else{
2867
            *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
2868
            *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
2869
        }
2870

    
2871
        if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
2872
            *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
2873
            *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
2874
        }else{
2875
            *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
2876
            *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
2877
        }
2878
        
2879
        mx = 0;
2880
        my = 0;
2881
        for(i=0;i<4;i++) {
2882
            const int x= (i&1)+1;
2883
            const int y= (i>>1)+1;
2884
            int16_t mv[5][2]= {
2885
                {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
2886
                {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
2887
                {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
2888
                {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
2889
                {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
2890
            //FIXME cleanup
2891
            obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2892
                        ref_picture[0],
2893
                        mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2894
                        pix_op[1],
2895
                        mv);
2896

    
2897
            mx += mv[0][0];
2898
            my += mv[0][1];
2899
        }
2900
        if(!(s->flags&CODEC_FLAG_GRAY))
2901
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2902

    
2903
        return;
2904
    }
2905
   
2906
    switch(s->mv_type) {
2907
    case MV_TYPE_16X16:
2908
#ifdef CONFIG_RISKY
2909
        if(s->mcsel){
2910
            if(s->real_sprite_warping_points==1){
2911
                gmc1_motion(s, dest_y, dest_cb, dest_cr,
2912
                            ref_picture);
2913
            }else{
2914
                gmc_motion(s, dest_y, dest_cb, dest_cr,
2915
                            ref_picture);
2916
            }
2917
        }else if(s->quarter_sample){
2918
            qpel_motion(s, dest_y, dest_cb, dest_cr, 
2919
                        0, 0, 0,
2920
                        ref_picture, pix_op, qpix_op,
2921
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2922
        }else if(s->mspel){
2923
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
2924
                        ref_picture, pix_op,
2925
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2926
        }else
2927
#endif
2928
        {
2929
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 
2930
                        0, 0, 0,
2931
                        ref_picture, pix_op,
2932
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2933
        }           
2934
        break;
2935
    case MV_TYPE_8X8:
2936
        mx = 0;
2937
        my = 0;
2938
        if(s->quarter_sample){
2939
            for(i=0;i<4;i++) {
2940
                motion_x = s->mv[dir][i][0];
2941
                motion_y = s->mv[dir][i][1];
2942

    
2943
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2944
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
2945
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
2946
                    
2947
                /* WARNING: do no forget half pels */
2948
                src_x = clip(src_x, -16, s->width);
2949
                if (src_x == s->width)
2950
                    dxy &= ~3;
2951
                src_y = clip(src_y, -16, s->height);
2952
                if (src_y == s->height)
2953
                    dxy &= ~12;
2954
                    
2955
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2956
                if(s->flags&CODEC_FLAG_EMU_EDGE){
2957
                    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8 
2958
                       || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
2959
                        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);
2960
                        ptr= s->edge_emu_buffer;
2961
                    }
2962
                }
2963
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2964
                qpix_op[1][dxy](dest, ptr, s->linesize);
2965

    
2966
                mx += s->mv[dir][i][0]/2;
2967
                my += s->mv[dir][i][1]/2;
2968
            }
2969
        }else{
2970
            for(i=0;i<4;i++) {
2971
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2972
                            ref_picture[0], 0, 0,
2973
                            mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2974
                            s->width, s->height, s->linesize,
2975
                            s->h_edge_pos, s->v_edge_pos,
2976
                            8, 8, pix_op[1],
2977
                            s->mv[dir][i][0], s->mv[dir][i][1]);
2978

    
2979
                mx += s->mv[dir][i][0];
2980
                my += s->mv[dir][i][1];
2981
            }
2982
        }
2983

    
2984
        if(!(s->flags&CODEC_FLAG_GRAY))
2985
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2986
        break;
2987
    case MV_TYPE_FIELD:
2988
        if (s->picture_structure == PICT_FRAME) {
2989
            if(s->quarter_sample){
2990
                for(i=0; i<2; i++){
2991
                    qpel_motion(s, dest_y, dest_cb, dest_cr,
2992
                                1, i, s->field_select[dir][i],
2993
                                ref_picture, pix_op, qpix_op,
2994
                                s->mv[dir][i][0], s->mv[dir][i][1], 8);
2995
                }
2996
            }else{
2997
                /* top field */       
2998
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
2999
                            1, 0, s->field_select[dir][0],
3000
                            ref_picture, pix_op,
3001
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
3002
                /* bottom field */
3003
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3004
                            1, 1, s->field_select[dir][1],
3005
                            ref_picture, pix_op,
3006
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
3007
            }
3008
        } else {
3009
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3010
                ref_picture= s->current_picture_ptr->data;
3011
            } 
3012

    
3013
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3014
                        0, 0, s->field_select[dir][0],
3015
                        ref_picture, pix_op,
3016
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3017
        }
3018
        break;
3019
    case MV_TYPE_16X8:
3020
        for(i=0; i<2; i++){
3021
            uint8_t ** ref2picture;
3022

    
3023
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3024
                ref2picture= ref_picture;
3025
            }else{
3026
                ref2picture= s->current_picture_ptr->data;
3027
            } 
3028

    
3029
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3030
                        0, 0, s->field_select[dir][i],
3031
                        ref2picture, pix_op,
3032
                        s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3033
                
3034
            dest_y += 16*s->linesize;
3035
            dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3036
            dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3037
        }        
3038
        break;
3039
    case MV_TYPE_DMV:
3040
        if(s->picture_structure == PICT_FRAME){
3041
            for(i=0; i<2; i++){
3042
                int j;
3043
                for(j=0; j<2; j++){
3044
                    mpeg_motion(s, dest_y, dest_cb, dest_cr,
3045
                                1, j, j^i,
3046
                                ref_picture, pix_op,
3047
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3048
                }
3049
                pix_op = s->dsp.avg_pixels_tab; 
3050
            }
3051
        }else{
3052
            for(i=0; i<2; i++){
3053
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3054
                            0, 0, s->picture_structure != i+1,
3055
                            ref_picture, pix_op,
3056
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3057

    
3058
                // after put we make avg of the same block
3059
                pix_op=s->dsp.avg_pixels_tab; 
3060

    
3061
                //opposite parity is always in the same frame if this is second field
3062
                if(!s->first_field){
3063
                    ref_picture = s->current_picture_ptr->data;    
3064
                }
3065
            }
3066
        }
3067
    break;
3068
    default: assert(0);
3069
    }
3070
}
3071

    
3072

    
3073
/* put block[] to dest[] */
3074
static inline void put_dct(MpegEncContext *s, 
3075
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3076
{
3077
    s->dct_unquantize_intra(s, block, i, qscale);
3078
    s->dsp.idct_put (dest, line_size, block);
3079
}
3080

    
3081
/* add block[] to dest[] */
3082
static inline void add_dct(MpegEncContext *s, 
3083
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
3084
{
3085
    if (s->block_last_index[i] >= 0) {
3086
        s->dsp.idct_add (dest, line_size, block);
3087
    }
3088
}
3089

    
3090
static inline void add_dequant_dct(MpegEncContext *s, 
3091
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3092
{
3093
    if (s->block_last_index[i] >= 0) {
3094
        s->dct_unquantize_inter(s, block, i, qscale);
3095

    
3096
        s->dsp.idct_add (dest, line_size, block);
3097
    }
3098
}
3099

    
3100
/**
3101
 * cleans dc, ac, coded_block for the current non intra MB
3102
 */
3103
void ff_clean_intra_table_entries(MpegEncContext *s)
3104
{
3105
    int wrap = s->b8_stride;
3106
    int xy = s->block_index[0];
3107
    
3108
    s->dc_val[0][xy           ] = 
3109
    s->dc_val[0][xy + 1       ] = 
3110
    s->dc_val[0][xy     + wrap] =
3111
    s->dc_val[0][xy + 1 + wrap] = 1024;
3112
    /* ac pred */
3113
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
3114
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3115
    if (s->msmpeg4_version>=3) {
3116
        s->coded_block[xy           ] =
3117
        s->coded_block[xy + 1       ] =
3118
        s->coded_block[xy     + wrap] =
3119
        s->coded_block[xy + 1 + wrap] = 0;
3120
    }
3121
    /* chroma */
3122
    wrap = s->mb_stride;
3123
    xy = s->mb_x + s->mb_y * wrap;
3124
    s->dc_val[1][xy] =
3125
    s->dc_val[2][xy] = 1024;
3126
    /* ac pred */
3127
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3128
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3129
    
3130
    s->mbintra_table[xy]= 0;
3131
}
3132

    
3133
/* generic function called after a macroblock has been parsed by the
3134
   decoder or after it has been encoded by the encoder.
3135

3136
   Important variables used:
3137
   s->mb_intra : true if intra macroblock
3138
   s->mv_dir   : motion vector direction
3139
   s->mv_type  : motion vector type
3140
   s->mv       : motion vector
3141
   s->interlaced_dct : true if interlaced dct used (mpeg2)
3142
 */
3143
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64])
3144
{
3145
    int mb_x, mb_y;
3146
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3147
#ifdef HAVE_XVMC
3148
    if(s->avctx->xvmc_acceleration){
3149
        XVMC_decode_mb(s);//xvmc uses pblocks
3150
        return;
3151
    }
3152
#endif
3153

    
3154
    mb_x = s->mb_x;
3155
    mb_y = s->mb_y;
3156

    
3157
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3158
       /* save DCT coefficients */
3159
       int i,j;
3160
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3161
       for(i=0; i<6; i++)
3162
           for(j=0; j<64; j++)
3163
               *dct++ = block[i][s->dsp.idct_permutation[j]];
3164
    }
3165

    
3166
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3167

    
3168
    /* update DC predictors for P macroblocks */
3169
    if (!s->mb_intra) {
3170
        if (s->h263_pred || s->h263_aic) {
3171
            if(s->mbintra_table[mb_xy])
3172
                ff_clean_intra_table_entries(s);
3173
        } else {
3174
            s->last_dc[0] =
3175
            s->last_dc[1] =
3176
            s->last_dc[2] = 128 << s->intra_dc_precision;
3177
        }
3178
    }
3179
    else if (s->h263_pred || s->h263_aic)
3180
        s->mbintra_table[mb_xy]=1;
3181

    
3182
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3183
        uint8_t *dest_y, *dest_cb, *dest_cr;
3184
        int dct_linesize, dct_offset;
3185
        op_pixels_func (*op_pix)[4];
3186
        qpel_mc_func (*op_qpix)[16];
3187
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3188
        const int uvlinesize= s->current_picture.linesize[1];
3189
        const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band;
3190

    
3191
        /* avoid copy if macroblock skipped in last frame too */
3192
        /* skip only during decoding as we might trash the buffers during encoding a bit */
3193
        if(!s->encoding){
3194
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3195
            const int age= s->current_picture.age;
3196

    
3197
            assert(age);
3198

    
3199
            if (s->mb_skiped) {
3200
                s->mb_skiped= 0;
3201
                assert(s->pict_type!=I_TYPE);
3202
 
3203
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
3204
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3205

    
3206
                /* if previous was skipped too, then nothing to do !  */
3207
                if (*mbskip_ptr >= age && s->current_picture.reference){
3208
                    return;
3209
                }
3210
            } else if(!s->current_picture.reference){
3211
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3212
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3213
            } else{
3214
                *mbskip_ptr = 0; /* not skipped */
3215
            }
3216
        }
3217

    
3218
        dct_linesize = linesize << s->interlaced_dct;
3219
        dct_offset =(s->interlaced_dct)? linesize : linesize*8;
3220

    
3221
        if(readable){
3222
            dest_y=  s->dest[0];
3223
            dest_cb= s->dest[1];
3224
            dest_cr= s->dest[2];
3225
        }else{
3226
            dest_y = s->b_scratchpad;
3227
            dest_cb= s->b_scratchpad+16*linesize;
3228
            dest_cr= s->b_scratchpad+32*linesize;
3229
        }
3230
        if (!s->mb_intra) {
3231
            /* motion handling */
3232
            /* decoding or more than one mb_type (MC was allready done otherwise) */
3233
            if(!s->encoding){
3234
                if ((!s->no_rounding) || s->pict_type==B_TYPE){                
3235
                    op_pix = s->dsp.put_pixels_tab;
3236
                    op_qpix= s->dsp.put_qpel_pixels_tab;
3237
                }else{
3238
                    op_pix = s->dsp.put_no_rnd_pixels_tab;
3239
                    op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3240
                }
3241

    
3242
                if (s->mv_dir & MV_DIR_FORWARD) {
3243
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3244
                    op_pix = s->dsp.avg_pixels_tab;
3245
                    op_qpix= s->dsp.avg_qpel_pixels_tab;
3246
                }
3247
                if (s->mv_dir & MV_DIR_BACKWARD) {
3248
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3249
                }
3250
            }
3251

    
3252
            /* skip dequant / idct if we are really late ;) */
3253
            if(s->hurry_up>1) return;
3254

    
3255
            /* add dct residue */
3256
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3257
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3258
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
3259
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
3260
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
3261
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
3262

    
3263
                if(!(s->flags&CODEC_FLAG_GRAY)){
3264
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3265
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3266
                }
3267
            } else if(s->codec_id != CODEC_ID_WMV2){
3268
                add_dct(s, block[0], 0, dest_y, dct_linesize);
3269
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
3270
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
3271
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
3272

    
3273
                if(!(s->flags&CODEC_FLAG_GRAY)){
3274
                    if(s->chroma_y_shift){//Chroma420
3275
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
3276
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
3277
                    }else{
3278
                        //chroma422
3279
                        dct_linesize = uvlinesize << s->interlaced_dct;
3280
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3281

    
3282
                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
3283
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
3284
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
3285
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
3286
                        if(!s->chroma_x_shift){//Chroma444
3287
                            add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
3288
                            add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
3289
                            add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
3290
                            add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
3291
                        }
3292
                    }
3293
                }//fi gray
3294
            }
3295
#ifdef CONFIG_RISKY
3296
            else{
3297
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3298
            }
3299
#endif
3300
        } else {
3301
            /* dct only in intra block */
3302
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3303
                put_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
3304
                put_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
3305
                put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
3306
                put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
3307

    
3308
                if(!(s->flags&CODEC_FLAG_GRAY)){
3309
                    put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3310
                    put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3311
                }
3312
            }else{
3313
                s->dsp.idct_put(dest_y                 , dct_linesize, block[0]);
3314
                s->dsp.idct_put(dest_y              + 8, dct_linesize, block[1]);
3315
                s->dsp.idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
3316
                s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
3317

    
3318
                if(!(s->flags&CODEC_FLAG_GRAY)){
3319
                    if(s->chroma_y_shift){
3320
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3321
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3322
                    }else{
3323

    
3324
                        dct_linesize = uvlinesize << s->interlaced_dct;
3325
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3326

    
3327
                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
3328
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
3329
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
3330
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
3331
                        if(!s->chroma_x_shift){//Chroma444
3332
                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
3333
                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
3334
                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
3335
                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
3336
                        }
3337
                    }
3338
                }//gray
3339
            }
3340
        }
3341
        if(!readable){
3342
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3343
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
3344
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
3345
        }
3346
    }
3347
}
3348

    
3349
#ifdef CONFIG_ENCODERS
3350

    
3351
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3352
{
3353
    static const char tab[64]=
3354
        {3,2,2,1,1,1,1,1,
3355
         1,1,1,1,1,1,1,1,
3356
         1,1,1,1,1,1,1,1,
3357
         0,0,0,0,0,0,0,0,
3358
         0,0,0,0,0,0,0,0,
3359
         0,0,0,0,0,0,0,0,
3360
         0,0,0,0,0,0,0,0,
3361
         0,0,0,0,0,0,0,0};
3362
    int score=0;
3363
    int run=0;
3364
    int i;
3365
    DCTELEM *block= s->block[n];
3366
    const int last_index= s->block_last_index[n];
3367
    int skip_dc;
3368

    
3369
    if(threshold<0){
3370
        skip_dc=0;
3371
        threshold= -threshold;
3372
    }else
3373
        skip_dc=1;
3374

    
3375
    /* are all which we could set to zero are allready zero? */
3376
    if(last_index<=skip_dc - 1) return;
3377

    
3378
    for(i=0; i<=last_index; i++){
3379
        const int j = s->intra_scantable.permutated[i];
3380
        const int level = ABS(block[j]);
3381
        if(level==1){
3382
            if(skip_dc && i==0) continue;
3383
            score+= tab[run];
3384
            run=0;
3385
        }else if(level>1){
3386
            return;
3387
        }else{
3388
            run++;
3389
        }
3390
    }
3391
    if(score >= threshold) return;
3392
    for(i=skip_dc; i<=last_index; i++){
3393
        const int j = s->intra_scantable.permutated[i];
3394
        block[j]=0;
3395
    }
3396
    if(block[0]) s->block_last_index[n]= 0;
3397
    else         s->block_last_index[n]= -1;
3398
}
3399

    
3400
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
3401
{
3402
    int i;
3403
    const int maxlevel= s->max_qcoeff;
3404
    const int minlevel= s->min_qcoeff;
3405
    int overflow=0;
3406
    
3407
    if(s->mb_intra){
3408
        i=1; //skip clipping of intra dc
3409
    }else
3410
        i=0;
3411
    
3412
    for(;i<=last_index; i++){
3413
        const int j= s->intra_scantable.permutated[i];
3414
        int level = block[j];
3415
       
3416
        if     (level>maxlevel){
3417
            level=maxlevel;
3418
            overflow++;
3419
        }else if(level<minlevel){
3420
            level=minlevel;
3421
            overflow++;
3422
        }
3423
        
3424
        block[j]= level;
3425
    }
3426
    
3427
    if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
3428
        av_log(s->avctx, AV_LOG_INFO, "warning, cliping %d dct coefficents to %d..%d\n", overflow, minlevel, maxlevel);
3429
}
3430

    
3431
#endif //CONFIG_ENCODERS
3432

    
3433
/**
3434
 *
3435
 * @param h is the normal height, this will be reduced automatically if needed for the last row
3436
 */
3437
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3438
    if (s->avctx->draw_horiz_band) {
3439
        AVFrame *src;
3440
        int offset[4];
3441
        
3442
        if(s->picture_structure != PICT_FRAME){
3443
            h <<= 1;
3444
            y <<= 1;
3445
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3446
        }
3447

    
3448
        h= FFMIN(h, s->height - y);
3449

    
3450
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) 
3451
            src= (AVFrame*)s->current_picture_ptr;
3452
        else if(s->last_picture_ptr)
3453
            src= (AVFrame*)s->last_picture_ptr;
3454
        else
3455
            return;
3456
            
3457
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3458
            offset[0]=
3459
            offset[1]=
3460
            offset[2]=
3461
            offset[3]= 0;
3462
        }else{
3463
            offset[0]= y * s->linesize;;
3464
            offset[1]= 
3465
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
3466
            offset[3]= 0;
3467
        }
3468

    
3469
        emms_c();
3470

    
3471
        s->avctx->draw_horiz_band(s->avctx, src, offset,
3472
                                  y, s->picture_structure, h);
3473
    }
3474
}
3475

    
3476
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3477
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3478
    const int uvlinesize= s->current_picture.linesize[1];
3479
        
3480
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
3481
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
3482
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
3483
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3484
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3485
    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;
3486
    //block_index is not used by mpeg2, so it is not affected by chroma_format
3487

    
3488
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << 4);
3489
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (4 - s->chroma_x_shift));
3490
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (4 - s->chroma_x_shift));
3491

    
3492
    if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
3493
    {
3494
        s->dest[0] += s->mb_y *   linesize << 4;
3495
        s->dest[1] += s->mb_y * uvlinesize << (4 - s->chroma_y_shift);
3496
        s->dest[2] += s->mb_y * uvlinesize << (4 - s->chroma_y_shift);
3497
    }
3498
}
3499

    
3500
#ifdef CONFIG_ENCODERS
3501

    
3502
static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
3503
    int x, y;
3504
//FIXME optimize
3505
    for(y=0; y<8; y++){
3506
        for(x=0; x<8; x++){
3507
            int x2, y2;
3508
            int sum=0;
3509
            int sqr=0;
3510
            int count=0;
3511

    
3512
            for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
3513
                for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
3514
                    int v= ptr[x2 + y2*stride];
3515
                    sum += v;
3516
                    sqr += v*v;
3517
                    count++;
3518
                }
3519
            }
3520
            weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
3521
        }
3522
    }
3523
}
3524

    
3525
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
3526
{
3527
    int16_t weight[6][64];
3528
    DCTELEM orig[6][64];
3529
    const int mb_x= s->mb_x;
3530
    const int mb_y= s->mb_y;
3531
    int i;
3532
    int skip_dct[6];
3533
    int dct_offset   = s->linesize*8; //default for progressive frames
3534
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3535
    int wrap_y, wrap_c;
3536
    
3537
    for(i=0; i<6; i++) skip_dct[i]=0;
3538
    
3539
    if(s->adaptive_quant){
3540
        const int last_qp= s->qscale;
3541
        const int mb_xy= mb_x + mb_y*s->mb_stride;
3542

    
3543
        s->lambda= s->lambda_table[mb_xy];
3544
        update_qscale(s);
3545
    
3546
        if(!(s->flags&CODEC_FLAG_QP_RD)){
3547
            s->dquant= s->qscale - last_qp;
3548

    
3549
            if(s->out_format==FMT_H263){
3550
                s->dquant= clip(s->dquant, -2, 2); //FIXME RD
3551
            
3552
                if(s->codec_id==CODEC_ID_MPEG4){        
3553
                    if(!s->mb_intra){
3554
                        if(s->pict_type == B_TYPE){
3555
                            if(s->dquant&1) 
3556
                                s->dquant= (s->dquant/2)*2;
3557
                            if(s->mv_dir&MV_DIRECT)
3558
                                s->dquant= 0;
3559
                        }
3560
                        if(s->mv_type==MV_TYPE_8X8)
3561
                            s->dquant=0;
3562
                    }
3563
                }
3564
            }
3565
        }
3566
        ff_set_qscale(s, last_qp + s->dquant);
3567
    }else if(s->flags&CODEC_FLAG_QP_RD)
3568
        ff_set_qscale(s, s->qscale + s->dquant);
3569

    
3570
    wrap_y = s->linesize;
3571
    wrap_c = s->uvlinesize;
3572
    ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
3573
    ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
3574
    ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3575

    
3576
    if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
3577
        uint8_t *ebuf= s->edge_emu_buffer + 32;
3578
        ff_emulated_edge_mc(ebuf            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
3579
        ptr_y= ebuf;
3580
        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);
3581
        ptr_cb= ebuf+18*wrap_y;
3582
        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);
3583
        ptr_cr= ebuf+18*wrap_y+8;
3584
    }
3585

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

    
3590
            s->interlaced_dct=0;
3591
            progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8) 
3592
                              +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
3593

    
3594
            if(progressive_score > 0){
3595
                interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8) 
3596
                                  +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
3597
                if(progressive_score > interlaced_score){
3598
                    s->interlaced_dct=1;
3599
            
3600
                    dct_offset= wrap_y;
3601
                    wrap_y<<=1;
3602
                }
3603
            }
3604
        }
3605
        
3606
        s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
3607
        s->dsp.get_pixels(s->block[1], ptr_y              + 8, wrap_y);
3608
        s->dsp.get_pixels(s->block[2], ptr_y + dct_offset    , wrap_y);
3609
        s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
3610

    
3611
        if(s->flags&CODEC_FLAG_GRAY){
3612
            skip_dct[4]= 1;
3613
            skip_dct[5]= 1;
3614
        }else{
3615
            s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
3616
            s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
3617
        }
3618
    }else{
3619
        op_pixels_func (*op_pix)[4];
3620
        qpel_mc_func (*op_qpix)[16];
3621
        uint8_t *dest_y, *dest_cb, *dest_cr;
3622

    
3623
        dest_y  = s->dest[0];
3624
        dest_cb = s->dest[1];
3625
        dest_cr = s->dest[2];
3626

    
3627
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
3628
            op_pix = s->dsp.put_pixels_tab;
3629
            op_qpix= s->dsp.put_qpel_pixels_tab;
3630
        }else{
3631
            op_pix = s->dsp.put_no_rnd_pixels_tab;
3632
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3633
        }
3634

    
3635
        if (s->mv_dir & MV_DIR_FORWARD) {
3636
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3637
            op_pix = s->dsp.avg_pixels_tab;
3638
            op_qpix= s->dsp.avg_qpel_pixels_tab;
3639
        }
3640
        if (s->mv_dir & MV_DIR_BACKWARD) {
3641
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3642
        }
3643

    
3644
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3645
            int progressive_score, interlaced_score;
3646

    
3647
            s->interlaced_dct=0;
3648
            progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8) 
3649
                              +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
3650
            
3651
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
3652

    
3653
            if(progressive_score>0){
3654
                interlaced_score = s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y*2, 8) 
3655
                                  +s->dsp.ildct_cmp[0](s, dest_y + wrap_y  , ptr_y + wrap_y  , wrap_y*2, 8);
3656
            
3657
                if(progressive_score > interlaced_score){
3658
                    s->interlaced_dct=1;
3659
            
3660
                    dct_offset= wrap_y;
3661
                    wrap_y<<=1;
3662
                }
3663
            }
3664
        }
3665
        
3666
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
3667
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
3668
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
3669
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
3670
        
3671
        if(s->flags&CODEC_FLAG_GRAY){
3672
            skip_dct[4]= 1;
3673
            skip_dct[5]= 1;
3674
        }else{
3675
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
3676
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
3677
        }
3678
        /* pre quantization */         
3679
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
3680
            //FIXME optimize
3681
            if(s->dsp.sad[1](NULL, ptr_y               , dest_y               , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
3682
            if(s->dsp.sad[1](NULL, ptr_y            + 8, dest_y            + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
3683
            if(s->dsp.sad[1](NULL, ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
3684
            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;
3685
            if(s->dsp.sad[1](NULL, ptr_cb              , dest_cb              , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
3686
            if(s->dsp.sad[1](NULL, ptr_cr              , dest_cr              , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
3687
        }
3688
    }
3689

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

    
3729
        if(s->flags & CODEC_FLAG_CBP_RD){
3730
            for(i=0;i<6;i++) {
3731
                if(s->block_last_index[i] == -1)
3732
                    s->coded_score[i]= INT_MAX/256;
3733
            }
3734
        }
3735
    }
3736

    
3737
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
3738
        s->block_last_index[4]=
3739
        s->block_last_index[5]= 0;
3740
        s->block[4][0]=
3741
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
3742
    }
3743

    
3744
    //non c quantize code returns incorrect block_last_index FIXME
3745
    if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
3746
        for(i=0; i<6; i++){
3747
            int j;
3748
            if(s->block_last_index[i]>0){
3749
                for(j=63; j>0; j--){
3750
                    if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
3751
                }
3752
                s->block_last_index[i]= j;
3753
            }
3754
        }
3755
    }
3756

    
3757
    /* huffman encode */
3758
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
3759
    case CODEC_ID_MPEG1VIDEO:
3760
    case CODEC_ID_MPEG2VIDEO:
3761
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
3762
#ifdef CONFIG_RISKY
3763
    case CODEC_ID_MPEG4:
3764
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3765
    case CODEC_ID_MSMPEG4V2:
3766
    case CODEC_ID_MSMPEG4V3:
3767
    case CODEC_ID_WMV1:
3768
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3769
    case CODEC_ID_WMV2:
3770
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
3771
    case CODEC_ID_H263:
3772
    case CODEC_ID_H263P:
3773
    case CODEC_ID_FLV1:
3774
    case CODEC_ID_RV10:
3775
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
3776
#endif
3777
    case CODEC_ID_MJPEG:
3778
        mjpeg_encode_mb(s, s->block); break;
3779
    default:
3780
        assert(0);
3781
    }
3782
}
3783

    
3784
#endif //CONFIG_ENCODERS
3785

    
3786
void ff_mpeg_flush(AVCodecContext *avctx){
3787
    int i;
3788
    MpegEncContext *s = avctx->priv_data;
3789
    
3790
    if(s==NULL || s->picture==NULL) 
3791
        return;
3792
    
3793
    for(i=0; i<MAX_PICTURE_COUNT; i++){
3794
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
3795
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
3796
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
3797
    }
3798
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
3799
    
3800
    s->parse_context.state= -1;
3801
    s->parse_context.frame_start_found= 0;
3802
    s->parse_context.overread= 0;
3803
    s->parse_context.overread_index= 0;
3804
    s->parse_context.index= 0;
3805
    s->parse_context.last_index= 0;
3806
    s->bitstream_buffer_size=0;
3807
}
3808

    
3809
#ifdef CONFIG_ENCODERS
3810
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
3811
{
3812
    const uint16_t *srcw= (uint16_t*)src;
3813
    int words= length>>4;
3814
    int bits= length&15;
3815
    int i;
3816

    
3817
    if(length==0) return;
3818
    
3819
    if(words < 16){
3820
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
3821
    }else if(put_bits_count(pb)&7){
3822
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
3823
    }else{
3824
        for(i=0; put_bits_count(pb)&31; i++)
3825
            put_bits(pb, 8, src[i]);
3826
        flush_put_bits(pb);
3827
        memcpy(pbBufPtr(pb), src+i, 2*words-i);
3828
        skip_put_bytes(pb, 2*words-i);
3829
    }
3830
        
3831
    put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
3832
}
3833

    
3834
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
3835
    int i;
3836

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

    
3839
    /* mpeg1 */
3840
    d->mb_skip_run= s->mb_skip_run;
3841
    for(i=0; i<3; i++)
3842
        d->last_dc[i]= s->last_dc[i];
3843
    
3844
    /* statistics */
3845
    d->mv_bits= s->mv_bits;
3846
    d->i_tex_bits= s->i_tex_bits;
3847
    d->p_tex_bits= s->p_tex_bits;
3848
    d->i_count= s->i_count;
3849
    d->f_count= s->f_count;
3850
    d->b_count= s->b_count;
3851
    d->skip_count= s->skip_count;
3852
    d->misc_bits= s->misc_bits;
3853
    d->last_bits= 0;
3854

    
3855
    d->mb_skiped= 0;
3856
    d->qscale= s->qscale;
3857
    d->dquant= s->dquant;
3858
}
3859

    
3860
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
3861
    int i;
3862

    
3863
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
3864
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
3865
    
3866
    /* mpeg1 */
3867
    d->mb_skip_run= s->mb_skip_run;
3868
    for(i=0; i<3; i++)
3869
        d->last_dc[i]= s->last_dc[i];
3870
    
3871
    /* statistics */
3872
    d->mv_bits= s->mv_bits;
3873
    d->i_tex_bits= s->i_tex_bits;
3874
    d->p_tex_bits= s->p_tex_bits;
3875
    d->i_count= s->i_count;
3876
    d->f_count= s->f_count;
3877
    d->b_count= s->b_count;
3878
    d->skip_count= s->skip_count;
3879
    d->misc_bits= s->misc_bits;
3880

    
3881
    d->mb_intra= s->mb_intra;
3882
    d->mb_skiped= s->mb_skiped;
3883
    d->mv_type= s->mv_type;
3884
    d->mv_dir= s->mv_dir;
3885
    d->pb= s->pb;
3886
    if(s->data_partitioning){
3887
        d->pb2= s->pb2;
3888
        d->tex_pb= s->tex_pb;
3889
    }
3890
    d->block= s->block;
3891
    for(i=0; i<6; i++)
3892
        d->block_last_index[i]= s->block_last_index[i];
3893
    d->interlaced_dct= s->interlaced_dct;
3894
    d->qscale= s->qscale;
3895
}
3896

    
3897
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
3898
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
3899
                           int *dmin, int *next_block, int motion_x, int motion_y)
3900
{
3901
    int score;
3902
    uint8_t *dest_backup[3];
3903
    
3904
    copy_context_before_encode(s, backup, type);
3905

    
3906
    s->block= s->blocks[*next_block];
3907
    s->pb= pb[*next_block];
3908
    if(s->data_partitioning){
3909
        s->pb2   = pb2   [*next_block];
3910
        s->tex_pb= tex_pb[*next_block];
3911
    }
3912
    
3913
    if(*next_block){
3914
        memcpy(dest_backup, s->dest, sizeof(s->dest));
3915
        s->dest[0] = s->rd_scratchpad;
3916
        s->dest[1] = s->rd_scratchpad + 16*s->linesize;
3917
        s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
3918
        assert(s->linesize >= 32); //FIXME
3919
    }
3920

    
3921
    encode_mb(s, motion_x, motion_y);
3922
    
3923
    score= put_bits_count(&s->pb);
3924
    if(s->data_partitioning){
3925
        score+= put_bits_count(&s->pb2);
3926
        score+= put_bits_count(&s->tex_pb);
3927
    }
3928
   
3929
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
3930
        MPV_decode_mb(s, s->block);
3931

    
3932
        score *= s->lambda2;
3933
        score += sse_mb(s) << FF_LAMBDA_SHIFT;
3934
    }
3935
    
3936
    if(*next_block){
3937
        memcpy(s->dest, dest_backup, sizeof(s->dest));
3938
    }
3939

    
3940
    if(score<*dmin){
3941
        *dmin= score;
3942
        *next_block^=1;
3943

    
3944
        copy_context_after_encode(best, s, type);
3945
    }
3946
}
3947
                
3948
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
3949
    uint32_t *sq = squareTbl + 256;
3950
    int acc=0;
3951
    int x,y;
3952
    
3953
    if(w==16 && h==16) 
3954
        return s->dsp.sse[0](NULL, src1, src2, stride, 16);
3955
    else if(w==8 && h==8)
3956
        return s->dsp.sse[1](NULL, src1, src2, stride, 8);
3957
    
3958
    for(y=0; y<h; y++){
3959
        for(x=0; x<w; x++){
3960
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
3961
        } 
3962
    }
3963
    
3964
    assert(acc>=0);
3965
    
3966
    return acc;
3967
}
3968

    
3969
static int sse_mb(MpegEncContext *s){
3970
    int w= 16;
3971
    int h= 16;
3972

    
3973
    if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3974
    if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3975

    
3976
    if(w==16 && h==16)
3977
      if(s->avctx->mb_cmp == FF_CMP_NSSE){
3978
        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)
3979
               +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)
3980
               +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);
3981
      }else{
3982
        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)
3983
               +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)
3984
               +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);
3985
      }
3986
    else
3987
        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)
3988
               +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)
3989
               +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);
3990
}
3991

    
3992
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
3993
    MpegEncContext *s= arg;
3994

    
3995
    
3996
    s->me.pre_pass=1;
3997
    s->me.dia_size= s->avctx->pre_dia_size;
3998
    s->first_slice_line=1;
3999
    for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
4000
        for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
4001
            ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4002
        }
4003
        s->first_slice_line=0;
4004
    }
4005
    
4006
    s->me.pre_pass=0;
4007
    
4008
    return 0;
4009
}
4010

    
4011
static int estimate_motion_thread(AVCodecContext *c, void *arg){
4012
    MpegEncContext *s= arg;
4013

    
4014
    s->me.dia_size= s->avctx->dia_size;
4015
    s->first_slice_line=1;
4016
    for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4017
        s->mb_x=0; //for block init below
4018
        ff_init_block_index(s);
4019
        for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
4020
            s->block_index[0]+=2;
4021
            s->block_index[1]+=2;
4022
            s->block_index[2]+=2;
4023
            s->block_index[3]+=2;
4024
            
4025
            /* compute motion vector & mb_type and store in context */
4026
            if(s->pict_type==B_TYPE)
4027
                ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
4028
            else
4029
                ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4030
        }
4031
        s->first_slice_line=0;
4032
    }
4033
    return 0;
4034
}
4035

    
4036
static int mb_var_thread(AVCodecContext *c, void *arg){
4037
    MpegEncContext *s= arg;
4038
    int mb_x, mb_y;
4039

    
4040
    for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4041
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4042
            int xx = mb_x * 16;
4043
            int yy = mb_y * 16;
4044
            uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
4045
            int varc;
4046
            int sum = s->dsp.pix_sum(pix, s->linesize);
4047
    
4048
            varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
4049

    
4050
            s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
4051
            s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
4052
            s->me.mb_var_sum_temp    += varc;
4053
        }
4054
    }
4055
    return 0;
4056
}
4057

    
4058
static void write_slice_end(MpegEncContext *s){
4059
    if(s->codec_id==CODEC_ID_MPEG4){
4060
        if(s->partitioned_frame){
4061
            ff_mpeg4_merge_partitions(s);
4062
        }
4063
    
4064
        ff_mpeg4_stuffing(&s->pb);
4065
    }else if(s->out_format == FMT_MJPEG){
4066
        ff_mjpeg_stuffing(&s->pb);
4067
    }
4068

    
4069
    align_put_bits(&s->pb);
4070
    flush_put_bits(&s->pb);
4071
}
4072

    
4073
static int encode_thread(AVCodecContext *c, void *arg){
4074
    MpegEncContext *s= arg;
4075
    int mb_x, mb_y, pdif = 0;
4076
    int i, j;
4077
    MpegEncContext best_s, backup_s;
4078
    uint8_t bit_buf[2][3000];
4079
    uint8_t bit_buf2[2][3000];
4080
    uint8_t bit_buf_tex[2][3000];
4081
    PutBitContext pb[2], pb2[2], tex_pb[2];
4082
//printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4083

    
4084
    for(i=0; i<2; i++){
4085
        init_put_bits(&pb    [i], bit_buf    [i], 3000);
4086
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000);
4087
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000);
4088
    }
4089

    
4090
    s->last_bits= put_bits_count(&s->pb);
4091
    s->mv_bits=0;
4092
    s->misc_bits=0;
4093
    s->i_tex_bits=0;
4094
    s->p_tex_bits=0;
4095
    s->i_count=0;
4096
    s->f_count=0;
4097
    s->b_count=0;
4098
    s->skip_count=0;
4099

    
4100
    for(i=0; i<3; i++){
4101
        /* init last dc values */
4102
        /* note: quant matrix value (8) is implied here */
4103
        s->last_dc[i] = 128 << s->intra_dc_precision;
4104
        
4105
        s->current_picture_ptr->error[i] = 0;
4106
    }
4107
    s->mb_skip_run = 0;
4108
    memset(s->last_mv, 0, sizeof(s->last_mv));
4109
     
4110
    s->last_mv_dir = 0;
4111

    
4112
#ifdef CONFIG_RISKY
4113
    switch(s->codec_id){
4114
    case CODEC_ID_H263:
4115
    case CODEC_ID_H263P:
4116
    case CODEC_ID_FLV1:
4117
        s->gob_index = ff_h263_get_gob_height(s);
4118
        break;
4119
    case CODEC_ID_MPEG4:
4120
        if(s->partitioned_frame)
4121
            ff_mpeg4_init_partitions(s);
4122
        break;
4123
    }
4124
#endif
4125

    
4126
    s->resync_mb_x=0;
4127
    s->resync_mb_y=0; 
4128
    s->first_slice_line = 1;
4129
    s->ptr_lastgob = s->pb.buf;
4130
    for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4131
//    printf("row %d at %X\n", s->mb_y, (int)s);
4132
        s->mb_x=0;
4133
        s->mb_y= mb_y;
4134

    
4135
        ff_set_qscale(s, s->qscale);
4136
        ff_init_block_index(s);
4137
        
4138
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4139
            const int xy= mb_y*s->mb_stride + mb_x;
4140
            int mb_type= s->mb_type[xy];
4141
//            int d;
4142
            int dmin= INT_MAX;
4143
            int dir;
4144

    
4145
            s->mb_x = mb_x;
4146
            ff_update_block_index(s);
4147

    
4148
            /* write gob / video packet header  */
4149
#ifdef CONFIG_RISKY
4150
            if(s->rtp_mode){
4151
                int current_packet_size, is_gob_start;
4152
                
4153
                current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
4154
                
4155
                is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0; 
4156
                
4157
                if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
4158
                
4159
                switch(s->codec_id){
4160
                case CODEC_ID_H263:
4161
                case CODEC_ID_H263P:
4162
                    if(!s->h263_slice_structured)
4163
                        if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
4164
                    break;
4165
                case CODEC_ID_MPEG2VIDEO:
4166
                    if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
4167
                case CODEC_ID_MPEG1VIDEO:
4168
                    if(s->mb_skip_run) is_gob_start=0;
4169
                    break;
4170
                }
4171

    
4172
                if(is_gob_start){
4173
                    if(s->start_mb_y != mb_y || mb_x!=0){
4174
                        write_slice_end(s);
4175

    
4176
                        if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
4177
                            ff_mpeg4_init_partitions(s);
4178
                        }
4179
                    }
4180
                
4181
                    assert((put_bits_count(&s->pb)&7) == 0);
4182
                    current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4183
                    
4184
                    if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
4185
                        int r= put_bits_count(&s->pb)/8 + s->picture_number + s->codec_id + s->mb_x + s->mb_y;
4186
                        int d= 100 / s->avctx->error_rate;
4187
                        if(r % d == 0){
4188
                            current_packet_size=0;
4189
#ifndef ALT_BITSTREAM_WRITER
4190
                            s->pb.buf_ptr= s->ptr_lastgob;
4191
#endif
4192
                            assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
4193
                        }
4194
                    }
4195
        
4196
                    if (s->avctx->rtp_callback)
4197
                        s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, 0);
4198
                    
4199
                    switch(s->codec_id){
4200
                    case CODEC_ID_MPEG4:
4201
                        ff_mpeg4_encode_video_packet_header(s);
4202
                        ff_mpeg4_clean_buffers(s);
4203
                    break;
4204
                    case CODEC_ID_MPEG1VIDEO:
4205
                    case CODEC_ID_MPEG2VIDEO:
4206
                        ff_mpeg1_encode_slice_header(s);
4207
                        ff_mpeg1_clean_buffers(s);
4208
                    break;
4209
                    case CODEC_ID_H263:
4210
                    case CODEC_ID_H263P:
4211
                        h263_encode_gob_header(s, mb_y);                       
4212
                    break;
4213
                    }
4214

    
4215
                    if(s->flags&CODEC_FLAG_PASS1){
4216
                        int bits= put_bits_count(&s->pb);
4217
                        s->misc_bits+= bits - s->last_bits;
4218
                        s->last_bits= bits;
4219
                    }
4220
    
4221
                    s->ptr_lastgob += current_packet_size;
4222
                    s->first_slice_line=1;
4223
                    s->resync_mb_x=mb_x;
4224
                    s->resync_mb_y=mb_y;
4225
                }
4226
            }
4227
#endif
4228

    
4229
            if(  (s->resync_mb_x   == s->mb_x)
4230
               && s->resync_mb_y+1 == s->mb_y){
4231
                s->first_slice_line=0; 
4232
            }
4233

    
4234
            s->mb_skiped=0;
4235
            s->dquant=0; //only for QP_RD
4236

    
4237
            if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD
4238
                int next_block=0;
4239
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
4240

    
4241
                copy_context_before_encode(&backup_s, s, -1);
4242
                backup_s.pb= s->pb;
4243
                best_s.data_partitioning= s->data_partitioning;
4244
                best_s.partitioned_frame= s->partitioned_frame;
4245
                if(s->data_partitioning){
4246
                    backup_s.pb2= s->pb2;
4247
                    backup_s.tex_pb= s->tex_pb;
4248
                }
4249

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

    
4386
                if(s->flags & CODEC_FLAG_QP_RD){
4387
                    if(best_s.mv_type==MV_TYPE_16X16 && !(best_s.mv_dir&MV_DIRECT)){
4388
                        const int last_qp= backup_s.qscale;
4389
                        int dquant, dir, qp, dc[6];
4390
                        DCTELEM ac[6][16];
4391
                        const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
4392
                        
4393
                        assert(backup_s.dquant == 0);
4394

    
4395
                        //FIXME intra
4396
                        s->mv_dir= best_s.mv_dir;
4397
                        s->mv_type = MV_TYPE_16X16;
4398
                        s->mb_intra= best_s.mb_intra;
4399
                        s->mv[0][0][0] = best_s.mv[0][0][0];
4400
                        s->mv[0][0][1] = best_s.mv[0][0][1];
4401
                        s->mv[1][0][0] = best_s.mv[1][0][0];
4402
                        s->mv[1][0][1] = best_s.mv[1][0][1];
4403
                        
4404
                        dir= s->pict_type == B_TYPE ? 2 : 1;
4405
                        if(last_qp + dir > s->avctx->qmax) dir= -dir;
4406
                        for(dquant= dir; dquant<=2 && dquant>=-2; dquant += dir){
4407
                            qp= last_qp + dquant;
4408
                            if(qp < s->avctx->qmin || qp > s->avctx->qmax)
4409
                                break;
4410
                            backup_s.dquant= dquant;
4411
                            if(s->mb_intra && s->dc_val[0]){
4412
                                for(i=0; i<6; i++){
4413
                                    dc[i]= s->dc_val[0][ s->block_index[i] ];
4414
                                    memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
4415
                                }
4416
                            }
4417

    
4418
                            encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb, 
4419
                                         &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
4420
                            if(best_s.qscale != qp){
4421
                                if(s->mb_intra && s->dc_val[0]){
4422
                                    for(i=0; i<6; i++){
4423
                                        s->dc_val[0][ s->block_index[i] ]= dc[i];
4424
                                        memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
4425
                                    }
4426
                                }
4427
                                if(dir > 0 && dquant==dir){
4428
                                    dquant= 0;
4429
                                    dir= -dir;
4430
                                }else
4431
                                    break;
4432
                            }
4433
                        }
4434
                        qp= best_s.qscale;
4435
                        s->current_picture.qscale_table[xy]= qp;
4436
                    }
4437
                }
4438

    
4439
                copy_context_after_encode(s, &best_s, -1);
4440
                
4441
                pb_bits_count= put_bits_count(&s->pb);
4442
                flush_put_bits(&s->pb);
4443
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
4444
                s->pb= backup_s.pb;
4445
                
4446
                if(s->data_partitioning){
4447
                    pb2_bits_count= put_bits_count(&s->pb2);
4448
                    flush_put_bits(&s->pb2);
4449
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
4450
                    s->pb2= backup_s.pb2;
4451
                    
4452
                    tex_pb_bits_count= put_bits_count(&s->tex_pb);
4453
                    flush_put_bits(&s->tex_pb);
4454
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
4455
                    s->tex_pb= backup_s.tex_pb;
4456
                }
4457
                s->last_bits= put_bits_count(&s->pb);
4458
               
4459
#ifdef CONFIG_RISKY
4460
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4461
                    ff_h263_update_motion_val(s);
4462
#endif
4463
        
4464
                if(next_block==0){ //FIXME 16 vs linesize16
4465
                    s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad                     , s->linesize  ,16);
4466
                    s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize    , s->uvlinesize, 8);
4467
                    s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
4468
                }
4469

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

    
4583
                encode_mb(s, motion_x, motion_y);
4584

    
4585
                // RAL: Update last macrobloc type
4586
                s->last_mv_dir = s->mv_dir;
4587
            
4588
#ifdef CONFIG_RISKY
4589
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4590
                    ff_h263_update_motion_val(s);
4591
#endif
4592
                
4593
                MPV_decode_mb(s, s->block);
4594
            }
4595

    
4596
            /* clean the MV table in IPS frames for direct mode in B frames */
4597
            if(s->mb_intra /* && I,P,S_TYPE */){
4598
                s->p_mv_table[xy][0]=0;
4599
                s->p_mv_table[xy][1]=0;
4600
            }
4601
            
4602
            if(s->flags&CODEC_FLAG_PSNR){
4603
                int w= 16;
4604
                int h= 16;
4605

    
4606
                if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4607
                if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4608

    
4609
                s->current_picture_ptr->error[0] += sse(
4610
                    s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
4611
                    s->dest[0], w, h, s->linesize);
4612
                s->current_picture_ptr->error[1] += sse(
4613
                    s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
4614
                    s->dest[1], w>>1, h>>1, s->uvlinesize);
4615
                s->current_picture_ptr->error[2] += sse(
4616
                    s, s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
4617
                    s->dest[2], w>>1, h>>1, s->uvlinesize);
4618
            }
4619
            if(s->loop_filter)
4620
                ff_h263_loop_filter(s);
4621
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
4622
        }
4623
    }
4624

    
4625
#ifdef CONFIG_RISKY
4626
    //not beautifull here but we must write it before flushing so it has to be here
4627
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
4628
        msmpeg4_encode_ext_header(s);
4629
#endif
4630

    
4631
    write_slice_end(s);
4632

    
4633
    /* Send the last GOB if RTP */    
4634
    if (s->avctx->rtp_callback) {
4635
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
4636
        /* Call the RTP callback to send the last GOB */
4637
        emms_c();
4638
        s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, 0);
4639
    }
4640

    
4641
    return 0;
4642
}
4643

    
4644
#define MERGE(field) dst->field += src->field; src->field=0