Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ e4cb187d

History | View | Annotate | Download (213 KB)

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

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

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

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

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

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

    
74

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

    
78
//#define DEBUG
79

    
80

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
255
#endif //CONFIG_ENCODERS
256

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

    
270
    return 0;
271
}
272

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
550
    s->picture_in_gop_number = 0;
551

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
754
    s->context_initialized = 1;
755

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

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

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

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

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

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

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

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

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

    
855
#ifdef CONFIG_ENCODERS
856

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

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

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

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

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

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

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

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

    
950
    if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
951
        av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
952
        return -1;
953
    }
954
    
955
    if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
956
        av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
957
        return -1;
958
    }
959

    
960
    if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN)) 
961
       && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
962
        av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
963
        return -1;
964
    }
965
        
966
    if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
967
        av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n");
968
        return -1;
969
    }
970
        
971
    if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
972
        av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
973
        return -1;
974
    }
975

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

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

    
1027
    av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1028
    s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1029

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

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

    
1161
    s->encoding = 1;
1162

    
1163
    /* init */
1164
    if (MPV_common_init(s) < 0)
1165
        return -1;
1166

    
1167
    if(s->modified_quant)
1168
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1169
    s->progressive_frame= 
1170
    s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1171
    s->quant_precision=5;
1172
    
1173
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1174
    
1175
#ifdef CONFIG_ENCODERS
1176
#ifdef CONFIG_RISKY
1177
    if (s->out_format == FMT_H263)
1178
        h263_encode_init(s);
1179
    if(s->msmpeg4_version)
1180
        ff_msmpeg4_encode_init(s);
1181
#endif
1182
    if (s->out_format == FMT_MPEG1)
1183
        ff_mpeg1_encode_init(s);
1184
#endif
1185

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

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

    
1217
    if(ff_rate_control_init(s) < 0)
1218
        return -1;
1219
    
1220
    return 0;
1221
}
1222

    
1223
int MPV_encode_end(AVCodecContext *avctx)
1224
{
1225
    MpegEncContext *s = avctx->priv_data;
1226

    
1227
#ifdef STATS
1228
    print_stats();
1229
#endif
1230

    
1231
    ff_rate_control_uninit(s);
1232

    
1233
    MPV_common_end(s);
1234
    if (s->out_format == FMT_MJPEG)
1235
        mjpeg_close(s);
1236

    
1237
    av_freep(&avctx->extradata);
1238
      
1239
    return 0;
1240
}
1241

    
1242
#endif //CONFIG_ENCODERS
1243

    
1244
void init_rl(RLTable *rl)
1245
{
1246
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1247
    uint8_t index_run[MAX_RUN+1];
1248
    int last, run, level, start, end, i;
1249

    
1250
    /* compute max_level[], max_run[] and index_run[] */
1251
    for(last=0;last<2;last++) {
1252
        if (last == 0) {
1253
            start = 0;
1254
            end = rl->last;
1255
        } else {
1256
            start = rl->last;
1257
            end = rl->n;
1258
        }
1259

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

    
1282
/* draw the edges of width 'w' of an image of size width, height */
1283
//FIXME check that this is ok for mpeg4 interlaced
1284
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1285
{
1286
    uint8_t *ptr, *last_line;
1287
    int i;
1288

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

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

    
1327
    assert(0);
1328
    return -1;
1329
}
1330

    
1331
static void update_noise_reduction(MpegEncContext *s){
1332
    int intra, i;
1333

    
1334
    for(intra=0; intra<2; intra++){
1335
        if(s->dct_count[intra] > (1<<16)){
1336
            for(i=0; i<64; i++){
1337
                s->dct_error_sum[intra][i] >>=1;
1338
            }
1339
            s->dct_count[intra] >>= 1;
1340
        }
1341
        
1342
        for(i=0; i<64; i++){
1343
            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);
1344
        }
1345
    }
1346
}
1347

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

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

    
1359
    /* mark&release old frames */
1360
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1361
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1362

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

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

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

    
1392
        pic->coded_picture_number= s->coded_picture_number++;
1393
        
1394
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1395
            return -1;
1396

    
1397
        s->current_picture_ptr= (Picture*)pic;
1398
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1399
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1400
    }
1401

    
1402
    s->current_picture_ptr->pict_type= s->pict_type;
1403
//    if(s->flags && CODEC_FLAG_QSCALE) 
1404
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1405
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1406

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

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

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

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

    
1461
    if(s->dct_error_sum){
1462
        assert(s->avctx->noise_reduction && s->encoding);
1463

    
1464
        update_noise_reduction(s);
1465
    }
1466
        
1467
#ifdef HAVE_XVMC
1468
    if(s->avctx->xvmc_acceleration)
1469
        return XVMC_field_start(s, avctx);
1470
#endif
1471
    return 0;
1472
}
1473

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

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

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

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

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

    
1605
/**
1606
 * prints debuging info for the given picture.
1607
 */
1608
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1609

    
1610
    if(!pict || !pict->mb_type) return;
1611

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

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

    
1696
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1697
        for(i=0; i<3; i++){
1698
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*s->height:pict->linesize[i]*s->height >> v_chroma_shift);
1699
            pict->data[i]= s->visualization_buffer[i];
1700
        }
1701
        pict->type= FF_BUFFER_TYPE_COPY;
1702
        ptr= pict->data[0];
1703

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

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

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

    
1807
                    u*= 0x0101010101010101ULL;
1808
                    v*= 0x0101010101010101ULL;
1809
                    for(y=0; y<8; y++){
1810
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1811
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1812
                    }
1813

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

    
1834
#ifdef CONFIG_ENCODERS
1835

    
1836
static int get_sae(uint8_t *src, int ref, int stride){
1837
    int x,y;
1838
    int acc=0;
1839
    
1840
    for(y=0; y<16; y++){
1841
        for(x=0; x<16; x++){
1842
            acc+= ABS(src[x+y*stride] - ref);
1843
        }
1844
    }
1845
    
1846
    return acc;
1847
}
1848

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

    
1869

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

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

    
1899
        pic= (AVFrame*)&s->picture[i];
1900
        pic->reference= 3;
1901

    
1902
        alloc_picture(s, (Picture*)pic, 0);
1903

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

    
1955
    return 0;
