Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ bbf18b21

History | View | Annotate | Download (236 KB)

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

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

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

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

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

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

    
73

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

    
77
//#define DEBUG
78

    
79

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
254
#endif //CONFIG_ENCODERS
255

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

    
269
    return 0;
270
}
271

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
549
    s->picture_in_gop_number = 0;
550

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

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

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

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

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

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

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

    
599
    if(s->avctx->thread_count > MAX_THREADS || (16*s->avctx->thread_count > s->height && s->height)){
600
        av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
601
        return -1;
602
    }
603

    
604
    dsputil_init(&s->dsp, s->avctx);
605
    DCT_common_init(s);
606

    
607
    s->flags= s->avctx->flags;
608
    s->flags2= s->avctx->flags2;
609

    
610
    s->mb_width  = (s->width  + 15) / 16;
611
    s->mb_height = (s->height + 15) / 16;
612
    s->mb_stride = s->mb_width + 1;
613
    s->b8_stride = s->mb_width*2 + 1;
614
    s->b4_stride = s->mb_width*4 + 1;
615
    mb_array_size= s->mb_height * s->mb_stride;
616
    mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
617

    
618
    /* set chroma shifts */
619
    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
620
                                                    &(s->chroma_y_shift) );
621

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

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

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

    
650
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
651

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

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

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

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

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

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

    
762
    s->context_initialized = 1;
763

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

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

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

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

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

    
795
    av_freep(&s->parse_context.buffer);
796
    s->parse_context.buffer_size=0;
797

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

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

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

    
862
    avcodec_default_free_buffers(s->avctx);
863
}
864

    
865
#ifdef CONFIG_ENCODERS
866

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

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

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

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

    
908
    s->me_method = avctx->me_method;
909

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

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

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

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

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

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

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

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

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

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

    
1195
    s->encoding = 1;
1196

    
1197
    /* init */
1198
    if (MPV_common_init(s) < 0)
1199
        return -1;
1200

    
1201
    if(s->modified_quant)
1202
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1203
    s->progressive_frame= 
1204
    s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1205
    s->quant_precision=5;
1206
    
1207
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1208
    
1209
#ifdef CONFIG_ENCODERS
1210
#ifdef CONFIG_RISKY
1211
    if (s->out_format == FMT_H261)
1212
        ff_h261_encode_init(s);
1213
    if (s->out_format == FMT_H263)
1214
        h263_encode_init(s);
1215
    if(s->msmpeg4_version)
1216
        ff_msmpeg4_encode_init(s);
1217
#endif
1218
    if (s->out_format == FMT_MPEG1)
1219
        ff_mpeg1_encode_init(s);
1220
#endif
1221

    
1222
    /* init q matrix */
1223
    for(i=0;i<64;i++) {
1224
        int j= s->dsp.idct_permutation[i];
1225
#ifdef CONFIG_RISKY
1226
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1227
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1228
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1229
        }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1230
            s->intra_matrix[j] =
1231
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1232
        }else
1233
#endif
1234
        { /* mpeg1/2 */
1235
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1236
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1237
        }
1238
        if(s->avctx->intra_matrix)
1239
            s->intra_matrix[j] = s->avctx->intra_matrix[i];
1240
        if(s->avctx->inter_matrix)
1241
            s->inter_matrix[j] = s->avctx->inter_matrix[i];
1242
    }
1243

    
1244
    /* precompute matrix */
1245
    /* for mjpeg, we do include qscale in the matrix */
1246
    if (s->out_format != FMT_MJPEG) {
1247
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 
1248
                       s->intra_matrix, s->intra_quant_bias, 1, 31);
1249
        convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, 
1250
                       s->inter_matrix, s->inter_quant_bias, 1, 31);
1251
    }
1252

    
1253
    if(ff_rate_control_init(s) < 0)
1254
        return -1;
1255
    
1256
    return 0;
1257
}
1258

    
1259
int MPV_encode_end(AVCodecContext *avctx)
1260
{
1261
    MpegEncContext *s = avctx->priv_data;
1262

    
1263
#ifdef STATS
1264
    print_stats();
1265
#endif
1266

    
1267
    ff_rate_control_uninit(s);
1268

    
1269
    MPV_common_end(s);
1270
    if (s->out_format == FMT_MJPEG)
1271
        mjpeg_close(s);
1272

    
1273
    av_freep(&avctx->extradata);
1274
      
1275
    return 0;
1276
}
1277

    
1278
#endif //CONFIG_ENCODERS
1279

    
1280
void init_rl(RLTable *rl, int use_static)
1281
{
1282
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1283
    uint8_t index_run[MAX_RUN+1];
1284
    int last, run, level, start, end, i;
1285

    
1286
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
1287
    if(use_static && rl->max_level[0])
1288
        return;
1289

    
1290
    /* compute max_level[], max_run[] and index_run[] */
1291
    for(last=0;last<2;last++) {
1292
        if (last == 0) {
1293
            start = 0;
1294
            end = rl->last;
1295
        } else {
1296
            start = rl->last;
1297
            end = rl->n;
1298
        }
1299

    
1300
        memset(max_level, 0, MAX_RUN + 1);
1301
        memset(max_run, 0, MAX_LEVEL + 1);
1302
        memset(index_run, rl->n, MAX_RUN + 1);
1303
        for(i=start;i<end;i++) {
1304
            run = rl->table_run[i];
1305
            level = rl->table_level[i];
1306
            if (index_run[run] == rl->n)
1307
                index_run[run] = i;
1308
            if (level > max_level[run])
1309
                max_level[run] = level;
1310
            if (run > max_run[level])
1311
                max_run[level] = run;
1312
        }
1313
        if(use_static)
1314
            rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1315
        else
1316
            rl->max_level[last] = av_malloc(MAX_RUN + 1);
1317
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1318
        if(use_static)
1319
            rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1320
        else
1321
            rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1322
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1323
        if(use_static)
1324
            rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1325
        else
1326
            rl->index_run[last] = av_malloc(MAX_RUN + 1);
1327
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1328
    }
1329
}
1330

    
1331
/* draw the edges of width 'w' of an image of size width, height */
1332
//FIXME check that this is ok for mpeg4 interlaced
1333
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1334
{
1335
    uint8_t *ptr, *last_line;
1336
    int i;
1337

    
1338
    last_line = buf + (height - 1) * wrap;
1339
    for(i=0;i<w;i++) {
1340
        /* top and bottom */
1341
        memcpy(buf - (i + 1) * wrap, buf, width);
1342
        memcpy(last_line + (i + 1) * wrap, last_line, width);
1343
    }
1344
    /* left and right */
1345
    ptr = buf;
1346
    for(i=0;i<height;i++) {
1347
        memset(ptr - w, ptr[0], w);
1348
        memset(ptr + width, ptr[width-1], w);
1349
        ptr += wrap;
1350
    }
1351
    /* corners */
1352
    for(i=0;i<w;i++) {
1353
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1354
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1355
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1356
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1357
    }
1358
}
1359

    
1360
int ff_find_unused_picture(MpegEncContext *s, int shared){
1361
    int i;
1362
    
1363
    if(shared){
1364
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1365
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1366
        }
1367
    }else{
1368
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1369
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1370
        }
1371
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1372
            if(s->picture[i].data[0]==NULL) return i;
1373
        }
1374
    }
1375

    
1376
    assert(0);
1377
    return -1;
1378
}
1379

    
1380
static void update_noise_reduction(MpegEncContext *s){
1381
    int intra, i;
1382

    
1383
    for(intra=0; intra<2; intra++){
1384
        if(s->dct_count[intra] > (1<<16)){
1385
            for(i=0; i<64; i++){
1386
                s->dct_error_sum[intra][i] >>=1;
1387
            }
1388
            s->dct_count[intra] >>= 1;
1389
        }
1390
        
1391
        for(i=0; i<64; i++){
1392
            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);
1393
        }
1394
    }
1395
}
1396

    
1397
/**
1398
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1399
 */
1400
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1401
{
1402
    int i;
1403
    AVFrame *pic;
1404
    s->mb_skiped = 0;
1405

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

    
1408
    /* mark&release old frames */
1409
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1410
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1411

    
1412
        /* release forgotten pictures */
1413
        /* if(mpeg124/h263) */
1414
        if(!s->encoding){
1415
            for(i=0; i<MAX_PICTURE_COUNT; i++){
1416
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1417
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1418
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
1419
                }
1420
            }
1421
        }
1422
    }
1423
alloc:
1424
    if(!s->encoding){
1425
        /* release non refernce frames */
1426
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1427
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1428
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1429
            }
1430
        }
1431

    
1432
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1433
            pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1434
        else{
1435
            i= ff_find_unused_picture(s, 0);
1436
            pic= (AVFrame*)&s->picture[i];
1437
        }
1438

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

    
1441
        pic->coded_picture_number= s->coded_picture_number++;
1442
        
1443
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1444
            return -1;
1445

    
1446
        s->current_picture_ptr= (Picture*)pic;
1447
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1448
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1449
    }
1450

    
1451
    s->current_picture_ptr->pict_type= s->pict_type;
1452
//    if(s->flags && CODEC_FLAG_QSCALE) 
1453
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1454
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1455

    
1456
    copy_picture(&s->current_picture, s->current_picture_ptr);
1457
  
1458
  if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1459
    if (s->pict_type != B_TYPE) {
1460
        s->last_picture_ptr= s->next_picture_ptr;
1461
        if(!s->dropable)
1462
            s->next_picture_ptr= s->current_picture_ptr;
1463
    }
1464
/*    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,
1465
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL, 
1466
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL, 
1467
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1468
        s->pict_type, s->dropable);*/
1469
    
1470
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1471
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1472
    
1473
    if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1474
        av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1475
        assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1476
        goto alloc;
1477
    }
1478

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

    
1481
    if(s->picture_structure!=PICT_FRAME){
1482
        int i;
1483
        for(i=0; i<4; i++){
1484
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1485
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1486
            } 
1487
            s->current_picture.linesize[i] *= 2;
1488
            s->last_picture.linesize[i] *=2;
1489
            s->next_picture.linesize[i] *=2;
1490
        }
1491
    }
1492
  }
1493
   
1494
    s->hurry_up= s->avctx->hurry_up;
1495
    s->error_resilience= avctx->error_resilience;
1496

    
1497
    /* set dequantizer, we cant do it during init as it might change for mpeg4
1498
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1499
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1500
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1501
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1502
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1503
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1504
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1505
    }else{
1506
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1507
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1508
    }
1509

    
1510
    if(s->dct_error_sum){
1511
        assert(s->avctx->noise_reduction && s->encoding);
1512

    
1513
        update_noise_reduction(s);
1514
    }
1515
        
1516
#ifdef HAVE_XVMC
1517
    if(s->avctx->xvmc_acceleration)
1518
        return XVMC_field_start(s, avctx);
1519
#endif
1520
    return 0;
1521
}
1522

    
1523
/* generic function for encode/decode called after a frame has been coded/decoded */
1524
void MPV_frame_end(MpegEncContext *s)
1525
{
1526
    int i;
1527
    /* draw edge for correct motion prediction if outside */
1528
#ifdef HAVE_XVMC
1529
//just to make sure that all data is rendered.
1530
    if(s->avctx->xvmc_acceleration){
1531
        XVMC_field_end(s);
1532
    }else
1533
#endif
1534
    if(s->unrestricted_mv && s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1535
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1536
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1537
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1538
    }
1539
    emms_c();
1540
    
1541
    s->last_pict_type    = s->pict_type;
1542
    if(s->pict_type!=B_TYPE){
1543
        s->last_non_b_pict_type= s->pict_type;
1544
    }
1545
#if 0
1546
        /* copy back current_picture variables */
1547
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1548
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1549
            s->picture[i]= s->current_picture;
1550
            break;
1551
        }    
1552
    }
1553
    assert(i<MAX_PICTURE_COUNT);
1554
#endif    
1555

    
1556
    if(s->encoding){
1557
        /* release non refernce frames */
1558
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1559
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1560
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1561
            }
1562
        }
1563
    }
1564
    // clear copies, to avoid confusion
1565
#if 0
1566
    memset(&s->last_picture, 0, sizeof(Picture));
1567
    memset(&s->next_picture, 0, sizeof(Picture));
1568
    memset(&s->current_picture, 0, sizeof(Picture));
1569
#endif
1570
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1571
}
1572

    
1573
/**
1574
 * draws an line from (ex, ey) -> (sx, sy).
1575
 * @param w width of the image
1576
 * @param h height of the image
1577
 * @param stride stride/linesize of the image
1578
 * @param color color of the arrow
1579
 */
1580
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1581
    int t, x, y, fr, f;
1582
    
1583
    sx= clip(sx, 0, w-1);
1584
    sy= clip(sy, 0, h-1);
1585
    ex= clip(ex, 0, w-1);
1586
    ey= clip(ey, 0, h-1);
1587
    
1588
    buf[sy*stride + sx]+= color;
1589
    
1590
    if(ABS(ex - sx) > ABS(ey - sy)){
1591
        if(sx > ex){
1592
            t=sx; sx=ex; ex=t;
1593
            t=sy; sy=ey; ey=t;
1594
        }
1595
        buf+= sx + sy*stride;
1596
        ex-= sx;
1597
        f= ((ey-sy)<<16)/ex;
1598
        for(x= 0; x <= ex; x++){
1599
            y = (x*f)>>16;
1600
            fr= (x*f)&0xFFFF;
1601
            buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1602
            buf[(y+1)*stride + x]+= (color*         fr )>>16;
1603
        }
1604
    }else{
1605
        if(sy > ey){
1606
            t=sx; sx=ex; ex=t;
1607
            t=sy; sy=ey; ey=t;
1608
        }
1609
        buf+= sx + sy*stride;
1610
        ey-= sy;
1611
        if(ey) f= ((ex-sx)<<16)/ey;
1612
        else   f= 0;
1613
        for(y= 0; y <= ey; y++){
1614
            x = (y*f)>>16;
1615
            fr= (y*f)&0xFFFF;
1616
            buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;;
1617
            buf[y*stride + x+1]+= (color*         fr )>>16;;
1618
        }
1619
    }