1956
}
1957

    
1958
static void select_input_picture(MpegEncContext *s){
1959
    int i;
1960

    
1961
    for(i=1; i<MAX_PICTURE_COUNT; i++)
1962
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1963
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1964

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

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

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

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

    
2050
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2051

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

    
2058
            /* mark us unused / free shared pic */
2059
            for(i=0; i<4; i++)
2060
                s->reordered_input_picture[0]->data[i]= NULL;
2061
            s->reordered_input_picture[0]->type= 0;
2062
            
2063
            pic->reference              = s->reordered_input_picture[0]->reference;
2064
            
2065
            alloc_picture(s, pic, 0);
2066

    
2067
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2068

    
2069
            s->current_picture_ptr= pic;
2070
        }else{
2071
            // input is not a shared pix -> reuse buffer for current_pix
2072

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

    
2090
int MPV_encode_picture(AVCodecContext *avctx,
2091
                       unsigned char *buf, int buf_size, void *data)
2092
{
2093
    MpegEncContext *s = avctx->priv_data;
2094
    AVFrame *pic_arg = data;
2095
    int i, stuffing_count;
2096

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

    
2109
        init_put_bits(&s->thread_context[i]->pb, start, end - start);
2110
    }
2111

    
2112
    s->picture_in_gop_number++;
2113

    
2114
    load_input_picture(s, pic_arg);
2115
    
2116
    select_input_picture(s);
2117
    
2118
    /* output? */
2119
    if(s->new_picture.data[0]){
2120
        s->pict_type= s->new_picture.pict_type;
2121
//emms_c();
2122
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2123
        MPV_frame_start(s, avctx);
2124

    
2125
        encode_picture(s, s->picture_number);
2126
        
2127
        avctx->real_pict_num  = s->picture_number;
2128
        avctx->header_bits = s->header_bits;
2129
        avctx->mv_bits     = s->mv_bits;
2130
        avctx->misc_bits   = s->misc_bits;
2131
        avctx->i_tex_bits  = s->i_tex_bits;
2132
        avctx->p_tex_bits  = s->p_tex_bits;
2133
        avctx->i_count     = s->i_count;
2134
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2135
        avctx->skip_count  = s->skip_count;
2136

    
2137
        MPV_frame_end(s);
2138

    
2139
        if (s->out_format == FMT_MJPEG)
2140
            mjpeg_picture_trailer(s);
2141
        
2142
        if(s->flags&CODEC_FLAG_PASS1)
2143
            ff_write_pass1_stats(s);
2144

    
2145
        for(i=0; i<4; i++){
2146
            avctx->error[i] += s->current_picture_ptr->error[i];
2147
        }
2148

    
2149
        flush_put_bits(&s->pb);
2150
        s->frame_bits  = put_bits_count(&s->pb);
2151

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

    
2176
        /* update mpeg1/2 vbv_delay for CBR */    
2177
        if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2178
           && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2179
            int vbv_delay;
2180

    
2181
            assert(s->repeat_first_field==0);
2182
            
2183
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2184
            assert(vbv_delay < 0xFFFF);
2185

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

    
2203
#endif //CONFIG_ENCODERS
2204

    
2205
static inline void gmc1_motion(MpegEncContext *s,
2206
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2207
                               uint8_t **ref_picture)
2208
{
2209
    uint8_t *ptr;
2210
    int offset, src_x, src_y, linesize, uvlinesize;
2211
    int motion_x, motion_y;
2212
    int emu=0;
2213

    
2214
    motion_x= s->sprite_offset[0][0];
2215
    motion_y= s->sprite_offset[0][1];
2216
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2217
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2218
    motion_x<<=(3-s->sprite_warping_accuracy);
2219
    motion_y<<=(3-s->sprite_warping_accuracy);
2220
    src_x = clip(src_x, -16, s->width);
2221
    if (src_x == s->width)
2222
        motion_x =0;
2223
    src_y = clip(src_y, -16, s->height);
2224
    if (src_y == s->height)
2225
        motion_y =0;
2226

    
2227
    linesize = s->linesize;
2228
    uvlinesize = s->uvlinesize;
2229
    
2230
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2231

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

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

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

    
2291
static inline void gmc_motion(MpegEncContext *s,
2292
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2293
                               uint8_t **ref_picture)
2294
{
2295
    uint8_t *ptr;
2296
    int linesize, uvlinesize;
2297
    const int a= s->sprite_warping_accuracy;
2298
    int ox, oy;
2299

    
2300
    linesize = s->linesize;
2301
    uvlinesize = s->uvlinesize;
2302

    
2303
    ptr = ref_picture[0];
2304

    
2305
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2306
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2307

    
2308
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2309
           ox, 
2310
           oy, 
2311
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2312
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2313
           a+1, (1<<(2*a+1)) - s->no_rounding,
2314
           s->h_edge_pos, s->v_edge_pos);
2315
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2316
           ox + s->sprite_delta[0][0]*8, 
2317
           oy + s->sprite_delta[1][0]*8, 
2318
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2319
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2320
           a+1, (1<<(2*a+1)) - s->no_rounding,
2321
           s->h_edge_pos, s->v_edge_pos);
2322

    
2323
    if(s->flags&CODEC_FLAG_GRAY) return;
2324

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

    
2328
    ptr = ref_picture[1];
2329
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2330
           ox, 
2331
           oy, 
2332
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2333
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2334
           a+1, (1<<(2*a+1)) - s->no_rounding,
2335
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2336
    
2337
    ptr = ref_picture[2];
2338
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2339
           ox, 
2340
           oy, 
2341
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2342
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2343
           a+1, (1<<(2*a+1)) - s->no_rounding,
2344
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2345
}
2346

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

    
2364
    if(src_y>= h){
2365
        src+= (h-1-src_y)*linesize;
2366
        src_y=h-1;
2367
    }else if(src_y<=-block_h){
2368
        src+= (1-block_h-src_y)*linesize;
2369
        src_y=1-block_h;
2370
    }
2371
    if(src_x>= w){
2372
        src+= (w-1-src_x);
2373
        src_x=w-1;
2374
    }else if(src_x<=-block_w){
2375
        src+= (1-block_w-src_x);
2376
        src_x=1-block_w;
2377
    }
2378

    
2379
    start_y= FFMAX(0, -src_y);
2380
    start_x= FFMAX(0, -src_x);
2381
    end_y= FFMIN(block_h, h-src_y);
2382
    end_x= FFMIN(block_w, w-src_x);
2383

    
2384
    // copy existing part
2385
    for(y=start_y; y<end_y; y++){
2386
        for(x=start_x; x<end_x; x++){
2387
            buf[x + y*linesize]= src[x + y*linesize];
2388
        }
2389
    }
2390

    
2391
    //top
2392
    for(y=0; y<start_y; y++){
2393
        for(x=start_x; x<end_x; x++){
2394
            buf[x + y*linesize]= buf[x + start_y*linesize];
2395
        }
2396
    }
2397

    
2398
    //bottom
2399
    for(y=end_y; y<block_h; y++){
2400
        for(x=start_x; x<end_x; x++){
2401
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2402
        }
2403
    }
2404
                                    
2405
    for(y=0; y<block_h; y++){
2406
       //left
2407
        for(x=0; x<start_x; x++){
2408
            buf[x + y*linesize]= buf[start_x + y*linesize];
2409
        }
2410
       
2411
       //right
2412
        for(x=end_x; x<block_w; x++){
2413
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2414
        }
2415
    }
2416
}
2417

    
2418
static inline int hpel_motion(MpegEncContext *s, 
2419
                                  uint8_t *dest, uint8_t *src,
2420
                                  int field_based, int field_select,
2421
                                  int src_x, int src_y,
2422
                                  int width, int height, int stride,
2423
                                  int h_edge_pos, int v_edge_pos,
2424
                                  int w, int h, op_pixels_func *pix_op,
2425
                                  int motion_x, int motion_y)
2426
{
2427
    int dxy;
2428
    int emu=0;
2429

    
2430
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2431
    src_x += motion_x >> 1;
2432
    src_y += motion_y >> 1;
2433
                
2434
    /* WARNING: do no forget half pels */
2435
    src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2436
    if (src_x == width)
2437
        dxy &= ~1;
2438
    src_y = clip(src_y, -16, height);
2439
    if (src_y == height)
2440
        dxy &= ~2;
2441
    src += src_y * stride + src_x;
2442

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

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

    
2476
    v_edge_pos = s->v_edge_pos >> field_based;
2477
    linesize   = s->current_picture.linesize[0] << field_based;
2478
    uvlinesize = s->current_picture.linesize[1] << field_based;
2479

    
2480
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2481
    src_x = s->mb_x* 16               + (motion_x >> 1);
2482
    src_y = s->mb_y*(16>>field_based) + (motion_y >> 1);
2483

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

    
2504
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2505
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2506
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2507

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

    
2524
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2525
        dest_y += s->linesize;
2526
        dest_cb+= s->uvlinesize;
2527
        dest_cr+= s->uvlinesize;
2528
    }
2529

    
2530
    if(field_select){
2531
        ptr_y += s->linesize;
2532
        ptr_cb+= s->uvlinesize;
2533
        ptr_cr+= s->uvlinesize;
2534
    }
2535

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

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

    
2622
    put_obmc(dest, ptr, s->linesize);                
2623
}
2624

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

    
2635
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2636
    src_x = s->mb_x *  16                 + (motion_x >> 2);
2637
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2638

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

    
2660
    uvdxy= (mx&1) | ((my&1)<<1);
2661
    mx>>=1;
2662
    my>>=1;
2663

    
2664
    uvsrc_x = s->mb_x *  8                 + mx;
2665
    uvsrc_y = s->mb_y * (8 >> field_based) + my;
2666

    
2667
    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
2668
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2669
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2670

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

    
2687
    if(!field_based)
2688
        qpix_op[0][dxy](dest_y, ptr_y, linesize);
2689
    else{
2690
        if(bottom_field){
2691
            dest_y += s->linesize;
2692
            dest_cb+= s->uvlinesize;
2693
            dest_cr+= s->uvlinesize;
2694
        }
2695

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

    
2712
inline int ff_h263_round_chroma(int x){
2713
    if (x >= 0)
2714
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2715
    else {
2716
        x = -x;
2717
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2718
    }
2719
}
2720

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

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

    
2762
    ptr = ref_picture[2] + offset;
2763
    if(emu){
2764
        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);
2765
        ptr= s->edge_emu_buffer;
2766
    }
2767
    pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
2768
}
2769

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

    
2791
    mb_x = s->mb_x;
2792
    mb_y = s->mb_y;
2793

    
2794
    if(s->obmc && s->pict_type != B_TYPE){
2795
        int16_t mv_cache[4][4][2];
2796
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
2797
        const int mot_stride= s->b8_stride;
2798
        const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
2799

    
2800
        assert(!s->mb_skiped);
2801
                
2802
        memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
2803
        memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2804
        memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2805

    
2806
        if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
2807
            memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
2808
        }else{
2809
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
2810
        }
2811

    
2812
        if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
2813
            *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
2814
            *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
2815
        }else{
2816
            *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
2817
            *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
2818
        }
2819

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

    
2846
            mx += mv[0][0];
2847
            my += mv[0][1];
2848
        }
2849
        if(!(s->flags&CODEC_FLAG_GRAY))
2850
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2851

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

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

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

    
2928
                mx += s->mv[dir][i][0];
2929
                my += s->mv[dir][i][1];
2930
            }
2931
        }
2932

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

    
2962
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
2963
                        0, 0, s->field_select[dir][0],
2964
                        ref_picture, pix_op,
2965
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2966
        }
2967
        break;
2968
    case MV_TYPE_16X8:
2969
        for(i=0; i<2; i++){
2970
            uint8_t ** ref2picture;
2971

    
2972
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
2973
                ref2picture= ref_picture;
2974
            }else{
2975
                ref2picture= s->current_picture_ptr->data;
2976
            } 
2977

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

    
3007
                // after put we make avg of the same block
3008
                pix_op=s->dsp.avg_pixels_tab; 
3009

    
3010
                //opposite parity is always in the same frame if this is second field
3011
                if(!s->first_field){
3012
                    ref_picture = s->current_picture_ptr->data;    
3013
                }
3014
            }
3015
        }
3016
    break;
3017
    default: assert(0);
3018
    }