1620
}
1621

    
1622
/**
1623
 * draws an arrow from (ex, ey) -> (sx, sy).
1624
 * @param w width of the image
1625
 * @param h height of the image
1626
 * @param stride stride/linesize of the image
1627
 * @param color color of the arrow
1628
 */
1629
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1630
    int dx,dy;
1631

    
1632
    sx= clip(sx, -100, w+100);
1633
    sy= clip(sy, -100, h+100);
1634
    ex= clip(ex, -100, w+100);
1635
    ey= clip(ey, -100, h+100);
1636
    
1637
    dx= ex - sx;
1638
    dy= ey - sy;
1639
    
1640
    if(dx*dx + dy*dy > 3*3){
1641
        int rx=  dx + dy;
1642
        int ry= -dx + dy;
1643
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1644
        
1645
        //FIXME subpixel accuracy
1646
        rx= ROUNDED_DIV(rx*3<<4, length);
1647
        ry= ROUNDED_DIV(ry*3<<4, length);
1648
        
1649
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1650
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1651
    }
1652
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1653
}
1654

    
1655
/**
1656
 * prints debuging info for the given picture.
1657
 */
1658
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1659

    
1660
    if(!pict || !pict->mb_type) return;
1661

    
1662
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1663
        int x,y;
1664
        
1665
        av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1666
        switch (pict->pict_type) {
1667
            case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1668
            case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1669
            case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1670
            case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1671
            case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1672
            case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;            
1673
        }
1674
        for(y=0; y<s->mb_height; y++){
1675
            for(x=0; x<s->mb_width; x++){
1676
                if(s->avctx->debug&FF_DEBUG_SKIP){
1677
                    int count= s->mbskip_table[x + y*s->mb_stride];
1678
                    if(count>9) count=9;
1679
                    av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1680
                }
1681
                if(s->avctx->debug&FF_DEBUG_QP){
1682
                    av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1683
                }
1684
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1685
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
1686
                    //Type & MV direction
1687
                    if(IS_PCM(mb_type))
1688
                        av_log(s->avctx, AV_LOG_DEBUG, "P");
1689
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1690
                        av_log(s->avctx, AV_LOG_DEBUG, "A");
1691
                    else if(IS_INTRA4x4(mb_type))
1692
                        av_log(s->avctx, AV_LOG_DEBUG, "i");
1693
                    else if(IS_INTRA16x16(mb_type))
1694
                        av_log(s->avctx, AV_LOG_DEBUG, "I");
1695
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1696
                        av_log(s->avctx, AV_LOG_DEBUG, "d");
1697
                    else if(IS_DIRECT(mb_type))
1698
                        av_log(s->avctx, AV_LOG_DEBUG, "D");
1699
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1700
                        av_log(s->avctx, AV_LOG_DEBUG, "g");
1701
                    else if(IS_GMC(mb_type))
1702
                        av_log(s->avctx, AV_LOG_DEBUG, "G");
1703
                    else if(IS_SKIP(mb_type))
1704
                        av_log(s->avctx, AV_LOG_DEBUG, "S");
1705
                    else if(!USES_LIST(mb_type, 1))
1706
                        av_log(s->avctx, AV_LOG_DEBUG, ">");
1707
                    else if(!USES_LIST(mb_type, 0))
1708
                        av_log(s->avctx, AV_LOG_DEBUG, "<");
1709
                    else{
1710
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1711
                        av_log(s->avctx, AV_LOG_DEBUG, "X");
1712
                    }
1713
                    
1714
                    //segmentation
1715
                    if(IS_8X8(mb_type))
1716
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1717
                    else if(IS_16X8(mb_type))
1718
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1719
                    else if(IS_8X16(mb_type))
1720
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1721
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1722
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1723
                    else
1724
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1725
                    
1726
                        
1727
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1728
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1729
                    else
1730
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1731
                }
1732
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1733
            }
1734
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1735
        }
1736
    }
1737

    
1738
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1739
        const int shift= 1 + s->quarter_sample;
1740
        int mb_y;
1741
        uint8_t *ptr;
1742
        int i;
1743
        int h_chroma_shift, v_chroma_shift;
1744
        const int width = s->avctx->width;
1745
        const int height= s->avctx->height;
1746
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1747

    
1748
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1749
        for(i=0; i<3; i++){
1750
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1751
            pict->data[i]= s->visualization_buffer[i];
1752
        }
1753
        pict->type= FF_BUFFER_TYPE_COPY;
1754
        ptr= pict->data[0];
1755

    
1756
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1757
            int mb_x;
1758
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1759
                const int mb_index= mb_x + mb_y*s->mb_stride;
1760
                if((s->avctx->debug_mv) && pict->motion_val){
1761
                  int type;
1762
                  for(type=0; type<3; type++){
1763
                    int direction = 0;
1764
                    switch (type) {
1765
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1766
                                continue;
1767
                              direction = 0;
1768
                              break;
1769
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1770
                                continue;
1771
                              direction = 0;
1772
                              break;
1773
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1774
                                continue;
1775
                              direction = 1;
1776
                              break;
1777
                    }
1778
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1779
                        continue;
1780

    
1781
                    //FIXME for h264
1782
                    if(IS_8X8(pict->mb_type[mb_index])){
1783
                      int i;
1784
                      for(i=0; i<4; i++){
1785
                        int sx= mb_x*16 + 4 + 8*(i&1);
1786
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1787
                        int xy= mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*s->b8_stride;
1788
                        int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1789
                        int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1790
                        draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1791
                      }
1792
                    }else if(IS_16X8(pict->mb_type[mb_index])){
1793
                      int i;
1794
                      for(i=0; i<2; i++){
1795
                        int sx=mb_x*16 + 8;
1796
                        int sy=mb_y*16 + 4 + 8*i;
1797
                        int xy= mb_x*2 + (mb_y*2 + i)*s->b8_stride;
1798
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1799
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1800
                        
1801
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1802
                            my*=2;
1803
                        
1804
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1805
                      }
1806
                    }else{
1807
                      int sx= mb_x*16 + 8;
1808
                      int sy= mb_y*16 + 8;
1809
                      int xy= mb_x*2 + mb_y*2*s->b8_stride;
1810
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1811
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1812
                      draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1813
                    }
1814
                  }                  
1815
                }
1816
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1817
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1818
                    int y;
1819
                    for(y=0; y<8; y++){
1820
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1821
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1822
                    }
1823
                }
1824
                if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1825
                    int mb_type= pict->mb_type[mb_index];
1826
                    uint64_t u,v;
1827
                    int y;
1828
#define COLOR(theta, r)\
1829
u= (int)(128 + r*cos(theta*3.141592/180));\
1830
v= (int)(128 + r*sin(theta*3.141592/180));
1831

    
1832
                    
1833
                    u=v=128;
1834
                    if(IS_PCM(mb_type)){
1835
                        COLOR(120,48)
1836
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1837
                        COLOR(30,48)
1838
                    }else if(IS_INTRA4x4(mb_type)){
1839
                        COLOR(90,48)
1840
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1841
//                        COLOR(120,48)
1842
                    }else if(IS_DIRECT(mb_type)){
1843
                        COLOR(150,48)
1844
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1845
                        COLOR(170,48)
1846
                    }else if(IS_GMC(mb_type)){
1847
                        COLOR(190,48)
1848
                    }else if(IS_SKIP(mb_type)){
1849
//                        COLOR(180,48)
1850
                    }else if(!USES_LIST(mb_type, 1)){
1851
                        COLOR(240,48)
1852
                    }else if(!USES_LIST(mb_type, 0)){
1853
                        COLOR(0,48)
1854
                    }else{
1855
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1856
                        COLOR(300,48)
1857
                    }
1858

    
1859
                    u*= 0x0101010101010101ULL;
1860
                    v*= 0x0101010101010101ULL;
1861
                    for(y=0; y<8; y++){
1862
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1863
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1864
                    }
1865

    
1866
                    //segmentation
1867
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1868
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1869
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1870
                    }
1871
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1872
                        for(y=0; y<16; y++)
1873
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1874
                    }
1875
                        
1876
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1877
                        // hmm
1878
                    }
1879
                }
1880
                s->mbskip_table[mb_index]=0;
1881
            }
1882
        }
1883
    }
1884
}
1885

    
1886
#ifdef CONFIG_ENCODERS
1887

    
1888
static int get_sae(uint8_t *src, int ref, int stride){
1889
    int x,y;
1890
    int acc=0;
1891
    
1892
    for(y=0; y<16; y++){
1893
        for(x=0; x<16; x++){
1894
            acc+= ABS(src[x+y*stride] - ref);
1895
        }
1896
    }
1897
    
1898
    return acc;
1899
}
1900

    
1901
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1902
    int x, y, w, h;
1903
    int acc=0;
1904
    
1905
    w= s->width &~15;
1906
    h= s->height&~15;
1907
    
1908
    for(y=0; y<h; y+=16){
1909
        for(x=0; x<w; x+=16){
1910
            int offset= x + y*stride;
1911
            int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1912
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1913
            int sae = get_sae(src + offset, mean, stride);
1914
            
1915
            acc+= sae + 500 < sad;
1916
        }
1917
    }
1918
    return acc;
1919
}
1920

    
1921

    
1922
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1923
    AVFrame *pic=NULL;
1924
    int i;
1925
    const int encoding_delay= s->max_b_frames;
1926
    int direct=1;
1927
    
1928
  if(pic_arg){
1929
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1930
    if(pic_arg->linesize[0] != s->linesize) direct=0;
1931
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1932
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1933
  
1934
//    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1935
    
1936
    if(direct){
1937
        i= ff_find_unused_picture(s, 1);
1938

    
1939
        pic= (AVFrame*)&s->picture[i];
1940
        pic->reference= 3;
1941
    
1942
        for(i=0; i<4; i++){
1943
            pic->data[i]= pic_arg->data[i];
1944
            pic->linesize[i]= pic_arg->linesize[i];
1945
        }
1946
        alloc_picture(s, (Picture*)pic, 1);
1947
    }else{
1948
        int offset= 16;
1949
        i= ff_find_unused_picture(s, 0);
1950

    
1951
        pic= (AVFrame*)&s->picture[i];
1952
        pic->reference= 3;
1953

    
1954
        alloc_picture(s, (Picture*)pic, 0);
1955

    
1956
        if(   pic->data[0] + offset == pic_arg->data[0] 
1957
           && pic->data[1] + offset == pic_arg->data[1]
1958
           && pic->data[2] + offset == pic_arg->data[2]){
1959
       // empty
1960
        }else{
1961
            int h_chroma_shift, v_chroma_shift;
1962
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1963
        
1964
            for(i=0; i<3; i++){
1965
                int src_stride= pic_arg->linesize[i];
1966
                int dst_stride= i ? s->uvlinesize : s->linesize;
1967
                int h_shift= i ? h_chroma_shift : 0;
1968
                int v_shift= i ? v_chroma_shift : 0;
1969
                int w= s->width >>h_shift;
1970
                int h= s->height>>v_shift;
1971
                uint8_t *src= pic_arg->data[i];
1972
                uint8_t *dst= pic->data[i] + offset;
1973
            
1974
                if(src_stride==dst_stride)
1975
                    memcpy(dst, src, src_stride*h);
1976
                else{
1977
                    while(h--){
1978
                        memcpy(dst, src, w);
1979
                        dst += dst_stride;
1980
                        src += src_stride;
1981
                    }
1982
                }
1983
            }
1984
        }
1985
    }
1986
    copy_picture_attributes(s, pic, pic_arg);
1987
    
1988
    pic->display_picture_number= s->input_picture_number++;
1989
 
1990
    if(pic->pts != AV_NOPTS_VALUE){ 
1991
        if(s->user_specified_pts != AV_NOPTS_VALUE){
1992
            int64_t time= av_rescale(pic->pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
1993
            int64_t last= av_rescale(s->user_specified_pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
1994
        
1995
            if(time <= last){            
1996
                av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%Ld, last=%Ld\n", pic->pts, s->user_specified_pts);
1997
                return -1;
1998
            }
1999
        }
2000
        s->user_specified_pts= pic->pts;
2001
    }else{
2002
        if(s->user_specified_pts != AV_NOPTS_VALUE){
2003
            s->user_specified_pts= 
2004
            pic->pts= s->user_specified_pts + AV_TIME_BASE*(int64_t)s->avctx->frame_rate_base / s->avctx->frame_rate;
2005
            av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%Ld)\n", pic->pts);
2006
        }else{
2007
            pic->pts= av_rescale(pic->display_picture_number*(int64_t)s->avctx->frame_rate_base, AV_TIME_BASE, s->avctx->frame_rate);
2008
        }
2009
    }
2010
  }
2011
  
2012
    /* shift buffer entries */
2013
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2014
        s->input_picture[i-1]= s->input_picture[i];
2015
        
2016
    s->input_picture[encoding_delay]= (Picture*)pic;
2017

    
2018
    return 0;
2019
}
2020

    
2021
static inline int block_max(DCTELEM *block){
2022
    int i, max;
2023
    
2024
    max=0;
2025
    for(i=0; i<64; i++){
2026
        int v= ABS(block[i]);
2027
        if(v>max) max= v;
2028
    }
2029
    return max;
2030
}
2031

    
2032
static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2033
    int x, y, plane;
2034
    int score=0;
2035

    
2036
    for(plane=0; plane<3; plane++){
2037
        const int stride= p->linesize[plane];
2038
        const int bw= plane ? 1 : 2;
2039
        for(y=0; y<s->mb_height*bw; y++){
2040
            for(x=0; x<s->mb_width*bw; x++){
2041
                int v;
2042
                
2043
                s->dsp.diff_pixels(s->block[0], p->data[plane] + 8*(x + y*stride), ref->data[plane] + 8*(x + y*stride), stride);
2044
                v= block_max(s->block[0]);
2045
                
2046
                if(v>score) 
2047
                    score=v;
2048
            }
2049
        }
2050
    }
2051

    
2052
    if(score < s->avctx->frame_skip_threshold)
2053
        return 1;
2054
    if(score < ((s->avctx->frame_skip_factor * s->lambda)>>8))
2055
        return 1;
2056
    return 0;
2057
}
2058

    
2059
static void select_input_picture(MpegEncContext *s){
2060
    int i;
2061

    
2062
    for(i=1; i<MAX_PICTURE_COUNT; i++)
2063
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2064
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2065

    
2066
    /* set next picture types & ordering */
2067
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2068
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2069
            s->reordered_input_picture[0]= s->input_picture[0];
2070
            s->reordered_input_picture[0]->pict_type= I_TYPE;
2071
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2072
        }else{
2073
            int b_frames;
2074

    
2075
            if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2076
                if(skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2077
//av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2078
                
2079
                    if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2080
                        for(i=0; i<4; i++)
2081
                            s->input_picture[0]->data[i]= NULL;
2082
                        s->input_picture[0]->type= 0;            
2083
                    }else{
2084
                        assert(   s->input_picture[0]->type==FF_BUFFER_TYPE_USER 
2085
                               || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2086
            
2087
                        s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2088
                    }
2089

    
2090
                    goto no_output_pic;
2091
                }
2092
            }
2093

    
2094
            if(s->flags&CODEC_FLAG_PASS2){
2095
                for(i=0; i<s->max_b_frames+1; i++){
2096
                    int pict_num= s->input_picture[0]->display_picture_number + i;
2097

    
2098
                    if(pict_num >= s->rc_context.num_entries) 
2099
                        break;
2100
                    if(!s->input_picture[i]){
2101
                        s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2102
                        break;
2103
                    }
2104

    
2105
                    s->input_picture[i]->pict_type= 
2106
                        s->rc_context.entry[pict_num].new_pict_type;
2107
                }
2108
            }
2109

    
2110
            if(s->avctx->b_frame_strategy==0){
2111
                b_frames= s->max_b_frames;
2112
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
2113
            }else if(s->avctx->b_frame_strategy==1){
2114
                for(i=1; i<s->max_b_frames+1; i++){
2115
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2116
                        s->input_picture[i]->b_frame_score= 
2117
                            get_intra_count(s, s->input_picture[i  ]->data[0], 
2118
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
2119
                    }
2120
                }
2121
                for(i=0; i<s->max_b_frames; i++){
2122
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2123
                }
2124
                                
2125
                b_frames= FFMAX(0, i-1);
2126
                
2127
                /* reset scores */
2128
                for(i=0; i<b_frames+1; i++){
2129
                    s->input_picture[i]->b_frame_score=0;
2130
                }
2131
            }else{
2132
                av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2133
                b_frames=0;
2134
            }
2135

    
2136
            emms_c();
2137
//static int b_count=0;
2138
//b_count+= b_frames;
2139
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2140

    
2141
            for(i= b_frames - 1; i>=0; i--){
2142
                int type= s->input_picture[i]->pict_type;
2143
                if(type && type != B_TYPE)
2144
                    b_frames= i;
2145
            }
2146
            if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2147
                av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
2148
            }
2149

    
2150
            if(s->picture_in_gop_number + b_frames >= s->gop_size){
2151
              if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2152
                    b_frames= s->gop_size - s->picture_in_gop_number - 1;
2153
              }else{
2154
                if(s->flags & CODEC_FLAG_CLOSED_GOP)
2155
                    b_frames=0;
2156
                s->input_picture[b_frames]->pict_type= I_TYPE;
2157
              }
2158
            }
2159
            
2160
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2161
               && b_frames
2162
               && s->input_picture[b_frames]->pict_type== I_TYPE)
2163
                b_frames--;
2164

    
2165
            s->reordered_input_picture[0]= s->input_picture[b_frames];
2166
            if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2167
                s->reordered_input_picture[0]->pict_type= P_TYPE;
2168
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2169
            for(i=0; i<b_frames; i++){
2170
                s->reordered_input_picture[i+1]= s->input_picture[i];
2171
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2172
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2173
            }
2174
        }
2175
    }
2176
no_output_pic:
2177
    if(s->reordered_input_picture[0]){
2178
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2179

    
2180
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2181

    
2182
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2183
            // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2184
        
2185
            int i= ff_find_unused_picture(s, 0);
2186
            Picture *pic= &s->picture[i];
2187

    
2188
            /* mark us unused / free shared pic */
2189
            for(i=0; i<4; i++)
2190
                s->reordered_input_picture[0]->data[i]= NULL;
2191
            s->reordered_input_picture[0]->type= 0;
2192
            
2193
            pic->reference              = s->reordered_input_picture[0]->reference;
2194
            
2195
            alloc_picture(s, pic, 0);
2196

    
2197
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2198

    
2199
            s->current_picture_ptr= pic;
2200
        }else{
2201
            // input is not a shared pix -> reuse buffer for current_pix
2202

    
2203
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
2204
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2205
            
2206
            s->current_picture_ptr= s->reordered_input_picture[0];
2207
            for(i=0; i<4; i++){
2208
                s->new_picture.data[i]+=16;
2209
            }
2210
        }
2211
        copy_picture(&s->current_picture, s->current_picture_ptr);
2212
    
2213
        s->picture_number= s->new_picture.display_picture_number;
2214
//printf("dpn:%d\n", s->picture_number);
2215
    }else{
2216
       memset(&s->new_picture, 0, sizeof(Picture));
2217
    }
2218
}
2219

    
2220
int MPV_encode_picture(AVCodecContext *avctx,
2221
                       unsigned char *buf, int buf_size, void *data)
2222
{
2223
    MpegEncContext *s = avctx->priv_data;
2224
    AVFrame *pic_arg = data;
2225
    int i, stuffing_count;
2226

    
2227
    if(avctx->pix_fmt != PIX_FMT_YUV420P){
2228
        av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2229
        return -1;
2230
    }
2231
    
2232
    for(i=0; i<avctx->thread_count; i++){
2233
        int start_y= s->thread_context[i]->start_mb_y;
2234
        int   end_y= s->thread_context[i]->  end_mb_y;
2235
        int h= s->mb_height;
2236
        uint8_t *start= buf + buf_size*start_y/h;
2237
        uint8_t *end  = buf + buf_size*  end_y/h;
2238

    
2239
        init_put_bits(&s->thread_context[i]->pb, start, end - start);
2240
    }
2241

    
2242
    s->picture_in_gop_number++;
2243

    
2244
    if(load_input_picture(s, pic_arg) < 0)
2245
        return -1;
2246
    
2247
    select_input_picture(s);
2248
    
2249
    /* output? */
2250
    if(s->new_picture.data[0]){
2251
        s->pict_type= s->new_picture.pict_type;
2252
//emms_c();
2253
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2254
        MPV_frame_start(s, avctx);
2255

    
2256
        encode_picture(s, s->picture_number);
2257
        
2258
        avctx->real_pict_num  = s->picture_number;
2259
        avctx->header_bits = s->header_bits;
2260
        avctx->mv_bits     = s->mv_bits;
2261
        avctx->misc_bits   = s->misc_bits;
2262
        avctx->i_tex_bits  = s->i_tex_bits;
2263
        avctx->p_tex_bits  = s->p_tex_bits;
2264
        avctx->i_count     = s->i_count;
2265
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2266
        avctx->skip_count  = s->skip_count;
2267

    
2268
        MPV_frame_end(s);
2269

    
2270
        if (s->out_format == FMT_MJPEG)
2271
            mjpeg_picture_trailer(s);
2272
        
2273
        if(s->flags&CODEC_FLAG_PASS1)
2274
            ff_write_pass1_stats(s);
2275

    
2276
        for(i=0; i<4; i++){
2277
            avctx->error[i] += s->current_picture_ptr->error[i];
2278
        }
2279

    
2280
        flush_put_bits(&s->pb);
2281
        s->frame_bits  = put_bits_count(&s->pb);
2282

    
2283
        stuffing_count= ff_vbv_update(s, s->frame_bits);
2284
        if(stuffing_count){
2285
            switch(s->codec_id){
2286
            case CODEC_ID_MPEG1VIDEO:
2287
            case CODEC_ID_MPEG2VIDEO:
2288
                while(stuffing_count--){
2289
                    put_bits(&s->pb, 8, 0);
2290
                }
2291
            break;
2292
            case CODEC_ID_MPEG4:
2293
                put_bits(&s->pb, 16, 0);
2294
                put_bits(&s->pb, 16, 0x1C3);
2295
                stuffing_count -= 4;
2296
                while(stuffing_count--){
2297
                    put_bits(&s->pb, 8, 0xFF);
2298
                }
2299
            break;
2300
            default:
2301
                av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2302
            }
2303
            flush_put_bits(&s->pb);
2304
            s->frame_bits  = put_bits_count(&s->pb);
2305
        }
2306

    
2307
        /* update mpeg1/2 vbv_delay for CBR */    
2308
        if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2309
           && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2310
            int vbv_delay;
2311

    
2312
            assert(s->repeat_first_field==0);
2313
            
2314
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2315
            assert(vbv_delay < 0xFFFF);
2316

    
2317
            s->vbv_delay_ptr[0] &= 0xF8;
2318
            s->vbv_delay_ptr[0] |= vbv_delay>>13;
2319
            s->vbv_delay_ptr[1]  = vbv_delay>>5;
2320
            s->vbv_delay_ptr[2] &= 0x07;
2321
            s->vbv_delay_ptr[2] |= vbv_delay<<3;
2322
        }
2323
        s->total_bits += s->frame_bits;
2324
        avctx->frame_bits  = s->frame_bits;
2325
    }else{
2326
        assert((pbBufPtr(&s->pb) == s->pb.buf));
2327
        s->frame_bits=0;
2328
    }
2329
    assert((s->frame_bits&7)==0);
2330
    
2331
    return s->frame_bits/8;
2332
}
2333

    
2334
#endif //CONFIG_ENCODERS
2335

    
2336
static inline void gmc1_motion(MpegEncContext *s,
2337
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2338
                               uint8_t **ref_picture)
2339
{
2340
    uint8_t *ptr;
2341
    int offset, src_x, src_y, linesize, uvlinesize;
2342
    int motion_x, motion_y;
2343
    int emu=0;
2344

    
2345
    motion_x= s->sprite_offset[0][0];
2346
    motion_y= s->sprite_offset[0][1];
2347
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2348
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2349
    motion_x<<=(3-s->sprite_warping_accuracy);
2350
    motion_y<<=(3-s->sprite_warping_accuracy);
2351
    src_x = clip(src_x, -16, s->width);
2352
    if (src_x == s->width)
2353
        motion_x =0;
2354
    src_y = clip(src_y, -16, s->height);
2355
    if (src_y == s->height)
2356
        motion_y =0;
2357

    
2358
    linesize = s->linesize;
2359
    uvlinesize = s->uvlinesize;
2360
    
2361
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2362

    
2363
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2364
        if(   (unsigned)src_x >= s->h_edge_pos - 17
2365
           || (unsigned)src_y >= s->v_edge_pos - 17){
2366
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2367
            ptr= s->edge_emu_buffer;
2368
        }
2369
    }
2370
    
2371
    if((motion_x|motion_y)&7){
2372
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2373
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2374
    }else{
2375
        int dxy;
2376
        
2377
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2378
        if (s->no_rounding){
2379
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2380
        }else{
2381
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2382
        }
2383
    }
2384
    
2385
    if(s->flags&CODEC_FLAG_GRAY) return;
2386

    
2387
    motion_x= s->sprite_offset[1][0];
2388
    motion_y= s->sprite_offset[1][1];
2389
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2390
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2391
    motion_x<<=(3-s->sprite_warping_accuracy);
2392
    motion_y<<=(3-s->sprite_warping_accuracy);
2393
    src_x = clip(src_x, -8, s->width>>1);
2394
    if (src_x == s->width>>1)
2395
        motion_x =0;
2396
    src_y = clip(src_y, -8, s->height>>1);
2397
    if (src_y == s->height>>1)
2398
        motion_y =0;
2399

    
2400
    offset = (src_y * uvlinesize) + src_x;
2401
    ptr = ref_picture[1] + offset;
2402
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2403
        if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2404
           || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2405
            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);
2406
            ptr= s->edge_emu_buffer;
2407
            emu=1;
2408
        }
2409
    }
2410
    s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2411
    
2412
    ptr = ref_picture[2] + offset;
2413
    if(emu){
2414
        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);
2415
        ptr= s->edge_emu_buffer;
2416
    }
2417
    s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2418
    
2419
    return;
2420
}
2421

    
2422
static inline void gmc_motion(MpegEncContext *s,
2423
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2424
                               uint8_t **ref_picture)
2425
{
2426
    uint8_t *ptr;
2427
    int linesize, uvlinesize;
2428
    const int a= s->sprite_warping_accuracy;
2429
    int ox, oy;
2430

    
2431
    linesize = s->linesize;
2432
    uvlinesize = s->uvlinesize;
2433

    
2434
    ptr = ref_picture[0];
2435

    
2436
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2437
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2438

    
2439
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2440
           ox, 
2441
           oy, 
2442
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2443
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2444
           a+1, (1<<(2*a+1)) - s->no_rounding,
2445
           s->h_edge_pos, s->v_edge_pos);
2446
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2447
           ox + s->sprite_delta[0][0]*8, 
2448
           oy + s->sprite_delta[1][0]*8, 
2449
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2450
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2451
           a+1, (1<<(2*a+1)) - s->no_rounding,
2452
           s->h_edge_pos, s->v_edge_pos);
2453

    
2454
    if(s->flags&CODEC_FLAG_GRAY) return;
2455

    
2456
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2457
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2458

    
2459
    ptr = ref_picture[1];
2460
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2461
           ox, 
2462
           oy, 
2463
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2464
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2465
           a+1, (1<<(2*a+1)) - s->no_rounding,
2466
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2467
    
2468
    ptr = ref_picture[2];
2469
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2470
           ox, 
2471
           oy, 
2472
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2473
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2474
           a+1, (1<<(2*a+1)) - s->no_rounding,
2475
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2476
}
2477

    
2478
/**
2479
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2480
 * @param buf destination buffer
2481
 * @param src source buffer
2482
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2483
 * @param block_w width of block
2484
 * @param block_h height of block
2485
 * @param src_x x coordinate of the top left sample of the block in the source buffer
2486
 * @param src_y y coordinate of the top left sample of the block in the source buffer
2487
 * @param w width of the source buffer
2488
 * @param h height of the source buffer
2489
 */