3019
}
3020

    
3021

    
3022
/* put block[] to dest[] */
3023
static inline void put_dct(MpegEncContext *s, 
3024
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3025
{
3026
    s->dct_unquantize_intra(s, block, i, qscale);
3027
    s->dsp.idct_put (dest, line_size, block);
3028
}
3029

    
3030
/* add block[] to dest[] */
3031
static inline void add_dct(MpegEncContext *s, 
3032
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
3033
{
3034
    if (s->block_last_index[i] >= 0) {
3035
        s->dsp.idct_add (dest, line_size, block);
3036
    }
3037
}
3038

    
3039
static inline void add_dequant_dct(MpegEncContext *s, 
3040
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3041
{
3042
    if (s->block_last_index[i] >= 0) {
3043
        s->dct_unquantize_inter(s, block, i, qscale);
3044

    
3045
        s->dsp.idct_add (dest, line_size, block);
3046
    }
3047
}
3048

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

    
3082
/* generic function called after a macroblock has been parsed by the
3083
   decoder or after it has been encoded by the encoder.
3084

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

    
3103
    mb_x = s->mb_x;
3104
    mb_y = s->mb_y;
3105

    
3106
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3107
       /* save DCT coefficients */
3108
       int i,j;
3109
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3110
       for(i=0; i<6; i++)
3111
           for(j=0; j<64; j++)
3112
               *dct++ = block[i][s->dsp.idct_permutation[j]];
3113
    }
3114

    
3115
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3116

    
3117
    /* update DC predictors for P macroblocks */
3118
    if (!s->mb_intra) {
3119
        if (s->h263_pred || s->h263_aic) {
3120
            if(s->mbintra_table[mb_xy])
3121
                ff_clean_intra_table_entries(s);
3122
        } else {
3123
            s->last_dc[0] =
3124
            s->last_dc[1] =
3125
            s->last_dc[2] = 128 << s->intra_dc_precision;
3126
        }
3127
    }
3128
    else if (s->h263_pred || s->h263_aic)
3129
        s->mbintra_table[mb_xy]=1;
3130

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

    
3140
        /* avoid copy if macroblock skipped in last frame too */
3141
        /* skip only during decoding as we might trash the buffers during encoding a bit */
3142
        if(!s->encoding){
3143
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3144
            const int age= s->current_picture.age;
3145

    
3146
            assert(age);
3147

    
3148
            if (s->mb_skiped) {
3149
                s->mb_skiped= 0;
3150
                assert(s->pict_type!=I_TYPE);
3151
 
3152
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
3153
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3154

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

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

    
3195
                if (s->mv_dir & MV_DIR_FORWARD) {
3196
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3197
                    op_pix = s->dsp.avg_pixels_tab;
3198
                    op_qpix= s->dsp.avg_qpel_pixels_tab;
3199
                }
3200
                if (s->mv_dir & MV_DIR_BACKWARD) {
3201
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3202
                }
3203
            }
3204

    
3205
            /* skip dequant / idct if we are really late ;) */
3206
            if(s->hurry_up>1) return;
3207

    
3208
            /* add dct residue */
3209
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3210
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3211
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
3212
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
3213
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
3214
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
3215

    
3216
                if(!(s->flags&CODEC_FLAG_GRAY)){
3217
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3218
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3219
                }
3220
            } else if(s->codec_id != CODEC_ID_WMV2){
3221
                add_dct(s, block[0], 0, dest_y, dct_linesize);
3222
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
3223
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
3224
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
3225

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

    
3244
                if(!(s->flags&CODEC_FLAG_GRAY)){
3245
                    put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3246
                    put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3247
                }
3248
            }else{
3249
                s->dsp.idct_put(dest_y                 , dct_linesize, block[0]);
3250
                s->dsp.idct_put(dest_y              + 8, dct_linesize, block[1]);
3251
                s->dsp.idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
3252
                s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
3253

    
3254
                if(!(s->flags&CODEC_FLAG_GRAY)){
3255
                    s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3256
                    s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3257
                }
3258
            }
3259
        }
3260
        if(!readable){
3261
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3262
            s->dsp.put_pixels_tab[1][0](s->dest[1], dest_cb, uvlinesize, 8);
3263
            s->dsp.put_pixels_tab[1][0](s->dest[2], dest_cr, uvlinesize, 8);
3264
        }
3265
    }
3266
}
3267

    
3268
#ifdef CONFIG_ENCODERS
3269

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

    
3288
    if(threshold<0){
3289
        skip_dc=0;
3290
        threshold= -threshold;
3291
    }else
3292
        skip_dc=1;
3293

    
3294
    /* are all which we could set to zero are allready zero? */
3295
    if(last_index<=skip_dc - 1) return;
3296

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

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

    
3350
#endif //CONFIG_ENCODERS
3351

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

    
3367
        h= FFMIN(h, s->height - y);
3368

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

    
3388
        emms_c();
3389

    
3390
        s->avctx->draw_horiz_band(s->avctx, src, offset,
3391
                                  y, s->picture_structure, h);
3392
    }
3393
}
3394

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

    
3417
#ifdef CONFIG_ENCODERS
3418

    
3419
static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
3420
    int x, y;
3421
//FIXME optimize
3422
    for(y=0; y<8; y++){
3423
        for(x=0; x<8; x++){
3424
            int x2, y2;
3425
            int sum=0;
3426
            int sqr=0;
3427
            int count=0;
3428

    
3429
            for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
3430
                for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
3431
                    int v= ptr[x2 + y2*stride];
3432
                    sum += v;
3433
                    sqr += v*v;
3434
                    count++;
3435
                }
3436
            }
3437
            weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
3438
        }
3439
    }
3440
}
3441

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

    
3460
        s->lambda= s->lambda_table[mb_xy];
3461
        update_qscale(s);
3462
    
3463
        if(!(s->flags&CODEC_FLAG_QP_RD)){
3464
            s->dquant= s->qscale - last_qp;
3465

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

    
3486
    wrap_y = s->linesize;
3487
    wrap_c = s->uvlinesize;
3488
    ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
3489
    ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
3490
    ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3491

    
3492
    if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
3493
        ff_emulated_edge_mc(s->edge_emu_buffer            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
3494
        ptr_y= s->edge_emu_buffer;
3495
        ff_emulated_edge_mc(s->edge_emu_buffer+18*wrap_y  , ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3496
        ptr_cb= s->edge_emu_buffer+18*wrap_y;
3497
        ff_emulated_edge_mc(s->edge_emu_buffer+18*wrap_y+9, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3498
        ptr_cr= s->edge_emu_buffer+18*wrap_y+9;
3499
    }
3500

    
3501
    if (s->mb_intra) {
3502
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3503
            int progressive_score, interlaced_score;
3504

    
3505
            s->interlaced_dct=0;
3506
            progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8) 
3507
                              +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
3508

    
3509
            if(progressive_score > 0){
3510
                interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8) 
3511
                                  +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
3512
                if(progressive_score > interlaced_score){
3513
                    s->interlaced_dct=1;
3514
            
3515
                    dct_offset= wrap_y;
3516
                    wrap_y<<=1;
3517
                }
3518
            }
3519
        }
3520
        
3521
        s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
3522
        s->dsp.get_pixels(s->block[1], ptr_y              + 8, wrap_y);
3523
        s->dsp.get_pixels(s->block[2], ptr_y + dct_offset    , wrap_y);
3524
        s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
3525

    
3526
        if(s->flags&CODEC_FLAG_GRAY){
3527
            skip_dct[4]= 1;
3528
            skip_dct[5]= 1;
3529
        }else{
3530
            s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
3531
            s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
3532
        }
3533
    }else{
3534
        op_pixels_func (*op_pix)[4];
3535
        qpel_mc_func (*op_qpix)[16];
3536
        uint8_t *dest_y, *dest_cb, *dest_cr;
3537

    
3538
        dest_y  = s->dest[0];
3539
        dest_cb = s->dest[1];
3540
        dest_cr = s->dest[2];
3541

    
3542
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
3543
            op_pix = s->dsp.put_pixels_tab;
3544
            op_qpix= s->dsp.put_qpel_pixels_tab;
3545
        }else{
3546
            op_pix = s->dsp.put_no_rnd_pixels_tab;
3547
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3548
        }