2490
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
2491
                                    int src_x, int src_y, int w, int h){
2492
    int x, y;
2493
    int start_y, start_x, end_y, end_x;
2494

    
2495
    if(src_y>= h){
2496
        src+= (h-1-src_y)*linesize;
2497
        src_y=h-1;
2498
    }else if(src_y<=-block_h){
2499
        src+= (1-block_h-src_y)*linesize;
2500
        src_y=1-block_h;
2501
    }
2502
    if(src_x>= w){
2503
        src+= (w-1-src_x);
2504
        src_x=w-1;
2505
    }else if(src_x<=-block_w){
2506
        src+= (1-block_w-src_x);
2507
        src_x=1-block_w;
2508
    }
2509

    
2510
    start_y= FFMAX(0, -src_y);
2511
    start_x= FFMAX(0, -src_x);
2512
    end_y= FFMIN(block_h, h-src_y);
2513
    end_x= FFMIN(block_w, w-src_x);
2514

    
2515
    // copy existing part
2516
    for(y=start_y; y<end_y; y++){
2517
        for(x=start_x; x<end_x; x++){
2518
            buf[x + y*linesize]= src[x + y*linesize];
2519
        }
2520
    }
2521

    
2522
    //top
2523
    for(y=0; y<start_y; y++){
2524
        for(x=start_x; x<end_x; x++){
2525
            buf[x + y*linesize]= buf[x + start_y*linesize];
2526
        }
2527
    }
2528

    
2529
    //bottom
2530
    for(y=end_y; y<block_h; y++){
2531
        for(x=start_x; x<end_x; x++){
2532
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2533
        }
2534
    }
2535
                                    
2536
    for(y=0; y<block_h; y++){
2537
       //left
2538
        for(x=0; x<start_x; x++){
2539
            buf[x + y*linesize]= buf[start_x + y*linesize];
2540
        }
2541
       
2542
       //right
2543
        for(x=end_x; x<block_w; x++){
2544
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2545
        }
2546
    }
2547
}
2548

    
2549
static inline int hpel_motion(MpegEncContext *s, 
2550
                                  uint8_t *dest, uint8_t *src,
2551
                                  int field_based, int field_select,
2552
                                  int src_x, int src_y,
2553
                                  int width, int height, int stride,
2554
                                  int h_edge_pos, int v_edge_pos,
2555
                                  int w, int h, op_pixels_func *pix_op,
2556
                                  int motion_x, int motion_y)
2557
{
2558
    int dxy;
2559
    int emu=0;
2560

    
2561
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2562
    src_x += motion_x >> 1;
2563
    src_y += motion_y >> 1;
2564
                
2565
    /* WARNING: do no forget half pels */
2566
    src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2567
    if (src_x == width)
2568
        dxy &= ~1;
2569
    src_y = clip(src_y, -16, height);
2570
    if (src_y == height)
2571
        dxy &= ~2;
2572
    src += src_y * stride + src_x;
2573

    
2574
    if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2575
        if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2576
           || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2577
            ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2578
                             src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2579
            src= s->edge_emu_buffer;
2580
            emu=1;
2581
        }
2582
    }
2583
    if(field_select)
2584
        src += s->linesize;
2585
    pix_op[dxy](dest, src, stride, h);
2586
    return emu;
2587
}
2588

    
2589
static inline int hpel_motion_lowres(MpegEncContext *s, 
2590
                                  uint8_t *dest, uint8_t *src,
2591
                                  int field_based, int field_select,
2592
                                  int src_x, int src_y,
2593
                                  int width, int height, int stride,
2594
                                  int h_edge_pos, int v_edge_pos,
2595
                                  int w, int h, h264_chroma_mc_func *pix_op,
2596
                                  int motion_x, int motion_y)
2597
{
2598
    const int lowres= s->avctx->lowres;
2599
    const int s_mask= (2<<lowres)-1;
2600
    int emu=0;
2601
    int sx, sy;
2602

    
2603
    if(s->quarter_sample){
2604
        motion_x/=2;
2605
        motion_y/=2;
2606
    }
2607

    
2608
    sx= motion_x & s_mask;
2609
    sy= motion_y & s_mask;
2610
    src_x += motion_x >> (lowres+1);
2611
    src_y += motion_y >> (lowres+1);
2612
                
2613
    src += src_y * stride + src_x;
2614

    
2615
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
2616
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2617
        ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2618
                            src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2619
        src= s->edge_emu_buffer;
2620
        emu=1;
2621
    }
2622

    
2623
    sx <<= 2 - lowres;
2624
    sy <<= 2 - lowres;
2625
    if(field_select)
2626
        src += s->linesize;
2627
    pix_op[lowres](dest, src, stride, h, sx, sy);
2628
    return emu;
2629
}
2630

    
2631
/* apply one mpeg motion vector to the three components */
2632
static always_inline void mpeg_motion(MpegEncContext *s,
2633
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2634
                               int field_based, int bottom_field, int field_select,
2635
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2636
                               int motion_x, int motion_y, int h)
2637
{
2638
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2639
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2640
    
2641
#if 0    
2642
if(s->quarter_sample)
2643
{
2644
    motion_x>>=1;
2645
    motion_y>>=1;
2646
}
2647
#endif
2648

    
2649
    v_edge_pos = s->v_edge_pos >> field_based;
2650
    linesize   = s->current_picture.linesize[0] << field_based;
2651
    uvlinesize = s->current_picture.linesize[1] << field_based;
2652

    
2653
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2654
    src_x = s->mb_x* 16               + (motion_x >> 1);
2655
    src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2656

    
2657
    if (s->out_format == FMT_H263) {
2658
        if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2659
            mx = (motion_x>>1)|(motion_x&1);
2660
            my = motion_y >>1;
2661
            uvdxy = ((my & 1) << 1) | (mx & 1);
2662
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2663
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2664
        }else{
2665
            uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2666
            uvsrc_x = src_x>>1;
2667
            uvsrc_y = src_y>>1;
2668
        }
2669
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2670
        mx = motion_x / 4;
2671
        my = motion_y / 4;
2672
        uvdxy = 0;
2673
        uvsrc_x = s->mb_x*8 + mx;
2674
        uvsrc_y = s->mb_y*8 + my;
2675
    } else {
2676
        if(s->chroma_y_shift){
2677
            mx = motion_x / 2;
2678
            my = motion_y / 2;
2679
            uvdxy = ((my & 1) << 1) | (mx & 1);
2680
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2681
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2682
        } else {
2683
            if(s->chroma_x_shift){
2684
            //Chroma422
2685
                mx = motion_x / 2;
2686
                uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2687
                uvsrc_x = s->mb_x* 8           + (mx >> 1);
2688
                uvsrc_y = src_y;
2689
            } else {
2690
            //Chroma444
2691
                uvdxy = dxy;
2692
                uvsrc_x = src_x;
2693
                uvsrc_y = src_y;
2694
            }
2695
        }
2696
    }
2697

    
2698
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2699
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2700
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2701

    
2702
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2703
       || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
2704
            if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2705
               s->codec_id == CODEC_ID_MPEG1VIDEO){
2706
                av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2707
                return ;
2708
            }
2709
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2710
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2711
            ptr_y = s->edge_emu_buffer;
2712
            if(!(s->flags&CODEC_FLAG_GRAY)){
2713
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2714
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2715
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2716
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2717
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2718
                ptr_cb= uvbuf;
2719
                ptr_cr= uvbuf+16;
2720
            }
2721
    }
2722

    
2723
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2724
        dest_y += s->linesize;
2725
        dest_cb+= s->uvlinesize;
2726
        dest_cr+= s->uvlinesize;
2727
    }
2728

    
2729
    if(field_select){
2730
        ptr_y += s->linesize;
2731
        ptr_cb+= s->uvlinesize;
2732
        ptr_cr+= s->uvlinesize;
2733
    }
2734

    
2735
    pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2736
    
2737
    if(!(s->flags&CODEC_FLAG_GRAY)){
2738
        pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2739
        pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2740
    }
2741
    if(s->out_format == FMT_H261){
2742
        ff_h261_loop_filter(s);
2743
    }
2744
}
2745

    
2746
/* apply one mpeg motion vector to the three components */
2747
static always_inline void mpeg_motion_lowres(MpegEncContext *s,
2748
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2749
                               int field_based, int bottom_field, int field_select,
2750
                               uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
2751
                               int motion_x, int motion_y, int h)
2752
{
2753
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2754
    int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
2755
    const int lowres= s->avctx->lowres;
2756
    const int block_s= 8>>lowres;
2757
    const int s_mask= (2<<lowres)-1;
2758
    const int h_edge_pos = s->h_edge_pos >> lowres;
2759
    const int v_edge_pos = s->v_edge_pos >> lowres;
2760
    linesize   = s->current_picture.linesize[0] << field_based;
2761
    uvlinesize = s->current_picture.linesize[1] << field_based;
2762

    
2763
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
2764
        motion_x/=2;
2765
        motion_y/=2;
2766
    }
2767
    
2768
    if(field_based){
2769
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
2770
    }
2771

    
2772
    sx= motion_x & s_mask;
2773
    sy= motion_y & s_mask;
2774
    src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
2775
    src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
2776
    
2777
    if (s->out_format == FMT_H263) {
2778
        uvsx = ((motion_x>>1) & s_mask) | (sx&1);
2779
        uvsy = ((motion_y>>1) & s_mask) | (sy&1);
2780
        uvsrc_x = src_x>>1;
2781
        uvsrc_y = src_y>>1;
2782
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2783
        mx = motion_x / 4;
2784
        my = motion_y / 4;
2785
        uvsx = (2*mx) & s_mask;
2786
        uvsy = (2*my) & s_mask;
2787
        uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
2788
        uvsrc_y = s->mb_y*block_s               + (my >> lowres);
2789
    } else {
2790
        mx = motion_x / 2;
2791
        my = motion_y / 2;
2792
        uvsx = mx & s_mask;
2793
        uvsy = my & s_mask;
2794
        uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2795
        uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
2796
    }
2797

    
2798
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2799
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2800
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2801

    
2802
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
2803
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2804
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2805
                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2806
            ptr_y = s->edge_emu_buffer;
2807
            if(!(s->flags&CODEC_FLAG_GRAY)){
2808
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2809
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2810
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2811
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2812
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2813
                ptr_cb= uvbuf;
2814
                ptr_cr= uvbuf+16;
2815
            }
2816
    }
2817

    
2818
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2819
        dest_y += s->linesize;
2820
        dest_cb+= s->uvlinesize;
2821
        dest_cr+= s->uvlinesize;
2822
    }
2823

    
2824
    if(field_select){
2825
        ptr_y += s->linesize;
2826
        ptr_cb+= s->uvlinesize;
2827
        ptr_cr+= s->uvlinesize;
2828
    }
2829

    
2830
    sx <<= 2 - lowres;
2831
    sy <<= 2 - lowres;
2832
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
2833
    
2834
    if(!(s->flags&CODEC_FLAG_GRAY)){
2835
        uvsx <<= 2 - lowres;
2836
        uvsy <<= 2 - lowres;
2837
        pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2838
        pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2839
    }
2840
    //FIXME h261 lowres loop filter
2841
}
2842

    
2843
//FIXME move to dsputil, avg variant, 16x16 version
2844
static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2845
    int x;
2846
    uint8_t * const top   = src[1];
2847
    uint8_t * const left  = src[2];
2848
    uint8_t * const mid   = src[0];
2849
    uint8_t * const right = src[3];
2850
    uint8_t * const bottom= src[4];
2851
#define OBMC_FILTER(x, t, l, m, r, b)\
2852
    dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2853
#define OBMC_FILTER4(x, t, l, m, r, b)\
2854
    OBMC_FILTER(x         , t, l, m, r, b);\
2855
    OBMC_FILTER(x+1       , t, l, m, r, b);\
2856
    OBMC_FILTER(x  +stride, t, l, m, r, b);\
2857
    OBMC_FILTER(x+1+stride, t, l, m, r, b);
2858
    
2859
    x=0;
2860
    OBMC_FILTER (x  , 2, 2, 4, 0, 0);
2861
    OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2862
    OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2863
    OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2864
    OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2865
    OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2866
    x+= stride;
2867
    OBMC_FILTER (x  , 1, 2, 5, 0, 0);
2868
    OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2869
    OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2870
    OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2871
    x+= stride;
2872
    OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
2873
    OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2874
    OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2875
    OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2876
    x+= 2*stride;
2877
    OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
2878
    OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2879
    OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2880
    OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2881
    x+= 2*stride;
2882
    OBMC_FILTER (x  , 0, 2, 5, 0, 1);
2883
    OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2884
    OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2885
    OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2886
    OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2887
    OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2888
    x+= stride;
2889
    OBMC_FILTER (x  , 0, 2, 4, 0, 2);
2890
    OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2891
    OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2892
    OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2893
}
2894

    
2895
/* obmc for 1 8x8 luma block */
2896
static inline void obmc_motion(MpegEncContext *s,
2897
                               uint8_t *dest, uint8_t *src,
2898
                               int src_x, int src_y,
2899
                               op_pixels_func *pix_op,
2900
                               int16_t mv[5][2]/* mid top left right bottom*/)
2901
#define MID    0
2902
{
2903
    int i;
2904
    uint8_t *ptr[5];
2905
    
2906
    assert(s->quarter_sample==0);
2907
    
2908
    for(i=0; i<5; i++){
2909
        if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2910
            ptr[i]= ptr[MID];
2911
        }else{
2912
            ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
2913
            hpel_motion(s, ptr[i], src, 0, 0,
2914
                        src_x, src_y,
2915
                        s->width, s->height, s->linesize,
2916
                        s->h_edge_pos, s->v_edge_pos,
2917
                        8, 8, pix_op,
2918
                        mv[i][0], mv[i][1]);
2919
        }
2920
    }
2921

    
2922
    put_obmc(dest, ptr, s->linesize);                
2923
}
2924

    
2925
static inline void qpel_motion(MpegEncContext *s,
2926
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2927
                               int field_based, int bottom_field, int field_select,
2928
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2929
                               qpel_mc_func (*qpix_op)[16],
2930
                               int motion_x, int motion_y, int h)