3549

    
3550
        if (s->mv_dir & MV_DIR_FORWARD) {
3551
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3552
            op_pix = s->dsp.avg_pixels_tab;
3553
            op_qpix= s->dsp.avg_qpel_pixels_tab;
3554
        }
3555
        if (s->mv_dir & MV_DIR_BACKWARD) {
3556
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3557
        }
3558

    
3559
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3560
            int progressive_score, interlaced_score;
3561

    
3562
            s->interlaced_dct=0;
3563
            progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8) 
3564
                              +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
3565
            
3566
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
3567

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

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

    
3644
        if(s->flags & CODEC_FLAG_CBP_RD){
3645
            for(i=0;i<6;i++) {
3646
                if(s->block_last_index[i] == -1)
3647
                    s->coded_score[i]= INT_MAX/256;
3648
            }
3649
        }
3650
    }
3651

    
3652
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
3653
        s->block_last_index[4]=
3654
        s->block_last_index[5]= 0;
3655
        s->block[4][0]=
3656
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
3657
    }
3658

    
3659
    //non c quantize code returns incorrect block_last_index FIXME
3660
    if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
3661
        for(i=0; i<6; i++){
3662
            int j;
3663
            if(s->block_last_index[i]>0){
3664
                for(j=63; j>0; j--){
3665
                    if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
3666
                }
3667
                s->block_last_index[i]= j;
3668
            }
3669
        }
3670
    }
3671

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

    
3699
#endif //CONFIG_ENCODERS
3700

    
3701
void ff_mpeg_flush(AVCodecContext *avctx){
3702
    int i;
3703
    MpegEncContext *s = avctx->priv_data;
3704
    
3705
    if(s==NULL || s->picture==NULL) 
3706
        return;
3707
    
3708
    for(i=0; i<MAX_PICTURE_COUNT; i++){
3709
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
3710
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
3711
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
3712
    }
3713
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
3714
    
3715
    s->parse_context.state= -1;
3716
    s->parse_context.frame_start_found= 0;
3717
    s->parse_context.overread= 0;
3718
    s->parse_context.overread_index= 0;
3719
    s->parse_context.index= 0;
3720
    s->parse_context.last_index= 0;
3721
    s->bitstream_buffer_size=0;
3722
}
3723

    
3724
#ifdef CONFIG_ENCODERS
3725
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
3726
{
3727
    const uint16_t *srcw= (uint16_t*)src;
3728
    int words= length>>4;
3729
    int bits= length&15;
3730
    int i;
3731

    
3732
    if(length==0) return;
3733
    
3734
    if(words < 16){
3735
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
3736
    }else if(put_bits_count(pb)&7){
3737
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
3738
    }else{
3739
        for(i=0; put_bits_count(pb)&31; i++)
3740
            put_bits(pb, 8, src[i]);
3741
        flush_put_bits(pb);
3742
        memcpy(pbBufPtr(pb), src+i, 2*words-i);
3743
        skip_put_bytes(pb, 2*words-i);
3744
    }
3745
        
3746
    put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
3747
}
3748

    
3749
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
3750
    int i;
3751

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

    
3754
    /* mpeg1 */
3755
    d->mb_skip_run= s->mb_skip_run;
3756
    for(i=0; i<3; i++)
3757
        d->last_dc[i]= s->last_dc[i];
3758
    
3759
    /* statistics */
3760
    d->mv_bits= s->mv_bits;
3761
    d->i_tex_bits= s->i_tex_bits;
3762
    d->p_tex_bits= s->p_tex_bits;
3763
    d->i_count= s->i_count;
3764
    d->f_count= s->f_count;
3765
    d->b_count= s->b_count;
3766
    d->skip_count= s->skip_count;
3767
    d->misc_bits= s->misc_bits;
3768
    d->last_bits= 0;
3769

    
3770
    d->mb_skiped= 0;
3771
    d->qscale= s->qscale;
3772
    d->dquant= s->dquant;
3773
}
3774

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

    
3778
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
3779
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
3780
    
3781
    /* mpeg1 */
3782
    d->mb_skip_run= s->mb_skip_run;
3783
    for(i=0; i<3; i++)
3784
        d->last_dc[i]= s->last_dc[i];
3785
    
3786
    /* statistics */
3787
    d->mv_bits= s->mv_bits;
3788
    d->i_tex_bits= s->i_tex_bits;
3789
    d->p_tex_bits= s->p_tex_bits;
3790
    d->i_count= s->i_count;
3791
    d->f_count= s->f_count;
3792
    d->b_count= s->b_count;
3793
    d->skip_count= s->skip_count;
3794
    d->misc_bits= s->misc_bits;
3795

    
3796
    d->mb_intra= s->mb_intra;
3797
    d->mb_skiped= s->mb_skiped;
3798
    d->mv_type= s->mv_type;
3799
    d->mv_dir= s->mv_dir;
3800
    d->pb= s->pb;
3801
    if(s->data_partitioning){
3802
        d->pb2= s->pb2;
3803
        d->tex_pb= s->tex_pb;
3804
    }
3805
    d->block= s->block;
3806
    for(i=0; i<6; i++)
3807
        d->block_last_index[i]= s->block_last_index[i];
3808
    d->interlaced_dct= s->interlaced_dct;
3809
    d->qscale= s->qscale;
3810
}
3811

    
3812
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
3813
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
3814
                           int *dmin, int *next_block, int motion_x, int motion_y)
3815
{
3816
    int score;
3817
    uint8_t *dest_backup[3];
3818
    
3819
    copy_context_before_encode(s, backup, type);
3820

    
3821
    s->block= s->blocks[*next_block];
3822
    s->pb= pb[*next_block];
3823
    if(s->data_partitioning){
3824
        s->pb2   = pb2   [*next_block];
3825
        s->tex_pb= tex_pb[*next_block];
3826
    }
3827
    
3828
    if(*next_block){
3829
        memcpy(dest_backup, s->dest, sizeof(s->dest));
3830
        s->dest[0] = s->rd_scratchpad;
3831
        s->dest[1] = s->rd_scratchpad + 16*s->linesize;
3832
        s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
3833
        assert(s->linesize >= 32); //FIXME
3834
    }
3835

    
3836
    encode_mb(s, motion_x, motion_y);
3837
    
3838
    score= put_bits_count(&s->pb);
3839
    if(s->data_partitioning){
3840
        score+= put_bits_count(&s->pb2);
3841
        score+= put_bits_count(&s->tex_pb);
3842
    }
3843
   
3844
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
3845
        MPV_decode_mb(s, s->block);
3846

    
3847
        score *= s->lambda2;
3848
        score += sse_mb(s) << FF_LAMBDA_SHIFT;
3849
    }
3850
    
3851
    if(*next_block){
3852
        memcpy(s->dest, dest_backup, sizeof(s->dest));
3853
    }
3854

    
3855
    if(score<*dmin){
3856
        *dmin= score;
3857
        *next_block^=1;
3858

    
3859
        copy_context_after_encode(best, s, type);
3860
    }
3861
}
3862
                
3863
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
3864
    uint32_t *sq = squareTbl + 256;
3865
    int acc=0;
3866
    int x,y;
3867
    
3868
    if(w==16 && h==16) 
3869
        return s->dsp.sse[0](NULL, src1, src2, stride, 16);
3870
    else if(w==8 && h==8)
3871
        return s->dsp.sse[1](NULL, src1, src2, stride, 8);
3872
    
3873
    for(y=0; y<h; y++){
3874
        for(x=0; x<w; x++){
3875
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
3876
        } 
3877
    }
3878
    
3879
    assert(acc>=0);
3880
    
3881
    return acc;
3882
}
3883

    
3884
static int sse_mb(MpegEncContext *s){
3885
    int w= 16;
3886
    int h= 16;
3887

    
3888
    if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3889
    if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3890

    
3891
    if(w==16 && h==16)
3892
        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)
3893
               +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)
3894
               +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);
3895
    else
3896
        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)
3897
               +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)
3898
               +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);
3899
}
3900

    
3901
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
3902
    MpegEncContext *s= arg;
3903

    
3904
    
3905
    s->me.pre_pass=1;
3906
    s->me.dia_size= s->avctx->pre_dia_size;
3907
    s->first_slice_line=1;
3908
    for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
3909
        for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
3910
            ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
3911
        }
3912
        s->first_slice_line=0;
3913
    }
3914
    
3915
    s->me.pre_pass=0;
3916
    
3917
    return 0;
3918
}
3919

    
3920
static int estimate_motion_thread(AVCodecContext *c, void *arg){
3921
    MpegEncContext *s= arg;
3922

    
3923
    s->me.dia_size= s->avctx->dia_size;
3924
    s->first_slice_line=1;
3925
    for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
3926
        s->mb_x=0; //for block init below
3927
        ff_init_block_index(s);
3928
        for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
3929
            s->block_index[0]+=2;
3930
            s->block_index[1]+=2;
3931
            s->block_index[2]+=2;
3932
            s->block_index[3]+=2;
3933
            
3934
            /* compute motion vector & mb_type and store in context */
3935
            if(s->pict_type==B_TYPE)
3936
                ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
3937
            else
3938
                ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
3939
        }
3940
        s->first_slice_line=0;
3941
    }
3942
    return 0;
3943
}
3944

    
3945
static int mb_var_thread(AVCodecContext *c, void *arg){
3946
    MpegEncContext *s= arg;
3947
    int mb_x, mb_y;
3948

    
3949
    for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
3950
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3951
            int xx = mb_x * 16;
3952
            int yy = mb_y * 16;
3953
            uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
3954
            int varc;
3955
            int sum = s->dsp.pix_sum(pix, s->linesize);
3956
    
3957
            varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
3958

    
3959
            s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
3960
            s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
3961
            s->mb_var_sum_temp    += varc;
3962
        }
3963
    }
3964
    return 0;
3965
}
3966

    
3967
static void write_slice_end(MpegEncContext *s){
3968
    if(s->codec_id==CODEC_ID_MPEG4){
3969
        if(s->partitioned_frame){
3970
            ff_mpeg4_merge_partitions(s);
3971
        }
3972
    
3973
        ff_mpeg4_stuffing(&s->pb);
3974
    }else if(s->out_format == FMT_MJPEG){
3975
        ff_mjpeg_stuffing(&s->pb);
3976
    }
3977

    
3978
    align_put_bits(&s->pb);
3979
    flush_put_bits(&s->pb);
3980
}
3981

    
3982
static int encode_thread(AVCodecContext *c, void *arg){
3983
    MpegEncContext *s= arg;
3984
    int mb_x, mb_y, pdif = 0;
3985
    int i, j;
3986
    MpegEncContext best_s, backup_s;
3987
    uint8_t bit_buf[2][3000];
3988
    uint8_t bit_buf2[2][3000];
3989
    uint8_t bit_buf_tex[2][3000];
3990
    PutBitContext pb[2], pb2[2], tex_pb[2];
3991
//printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
3992

    
3993
    for(i=0; i<2; i++){
3994
        init_put_bits(&pb    [i], bit_buf    [i], 3000);
3995
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000);
3996
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000);
3997
    }
3998

    
3999
    s->last_bits= put_bits_count(&s->pb);
4000
    s->mv_bits=0;
4001
    s->misc_bits=0;
4002
    s->i_tex_bits=0;
4003
    s->p_tex_bits=0;
4004
    s->i_count=0;
4005
    s->f_count=0;
4006
    s->b_count=0;
4007
    s->skip_count=0;
4008

    
4009
    for(i=0; i<3; i++){
4010
        /* init last dc values */
4011
        /* note: quant matrix value (8) is implied here */
4012
        s->last_dc[i] = 128;
4013
        
4014
        s->current_picture_ptr->error[i] = 0;
4015
    }
4016
    s->mb_skip_run = 0;
4017
    memset(s->last_mv, 0, sizeof(s->last_mv));
4018
     
4019
    s->last_mv_dir = 0;
4020

    
4021
#ifdef CONFIG_RISKY
4022
    switch(s->codec_id){
4023
    case CODEC_ID_H263:
4024
    case CODEC_ID_H263P:
4025
    case CODEC_ID_FLV1:
4026
        s->gob_index = ff_h263_get_gob_height(s);
4027
        break;
4028
    case CODEC_ID_MPEG4:
4029
        if(s->partitioned_frame)
4030
            ff_mpeg4_init_partitions(s);
4031
        break;
4032
    }
4033
#endif
4034

    
4035
    s->resync_mb_x=0;
4036
    s->resync_mb_y=0; 
4037
    s->first_slice_line = 1;
4038
    s->ptr_lastgob = s->pb.buf;
4039
    for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4040
//    printf("row %d at %X\n", s->mb_y, (int)s);
4041
        s->mb_x=0;
4042
        s->mb_y= mb_y;
4043

    
4044
        ff_set_qscale(s, s->qscale);
4045
        ff_init_block_index(s);
4046
        
4047
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4048
            const int xy= mb_y*s->mb_stride + mb_x;
4049
            int mb_type= s->mb_type[xy];
4050
//            int d;
4051
            int dmin= INT_MAX;
4052
            int dir;
4053

    
4054
            s->mb_x = mb_x;
4055
            ff_update_block_index(s);
4056

    
4057
            /* write gob / video packet header  */