2931
{
2932
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2933
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
2934

    
2935
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2936
    src_x = s->mb_x *  16                 + (motion_x >> 2);
2937
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2938

    
2939
    v_edge_pos = s->v_edge_pos >> field_based;
2940
    linesize = s->linesize << field_based;
2941
    uvlinesize = s->uvlinesize << field_based;
2942
    
2943
    if(field_based){
2944
        mx= motion_x/2;
2945
        my= motion_y>>1;
2946
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2947
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
2948
        mx= (motion_x>>1) + rtab[motion_x&7];
2949
        my= (motion_y>>1) + rtab[motion_y&7];
2950
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2951
        mx= (motion_x>>1)|(motion_x&1);
2952
        my= (motion_y>>1)|(motion_y&1);
2953
    }else{
2954
        mx= motion_x/2;
2955
        my= motion_y/2;
2956
    }
2957
    mx= (mx>>1)|(mx&1);
2958
    my= (my>>1)|(my&1);
2959

    
2960
    uvdxy= (mx&1) | ((my&1)<<1);
2961
    mx>>=1;
2962
    my>>=1;
2963

    
2964
    uvsrc_x = s->mb_x *  8                 + mx;
2965
    uvsrc_y = s->mb_y * (8 >> field_based) + my;
2966

    
2967
    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
2968
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2969
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2970

    
2971
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 
2972
       || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
2973
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, 
2974
                         src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2975
        ptr_y= s->edge_emu_buffer;
2976
        if(!(s->flags&CODEC_FLAG_GRAY)){
2977
            uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
2978
            ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based, 
2979
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2980
            ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based, 
2981
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2982
            ptr_cb= uvbuf;
2983
            ptr_cr= uvbuf + 16;
2984
        }
2985
    }
2986

    
2987
    if(!field_based)
2988
        qpix_op[0][dxy](dest_y, ptr_y, linesize);
2989
    else{
2990
        if(bottom_field){
2991
            dest_y += s->linesize;
2992
            dest_cb+= s->uvlinesize;
2993
            dest_cr+= s->uvlinesize;
2994
        }
2995

    
2996
        if(field_select){
2997
            ptr_y  += s->linesize;
2998
            ptr_cb += s->uvlinesize;
2999
            ptr_cr += s->uvlinesize;
3000
        }
3001
        //damn interlaced mode
3002
        //FIXME boundary mirroring is not exactly correct here
3003
        qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
3004
        qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3005
    }
3006
    if(!(s->flags&CODEC_FLAG_GRAY)){
3007
        pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3008
        pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3009
    }
3010
}
3011

    
3012
inline int ff_h263_round_chroma(int x){
3013
    if (x >= 0)
3014
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3015
    else {
3016
        x = -x;
3017
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3018
    }
3019
}
3020

    
3021
/**
3022
 * h263 chorma 4mv motion compensation.
3023
 */
3024
static inline void chroma_4mv_motion(MpegEncContext *s,
3025
                                     uint8_t *dest_cb, uint8_t *dest_cr,
3026
                                     uint8_t **ref_picture,
3027
                                     op_pixels_func *pix_op,
3028
                                     int mx, int my){
3029
    int dxy, emu=0, src_x, src_y, offset;
3030
    uint8_t *ptr;
3031
    
3032
    /* In case of 8X8, we construct a single chroma motion vector
3033
       with a special rounding */
3034
    mx= ff_h263_round_chroma(mx);
3035
    my= ff_h263_round_chroma(my);
3036
    
3037
    dxy = ((my & 1) << 1) | (mx & 1);
3038
    mx >>= 1;
3039
    my >>= 1;
3040

    
3041
    src_x = s->mb_x * 8 + mx;
3042
    src_y = s->mb_y * 8 + my;
3043
    src_x = clip(src_x, -8, s->width/2);
3044
    if (src_x == s->width/2)
3045
        dxy &= ~1;
3046
    src_y = clip(src_y, -8, s->height/2);
3047
    if (src_y == s->height/2)
3048
        dxy &= ~2;
3049
    
3050
    offset = (src_y * (s->uvlinesize)) + src_x;
3051
    ptr = ref_picture[1] + offset;
3052
    if(s->flags&CODEC_FLAG_EMU_EDGE){
3053
        if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3054
           || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3055
            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);
3056
            ptr= s->edge_emu_buffer;
3057
            emu=1;
3058
        }
3059
    }
3060
    pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3061

    
3062
    ptr = ref_picture[2] + offset;
3063
    if(emu){
3064
        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);
3065
        ptr= s->edge_emu_buffer;
3066
    }
3067
    pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3068
}
3069

    
3070
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3071
                                     uint8_t *dest_cb, uint8_t *dest_cr,
3072
                                     uint8_t **ref_picture,
3073
                                     h264_chroma_mc_func *pix_op,
3074
                                     int mx, int my){
3075
    const int lowres= s->avctx->lowres;
3076
    const int block_s= 8>>lowres;
3077
    const int s_mask= (2<<lowres)-1;
3078
    const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3079
    const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3080
    int emu=0, src_x, src_y, offset, sx, sy;
3081
    uint8_t *ptr;
3082
    
3083
    if(s->quarter_sample){
3084
        mx/=2;
3085
        my/=2;
3086
    }
3087

    
3088
    /* In case of 8X8, we construct a single chroma motion vector
3089
       with a special rounding */
3090
    mx= ff_h263_round_chroma(mx);
3091
    my= ff_h263_round_chroma(my);
3092
    
3093
    sx= mx & s_mask;
3094
    sy= my & s_mask;
3095
    src_x = s->mb_x*block_s + (mx >> (lowres+1));
3096
    src_y = s->mb_y*block_s + (my >> (lowres+1));
3097
    
3098
    offset = src_y * s->uvlinesize + src_x;
3099
    ptr = ref_picture[1] + offset;
3100
    if(s->flags&CODEC_FLAG_EMU_EDGE){
3101
        if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3102
           || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3103
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3104
            ptr= s->edge_emu_buffer;
3105
            emu=1;
3106
        }
3107
    }     
3108
    sx <<= 2 - lowres;
3109
    sy <<= 2 - lowres;
3110
    pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3111
          
3112
    ptr = ref_picture[2] + offset;
3113
    if(emu){
3114
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3115
        ptr= s->edge_emu_buffer;
3116
    }
3117
    pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3118
}
3119

    
3120
/**
3121
 * motion compesation of a single macroblock
3122
 * @param s context
3123
 * @param dest_y luma destination pointer
3124
 * @param dest_cb chroma cb/u destination pointer
3125
 * @param dest_cr chroma cr/v destination pointer
3126
 * @param dir direction (0->forward, 1->backward)
3127
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3128
 * @param pic_op halfpel motion compensation function (average or put normally)
3129
 * @param pic_op qpel motion compensation function (average or put normally)
3130
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3131
 */
3132
static inline void MPV_motion(MpegEncContext *s, 
3133
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3134
                              int dir, uint8_t **ref_picture, 
3135
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3136
{
3137
    int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3138
    int mb_x, mb_y, i;
3139
    uint8_t *ptr, *dest;
3140

    
3141
    mb_x = s->mb_x;
3142
    mb_y = s->mb_y;
3143

    
3144
    if(s->obmc && s->pict_type != B_TYPE){
3145
        int16_t mv_cache[4][4][2];
3146
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
3147
        const int mot_stride= s->b8_stride;
3148
        const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3149

    
3150
        assert(!s->mb_skiped);
3151
                
3152
        memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
3153
        memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3154
        memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3155

    
3156
        if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3157
            memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3158
        }else{
3159
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3160
        }
3161

    
3162
        if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3163
            *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3164
            *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3165
        }else{
3166
            *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3167
            *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3168
        }
3169

    
3170
        if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3171
            *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3172
            *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3173
        }else{
3174
            *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3175
            *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3176
        }
3177
        
3178
        mx = 0;
3179
        my = 0;
3180
        for(i=0;i<4;i++) {
3181
            const int x= (i&1)+1;
3182
            const int y= (i>>1)+1;
3183
            int16_t mv[5][2]= {
3184
                {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
3185
                {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3186
                {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3187
                {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3188
                {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3189
            //FIXME cleanup
3190
            obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3191
                        ref_picture[0],
3192
                        mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3193
                        pix_op[1],
3194
                        mv);
3195

    
3196
            mx += mv[0][0];
3197
            my += mv[0][1];
3198
        }
3199
        if(!(s->flags&CODEC_FLAG_GRAY))
3200
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3201

    
3202
        return;
3203
    }
3204
   
3205
    switch(s->mv_type) {
3206
    case MV_TYPE_16X16:
3207
#ifdef CONFIG_RISKY
3208
        if(s->mcsel){
3209
            if(s->real_sprite_warping_points==1){
3210
                gmc1_motion(s, dest_y, dest_cb, dest_cr,
3211
                            ref_picture);
3212
            }else{
3213
                gmc_motion(s, dest_y, dest_cb, dest_cr,
3214
                            ref_picture);
3215
            }
3216
        }else if(s->quarter_sample){
3217
            qpel_motion(s, dest_y, dest_cb, dest_cr, 
3218
                        0, 0, 0,
3219
                        ref_picture, pix_op, qpix_op,
3220
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3221
        }else if(s->mspel){
3222
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3223
                        ref_picture, pix_op,
3224
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3225
        }else
3226
#endif
3227
        {
3228
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3229
                        0, 0, 0,
3230
                        ref_picture, pix_op,
3231
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3232
        }           
3233
        break;
3234
    case MV_TYPE_8X8:
3235
        mx = 0;
3236
        my = 0;
3237
        if(s->quarter_sample){
3238
            for(i=0;i<4;i++) {
3239
                motion_x = s->mv[dir][i][0];
3240
                motion_y = s->mv[dir][i][1];
3241

    
3242
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3243
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3244
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3245
                    
3246
                /* WARNING: do no forget half pels */
3247
                src_x = clip(src_x, -16, s->width);
3248
                if (src_x == s->width)
3249
                    dxy &= ~3;
3250
                src_y = clip(src_y, -16, s->height);
3251
                if (src_y == s->height)
3252
                    dxy &= ~12;
3253
                    
3254
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3255
                if(s->flags&CODEC_FLAG_EMU_EDGE){
3256
                    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8 
3257
                       || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3258
                        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);
3259
                        ptr= s->edge_emu_buffer;
3260
                    }
3261
                }
3262
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3263
                qpix_op[1][dxy](dest, ptr, s->linesize);
3264

    
3265
                mx += s->mv[dir][i][0]/2;
3266
                my += s->mv[dir][i][1]/2;
3267
            }
3268
        }else{
3269
            for(i=0;i<4;i++) {
3270
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3271
                            ref_picture[0], 0, 0,
3272
                            mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3273
                            s->width, s->height, s->linesize,
3274
                            s->h_edge_pos, s->v_edge_pos,
3275
                            8, 8, pix_op[1],
3276
                            s->mv[dir][i][0], s->mv[dir][i][1]);
3277

    
3278
                mx += s->mv[dir][i][0];
3279
                my += s->mv[dir][i][1];
3280
            }
3281
        }
3282

    
3283
        if(!(s->flags&CODEC_FLAG_GRAY))
3284
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3285
        break;
3286
    case MV_TYPE_FIELD:
3287
        if (s->picture_structure == PICT_FRAME) {
3288
            if(s->quarter_sample){
3289
                for(i=0; i<2; i++){
3290
                    qpel_motion(s, dest_y, dest_cb, dest_cr,
3291
                                1, i, s->field_select[dir][i],
3292
                                ref_picture, pix_op, qpix_op,
3293
                                s->mv[dir][i][0], s->mv[dir][i][1], 8);
3294
                }
3295
            }else{
3296
                /* top field */       
3297
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3298
                            1, 0, s->field_select[dir][0],
3299
                            ref_picture, pix_op,
3300
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
3301
                /* bottom field */
3302
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3303
                            1, 1, s->field_select[dir][1],
3304
                            ref_picture, pix_op,
3305
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
3306
            }
3307
        } else {
3308
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3309
                ref_picture= s->current_picture_ptr->data;
3310
            } 
3311

    
3312
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3313
                        0, 0, s->field_select[dir][0],
3314
                        ref_picture, pix_op,
3315
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3316
        }
3317
        break;
3318
    case MV_TYPE_16X8:
3319
        for(i=0; i<2; i++){
3320
            uint8_t ** ref2picture;
3321

    
3322
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3323
                ref2picture= ref_picture;
3324
            }else{
3325
                ref2picture= s->current_picture_ptr->data;
3326
            } 
3327

    
3328
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3329
                        0, 0, s->field_select[dir][i],
3330
                        ref2picture, pix_op,
3331
                        s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3332
                
3333
            dest_y += 16*s->linesize;
3334
            dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3335
            dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3336
        }        
3337
        break;
3338
    case MV_TYPE_DMV:
3339
        if(s->picture_structure == PICT_FRAME){
3340
            for(i=0; i<2; i++){
3341
                int j;
3342
                for(j=0; j<2; j++){
3343
                    mpeg_motion(s, dest_y, dest_cb, dest_cr,
3344
                                1, j, j^i,
3345
                                ref_picture, pix_op,
3346
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3347
                }
3348
                pix_op = s->dsp.avg_pixels_tab; 
3349
            }
3350
        }else{
3351
            for(i=0; i<2; i++){
3352
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3353
                            0, 0, s->picture_structure != i+1,
3354
                            ref_picture, pix_op,
3355
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3356

    
3357
                // after put we make avg of the same block
3358
                pix_op=s->dsp.avg_pixels_tab; 
3359

    
3360
                //opposite parity is always in the same frame if this is second field
3361
                if(!s->first_field){
3362
                    ref_picture = s->current_picture_ptr->data;    
3363
                }
3364
            }
3365
        }
3366
    break;
3367
    default: assert(0);
3368
    }
3369
}
3370

    
3371
/**
3372
 * motion compesation of a single macroblock
3373
 * @param s context
3374
 * @param dest_y luma destination pointer
3375
 * @param dest_cb chroma cb/u destination pointer
3376
 * @param dest_cr chroma cr/v destination pointer
3377
 * @param dir direction (0->forward, 1->backward)
3378
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3379
 * @param pic_op halfpel motion compensation function (average or put normally)
3380
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3381
 */