4058
#ifdef CONFIG_RISKY
4059
            if(s->rtp_mode){
4060
                int current_packet_size, is_gob_start;
4061
                
4062
                current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
4063
                
4064
                is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0; 
4065
                
4066
                if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
4067
                
4068
                switch(s->codec_id){
4069
                case CODEC_ID_H263:
4070
                case CODEC_ID_H263P:
4071
                    if(!s->h263_slice_structured)
4072
                        if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
4073
                    break;
4074
                case CODEC_ID_MPEG2VIDEO:
4075
                    if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
4076
                case CODEC_ID_MPEG1VIDEO:
4077
                    if(s->mb_skip_run) is_gob_start=0;
4078
                    break;
4079
                }
4080

    
4081
                if(is_gob_start){
4082
                    if(s->start_mb_y != mb_y || mb_x!=0){
4083
                        write_slice_end(s);
4084

    
4085
                        if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
4086
                            ff_mpeg4_init_partitions(s);
4087
                        }
4088
                    }
4089
                
4090
                    assert((put_bits_count(&s->pb)&7) == 0);
4091
                    current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4092
                    
4093
                    if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
4094
                        int r= put_bits_count(&s->pb)/8 + s->picture_number + s->codec_id + s->mb_x + s->mb_y;
4095
                        int d= 100 / s->avctx->error_rate;
4096
                        if(r % d == 0){
4097
                            current_packet_size=0;
4098
#ifndef ALT_BITSTREAM_WRITER
4099
                            s->pb.buf_ptr= s->ptr_lastgob;
4100
#endif
4101
                            assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
4102
                        }
4103
                    }
4104
        
4105
                    if (s->avctx->rtp_callback)
4106
                        s->avctx->rtp_callback(s->ptr_lastgob, current_packet_size, 0);
4107
                    
4108
                    switch(s->codec_id){
4109
                    case CODEC_ID_MPEG4:
4110
                        ff_mpeg4_encode_video_packet_header(s);
4111
                        ff_mpeg4_clean_buffers(s);
4112
                    break;
4113
                    case CODEC_ID_MPEG1VIDEO:
4114
                    case CODEC_ID_MPEG2VIDEO:
4115
                        ff_mpeg1_encode_slice_header(s);
4116
                        ff_mpeg1_clean_buffers(s);
4117
                    break;
4118
                    case CODEC_ID_H263:
4119
                    case CODEC_ID_H263P:
4120
                        h263_encode_gob_header(s, mb_y);                       
4121
                    break;
4122
                    }
4123

    
4124
                    if(s->flags&CODEC_FLAG_PASS1){
4125
                        int bits= put_bits_count(&s->pb);
4126
                        s->misc_bits+= bits - s->last_bits;
4127
                        s->last_bits= bits;
4128
                    }
4129
    
4130
                    s->ptr_lastgob += current_packet_size;
4131
                    s->first_slice_line=1;
4132
                    s->resync_mb_x=mb_x;
4133
                    s->resync_mb_y=mb_y;
4134
                }
4135
            }
4136
#endif
4137

    
4138
            if(  (s->resync_mb_x   == s->mb_x)
4139
               && s->resync_mb_y+1 == s->mb_y){
4140
                s->first_slice_line=0; 
4141
            }
4142

    
4143
            s->mb_skiped=0;
4144
            s->dquant=0; //only for QP_RD
4145

    
4146
            if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible
4147
                int next_block=0;
4148
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
4149

    
4150
                copy_context_before_encode(&backup_s, s, -1);
4151
                backup_s.pb= s->pb;
4152
                best_s.data_partitioning= s->data_partitioning;
4153
                best_s.partitioned_frame= s->partitioned_frame;
4154
                if(s->data_partitioning){
4155
                    backup_s.pb2= s->pb2;
4156
                    backup_s.tex_pb= s->tex_pb;
4157
                }
4158

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

    
4295
                if(s->flags & CODEC_FLAG_QP_RD){
4296
                    if(best_s.mv_type==MV_TYPE_16X16 && !(best_s.mv_dir&MV_DIRECT)){
4297
                        const int last_qp= backup_s.qscale;
4298
                        int dquant, dir, qp, dc[6];
4299
                        DCTELEM ac[6][16];
4300
                        const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
4301
                        
4302
                        assert(backup_s.dquant == 0);
4303

    
4304
                        //FIXME intra
4305
                        s->mv_dir= best_s.mv_dir;
4306
                        s->mv_type = MV_TYPE_16X16;
4307
                        s->mb_intra= best_s.mb_intra;
4308
                        s->mv[0][0][0] = best_s.mv[0][0][0];
4309
                        s->mv[0][0][1] = best_s.mv[0][0][1];
4310
                        s->mv[1][0][0] = best_s.mv[1][0][0];
4311
                        s->mv[1][0][1] = best_s.mv[1][0][1];
4312
                        
4313
                        dir= s->pict_type == B_TYPE ? 2 : 1;
4314
                        if(last_qp + dir > s->avctx->qmax) dir= -dir;
4315
                        for(dquant= dir; dquant<=2 && dquant>=-2; dquant += dir){
4316
                            qp= last_qp + dquant;
4317
                            if(qp < s->avctx->qmin || qp > s->avctx->qmax)
4318
                                break;
4319
                            backup_s.dquant= dquant;
4320
                            if(s->mb_intra){
4321
                                for(i=0; i<6; i++){
4322
                                    dc[i]= s->dc_val[0][ s->block_index[i] ];
4323
                                    memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
4324
                                }
4325
                            }
4326

    
4327
                            encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb, 
4328
                                         &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
4329
                            if(best_s.qscale != qp){
4330
                                if(s->mb_intra){
4331
                                    for(i=0; i<6; i++){
4332
                                        s->dc_val[0][ s->block_index[i] ]= dc[i];
4333
                                        memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
4334
                                    }
4335
                                }
4336
                                if(dir > 0 && dquant==dir){
4337
                                    dquant= 0;
4338
                                    dir= -dir;
4339
                                }else
4340
                                    break;
4341
                            }
4342
                        }
4343
                        qp= best_s.qscale;
4344
                        s->current_picture.qscale_table[xy]= qp;
4345
                    }
4346
                }
4347

    
4348
                copy_context_after_encode(s, &best_s, -1);
4349
                
4350
                pb_bits_count= put_bits_count(&s->pb);
4351
                flush_put_bits(&s->pb);
4352
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
4353
                s->pb= backup_s.pb;
4354
                
4355
                if(s->data_partitioning){
4356
                    pb2_bits_count= put_bits_count(&s->pb2);
4357
                    flush_put_bits(&s->pb2);
4358
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
4359
                    s->pb2= backup_s.pb2;
4360
                    
4361
                    tex_pb_bits_count= put_bits_count(&s->tex_pb);
4362
                    flush_put_bits(&s->tex_pb);
4363
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
4364
                    s->tex_pb= backup_s.tex_pb;
4365
                }