3382
static inline void MPV_motion_lowres(MpegEncContext *s, 
3383
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3384
                              int dir, uint8_t **ref_picture, 
3385
                              h264_chroma_mc_func *pix_op)
3386
{
3387
    int mx, my;
3388
    int mb_x, mb_y, i;
3389
    const int lowres= s->avctx->lowres;
3390
    const int block_s= 8>>lowres;    
3391

    
3392
    mb_x = s->mb_x;
3393
    mb_y = s->mb_y;
3394

    
3395
    switch(s->mv_type) {
3396
    case MV_TYPE_16X16:
3397
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3398
                    0, 0, 0,
3399
                    ref_picture, pix_op,
3400
                    s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3401
        break;
3402
    case MV_TYPE_8X8:
3403
        mx = 0;
3404
        my = 0;
3405
            for(i=0;i<4;i++) {
3406
                hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
3407
                            ref_picture[0], 0, 0,
3408
                            (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
3409
                            s->width, s->height, s->linesize,
3410
                            s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
3411
                            block_s, block_s, pix_op,
3412
                            s->mv[dir][i][0], s->mv[dir][i][1]);
3413

    
3414
                mx += s->mv[dir][i][0];
3415
                my += s->mv[dir][i][1];
3416
            }
3417

    
3418
        if(!(s->flags&CODEC_FLAG_GRAY))
3419
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
3420
        break;
3421
    case MV_TYPE_FIELD:
3422
        if (s->picture_structure == PICT_FRAME) {
3423
            /* top field */       
3424
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3425
                        1, 0, s->field_select[dir][0],
3426
                        ref_picture, pix_op,
3427
                        s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3428
            /* bottom field */
3429
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3430
                        1, 1, s->field_select[dir][1],
3431
                        ref_picture, pix_op,
3432
                        s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3433
        } else {
3434
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3435
                ref_picture= s->current_picture_ptr->data;
3436
            } 
3437

    
3438
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3439
                        0, 0, s->field_select[dir][0],
3440
                        ref_picture, pix_op,
3441
                        s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3442
        }
3443
        break;
3444
    case MV_TYPE_16X8:
3445
        for(i=0; i<2; i++){
3446
            uint8_t ** ref2picture;
3447

    
3448
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3449
                ref2picture= ref_picture;
3450
            }else{
3451
                ref2picture= s->current_picture_ptr->data;
3452
            } 
3453

    
3454
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3455
                        0, 0, s->field_select[dir][i],
3456
                        ref2picture, pix_op,
3457
                        s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
3458
                
3459
            dest_y += 2*block_s*s->linesize;
3460
            dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3461
            dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3462
        }        
3463
        break;
3464
    case MV_TYPE_DMV:
3465
        if(s->picture_structure == PICT_FRAME){
3466
            for(i=0; i<2; i++){
3467
                int j;
3468
                for(j=0; j<2; j++){
3469
                    mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3470
                                1, j, j^i,
3471
                                ref_picture, pix_op,
3472
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
3473
                }
3474
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3475
            }
3476
        }else{
3477
            for(i=0; i<2; i++){
3478
                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3479
                            0, 0, s->picture_structure != i+1,
3480
                            ref_picture, pix_op,
3481
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
3482

    
3483
                // after put we make avg of the same block
3484
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3485

    
3486
                //opposite parity is always in the same frame if this is second field
3487
                if(!s->first_field){
3488
                    ref_picture = s->current_picture_ptr->data;    
3489
                }
3490
            }
3491
        }
3492
    break;
3493
    default: assert(0);
3494
    }
3495
}
3496

    
3497
/* put block[] to dest[] */
3498
static inline void put_dct(MpegEncContext *s, 
3499
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3500
{
3501
    s->dct_unquantize_intra(s, block, i, qscale);
3502
    s->dsp.idct_put (dest, line_size, block);
3503
}
3504

    
3505
/* add block[] to dest[] */
3506
static inline void add_dct(MpegEncContext *s, 
3507
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
3508
{
3509
    if (s->block_last_index[i] >= 0) {
3510
        s->dsp.idct_add (dest, line_size, block);
3511
    }
3512
}
3513

    
3514
static inline void add_dequant_dct(MpegEncContext *s, 
3515
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3516
{
3517
    if (s->block_last_index[i] >= 0) {
3518
        s->dct_unquantize_inter(s, block, i, qscale);
3519

    
3520
        s->dsp.idct_add (dest, line_size, block);
3521
    }
3522
}
3523

    
3524
/**
3525
 * cleans dc, ac, coded_block for the current non intra MB
3526
 */
3527
void ff_clean_intra_table_entries(MpegEncContext *s)
3528
{
3529
    int wrap = s->b8_stride;
3530
    int xy = s->block_index[0];
3531
    
3532
    s->dc_val[0][xy           ] = 
3533
    s->dc_val[0][xy + 1       ] = 
3534
    s->dc_val[0][xy     + wrap] =
3535
    s->dc_val[0][xy + 1 + wrap] = 1024;
3536
    /* ac pred */
3537
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
3538
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3539
    if (s->msmpeg4_version>=3) {
3540
        s->coded_block[xy           ] =
3541
        s->coded_block[xy + 1       ] =
3542
        s->coded_block[xy     + wrap] =
3543
        s->coded_block[xy + 1 + wrap] = 0;
3544
    }
3545
    /* chroma */
3546
    wrap = s->mb_stride;
3547
    xy = s->mb_x + s->mb_y * wrap;
3548
    s->dc_val[1][xy] =
3549
    s->dc_val[2][xy] = 1024;
3550
    /* ac pred */
3551
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3552
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3553
    
3554
    s->mbintra_table[xy]= 0;
3555
}
3556

    
3557
/* generic function called after a macroblock has been parsed by the
3558
   decoder or after it has been encoded by the encoder.
3559

3560
   Important variables used:
3561
   s->mb_intra : true if intra macroblock
3562
   s->mv_dir   : motion vector direction
3563
   s->mv_type  : motion vector type
3564
   s->mv       : motion vector
3565
   s->interlaced_dct : true if interlaced dct used (mpeg2)
3566
 */
3567
static always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
3568
{
3569
    int mb_x, mb_y;
3570
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3571
#ifdef HAVE_XVMC
3572
    if(s->avctx->xvmc_acceleration){
3573
        XVMC_decode_mb(s);//xvmc uses pblocks
3574
        return;
3575
    }
3576
#endif
3577

    
3578
    mb_x = s->mb_x;
3579
    mb_y = s->mb_y;
3580

    
3581
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3582
       /* save DCT coefficients */
3583
       int i,j;
3584
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3585
       for(i=0; i<6; i++)
3586
           for(j=0; j<64; j++)
3587
               *dct++ = block[i][s->dsp.idct_permutation[j]];
3588
    }
3589

    
3590
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3591

    
3592
    /* update DC predictors for P macroblocks */
3593
    if (!s->mb_intra) {
3594
        if (s->h263_pred || s->h263_aic) {
3595
            if(s->mbintra_table[mb_xy])
3596
                ff_clean_intra_table_entries(s);
3597
        } else {
3598
            s->last_dc[0] =
3599
            s->last_dc[1] =
3600
            s->last_dc[2] = 128 << s->intra_dc_precision;
3601
        }
3602
    }
3603
    else if (s->h263_pred || s->h263_aic)
3604
        s->mbintra_table[mb_xy]=1;
3605

    
3606
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3607
        uint8_t *dest_y, *dest_cb, *dest_cr;
3608
        int dct_linesize, dct_offset;
3609
        op_pixels_func (*op_pix)[4];
3610
        qpel_mc_func (*op_qpix)[16];
3611
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3612
        const int uvlinesize= s->current_picture.linesize[1];
3613
        const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3614
        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3615

    
3616
        /* avoid copy if macroblock skipped in last frame too */
3617
        /* skip only during decoding as we might trash the buffers during encoding a bit */
3618
        if(!s->encoding){
3619
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3620
            const int age= s->current_picture.age;
3621

    
3622
            assert(age);
3623

    
3624
            if (s->mb_skiped) {
3625
                s->mb_skiped= 0;
3626
                assert(s->pict_type!=I_TYPE);
3627
 
3628
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
3629
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3630

    
3631
                /* if previous was skipped too, then nothing to do !  */
3632
                if (*mbskip_ptr >= age && s->current_picture.reference){
3633
                    return;
3634
                }
3635
            } else if(!s->current_picture.reference){
3636
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3637
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3638
            } else{
3639
                *mbskip_ptr = 0; /* not skipped */
3640
            }
3641
        }
3642
        
3643
        dct_linesize = linesize << s->interlaced_dct;
3644
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3645
        
3646
        if(readable){
3647
            dest_y=  s->dest[0];
3648
            dest_cb= s->dest[1];
3649
            dest_cr= s->dest[2];
3650
        }else{
3651
            dest_y = s->b_scratchpad;
3652
            dest_cb= s->b_scratchpad+16*linesize;
3653
            dest_cr= s->b_scratchpad+32*linesize;
3654
        }
3655

    
3656
        if (!s->mb_intra) {
3657
            /* motion handling */
3658
            /* decoding or more than one mb_type (MC was allready done otherwise) */
3659
            if(!s->encoding){
3660
                if(lowres_flag){
3661
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
3662

    
3663
                    if (s->mv_dir & MV_DIR_FORWARD) {
3664
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
3665
                        op_pix = s->dsp.avg_h264_chroma_pixels_tab;
3666
                    }
3667
                    if (s->mv_dir & MV_DIR_BACKWARD) {
3668
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
3669
                    }
3670
                }else{
3671
                    if ((!s->no_rounding) || s->pict_type==B_TYPE){                
3672
                        op_pix = s->dsp.put_pixels_tab;
3673
                        op_qpix= s->dsp.put_qpel_pixels_tab;
3674
                    }else{
3675
                        op_pix = s->dsp.put_no_rnd_pixels_tab;
3676
                        op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3677
                    }
3678
                    if (s->mv_dir & MV_DIR_FORWARD) {
3679
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3680
                        op_pix = s->dsp.avg_pixels_tab;
3681
                        op_qpix= s->dsp.avg_qpel_pixels_tab;
3682
                    }
3683
                    if (s->mv_dir & MV_DIR_BACKWARD) {
3684
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3685
                    }
3686
                }
3687
            }
3688

    
3689
            /* skip dequant / idct if we are really late ;) */
3690
            if(s->hurry_up>1) return;
3691

    
3692
            /* add dct residue */
3693
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3694
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3695
                add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3696
                add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3697
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3698
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3699

    
3700
                if(!(s->flags&CODEC_FLAG_GRAY)){
3701
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3702
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3703
                }
3704
            } else if(s->codec_id != CODEC_ID_WMV2){
3705
                add_dct(s, block[0], 0, dest_y                          , dct_linesize);
3706
                add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
3707
                add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
3708
                add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3709

    
3710
                if(!(s->flags&CODEC_FLAG_GRAY)){
3711
                    if(s->chroma_y_shift){//Chroma420
3712
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
3713
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
3714
                    }else{
3715
                        //chroma422
3716
                        dct_linesize = uvlinesize << s->interlaced_dct;
3717
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3718

    
3719
                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
3720
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
3721
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
3722
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
3723
                        if(!s->chroma_x_shift){//Chroma444
3724
                            add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
3725
                            add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
3726
                            add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
3727
                            add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
3728
                        }
3729
                    }
3730
                }//fi gray
3731
            }
3732
#ifdef CONFIG_RISKY
3733
            else{
3734
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3735
            }
3736
#endif
3737
        } else {
3738
            /* dct only in intra block */
3739
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3740
                put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3741
                put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3742
                put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3743
                put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3744

    
3745
                if(!(s->flags&CODEC_FLAG_GRAY)){
3746
                    put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3747
                    put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3748
                }
3749
            }else{
3750
                s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
3751
                s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
3752
                s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
3753
                s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
3754

    
3755
                if(!(s->flags&CODEC_FLAG_GRAY)){
3756
                    if(s->chroma_y_shift){
3757
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3758
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3759
                    }else{
3760

    
3761
                        dct_linesize = uvlinesize << s->interlaced_dct;
3762
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3763

    
3764
                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
3765
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
3766
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
3767
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
3768
                        if(!s->chroma_x_shift){//Chroma444
3769
                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
3770
                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
3771
                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
3772
                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
3773
                        }
3774
                    }
3775
                }//gray
3776
            }
3777
        }
3778
        if(!readable){
3779
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3780
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
3781
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
3782
        }
3783
    }
3784
}
3785

    
3786
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
3787
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
3788
    else                  MPV_decode_mb_internal(s, block, 0);