4366
                s->last_bits= put_bits_count(&s->pb);
4367
               
4368
#ifdef CONFIG_RISKY
4369
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4370
                    ff_h263_update_motion_val(s);
4371
#endif
4372
        
4373
                if(next_block==0){ //FIXME 16 vs linesize16
4374
                    s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad                     , s->linesize  ,16);
4375
                    s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize    , s->uvlinesize, 8);
4376
                    s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
4377
                }
4378

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

    
4492
                encode_mb(s, motion_x, motion_y);
4493

    
4494
                // RAL: Update last macrobloc type
4495
                s->last_mv_dir = s->mv_dir;
4496
            
4497
#ifdef CONFIG_RISKY
4498
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4499
                    ff_h263_update_motion_val(s);
4500
#endif
4501
                
4502
                MPV_decode_mb(s, s->block);
4503
            }
4504

    
4505
            /* clean the MV table in IPS frames for direct mode in B frames */
4506
            if(s->mb_intra /* && I,P,S_TYPE */){
4507
                s->p_mv_table[xy][0]=0;
4508
                s->p_mv_table[xy][1]=0;
4509
            }
4510
            
4511
            if(s->flags&CODEC_FLAG_PSNR){
4512
                int w= 16;
4513
                int h= 16;
4514

    
4515
                if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4516
                if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4517

    
4518
                s->current_picture_ptr->error[0] += sse(
4519
                    s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
4520
                    s->dest[0], w, h, s->linesize);
4521
                s->current_picture_ptr->error[1] += sse(
4522
                    s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
4523
                    s->dest[1], w>>1, h>>1, s->uvlinesize);
4524
                s->current_picture_ptr->error[2] += sse(
4525
                    s, s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
4526
                    s->dest[2], w>>1, h>>1, s->uvlinesize);
4527
            }
4528
            if(s->loop_filter)
4529
                ff_h263_loop_filter(s);
4530
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
4531
        }
4532
    }
4533

    
4534
#ifdef CONFIG_RISKY
4535
    //not beautifull here but we must write it before flushing so it has to be here
4536
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
4537
        msmpeg4_encode_ext_header(s);
4538
#endif
4539

    
4540
    write_slice_end(s);
4541

    
4542
    /* Send the last GOB if RTP */    
4543
    if (s->avctx->rtp_callback) {
4544
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
4545
        /* Call the RTP callback to send the last GOB */
4546
        emms_c();
4547
        s->avctx->rtp_callback(s->ptr_lastgob, pdif, 0);
4548
    }
4549

    
4550
    return 0;
4551
}
4552

    
4553
#define MERGE(field) dst->field += src->field; src->field=0
4554
static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
4555
    MERGE(scene_change_score);
4556
    MERGE(mc_mb_var_sum_temp);
4557
    MERGE(mb_var_sum_temp);
4558
}
4559

    
4560
static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
4561
    int i;
4562

    
4563
    MERGE(dct_count[0]); //note, the other dct vars are not part of the context
4564
    MERGE(dct_count[1]);
4565
    MERGE(mv_bits);
4566
    MERGE(header_bits);
4567
    MERGE(i_tex_bits);
4568
    MERGE(p_tex_bits);
4569
    MERGE(i_count);
4570
    MERGE(f_count);
4571
    MERGE(b_count);
4572
    MERGE(skip_count);
4573
    MERGE(misc_bits);
4574
    MERGE(error_count);
4575
    MERGE(padding_bug_score);
4576

    
4577
    if(dst->avctx->noise_reduction){
4578
        for(i=0; i<64; i++){
4579
            MERGE(dct_error_sum[0][i]);
4580
            MERGE(dct_error_sum[1][i]);
4581
        }
4582
    }
4583
    
4584
    assert(put_bits_count(&src->pb) % 8 ==0);
4585
    assert(put_bits_count(&dst->pb) % 8 ==0);
4586
    ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
4587
    flush_put_bits(&dst->pb);
4588
}
4589

    
4590
static void encode_picture(MpegEncContext *s, int picture_number)
4591
{
4592
    int i, j;
4593
    int bits;
4594

    
4595
    s->picture_number = picture_number;
4596
    
4597
    /* Reset the average MB variance */
4598
    s->mb_var_sum_temp    =
4599
    s->mc_mb_var_sum_temp = 0;
4600

    
4601
#ifdef CONFIG_RISKY
4602
    /* we need to initialize some time vars before we can encode b-frames */
4603
    // RAL: Condition added for MPEG1VIDEO
4604
    if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
4605
        ff_set_mpeg4_time(s, s->picture_number);  //FIXME rename and use has_b_frames or similar
4606
#endif
4607
        
4608
    s->scene_change_score=0;
4609
    
4610
    s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration
4611
    
4612
    if(s->pict_type==I_TYPE){
4613
        if(s->msmpeg4_version >= 3) s->no_rounding=1;
4614
        else                        s->no_rounding=0;
4615
    }else if(s->pict_type!=B_TYPE){
4616
        if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
4617
            s->no_rounding ^= 1;          
4618
    }
4619
    
4620
    s->mb_intra=0; //for the rate distoration & bit compare functions
4621
    for(i=1; i<s->avctx->thread_count; i++){
4622
        ff_update_duplicate_context(s->thread_context[i], s);
4623
    }
4624

    
4625
    ff_init_me(s);
4626

    
4627
    /* Estimate motion for every MB */
4628
    if(s->pict_type != I_TYPE){
4629
        if(s->pict_type != B_TYPE && s->avctx->me_threshold==0){
4630
            if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
4631
                s->avctx->execute(s->avctx, pre_estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
4632
            }
4633
        }
4634

    
4635
        s->avctx->execute(s->avctx, estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
4636
    }else /* if(s->pict_type == I_TYPE) */{
4637
        /* I-Frame */
4638
        for(i=0; i<s->mb_stride*s->mb_height; i++)
4639
            s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
4640
        
4641
        if(!s->fixed_qscale){
4642
            /* finding spatial complexity for I-frame rate control */
4643
            s->avctx->execute(s->avctx, mb_var_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
4644
        }
4645
    }
4646
    for(i=1; i<s->avctx->thread_count; i++){
4647
        merge_context_after_me(s, s->thread_context[i]);
4648
    }
4649
    s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->mc_mb_var_sum_temp;
4650
    s->current_picture.   mb_var_sum= s->current_picture_ptr->   mb_var_sum= s->   mb_var_sum_temp;
4651
    emms_c();
4652

    
4653
    if(s->scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){
4654
        s->pict_type= I_TYPE;
4655
        for(i=0; i<s->mb_stride*s->mb_height; i++)
4656
            s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
4657
//printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);