3789
}
3790

    
3791
#ifdef CONFIG_ENCODERS
3792

    
3793
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3794
{
3795
    static const char tab[64]=
3796
        {3,2,2,1,1,1,1,1,
3797
         1,1,1,1,1,1,1,1,
3798
         1,1,1,1,1,1,1,1,
3799
         0,0,0,0,0,0,0,0,
3800
         0,0,0,0,0,0,0,0,
3801
         0,0,0,0,0,0,0,0,
3802
         0,0,0,0,0,0,0,0,
3803
         0,0,0,0,0,0,0,0};
3804
    int score=0;
3805
    int run=0;
3806
    int i;
3807
    DCTELEM *block= s->block[n];
3808
    const int last_index= s->block_last_index[n];
3809
    int skip_dc;
3810

    
3811
    if(threshold<0){
3812
        skip_dc=0;
3813
        threshold= -threshold;
3814
    }else
3815
        skip_dc=1;
3816

    
3817
    /* are all which we could set to zero are allready zero? */
3818
    if(last_index<=skip_dc - 1) return;
3819

    
3820
    for(i=0; i<=last_index; i++){
3821
        const int j = s->intra_scantable.permutated[i];
3822
        const int level = ABS(block[j]);
3823
        if(level==1){
3824
            if(skip_dc && i==0) continue;
3825
            score+= tab[run];
3826
            run=0;
3827
        }else if(level>1){
3828
            return;
3829
        }else{
3830
            run++;
3831
        }
3832
    }
3833
    if(score >= threshold) return;
3834
    for(i=skip_dc; i<=last_index; i++){
3835
        const int j = s->intra_scantable.permutated[i];
3836
        block[j]=0;
3837
    }
3838
    if(block[0]) s->block_last_index[n]= 0;
3839
    else         s->block_last_index[n]= -1;
3840
}
3841

    
3842
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
3843
{
3844
    int i;
3845
    const int maxlevel= s->max_qcoeff;
3846
    const int minlevel= s->min_qcoeff;
3847
    int overflow=0;
3848
    
3849
    if(s->mb_intra){
3850
        i=1; //skip clipping of intra dc
3851
    }else
3852
        i=0;
3853
    
3854
    for(;i<=last_index; i++){
3855
        const int j= s->intra_scantable.permutated[i];
3856
        int level = block[j];
3857
       
3858
        if     (level>maxlevel){
3859
            level=maxlevel;
3860
            overflow++;
3861
        }else if(level<minlevel){
3862
            level=minlevel;
3863
            overflow++;
3864
        }
3865
        
3866
        block[j]= level;
3867
    }
3868
    
3869
    if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
3870
        av_log(s->avctx, AV_LOG_INFO, "warning, cliping %d dct coefficents to %d..%d\n", overflow, minlevel, maxlevel);
3871
}
3872

    
3873
#endif //CONFIG_ENCODERS
3874

    
3875
/**
3876
 *
3877
 * @param h is the normal height, this will be reduced automatically if needed for the last row
3878
 */
3879
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3880
    if (s->avctx->draw_horiz_band) {
3881
        AVFrame *src;
3882
        int offset[4];
3883
        
3884
        if(s->picture_structure != PICT_FRAME){
3885
            h <<= 1;
3886
            y <<= 1;
3887
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3888
        }
3889

    
3890
        h= FFMIN(h, s->avctx->height - y);
3891

    
3892
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) 
3893
            src= (AVFrame*)s->current_picture_ptr;
3894
        else if(s->last_picture_ptr)
3895
            src= (AVFrame*)s->last_picture_ptr;
3896
        else
3897
            return;
3898
            
3899
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3900
            offset[0]=
3901
            offset[1]=
3902
            offset[2]=
3903
            offset[3]= 0;
3904
        }else{
3905
            offset[0]= y * s->linesize;;
3906
            offset[1]= 
3907
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
3908
            offset[3]= 0;
3909
        }
3910

    
3911
        emms_c();
3912

    
3913
        s->avctx->draw_horiz_band(s->avctx, src, offset,
3914
                                  y, s->picture_structure, h);
3915
    }
3916
}
3917

    
3918
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3919
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3920
    const int uvlinesize= s->current_picture.linesize[1];
3921
    const int mb_size= 4 - s->avctx->lowres;
3922
        
3923
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
3924
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
3925
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
3926
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3927
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3928
    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;
3929
    //block_index is not used by mpeg2, so it is not affected by chroma_format
3930

    
3931
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
3932
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3933
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3934

    
3935
    if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
3936
    {
3937
        s->dest[0] += s->mb_y *   linesize << mb_size;
3938
        s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3939
        s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3940
    }
3941
}
3942

    
3943
#ifdef CONFIG_ENCODERS
3944

    
3945
static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
3946
    int x, y;
3947
//FIXME optimize
3948
    for(y=0; y<8; y++){
3949
        for(x=0; x<8; x++){
3950
            int x2, y2;
3951
            int sum=0;
3952
            int sqr=0;
3953
            int count=0;
3954

    
3955
            for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
3956
                for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
3957
                    int v= ptr[x2 + y2*stride];
3958
                    sum += v;
3959
                    sqr += v*v;
3960
                    count++;
3961
                }
3962
            }
3963
            weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
3964
        }
3965
    }
3966
}
3967

    
3968
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
3969
{
3970
    int16_t weight[6][64];
3971
    DCTELEM orig[6][64];
3972
    const int mb_x= s->mb_x;
3973
    const int mb_y= s->mb_y;
3974
    int i;
3975
    int skip_dct[6];
3976
    int dct_offset   = s->linesize*8; //default for progressive frames
3977
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3978
    int wrap_y, wrap_c;
3979
    
3980
    for(i=0; i<6; i++) skip_dct[i]=0;
3981
    
3982
    if(s->adaptive_quant){
3983
        const int last_qp= s->qscale;
3984
        const int mb_xy= mb_x + mb_y*s->mb_stride;
3985

    
3986
        s->lambda= s->lambda_table[mb_xy];
3987
        update_qscale(s);
3988
    
3989
        if(!(s->flags&CODEC_FLAG_QP_RD)){
3990
            s->dquant= s->qscale - last_qp;
3991

    
3992
            if(s->out_format==FMT_H263){
3993
                s->dquant= clip(s->dquant, -2, 2); //FIXME RD
3994
            
3995
                if(s->codec_id==CODEC_ID_MPEG4){        
3996
                    if(!s->mb_intra){
3997
                        if(s->pict_type == B_TYPE){
3998
                            if(s->dquant&1) 
3999
                                s->dquant= (s->dquant/2)*2;
4000
                            if(s->mv_dir&MV_DIRECT)
4001
                                s->dquant= 0;
4002
                        }
4003
                        if(s->mv_type==MV_TYPE_8X8)
4004
                            s->dquant=0;
4005
                    }
4006
                }
4007
            }
4008
        }
4009
        ff_set_qscale(s, last_qp + s->dquant);
4010
    }else if(s->flags&CODEC_FLAG_QP_RD)
4011
        ff_set_qscale(s, s->qscale + s->dquant);
4012

    
4013
    wrap_y = s->linesize;
4014
    wrap_c = s->uvlinesize;
4015
    ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
4016
    ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
4017
    ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
4018

    
4019
    if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
4020
        uint8_t *ebuf= s->edge_emu_buffer + 32;
4021
        ff_emulated_edge_mc(ebuf            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
4022
        ptr_y= ebuf;
4023
        ff_emulated_edge_mc(ebuf+18*wrap_y  , ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
4024
        ptr_cb= ebuf+18*wrap_y;
4025
        ff_emulated_edge_mc(ebuf+18*wrap_y+8, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
4026
        ptr_cr= ebuf+18*wrap_y+8;
4027
    }
4028

    
4029
    if (s->mb_intra) {
4030
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4031
            int progressive_score, interlaced_score;
4032

    
4033
            s->interlaced_dct=0;
4034
            progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8) 
4035
                              +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
4036

    
4037
            if(progressive_score > 0){
4038
                interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8) 
4039
                                  +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
4040
                if(progressive_score > interlaced_score){
4041
                    s->interlaced_dct=1;
4042
            
4043
                    dct_offset= wrap_y;
4044
                    wrap_y<<=1;
4045
                }
4046
            }
4047
        }
4048
        
4049
        s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
4050
        s->dsp.get_pixels(s->block[1], ptr_y              + 8, wrap_y);
4051
        s->dsp.get_pixels(s->block[2], ptr_y + dct_offset    , wrap_y);
4052
        s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
4053

    
4054
        if(s->flags&CODEC_FLAG_GRAY){
4055
            skip_dct[4]= 1;
4056
            skip_dct[5]= 1;
4057
        }else{
4058
            s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
4059
            s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
4060
        }
4061
    }else{
4062
        op_pixels_func (*op_pix)[4];
4063
        qpel_mc_func (*op_qpix)[16];
4064
        uint8_t *dest_y, *dest_cb, *dest_cr;
4065

    
4066
        dest_y  = s->dest[0];
4067
        dest_cb = s->dest[1];
4068
        dest_cr = s->dest[2];
4069

    
4070
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
4071
            op_pix = s->dsp.put_pixels_tab;
4072
            op_qpix= s->dsp.put_qpel_pixels_tab;
4073
        }else{
4074
            op_pix = s->dsp.put_no_rnd_pixels_tab;
4075
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
4076
        }
4077

    
4078
        if (s->mv_dir & MV_DIR_FORWARD) {
4079
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
4080
            op_pix = s->dsp.avg_pixels_tab;
4081
            op_qpix= s->dsp.avg_qpel_pixels_tab;
4082
        }
4083
        if (s->mv_dir & MV_DIR_BACKWARD) {
4084
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
4085
        }
4086

    
4087
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4088
            int progressive_score, interlaced_score;
4089

    
4090
            s->interlaced_dct=0;
4091
            progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8) 
4092
                              +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
4093
            
4094
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
4095

    
4096
            if(progressive_score>0){
4097
                interlaced_score = s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y*2, 8) 
4098
                                  +s->dsp.ildct_cmp[0](s, dest_y + wrap_y  , ptr_y + wrap_y  , wrap_y*2, 8);
4099
            
4100
                if(progressive_score > interlaced_score){
4101
                    s->interlaced_dct=1;
4102
            
4103
                    dct_offset= wrap_y;
4104
                    wrap_y<<=1;
4105
                }
4106
            }
4107
        }
4108
        
4109
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
4110
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
4111
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
4112
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
4113
        
4114
        if(s->flags&CODEC_FLAG_GRAY){
4115
            skip_dct[4]= 1;
4116
            skip_dct[5]= 1;
4117
        }else{
4118
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
4119
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
4120
        }
4121
        /* pre quantization */         
4122
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
4123
            //FIXME optimize
4124
            if(s->dsp.sad[1](NULL, ptr_y               , dest_y               , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
4125
            if(s->dsp.sad[1](NULL, ptr_y            + 8, dest_y            + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
4126
            if(s->dsp.sad[1](NULL, ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
4127
            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;
4128
            if(s->dsp.sad[1](NULL, ptr_cb              , dest_cb              , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
4129
            if(s->dsp.sad[1](NULL, ptr_cr              , dest_cr              , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
4130
        }
4131
    }
4132

    
4133
    if(s->avctx->quantizer_noise_shaping){
4134
        if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y                 , wrap_y);
4135
        if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y              + 8, wrap_y);
4136
        if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset    , wrap_y);
4137
        if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
4138
        if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb                , wrap_c);
4139
        if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr                , wrap_c);
4140
        memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*6);
4141
    }
4142
            
4143
    /* DCT & quantize */
4144
    assert(s->out_format!=FMT_MJPEG || s->qscale==8);
4145
    {
4146
        for(i=0;i<6;i++) {
4147
            if(!skip_dct[i]){
4148
                int overflow;
4149
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
4150
            // FIXME we could decide to change to quantizer instead of clipping
4151
            // JS: I don't think that would be a good idea it could lower quality instead
4152
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
4153
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
4154
            }else
4155
                s->block_last_index[i]= -1;
4156
        }
4157
        if(s->avctx->quantizer_noise_shaping){
4158
            for(i=0;i<6;i++) {
4159
                if(!skip_dct[i]){
4160
                    s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
4161
                }
4162
            }
4163
        }
4164
        
4165
        if(s->luma_elim_threshold && !s->mb_intra)
4166
            for(i=0; i<4; i++)
4167
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
4168
        if(s->chroma_elim_threshold && !s->mb_intra)
4169
            for(i=4; i<6; i++)
4170
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
4171

    
4172
        if(s->flags & CODEC_FLAG_CBP_RD){
4173
            for(i=0;i<6;i++) {
4174
                if(s->block_last_index[i] == -1)
4175
                    s->coded_score[i]= INT_MAX/256;
4176
            }
4177
        }
4178
    }
4179

    
4180
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
4181
        s->block_last_index[4]=
4182
        s->block_last_index[5]= 0;
4183
        s->block[4][0]=
4184
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
4185
    }
4186

    
4187
    //non c quantize code returns incorrect block_last_index FIXME
4188
    if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
4189
        for(i=0; i<6; i++){
4190
            int j;
4191
            if(s->block_last_index[i]>0){
4192
                for(j=63; j>0; j--){
4193
                    if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
4194
                }
4195
                s->block_last_index[i]= j;
4196
            }
4197
        }
4198
    }
4199

    
4200
    /* huffman encode */
4201
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
4202
    case CODEC_ID_MPEG1VIDEO:
4203
    case CODEC_ID_MPEG2VIDEO:
4204
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
4205
#ifdef CONFIG_RISKY
4206
    case CODEC_ID_MPEG4:
4207
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4208
    case CODEC_ID_MSMPEG4V2:
4209
    case CODEC_ID_MSMPEG4V3:
4210
    case CODEC_ID_WMV1:
4211
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4212
    case CODEC_ID_WMV2:
4213
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
4214
    case CODEC_ID_H261:
4215
        ff_h261_encode_mb(s, s->block, motion_x, motion_y); break;
4216
    case CODEC_ID_H263:
4217
    case CODEC_ID_H263P:
4218
    case CODEC_ID_FLV1:
4219
    case CODEC_ID_RV10:
4220
    case CODEC_ID_RV20:
4221
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
4222
#endif
4223
    case CODEC_ID_MJPEG:
4224
        mjpeg_encode_mb(s, s->block); break;
4225
    default:
4226
        assert(0);
4227
    }
4228
}
4229

    
4230
#endif //CONFIG_ENCODERS
4231

    
4232
void ff_mpeg_flush(AVCodecContext *avctx){
4233
    int i;
4234
    MpegEncContext *s = avctx->priv_data;
4235
    
4236
    if(s==NULL || s->picture==NULL) 
4237
        return;
4238
    
4239
    for(i=0; i<MAX_PICTURE_COUNT; i++){
4240
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
4241
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
4242
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
4243
    }
4244
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
4245
    
4246
    s->mb_x= s->mb_y= 0;
4247
    
4248
    s->parse_context.state= -1;
4249
    s->parse_context.frame_start_found= 0;
4250
    s->parse_context.overread= 0;
4251
    s->parse_context.overread_index= 0;
4252
    s->parse_context.index= 0;
4253
    s->parse_context.last_index= 0;
4254
    s->bitstream_buffer_size=0;
4255
}
4256

    
4257
#ifdef CONFIG_ENCODERS
4258
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4259
{
4260
    const uint16_t *srcw= (uint16_t*)src;
4261
    int words= length>>4;
4262
    int bits= length&15;
4263
    int i;
4264

    
4265
    if(length==0) return;
4266
    
4267
    if(words < 16){
4268
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4269
    }else if(put_bits_count(pb)&7){
4270
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4271
    }else{
4272
        for(i=0; put_bits_count(pb)&31; i++)
4273
            put_bits(pb, 8, src[i]);
4274
        flush_put_bits(pb);
4275
        memcpy(pbBufPtr(pb), src+i, 2*words-i);
4276
        skip_put_bytes(pb, 2*words-i);
4277
    }
4278
        
4279
    put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
4280
}
4281

    
4282
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
4283
    int i;
4284

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

    
4287
    /* mpeg1 */
4288
    d->mb_skip_run= s->mb_skip_run;
4289
    for(i=0; i<3; i++)
4290
        d->last_dc[i]= s->last_dc[i];
4291
    
4292
    /* statistics */
4293
    d->mv_bits= s->mv_bits;
4294
    d->i_tex_bits= s->i_tex_bits;
4295
    d->p_tex_bits= s->p_tex_bits;
4296
    d->i_count= s->i_count;
4297
    d->f_count= s->f_count;
4298
    d->b_count= s->b_count;
4299
    d->skip_count= s->skip_count;
4300
    d->misc_bits= s->misc_bits;
4301
    d->last_bits= 0;
4302

    
4303
    d->mb_skiped= 0;
4304
    d->qscale= s->qscale;
4305
    d->dquant= s->dquant;
4306
}
4307

    
4308
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
4309
    int i;
4310

    
4311
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
4312
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4313
    
4314
    /* mpeg1 */
4315
    d->mb_skip_run= s->mb_skip_run;
4316
    for(i=0; i<3; i++)
4317
        d->last_dc[i]= s->last_dc[i];
4318
    
4319
    /* statistics */
4320
    d->mv_bits= s->mv_bits;
4321
    d->i_tex_bits= s->i_tex_bits;
4322
    d->p_tex_bits= s->p_tex_bits;
4323
    d->i_count= s->i_count;
4324
    d->f_count= s->f_count;
4325
    d->b_count= s->b_count;
4326
    d->skip_count= s->skip_count;
4327
    d->misc_bits= s->misc_bits;
4328

    
4329
    d->mb_intra= s->mb_intra;
4330
    d->mb_skiped= s->mb_skiped;
4331
    d->mv_type= s->mv_type;
4332
    d->mv_dir= s->mv_dir;
4333
    d->pb= s->pb;
4334
    if(s->data_partitioning){
4335
        d->pb2= s->pb2;
4336
        d->tex_pb= s->tex_pb;
4337
    }
4338
    d->block= s->block;
4339
    for(i=0; i<6; i++)
4340
        d->block_last_index[i]= s->block_last_index[i];
4341
    d->interlaced_dct= s->interlaced_dct;
4342
    d->qscale= s->qscale;
4343
}
4344

    
4345
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
4346
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
4347
                           int *dmin, int *next_block, int motion_x, int motion_y)
4348
{
4349
    int score;
4350
    uint8_t *dest_backup[3];
4351
    
4352
    copy_context_before_encode(s, backup, type);
4353

    
4354
    s->block= s->blocks[*next_block];
4355
    s->pb= pb[*next_block];
4356
    if(s->data_partitioning){
4357
        s->pb2   = pb2   [*next_block];
4358
        s->tex_pb= tex_pb[*next_block];
4359
    }
4360
    
4361
    if(*next_block){
4362
        memcpy(dest_backup, s->dest, sizeof(s->dest));
4363
        s->dest[0] = s->rd_scratchpad;
4364
        s->dest[1] = s->rd_scratchpad + 16*s->linesize;
4365
        s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
4366
        assert(s->linesize >= 32); //FIXME
4367
    }
4368

    
4369
    encode_mb(s, motion_x, motion_y);
4370
    
4371
    score= put_bits_count(&s->pb);
4372
    if(s->data_partitioning){
4373
        score+= put_bits_count(&s->pb2);
4374
        score+= put_bits_count(&s->tex_pb);
4375
    }
4376
   
4377
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
4378
        MPV_decode_mb(s, s->block);
4379

    
4380
        score *= s->lambda2;
4381
        score += sse_mb(s) << FF_LAMBDA_SHIFT;
4382
    }
4383
    
4384
    if(*next_block){
4385
        memcpy(s->dest, dest_backup, sizeof(s->dest));
4386
    }
4387

    
4388
    if(score<*dmin){
4389
        *dmin= score;
4390
        *next_block^=1;
4391

    
4392
        copy_context_after_encode(best, s, type);
4393
    }
4394
}
4395
                
4396
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
4397
    uint32_t *sq = squareTbl + 256;
4398
    int acc=0;
4399
    int x,y;
4400
    
4401
    if(w==16 && h==16) 
4402
        return s->dsp.sse[0](NULL, src1, src2, stride, 16);
4403
    else if(w==8 && h==8)
4404
        return s->dsp.sse[1](NULL, src1, src2, stride, 8);
4405
    
4406
    for(y=0; y<h; y++){
4407
        for(x=0; x<w; x++){
4408
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
4409
        } 
4410
    }
4411
    
4412
    assert(acc>=0);
4413
    
4414
    return acc;
4415
}
4416

    
4417
static int sse_mb(MpegEncContext *s){
4418
    int w= 16;
4419
    int h= 16;
4420

    
4421
    if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4422
    if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4423

    
4424
    if(w==16 && h==16)
4425
      if(s->avctx->mb_cmp == FF_CMP_NSSE){
4426
        return  s->dsp.nsse[0](s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16)
4427
               +s->dsp.nsse[1](s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8)
4428
               +s->dsp.nsse[1](s, s->new_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
4429
      }else{
4430
        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)
4431
               +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)
4432
               +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);
4433
      }
4434
    else
4435
        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)
4436
               +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)
4437
               +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);
4438
}
4439

    
4440
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
4441
    MpegEncContext *s= arg;
4442

    
4443
    
4444
    s->me.pre_pass=1;
4445
    s->me.dia_size= s->avctx->pre_dia_size;
4446
    s->first_slice_line=1;
4447
    for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
4448
        for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
4449
            ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4450
        }
4451
        s->first_slice_line=0;
4452
    }
4453
    
4454
    s->me.pre_pass=0;
4455
    
4456
    return 0;
4457
}
4458

    
4459
static int estimate_motion_thread(AVCodecContext *c, void *arg){
4460
    MpegEncContext *s= arg;
4461

    
4462
    s->me.dia_size= s->avctx->dia_size;
4463
    s->first_slice_line=1;
4464
    for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4465
        s->mb_x=0; //for block init below
4466
        ff_init_block_index(s);
4467
        for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
4468
            s->block_index[0]+=2;
4469
            s->block_index[1]+=2;
4470
            s->block_index[2]+=2;
4471
            s->block_index[3]+=2;
4472
            
4473
            /* compute motion vector & mb_type and store in context */
4474
            if(s->pict_type==B_TYPE)
4475
                ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
4476
            else
4477
                ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4478
        }
4479
        s->first_slice_line=0;
4480
    }
4481
    return 0;
4482
}
4483

    
4484
static int mb_var_thread(AVCodecContext *c, void *arg){
4485
    MpegEncContext *s= arg;
4486
    int mb_x, mb_y;
4487

    
4488
    for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4489
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4490
            int xx = mb_x * 16;
4491
            int yy = mb_y * 16;
4492
            uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
4493
            int varc;
4494
            int sum = s->dsp.pix_sum(pix, s->linesize);
4495
    
4496
            varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
4497

    
4498
            s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
4499
            s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
4500
            s->me.mb_var_sum_temp    += varc;
4501
        }
4502
    }
4503
    return 0;
4504
}
4505

    
4506
static void write_slice_end(MpegEncContext *s){
4507
    if(s->codec_id==CODEC_ID_MPEG4){
4508
        if(s->partitioned_frame){
4509
            ff_mpeg4_merge_partitions(s);
4510
        }
4511
    
4512
        ff_mpeg4_stuffing(&s->pb);
4513
    }else if(s->out_format == FMT_MJPEG){
4514
        ff_mjpeg_stuffing(&s->pb);
4515
    }
4516

    
4517
    align_put_bits(&s->pb);
4518
    flush_put_bits(&s->pb);
4519
}
4520

    
4521
static int encode_thread(AVCodecContext *c, void *arg){
4522
    MpegEncContext *s= arg;
4523
    int mb_x, mb_y, pdif = 0;
4524
    int i, j;
4525
    MpegEncContext best_s, backup_s;
4526
    uint8_t bit_buf[2][3000];
4527
    uint8_t bit_buf2[2][3000];
4528
    uint8_t bit_buf_tex[2][3000];
4529
    PutBitContext pb[2], pb2[2], tex_pb[2];
4530
//printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4531

    
4532
    for(i=0; i<2; i++){
4533
        init_put_bits(&pb    [i], bit_buf    [i], 3000);
4534
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000);
4535
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000);
4536
    }
4537

    
4538
    s->last_bits= put_bits_count(&s->pb);
4539
    s->mv_bits=0;
4540
    s->misc_bits=0;
4541
    s->i_tex_bits=0;
4542
    s->p_tex_bits=0;
4543
    s->i_count=0;
4544
    s->f_count=0;
4545
    s->b_count=0;
4546
    s->skip_count=0;
4547

    
4548
    for(i=0; i<3; i++){
4549
        /* init last dc values */
4550
        /* note: quant matrix value (8) is implied here */
4551
        s->last_dc[i] = 128 << s->intra_dc_precision;
4552
        
4553
        s->current_picture_ptr->error[i] = 0;
4554
    }
4555
    s->mb_skip_run = 0;
4556
    memset(s->last_mv, 0, sizeof(s->last_mv));
4557
     
4558
    s->last_mv_dir = 0;
4559

    
4560
#ifdef CONFIG_RISKY
4561
    switch(s->codec_id){
4562
    case CODEC_ID_H263:
4563
    case CODEC_ID_H263P:
4564
    case CODEC_ID_FLV1:
4565
        s->gob_index = ff_h263_get_gob_height(s);
4566
        break;
4567
    case CODEC_ID_MPEG4:
4568
        if(s->partitioned_frame)
4569
            ff_mpeg4_init_partitions(s);
4570
        break;
4571
    }
4572
#endif
4573

    
4574
    s->resync_mb_x=0;
4575
    s->resync_mb_y=0; 
4576
    s->first_slice_line = 1;
4577
    s->ptr_lastgob = s->pb.buf;
4578
    for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4579
//    printf("row %d at %X\n", s->mb_y, (int)s);
4580
        s->mb_x=0;
4581
        s->mb_y= mb_y;
4582

    
4583
        ff_set_qscale(s, s->qscale);
4584
        ff_init_block_index(s);
4585
        
4586
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4587
            int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
4588
            int mb_type= s->mb_type[xy];
4589
//            int d;
4590
            int dmin= INT_MAX;
4591
            int dir;
4592

    
4593
            s->mb_x = mb_x;
4594
            s->mb_y = mb_y;  // moved into loop, can get changed by H.261
4595
            ff_update_block_index(s);
4596

    
4597
            if(s->codec_id == CODEC_ID_H261){
4598
                ff_h261_reorder_mb_index(s);
4599
                xy= s->mb_y*s->mb_stride + s->mb_x;
4600
                mb_type= s->mb_type[xy];
4601
            }
4602

    
4603
            /* write gob / video packet header  */
4604
#ifdef CONFIG_RISKY
4605
            if(s->rtp_mode){
4606
                int current_packet_size, is_gob_start;
4607
                
4608
                current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
4609
                
4610
                is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0; 
4611
                
4612
                if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
4613
                
4614
                switch(s->codec_id){
4615
                case CODEC_ID_H263:
4616
                case CODEC_ID_H263P:
4617
                    if(!s->h263_slice_structured)
4618
                        if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
4619
                    break;
4620
                case CODEC_ID_MPEG2VIDEO:
4621
                    if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
4622
                case CODEC_ID_MPEG1VIDEO:
4623
                    if(s->mb_skip_run) is_gob_start=0;
4624
                    break;
4625
                }
4626

    
4627
                if(is_gob_start){
4628
                    if(s->start_mb_y != mb_y || mb_x!=0){
4629
                        write_slice_end(s);
4630

    
4631
                        if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
4632
                            ff_mpeg4_init_partitions(s);
4633
                        }
4634
                    }
4635
                
4636
                    assert((put_bits_count(&s->pb)&7) == 0);
4637
                    current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4638
                    
4639
                    if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
4640
                        int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
4641
                        int d= 100 / s->avctx->error_rate;
4642
                        if(r % d == 0){
4643
                            current_packet_size=0;
4644
#ifndef ALT_BITSTREAM_WRITER
4645
                            s->pb.buf_ptr= s->ptr_lastgob;
4646
#endif
4647
                            assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
4648
                        }
4649
                    }
4650
        
4651
                    if (s->avctx->rtp_callback)
4652
                        s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, 0);
4653
                    
4654
                    switch(s->codec_id){
4655
                    case CODEC_ID_MPEG4:
4656
                        ff_mpeg4_encode_video_packet_header(s);
4657
                        ff_mpeg4_clean_buffers(s);
4658
                    break;
4659
                    case CODEC_ID_MPEG1VIDEO:
4660
                    case CODEC_ID_MPEG2VIDEO:
4661
                        ff_mpeg1_encode_slice_header(s);
4662
                        ff_mpeg1_clean_buffers(s);
4663
                    break;
4664
                    case CODEC_ID_H263:
4665
                    case CODEC_ID_H263P:
4666
                        h263_encode_gob_header(s, mb_y);                       
4667
                    break;
4668
                    }
4669

    
4670
                    if(s->flags&CODEC_FLAG_PASS1){
4671
                        int bits= put_bits_count(&s->pb);
4672
                        s->misc_bits+= bits - s->last_bits;
4673
                        s->last_bits= bits;
4674
                    }
4675
    
4676
                    s->ptr_lastgob += current_packet_size;
4677
                    s->first_slice_line=1;
4678
                    s->resync_mb_x=mb_x;
4679
                    s->resync_mb_y=mb_y;
4680
                }
4681
            }
4682
#endif
4683