Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 307eb248

History | View | Annotate | Download (243 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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_intra_bitexact(MpegEncContext *s,
51
                                   DCTELEM *block, int n, int qscale);
52
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
53
                                   DCTELEM *block, int n, int qscale);
54
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
55
                                  DCTELEM *block, int n, int qscale);
56
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
57
                                  DCTELEM *block, int n, int qscale);
58
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
59
#ifdef CONFIG_ENCODERS
60
static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
61
static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
62
static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
63
static int sse_mb(MpegEncContext *s);
64
static void  denoise_dct_c(MpegEncContext *s, DCTELEM *block);
65
#endif //CONFIG_ENCODERS
66

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

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

    
75

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

    
79
//#define DEBUG
80

    
81

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

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

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

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

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

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

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

    
119
    for(qscale=qmin; qscale<=qmax; qscale++){
120
        int i;
121
        if (dsp->fdct == ff_jpeg_fdct_islow
122
#ifdef FAAN_POSTSCALE
123
            || dsp->fdct == ff_faandct
124
#endif
125
            ) {
126
            for(i=0;i<64;i++) {
127
                const int j= dsp->idct_permutation[i];
128
                /* 16 <= qscale * quant_matrix[i] <= 7905 */
129
                /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
130
                /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
131
                /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
132

    
133
                qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) /
134
                                (qscale * quant_matrix[j]));
135
            }
136
        } else if (dsp->fdct == fdct_ifast
137
#ifndef FAAN_POSTSCALE
138
                   || dsp->fdct == ff_faandct
139
#endif
140
                   ) {
141
            for(i=0;i<64;i++) {
142
                const int j= dsp->idct_permutation[i];
143
                /* 16 <= qscale * quant_matrix[i] <= 7905 */
144
                /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
145
                /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
146
                /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
147

    
148
                qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) /
149
                                (aanscales[i] * qscale * quant_matrix[j]));
150
            }
151
        } else {
152
            for(i=0;i<64;i++) {
153
                const int j= dsp->idct_permutation[i];
154
                /* We can safely suppose that 16 <= quant_matrix[i] <= 255
155
                   So 16           <= qscale * quant_matrix[i]             <= 7905
156
                   so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
157
                   so 32768        >= (1<<19) / (qscale * quant_matrix[i]) >= 67
158
                */
159
                qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
160
//                qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
161
                qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
162

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

    
168
        for(i=intra; i<64; i++){
169
            int64_t max= 8191;
170
            if (dsp->fdct == fdct_ifast
171
#ifndef FAAN_POSTSCALE
172
                   || dsp->fdct == ff_faandct
173
#endif
174
                   ) {
175
                max= (8191LL*aanscales[i]) >> 14;
176
            }
177
            while(((max * qmat[qscale][i]) >> shift) > INT_MAX){
178
                shift++;
179
            }
180
        }
181
    }
182
    if(shift){
183
        av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger then %d, overflows possible\n", QMAT_SHIFT - shift);
184
    }
185
}
186

    
187
static inline void update_qscale(MpegEncContext *s){
188
    s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
189
    s->qscale= clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
190

    
191
    s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
192
}
193
#endif //CONFIG_ENCODERS
194

    
195
void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
196
    int i;
197
    int end;
198

    
199
    st->scantable= src_scantable;
200

    
201
    for(i=0; i<64; i++){
202
        int j;
203
        j = src_scantable[i];
204
        st->permutated[i] = permutation[j];
205
#ifdef ARCH_POWERPC
206
        st->inverse[j] = i;
207
#endif
208
    }
209

    
210
    end=-1;
211
    for(i=0; i<64; i++){
212
        int j;
213
        j = st->permutated[i];
214
        if(j>end) end=j;
215
        st->raster_end[i]= end;
216
    }
217
}
218

    
219
#ifdef CONFIG_ENCODERS
220
void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
221
    int i;
222

    
223
    if(matrix){
224
        put_bits(pb, 1, 1);
225
        for(i=0;i<64;i++) {
226
            put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
227
        }
228
    }else
229
        put_bits(pb, 1, 0);
230
}
231
#endif //CONFIG_ENCODERS
232

    
233
const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
234
    int i;
235

    
236
    assert(p<=end);
237
    if(p>=end)
238
        return end;
239

    
240
    for(i=0; i<3; i++){
241
        uint32_t tmp= *state << 8;
242
        *state= tmp + *(p++);
243
        if(tmp == 0x100 || p==end)
244
            return p;
245
    }
246

    
247
    while(p<end){
248
        if     (p[-1] > 1      ) p+= 3;
249
        else if(p[-2]          ) p+= 2;
250
        else if(p[-3]|(p[-1]-1)) p++;
251
        else{
252
            p++;
253
            break;
254
        }
255
    }
256

    
257
    p= FFMIN(p, end)-4;
258
    *state=  be2me_32(unaligned32(p));
259

    
260
    return p+4;
261
}
262

    
263
/* init common dct for both encoder and decoder */
264
int DCT_common_init(MpegEncContext *s)
265
{
266
    s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
267
    s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
268
    s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
269
    s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
270
    s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
271
    if(s->flags & CODEC_FLAG_BITEXACT)
272
        s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
273
    s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
274

    
275
#ifdef CONFIG_ENCODERS
276
    s->dct_quantize= dct_quantize_c;
277
    s->denoise_dct= denoise_dct_c;
278
#endif //CONFIG_ENCODERS
279

    
280
#ifdef HAVE_MMX
281
    MPV_common_init_mmx(s);
282
#endif
283
#ifdef ARCH_ALPHA
284
    MPV_common_init_axp(s);
285
#endif
286
#ifdef HAVE_MLIB
287
    MPV_common_init_mlib(s);
288
#endif
289
#ifdef HAVE_MMI
290
    MPV_common_init_mmi(s);
291
#endif
292
#ifdef ARCH_ARMV4L
293
    MPV_common_init_armv4l(s);
294
#endif
295
#ifdef ARCH_POWERPC
296
    MPV_common_init_ppc(s);
297
#endif
298

    
299
#ifdef CONFIG_ENCODERS
300
    s->fast_dct_quantize= s->dct_quantize;
301

    
302
    if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
303
        s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
304
    }
305

    
306
#endif //CONFIG_ENCODERS
307

    
308
    /* load & permutate scantables
309
       note: only wmv uses different ones
310
    */
311
    if(s->alternate_scan){
312
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
313
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
314
    }else{
315
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
316
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
317
    }
318
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
319
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
320

    
321
    return 0;
322
}
323

    
324
static void copy_picture(Picture *dst, Picture *src){
325
    *dst = *src;
326
    dst->type= FF_BUFFER_TYPE_COPY;
327
}
328

    
329
static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
330
    int i;
331

    
332
    dst->pict_type              = src->pict_type;
333
    dst->quality                = src->quality;
334
    dst->coded_picture_number   = src->coded_picture_number;
335
    dst->display_picture_number = src->display_picture_number;
336
//    dst->reference              = src->reference;
337
    dst->pts                    = src->pts;
338
    dst->interlaced_frame       = src->interlaced_frame;
339
    dst->top_field_first        = src->top_field_first;
340

    
341
    if(s->avctx->me_threshold){
342
        if(!src->motion_val[0])
343
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
344
        if(!src->mb_type)
345
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
346
        if(!src->ref_index[0])
347
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
348
        if(src->motion_subsample_log2 != dst->motion_subsample_log2)
349
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
350
            src->motion_subsample_log2, dst->motion_subsample_log2);
351

    
352
        memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
353

    
354
        for(i=0; i<2; i++){
355
            int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
356
            int height= ((16*s->mb_height)>>src->motion_subsample_log2);
357

    
358
            if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
359
                memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
360
            }
361
            if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
362
                memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
363
            }
364
        }
365
    }
366
}
367

    
368
/**
369
 * allocates a Picture
370
 * The pixels are allocated/set by calling get_buffer() if shared=0
371
 */
372
static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
373
    const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
374
    const int mb_array_size= s->mb_stride*s->mb_height;
375
    const int b8_array_size= s->b8_stride*s->mb_height*2;
376
    const int b4_array_size= s->b4_stride*s->mb_height*4;
377
    int i;
378

    
379
    if(shared){
380
        assert(pic->data[0]);
381
        assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
382
        pic->type= FF_BUFFER_TYPE_SHARED;
383
    }else{
384
        int r;
385

    
386
        assert(!pic->data[0]);
387

    
388
        r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
389

    
390
        if(r<0 || !pic->age || !pic->type || !pic->data[0]){
391
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
392
            return -1;
393
        }
394

    
395
        if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
396
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
397
            return -1;
398
        }
399

    
400
        if(pic->linesize[1] != pic->linesize[2]){
401
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
402
            return -1;
403
        }
404

    
405
        s->linesize  = pic->linesize[0];
406
        s->uvlinesize= pic->linesize[1];
407
    }
408

    
409
    if(pic->qscale_table==NULL){
410
        if (s->encoding) {
411
            CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
412
            CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
413
            CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
414
        }
415

    
416
        CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
417
        CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
418
        CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num    * sizeof(uint32_t))
419
        pic->mb_type= pic->mb_type_base + s->mb_stride+1;
420
        if(s->out_format == FMT_H264){
421
            for(i=0; i<2; i++){
422
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4)  * sizeof(int16_t))
423
                pic->motion_val[i]= pic->motion_val_base[i]+4;
424
                CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
425
            }
426
            pic->motion_subsample_log2= 2;
427
        }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
428
            for(i=0; i<2; i++){
429
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
430
                pic->motion_val[i]= pic->motion_val_base[i]+4;
431
                CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
432
            }
433
            pic->motion_subsample_log2= 3;
434
        }
435
        if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
436
            CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
437
        }
438
        pic->qstride= s->mb_stride;
439
        CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
440
    }
441

    
442
    //it might be nicer if the application would keep track of these but it would require a API change
443
    memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
444
    s->prev_pict_types[0]= s->pict_type;
445
    if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
446
        pic->age= INT_MAX; // skipped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
447

    
448
    return 0;
449
fail: //for the CHECKED_ALLOCZ macro
450
    return -1;
451
}
452

    
453
/**
454
 * deallocates a picture
455
 */
456
static void free_picture(MpegEncContext *s, Picture *pic){
457
    int i;
458

    
459
    if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
460
        s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
461
    }
462

    
463
    av_freep(&pic->mb_var);
464
    av_freep(&pic->mc_mb_var);
465
    av_freep(&pic->mb_mean);
466
    av_freep(&pic->mbskip_table);
467
    av_freep(&pic->qscale_table);
468
    av_freep(&pic->mb_type_base);
469
    av_freep(&pic->dct_coeff);
470
    av_freep(&pic->pan_scan);
471
    pic->mb_type= NULL;
472
    for(i=0; i<2; i++){
473
        av_freep(&pic->motion_val_base[i]);
474
        av_freep(&pic->ref_index[i]);
475
    }
476

    
477
    if(pic->type == FF_BUFFER_TYPE_SHARED){
478
        for(i=0; i<4; i++){
479
            pic->base[i]=
480
            pic->data[i]= NULL;
481
        }
482
        pic->type= 0;
483
    }
484
}
485

    
486
static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
487
    int i;
488

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

    
493
     //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
494
    CHECKED_ALLOCZ(s->me.scratchpad,  (s->width+64)*4*16*2*sizeof(uint8_t))
495
    s->rd_scratchpad=   s->me.scratchpad;
496
    s->b_scratchpad=    s->me.scratchpad;
497
    s->obmc_scratchpad= s->me.scratchpad + 16;
498
    if (s->encoding) {
499
        CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
500
        CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
501
        if(s->avctx->noise_reduction){
502
            CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
503
        }
504
    }
505
    CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
506
    s->block= s->blocks[0];
507

    
508
    for(i=0;i<12;i++){
509
        s->pblocks[i] = (short *)(&s->block[i]);
510
    }
511
    return 0;
512
fail:
513
    return -1; //free() through MPV_common_end()
514
}
515

    
516
static void free_duplicate_context(MpegEncContext *s){
517
    if(s==NULL) return;
518

    
519
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
520
    av_freep(&s->me.scratchpad);
521
    s->rd_scratchpad=
522
    s->b_scratchpad=
523
    s->obmc_scratchpad= NULL;
524

    
525
    av_freep(&s->dct_error_sum);
526
    av_freep(&s->me.map);
527
    av_freep(&s->me.score_map);
528
    av_freep(&s->blocks);
529
    s->block= NULL;
530
}
531

    
532
static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
533
#define COPY(a) bak->a= src->a
534
    COPY(allocated_edge_emu_buffer);
535
    COPY(edge_emu_buffer);
536
    COPY(me.scratchpad);
537
    COPY(rd_scratchpad);
538
    COPY(b_scratchpad);
539
    COPY(obmc_scratchpad);
540
    COPY(me.map);
541
    COPY(me.score_map);
542
    COPY(blocks);
543
    COPY(block);
544
    COPY(start_mb_y);
545
    COPY(end_mb_y);
546
    COPY(me.map_generation);
547
    COPY(pb);
548
    COPY(dct_error_sum);
549
    COPY(dct_count[0]);
550
    COPY(dct_count[1]);
551
#undef COPY
552
}
553

    
554
void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
555
    MpegEncContext bak;
556
    int i;
557
    //FIXME copy only needed parts
558
//START_TIMER
559
    backup_duplicate_context(&bak, dst);
560
    memcpy(dst, src, sizeof(MpegEncContext));
561
    backup_duplicate_context(dst, &bak);
562
    for(i=0;i<12;i++){
563
        dst->pblocks[i] = (short *)(&dst->block[i]);
564
    }
565
//STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
566
}
567

    
568
static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
569
#define COPY(a) dst->a= src->a
570
    COPY(pict_type);
571
    COPY(current_picture);
572
    COPY(f_code);
573
    COPY(b_code);
574
    COPY(qscale);
575
    COPY(lambda);
576
    COPY(lambda2);
577
    COPY(picture_in_gop_number);
578
    COPY(gop_picture_number);
579
    COPY(frame_pred_frame_dct); //FIXME don't set in encode_header
580
    COPY(progressive_frame); //FIXME don't set in encode_header
581
    COPY(partitioned_frame); //FIXME don't set in encode_header
582
#undef COPY
583
}
584

    
585
/**
586
 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
587
 * the changed fields will not depend upon the prior state of the MpegEncContext.
588
 */
589
static void MPV_common_defaults(MpegEncContext *s){
590
    s->y_dc_scale_table=
591
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
592
    s->chroma_qscale_table= ff_default_chroma_qscale_table;
593
    s->progressive_frame= 1;
594
    s->progressive_sequence= 1;
595
    s->picture_structure= PICT_FRAME;
596

    
597
    s->coded_picture_number = 0;
598
    s->picture_number = 0;
599
    s->input_picture_number = 0;
600

    
601
    s->picture_in_gop_number = 0;
602

    
603
    s->f_code = 1;
604
    s->b_code = 1;
605
}
606

    
607
/**
608
 * sets the given MpegEncContext to defaults for decoding.
609
 * the changed fields will not depend upon the prior state of the MpegEncContext.
610
 */
611
void MPV_decode_defaults(MpegEncContext *s){
612
    MPV_common_defaults(s);
613
}
614

    
615
/**
616
 * sets the given MpegEncContext to defaults for encoding.
617
 * the changed fields will not depend upon the prior state of the MpegEncContext.
618
 */
619

    
620
#ifdef CONFIG_ENCODERS
621
static void MPV_encode_defaults(MpegEncContext *s){
622
    static int done=0;
623

    
624
    MPV_common_defaults(s);
625

    
626
    if(!done){
627
        int i;
628
        done=1;
629

    
630
        default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
631
        memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
632

    
633
        for(i=-16; i<16; i++){
634
            default_fcode_tab[i + MAX_MV]= 1;
635
        }
636
    }
637
    s->me.mv_penalty= default_mv_penalty;
638
    s->fcode_tab= default_fcode_tab;
639
}
640
#endif //CONFIG_ENCODERS
641

    
642
/**
643
 * init common structure for both encoder and decoder.
644
 * this assumes that some variables like width/height are already set
645
 */
646
int MPV_common_init(MpegEncContext *s)
647
{
648
    int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
649

    
650
    s->mb_height = (s->height + 15) / 16;
651

    
652
    if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
653
        av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
654
        return -1;
655
    }
656

    
657
    if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
658
        return -1;
659

    
660
    dsputil_init(&s->dsp, s->avctx);
661
    DCT_common_init(s);
662

    
663
    s->flags= s->avctx->flags;
664
    s->flags2= s->avctx->flags2;
665

    
666
    s->mb_width  = (s->width  + 15) / 16;
667
    s->mb_stride = s->mb_width + 1;
668
    s->b8_stride = s->mb_width*2 + 1;
669
    s->b4_stride = s->mb_width*4 + 1;
670
    mb_array_size= s->mb_height * s->mb_stride;
671
    mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
672

    
673
    /* set chroma shifts */
674
    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
675
                                                    &(s->chroma_y_shift) );
676

    
677
    /* set default edge pos, will be overriden in decode_header if needed */
678
    s->h_edge_pos= s->mb_width*16;
679
    s->v_edge_pos= s->mb_height*16;
680

    
681
    s->mb_num = s->mb_width * s->mb_height;
682

    
683
    s->block_wrap[0]=
684
    s->block_wrap[1]=
685
    s->block_wrap[2]=
686
    s->block_wrap[3]= s->b8_stride;
687
    s->block_wrap[4]=
688
    s->block_wrap[5]= s->mb_stride;
689

    
690
    y_size = s->b8_stride * (2 * s->mb_height + 1);
691
    c_size = s->mb_stride * (s->mb_height + 1);
692
    yc_size = y_size + 2 * c_size;
693

    
694
    /* convert fourcc to upper case */
695
    s->avctx->codec_tag=   toupper( s->avctx->codec_tag     &0xFF)
696
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
697
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
698
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
699

    
700
    s->avctx->stream_codec_tag=   toupper( s->avctx->stream_codec_tag     &0xFF)
701
                               + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
702
                               + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
703
                               + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
704

    
705
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
706

    
707
    CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
708
    for(y=0; y<s->mb_height; y++){
709
        for(x=0; x<s->mb_width; x++){
710
            s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
711
        }
712
    }
713
    s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
714

    
715
    if (s->encoding) {
716
        /* Allocate MV tables */
717
        CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
718
        CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
719
        CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
720
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
721
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
722
        CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
723
        s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
724
        s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
725
        s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
726
        s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
727
        s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
728
        s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
729

    
730
        if(s->msmpeg4_version){
731
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
732
        }
733
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
734

    
735
        /* Allocate MB type table */
736
        CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint16_t)) //needed for encoding
737

    
738
        CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
739

    
740
        CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
741
        CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
742
        CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
743
        CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
744
        CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
745
        CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
746

    
747
        if(s->avctx->noise_reduction){
748
            CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
749
        }
750
    }
751
    CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
752

    
753
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
754

    
755
    if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
756
        /* interlaced direct mode decoding tables */
757
            for(i=0; i<2; i++){
758
                int j, k;
759
                for(j=0; j<2; j++){
760
                    for(k=0; k<2; k++){
761
                        CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k]     , mv_table_size * 2 * sizeof(int16_t))
762
                        s->b_field_mv_table[i][j][k]    = s->b_field_mv_table_base[i][j][k]     + s->mb_stride + 1;
763
                    }
764
                    CHECKED_ALLOCZ(s->b_field_select_table[i][j]     , mb_array_size * 2 * sizeof(uint8_t))
765
                    CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j]     , mv_table_size * 2 * sizeof(int16_t))
766
                    s->p_field_mv_table[i][j]    = s->p_field_mv_table_base[i][j]     + s->mb_stride + 1;
767
                }
768
                CHECKED_ALLOCZ(s->p_field_select_table[i]      , mb_array_size * 2 * sizeof(uint8_t))
769
            }
770
    }
771
    if (s->out_format == FMT_H263) {
772
        /* ac values */
773
        CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
774
        s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
775
        s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
776
        s->ac_val[2] = s->ac_val[1] + c_size;
777

    
778
        /* cbp values */
779
        CHECKED_ALLOCZ(s->coded_block_base, y_size);
780
        s->coded_block= s->coded_block_base + s->b8_stride + 1;
781

    
782
        /* cbp, ac_pred, pred_dir */
783
        CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
784
        CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
785
    }
786

    
787
    if (s->h263_pred || s->h263_plus || !s->encoding) {
788
        /* dc values */
789
        //MN: we need these for error resilience of intra-frames
790
        CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
791
        s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
792
        s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
793
        s->dc_val[2] = s->dc_val[1] + c_size;
794
        for(i=0;i<yc_size;i++)
795
            s->dc_val_base[i] = 1024;
796
    }
797

    
798
    /* which mb is a intra block */
799
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
800
    memset(s->mbintra_table, 1, mb_array_size);
801

    
802
    /* init macroblock skip table */
803
    CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
804
    //Note the +1 is for a quicker mpeg4 slice_end detection
805
    CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
806

    
807
    s->parse_context.state= -1;
808
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
809
       s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
810
       s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
811
       s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
812
    }
813

    
814
    s->context_initialized = 1;
815

    
816
    s->thread_context[0]= s;
817
    for(i=1; i<s->avctx->thread_count; i++){
818
        s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
819
        memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
820
    }
821

    
822
    for(i=0; i<s->avctx->thread_count; i++){
823
        if(init_duplicate_context(s->thread_context[i], s) < 0)
824
           goto fail;
825
        s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
826
        s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
827
    }
828

    
829
    return 0;
830
 fail:
831
    MPV_common_end(s);
832
    return -1;
833
}
834

    
835
/* init common structure for both encoder and decoder */
836
void MPV_common_end(MpegEncContext *s)
837
{
838
    int i, j, k;
839

    
840
    for(i=0; i<s->avctx->thread_count; i++){
841
        free_duplicate_context(s->thread_context[i]);
842
    }
843
    for(i=1; i<s->avctx->thread_count; i++){
844
        av_freep(&s->thread_context[i]);
845
    }
846

    
847
    av_freep(&s->parse_context.buffer);
848
    s->parse_context.buffer_size=0;
849

    
850
    av_freep(&s->mb_type);
851
    av_freep(&s->p_mv_table_base);
852
    av_freep(&s->b_forw_mv_table_base);
853
    av_freep(&s->b_back_mv_table_base);
854
    av_freep(&s->b_bidir_forw_mv_table_base);
855
    av_freep(&s->b_bidir_back_mv_table_base);
856
    av_freep(&s->b_direct_mv_table_base);
857
    s->p_mv_table= NULL;
858
    s->b_forw_mv_table= NULL;
859
    s->b_back_mv_table= NULL;
860
    s->b_bidir_forw_mv_table= NULL;
861
    s->b_bidir_back_mv_table= NULL;
862
    s->b_direct_mv_table= NULL;
863
    for(i=0; i<2; i++){
864
        for(j=0; j<2; j++){
865
            for(k=0; k<2; k++){
866
                av_freep(&s->b_field_mv_table_base[i][j][k]);
867
                s->b_field_mv_table[i][j][k]=NULL;
868
            }
869
            av_freep(&s->b_field_select_table[i][j]);
870
            av_freep(&s->p_field_mv_table_base[i][j]);
871
            s->p_field_mv_table[i][j]=NULL;
872
        }
873
        av_freep(&s->p_field_select_table[i]);
874
    }
875

    
876
    av_freep(&s->dc_val_base);
877
    av_freep(&s->ac_val_base);
878
    av_freep(&s->coded_block_base);
879
    av_freep(&s->mbintra_table);
880
    av_freep(&s->cbp_table);
881
    av_freep(&s->pred_dir_table);
882

    
883
    av_freep(&s->mbskip_table);
884
    av_freep(&s->prev_pict_types);
885
    av_freep(&s->bitstream_buffer);
886
    s->allocated_bitstream_buffer_size=0;
887

    
888
    av_freep(&s->avctx->stats_out);
889
    av_freep(&s->ac_stats);
890
    av_freep(&s->error_status_table);
891
    av_freep(&s->mb_index2xy);
892
    av_freep(&s->lambda_table);
893
    av_freep(&s->q_intra_matrix);
894
    av_freep(&s->q_inter_matrix);
895
    av_freep(&s->q_intra_matrix16);
896
    av_freep(&s->q_inter_matrix16);
897
    av_freep(&s->input_picture);
898
    av_freep(&s->reordered_input_picture);
899
    av_freep(&s->dct_offset);
900

    
901
    if(s->picture){
902
        for(i=0; i<MAX_PICTURE_COUNT; i++){
903
            free_picture(s, &s->picture[i]);
904
        }
905
    }
906
    av_freep(&s->picture);
907
    s->context_initialized = 0;
908
    s->last_picture_ptr=
909
    s->next_picture_ptr=
910
    s->current_picture_ptr= NULL;
911
    s->linesize= s->uvlinesize= 0;
912

    
913
    for(i=0; i<3; i++)
914
        av_freep(&s->visualization_buffer[i]);
915

    
916
    avcodec_default_free_buffers(s->avctx);
917
}
918

    
919
#ifdef CONFIG_ENCODERS
920

    
921
/* init video encoder */
922
int MPV_encode_init(AVCodecContext *avctx)
923
{
924
    MpegEncContext *s = avctx->priv_data;
925
    int i;
926
    int chroma_h_shift, chroma_v_shift;
927

    
928
    MPV_encode_defaults(s);
929

    
930
    if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUV420P){
931
        av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
932
        return -1;
933
    }
934

    
935
    if(avctx->codec_id == CODEC_ID_MJPEG || avctx->codec_id == CODEC_ID_LJPEG){
936
        if(avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL && avctx->pix_fmt != PIX_FMT_YUVJ420P){
937
            av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
938
            return -1;
939
        }
940
    }else{
941
        if(avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL && avctx->pix_fmt != PIX_FMT_YUV420P){
942
            av_log(avctx, AV_LOG_ERROR, "colorspace not supported\n");
943
            return -1;
944
        }
945
    }
946

    
947
    s->bit_rate = avctx->bit_rate;
948
    s->width = avctx->width;
949
    s->height = avctx->height;
950
    if(avctx->gop_size > 600 && avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){
951
        av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
952
        avctx->gop_size=600;
953
    }
954
    s->gop_size = avctx->gop_size;
955
    s->avctx = avctx;
956
    s->flags= avctx->flags;
957
    s->flags2= avctx->flags2;
958
    s->max_b_frames= avctx->max_b_frames;
959
    s->codec_id= avctx->codec->id;
960
    s->luma_elim_threshold  = avctx->luma_elim_threshold;
961
    s->chroma_elim_threshold= avctx->chroma_elim_threshold;
962
    s->strict_std_compliance= avctx->strict_std_compliance;
963
    s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
964
    s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
965
    s->mpeg_quant= avctx->mpeg_quant;
966
    s->rtp_mode= !!avctx->rtp_payload_size;
967
    s->intra_dc_precision= avctx->intra_dc_precision;
968
    s->user_specified_pts = AV_NOPTS_VALUE;
969

    
970
    if (s->gop_size <= 1) {
971
        s->intra_only = 1;
972
        s->gop_size = 12;
973
    } else {
974
        s->intra_only = 0;
975
    }
976

    
977
    s->me_method = avctx->me_method;
978

    
979
    /* Fixed QSCALE */
980
    s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
981

    
982
    s->adaptive_quant= (   s->avctx->lumi_masking
983
                        || s->avctx->dark_masking
984
                        || s->avctx->temporal_cplx_masking
985
                        || s->avctx->spatial_cplx_masking
986
                        || s->avctx->p_masking
987
                        || s->avctx->border_masking
988
                        || (s->flags&CODEC_FLAG_QP_RD))
989
                       && !s->fixed_qscale;
990

    
991
    s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
992
    s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
993
    s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
994
    s->intra_vlc_format= !!(s->flags2 & CODEC_FLAG2_INTRA_VLC);
995

    
996
    if(avctx->rc_max_rate && !avctx->rc_buffer_size){
997
        av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
998
        return -1;
999
    }
1000

    
1001
    if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
1002
        av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
1003
    }
1004

    
1005
    if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
1006
        av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
1007
        return -1;
1008
    }
1009

    
1010
    if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
1011
        av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
1012
        return -1;
1013
    }
1014

    
1015
    if(   s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
1016
       && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
1017
       && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
1018

    
1019
        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");
1020
    }
1021

    
1022
    if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
1023
       && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
1024
        av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
1025
        return -1;
1026
    }
1027

    
1028
    if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
1029
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n");
1030
        return -1;
1031
    }
1032

    
1033
    if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
1034
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
1035
        return -1;
1036
    }
1037

    
1038
    if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
1039
        av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
1040
        return -1;
1041
    }
1042

    
1043
    if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
1044
        av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
1045
        return -1;
1046
    }
1047

    
1048
    if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
1049
        av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
1050
        return -1;
1051
    }
1052

    
1053
    if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
1054
       && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1055
        av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1056
        return -1;
1057
    }
1058

    
1059
    if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1060
        av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n");
1061
        return -1;
1062
    }
1063

    
1064
    if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1065
        av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1066
        return -1;
1067
    }
1068

    
1069
    if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1070
        av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1071
        return -1;
1072
    }
1073

    
1074
    if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1075
        av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
1076
        return -1;
1077
    }
1078

    
1079
    if((s->flags2 & CODEC_FLAG2_INTRA_VLC) && s->codec_id != CODEC_ID_MPEG2VIDEO){
1080
        av_log(avctx, AV_LOG_ERROR, "intra vlc table not supported by codec\n");
1081
        return -1;
1082
    }
1083

    
1084
    if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1085
       && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1086
       && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1087
        av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1088
        return -1;
1089
    }
1090

    
1091
    if(s->avctx->thread_count > 1)
1092
        s->rtp_mode= 1;
1093

    
1094
    if(!avctx->time_base.den || !avctx->time_base.num){
1095
        av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1096
        return -1;
1097
    }
1098

    
1099
    i= (INT_MAX/2+128)>>8;
1100
    if(avctx->me_threshold >= i){
1101
        av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1102
        return -1;
1103
    }
1104
    if(avctx->mb_threshold >= i){
1105
        av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1106
        return -1;
1107
    }
1108

    
1109
    if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
1110
        av_log(avctx, AV_LOG_ERROR, "b_frame_strategy must be 0 on the second pass\n");
1111
        return -1;
1112
    }
1113

    
1114
    i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
1115
    if(i > 1){
1116
        av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1117
        avctx->time_base.den /= i;
1118
        avctx->time_base.num /= i;
1119
//        return -1;
1120
    }
1121

    
1122
    if(s->codec_id==CODEC_ID_MJPEG){
1123
        s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1124
        s->inter_quant_bias= 0;
1125
    }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1126
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1127
        s->inter_quant_bias= 0;
1128
    }else{
1129
        s->intra_quant_bias=0;
1130
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1131
    }
1132

    
1133
    if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1134
        s->intra_quant_bias= avctx->intra_quant_bias;
1135
    if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1136
        s->inter_quant_bias= avctx->inter_quant_bias;
1137

    
1138
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1139

    
1140
    if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
1141
        av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1142
        return -1;
1143
    }
1144
    s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1145

    
1146
    switch(avctx->codec->id) {
1147
    case CODEC_ID_MPEG1VIDEO:
1148
        s->out_format = FMT_MPEG1;
1149
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1150
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1151
        break;
1152
    case CODEC_ID_MPEG2VIDEO:
1153
        s->out_format = FMT_MPEG1;
1154
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1155
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1156
        s->rtp_mode= 1;
1157
        break;
1158
    case CODEC_ID_LJPEG:
1159
    case CODEC_ID_JPEGLS:
1160
    case CODEC_ID_MJPEG:
1161
        s->out_format = FMT_MJPEG;
1162
        s->intra_only = 1; /* force intra only for jpeg */
1163
        s->mjpeg_write_tables = avctx->codec->id != CODEC_ID_JPEGLS;
1164
        s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1165
        s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1166
        s->mjpeg_vsample[1] = 1;
1167
        s->mjpeg_vsample[2] = 1;
1168
        s->mjpeg_hsample[0] = 1<<chroma_h_shift;
1169
        s->mjpeg_hsample[1] = 1;
1170
        s->mjpeg_hsample[2] = 1;
1171
        if (mjpeg_init(s) < 0)
1172
            return -1;
1173
        avctx->delay=0;
1174
        s->low_delay=1;
1175
        break;
1176
    case CODEC_ID_H261:
1177
        s->out_format = FMT_H261;
1178
        avctx->delay=0;
1179
        s->low_delay=1;
1180
        break;
1181
    case CODEC_ID_H263:
1182
        if (h263_get_picture_format(s->width, s->height) == 7) {
1183
            av_log(avctx, AV_LOG_INFO, "The specified picture size of %dx%d is not valid for the H.263 codec.\nValid sizes are 128x96, 176x144, 352x288, 704x576, and 1408x1152. Try H.263+.\n", s->width, s->height);
1184
            return -1;
1185
        }
1186
        s->out_format = FMT_H263;
1187
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1188
        avctx->delay=0;
1189
        s->low_delay=1;
1190
        break;
1191
    case CODEC_ID_H263P:
1192
        s->out_format = FMT_H263;
1193
        s->h263_plus = 1;
1194
        /* Fx */
1195
        s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1196
        s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1197
        s->modified_quant= s->h263_aic;
1198
        s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1199
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1200
        s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1201
        s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1202
        s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1203

    
1204
        /* /Fx */
1205
        /* These are just to be sure */
1206
        avctx->delay=0;
1207
        s->low_delay=1;
1208
        break;
1209
    case CODEC_ID_FLV1:
1210
        s->out_format = FMT_H263;
1211
        s->h263_flv = 2; /* format = 1; 11-bit codes */
1212
        s->unrestricted_mv = 1;
1213
        s->rtp_mode=0; /* don't allow GOB */
1214
        avctx->delay=0;
1215
        s->low_delay=1;
1216
        break;
1217
    case CODEC_ID_RV10:
1218
        s->out_format = FMT_H263;
1219
        avctx->delay=0;
1220
        s->low_delay=1;
1221
        break;
1222
    case CODEC_ID_RV20:
1223
        s->out_format = FMT_H263;
1224
        avctx->delay=0;
1225
        s->low_delay=1;
1226
        s->modified_quant=1;
1227
        s->h263_aic=1;
1228
        s->h263_plus=1;
1229
        s->loop_filter=1;
1230
        s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1231
        break;
1232
    case CODEC_ID_MPEG4:
1233
        s->out_format = FMT_H263;
1234
        s->h263_pred = 1;
1235
        s->unrestricted_mv = 1;
1236
        s->low_delay= s->max_b_frames ? 0 : 1;
1237
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1238
        break;
1239
    case CODEC_ID_MSMPEG4V1:
1240
        s->out_format = FMT_H263;
1241
        s->h263_msmpeg4 = 1;
1242
        s->h263_pred = 1;
1243
        s->unrestricted_mv = 1;
1244
        s->msmpeg4_version= 1;
1245
        avctx->delay=0;
1246
        s->low_delay=1;
1247
        break;
1248
    case CODEC_ID_MSMPEG4V2:
1249
        s->out_format = FMT_H263;
1250
        s->h263_msmpeg4 = 1;
1251
        s->h263_pred = 1;
1252
        s->unrestricted_mv = 1;
1253
        s->msmpeg4_version= 2;
1254
        avctx->delay=0;
1255
        s->low_delay=1;
1256
        break;
1257
    case CODEC_ID_MSMPEG4V3:
1258
        s->out_format = FMT_H263;
1259
        s->h263_msmpeg4 = 1;
1260
        s->h263_pred = 1;
1261
        s->unrestricted_mv = 1;
1262
        s->msmpeg4_version= 3;
1263
        s->flipflop_rounding=1;
1264
        avctx->delay=0;
1265
        s->low_delay=1;
1266
        break;
1267
    case CODEC_ID_WMV1:
1268
        s->out_format = FMT_H263;
1269
        s->h263_msmpeg4 = 1;
1270
        s->h263_pred = 1;
1271
        s->unrestricted_mv = 1;
1272
        s->msmpeg4_version= 4;
1273
        s->flipflop_rounding=1;
1274
        avctx->delay=0;
1275
        s->low_delay=1;
1276
        break;
1277
    case CODEC_ID_WMV2:
1278
        s->out_format = FMT_H263;
1279
        s->h263_msmpeg4 = 1;
1280
        s->h263_pred = 1;
1281
        s->unrestricted_mv = 1;
1282
        s->msmpeg4_version= 5;
1283
        s->flipflop_rounding=1;
1284
        avctx->delay=0;
1285
        s->low_delay=1;
1286
        break;
1287
    default:
1288
        return -1;
1289
    }
1290

    
1291
    avctx->has_b_frames= !s->low_delay;
1292

    
1293
    s->encoding = 1;
1294

    
1295
    /* init */
1296
    if (MPV_common_init(s) < 0)
1297
        return -1;
1298

    
1299
    if(s->modified_quant)
1300
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1301
    s->progressive_frame=
1302
    s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1303
    s->quant_precision=5;
1304

    
1305
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1306
    ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1307

    
1308
#ifdef CONFIG_H261_ENCODER
1309
    if (s->out_format == FMT_H261)
1310
        ff_h261_encode_init(s);
1311
#endif
1312
    if (s->out_format == FMT_H263)
1313
        h263_encode_init(s);
1314
    if(s->msmpeg4_version)
1315
        ff_msmpeg4_encode_init(s);
1316
    if (s->out_format == FMT_MPEG1)
1317
        ff_mpeg1_encode_init(s);
1318

    
1319
    /* init q matrix */
1320
    for(i=0;i<64;i++) {
1321
        int j= s->dsp.idct_permutation[i];
1322
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1323
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1324
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1325
        }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1326
            s->intra_matrix[j] =
1327
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1328
        }else
1329
        { /* mpeg1/2 */
1330
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1331
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1332
        }
1333
        if(s->avctx->intra_matrix)
1334
            s->intra_matrix[j] = s->avctx->intra_matrix[i];
1335
        if(s->avctx->inter_matrix)
1336
            s->inter_matrix[j] = s->avctx->inter_matrix[i];
1337
    }
1338

    
1339
    /* precompute matrix */
1340
    /* for mjpeg, we do include qscale in the matrix */
1341
    if (s->out_format != FMT_MJPEG) {
1342
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1343
                       s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1344
        convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1345
                       s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1346
    }
1347

    
1348
    if(ff_rate_control_init(s) < 0)
1349
        return -1;
1350

    
1351
    return 0;
1352
}
1353

    
1354
int MPV_encode_end(AVCodecContext *avctx)
1355
{
1356
    MpegEncContext *s = avctx->priv_data;
1357

    
1358
#ifdef STATS
1359
    print_stats();
1360
#endif
1361

    
1362
    ff_rate_control_uninit(s);
1363

    
1364
    MPV_common_end(s);
1365
    if (s->out_format == FMT_MJPEG)
1366
        mjpeg_close(s);
1367

    
1368
    av_freep(&avctx->extradata);
1369

    
1370
    return 0;
1371
}
1372

    
1373
#endif //CONFIG_ENCODERS
1374

    
1375
void init_rl(RLTable *rl, int use_static)
1376
{
1377
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1378
    uint8_t index_run[MAX_RUN+1];
1379
    int last, run, level, start, end, i;
1380

    
1381
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
1382
    if(use_static && rl->max_level[0])
1383
        return;
1384

    
1385
    /* compute max_level[], max_run[] and index_run[] */
1386
    for(last=0;last<2;last++) {
1387
        if (last == 0) {
1388
            start = 0;
1389
            end = rl->last;
1390
        } else {
1391
            start = rl->last;
1392
            end = rl->n;
1393
        }
1394

    
1395
        memset(max_level, 0, MAX_RUN + 1);
1396
        memset(max_run, 0, MAX_LEVEL + 1);
1397
        memset(index_run, rl->n, MAX_RUN + 1);
1398
        for(i=start;i<end;i++) {
1399
            run = rl->table_run[i];
1400
            level = rl->table_level[i];
1401
            if (index_run[run] == rl->n)
1402
                index_run[run] = i;
1403
            if (level > max_level[run])
1404
                max_level[run] = level;
1405
            if (run > max_run[level])
1406
                max_run[level] = run;
1407
        }
1408
        if(use_static)
1409
            rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1410
        else
1411
            rl->max_level[last] = av_malloc(MAX_RUN + 1);
1412
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1413
        if(use_static)
1414
            rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1415
        else
1416
            rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1417
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1418
        if(use_static)
1419
            rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1420
        else
1421
            rl->index_run[last] = av_malloc(MAX_RUN + 1);
1422
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1423
    }
1424
}
1425

    
1426
/* draw the edges of width 'w' of an image of size width, height */
1427
//FIXME check that this is ok for mpeg4 interlaced
1428
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1429
{
1430
    uint8_t *ptr, *last_line;
1431
    int i;
1432

    
1433
    last_line = buf + (height - 1) * wrap;
1434
    for(i=0;i<w;i++) {
1435
        /* top and bottom */
1436
        memcpy(buf - (i + 1) * wrap, buf, width);
1437
        memcpy(last_line + (i + 1) * wrap, last_line, width);
1438
    }
1439
    /* left and right */
1440
    ptr = buf;
1441
    for(i=0;i<height;i++) {
1442
        memset(ptr - w, ptr[0], w);
1443
        memset(ptr + width, ptr[width-1], w);
1444
        ptr += wrap;
1445
    }
1446
    /* corners */
1447
    for(i=0;i<w;i++) {
1448
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1449
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1450
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1451
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1452
    }
1453
}
1454

    
1455
int ff_find_unused_picture(MpegEncContext *s, int shared){
1456
    int i;
1457

    
1458
    if(shared){
1459
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1460
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1461
        }
1462
    }else{
1463
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1464
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1465
        }
1466
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1467
            if(s->picture[i].data[0]==NULL) return i;
1468
        }
1469
    }
1470

    
1471
    assert(0);
1472
    return -1;
1473
}
1474

    
1475
static void update_noise_reduction(MpegEncContext *s){
1476
    int intra, i;
1477

    
1478
    for(intra=0; intra<2; intra++){
1479
        if(s->dct_count[intra] > (1<<16)){
1480
            for(i=0; i<64; i++){
1481
                s->dct_error_sum[intra][i] >>=1;
1482
            }
1483
            s->dct_count[intra] >>= 1;
1484
        }
1485

    
1486
        for(i=0; i<64; i++){
1487
            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);
1488
        }
1489
    }
1490
}
1491

    
1492
/**
1493
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1494
 */
1495
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1496
{
1497
    int i;
1498
    AVFrame *pic;
1499
    s->mb_skipped = 0;
1500

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

    
1503
    /* mark&release old frames */
1504
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1505
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1506

    
1507
        /* release forgotten pictures */
1508
        /* if(mpeg124/h263) */
1509
        if(!s->encoding){
1510
            for(i=0; i<MAX_PICTURE_COUNT; i++){
1511
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1512
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1513
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1514
                }
1515
            }
1516
        }
1517
    }
1518
alloc:
1519
    if(!s->encoding){
1520
        /* release non reference frames */
1521
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1522
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1523
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1524
            }
1525
        }
1526

    
1527
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1528
            pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1529
        else{
1530
            i= ff_find_unused_picture(s, 0);
1531
            pic= (AVFrame*)&s->picture[i];
1532
        }
1533

    
1534
        pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1535
                        && !s->dropable ? 3 : 0;
1536

    
1537
        pic->coded_picture_number= s->coded_picture_number++;
1538

    
1539
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1540
            return -1;
1541

    
1542
        s->current_picture_ptr= (Picture*)pic;
1543
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1544
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1545
    }
1546

    
1547
    s->current_picture_ptr->pict_type= s->pict_type;
1548
//    if(s->flags && CODEC_FLAG_QSCALE)
1549
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1550
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1551

    
1552
    copy_picture(&s->current_picture, s->current_picture_ptr);
1553

    
1554
  if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1555
    if (s->pict_type != B_TYPE) {
1556
        s->last_picture_ptr= s->next_picture_ptr;
1557
        if(!s->dropable)
1558
            s->next_picture_ptr= s->current_picture_ptr;
1559
    }
1560
/*    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,
1561
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
1562
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
1563
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1564
        s->pict_type, s->dropable);*/
1565

    
1566
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1567
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1568

    
1569
    if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1570
        av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1571
        assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference
1572
        goto alloc;
1573
    }
1574

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

    
1577
    if(s->picture_structure!=PICT_FRAME){
1578
        int i;
1579
        for(i=0; i<4; i++){
1580
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1581
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1582
            }
1583
            s->current_picture.linesize[i] *= 2;
1584
            s->last_picture.linesize[i] *=2;
1585
            s->next_picture.linesize[i] *=2;
1586
        }
1587
    }
1588
  }
1589

    
1590
    s->hurry_up= s->avctx->hurry_up;
1591
    s->error_resilience= avctx->error_resilience;
1592

    
1593
    /* set dequantizer, we can't do it during init as it might change for mpeg4
1594
       and we can't do it in the header decode as init isnt called for mpeg4 there yet */
1595
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1596
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1597
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1598
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1599
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1600
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1601
    }else{
1602
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1603
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1604
    }
1605

    
1606
    if(s->dct_error_sum){
1607
        assert(s->avctx->noise_reduction && s->encoding);
1608

    
1609
        update_noise_reduction(s);
1610
    }
1611

    
1612
#ifdef HAVE_XVMC
1613
    if(s->avctx->xvmc_acceleration)
1614
        return XVMC_field_start(s, avctx);
1615
#endif
1616
    return 0;
1617
}
1618

    
1619
/* generic function for encode/decode called after a frame has been coded/decoded */
1620
void MPV_frame_end(MpegEncContext *s)
1621
{
1622
    int i;
1623
    /* draw edge for correct motion prediction if outside */
1624
#ifdef HAVE_XVMC
1625
//just to make sure that all data is rendered.
1626
    if(s->avctx->xvmc_acceleration){
1627
        XVMC_field_end(s);
1628
    }else
1629
#endif
1630
    if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1631
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1632
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1633
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1634
    }
1635
    emms_c();
1636

    
1637
    s->last_pict_type    = s->pict_type;
1638
    s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1639
    if(s->pict_type!=B_TYPE){
1640
        s->last_non_b_pict_type= s->pict_type;
1641
    }
1642
#if 0
1643
        /* copy back current_picture variables */
1644
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1645
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1646
            s->picture[i]= s->current_picture;
1647
            break;
1648
        }
1649
    }
1650
    assert(i<MAX_PICTURE_COUNT);
1651
#endif
1652

    
1653
    if(s->encoding){
1654
        /* release non-reference frames */
1655
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1656
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1657
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1658
            }
1659
        }
1660
    }
1661
    // clear copies, to avoid confusion
1662
#if 0
1663
    memset(&s->last_picture, 0, sizeof(Picture));
1664
    memset(&s->next_picture, 0, sizeof(Picture));
1665
    memset(&s->current_picture, 0, sizeof(Picture));
1666
#endif
1667
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1668
}
1669

    
1670
/**
1671
 * draws an line from (ex, ey) -> (sx, sy).
1672
 * @param w width of the image
1673
 * @param h height of the image
1674
 * @param stride stride/linesize of the image
1675
 * @param color color of the arrow
1676
 */
1677
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1678
    int t, x, y, fr, f;
1679

    
1680
    sx= clip(sx, 0, w-1);
1681
    sy= clip(sy, 0, h-1);
1682
    ex= clip(ex, 0, w-1);
1683
    ey= clip(ey, 0, h-1);
1684

    
1685
    buf[sy*stride + sx]+= color;
1686

    
1687
    if(ABS(ex - sx) > ABS(ey - sy)){
1688
        if(sx > ex){
1689
            t=sx; sx=ex; ex=t;
1690
            t=sy; sy=ey; ey=t;
1691
        }
1692
        buf+= sx + sy*stride;
1693
        ex-= sx;
1694
        f= ((ey-sy)<<16)/ex;
1695
        for(x= 0; x <= ex; x++){
1696
            y = (x*f)>>16;
1697
            fr= (x*f)&0xFFFF;
1698
            buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1699
            buf[(y+1)*stride + x]+= (color*         fr )>>16;
1700
        }
1701
    }else{
1702
        if(sy > ey){
1703
            t=sx; sx=ex; ex=t;
1704
            t=sy; sy=ey; ey=t;
1705
        }
1706
        buf+= sx + sy*stride;
1707
        ey-= sy;
1708
        if(ey) f= ((ex-sx)<<16)/ey;
1709
        else   f= 0;
1710
        for(y= 0; y <= ey; y++){
1711
            x = (y*f)>>16;
1712
            fr= (y*f)&0xFFFF;
1713
            buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;;
1714
            buf[y*stride + x+1]+= (color*         fr )>>16;;
1715
        }
1716
    }
1717
}
1718

    
1719
/**
1720
 * draws an arrow from (ex, ey) -> (sx, sy).
1721
 * @param w width of the image
1722
 * @param h height of the image
1723
 * @param stride stride/linesize of the image
1724
 * @param color color of the arrow
1725
 */
1726
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1727
    int dx,dy;
1728

    
1729
    sx= clip(sx, -100, w+100);
1730
    sy= clip(sy, -100, h+100);
1731
    ex= clip(ex, -100, w+100);
1732
    ey= clip(ey, -100, h+100);
1733

    
1734
    dx= ex - sx;
1735
    dy= ey - sy;
1736

    
1737
    if(dx*dx + dy*dy > 3*3){
1738
        int rx=  dx + dy;
1739
        int ry= -dx + dy;
1740
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1741

    
1742
        //FIXME subpixel accuracy
1743
        rx= ROUNDED_DIV(rx*3<<4, length);
1744
        ry= ROUNDED_DIV(ry*3<<4, length);
1745

    
1746
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1747
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1748
    }
1749
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1750
}
1751

    
1752
/**
1753
 * prints debuging info for the given picture.
1754
 */
1755
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1756

    
1757
    if(!pict || !pict->mb_type) return;
1758

    
1759
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1760
        int x,y;
1761

    
1762
        av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1763
        switch (pict->pict_type) {
1764
            case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1765
            case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1766
            case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1767
            case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1768
            case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1769
            case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1770
        }
1771
        for(y=0; y<s->mb_height; y++){
1772
            for(x=0; x<s->mb_width; x++){
1773
                if(s->avctx->debug&FF_DEBUG_SKIP){
1774
                    int count= s->mbskip_table[x + y*s->mb_stride];
1775
                    if(count>9) count=9;
1776
                    av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1777
                }
1778
                if(s->avctx->debug&FF_DEBUG_QP){
1779
                    av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1780
                }
1781
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1782
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
1783
                    //Type & MV direction
1784
                    if(IS_PCM(mb_type))
1785
                        av_log(s->avctx, AV_LOG_DEBUG, "P");
1786
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1787
                        av_log(s->avctx, AV_LOG_DEBUG, "A");
1788
                    else if(IS_INTRA4x4(mb_type))
1789
                        av_log(s->avctx, AV_LOG_DEBUG, "i");
1790
                    else if(IS_INTRA16x16(mb_type))
1791
                        av_log(s->avctx, AV_LOG_DEBUG, "I");
1792
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1793
                        av_log(s->avctx, AV_LOG_DEBUG, "d");
1794
                    else if(IS_DIRECT(mb_type))
1795
                        av_log(s->avctx, AV_LOG_DEBUG, "D");
1796
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1797
                        av_log(s->avctx, AV_LOG_DEBUG, "g");
1798
                    else if(IS_GMC(mb_type))
1799
                        av_log(s->avctx, AV_LOG_DEBUG, "G");
1800
                    else if(IS_SKIP(mb_type))
1801
                        av_log(s->avctx, AV_LOG_DEBUG, "S");
1802
                    else if(!USES_LIST(mb_type, 1))
1803
                        av_log(s->avctx, AV_LOG_DEBUG, ">");
1804
                    else if(!USES_LIST(mb_type, 0))
1805
                        av_log(s->avctx, AV_LOG_DEBUG, "<");
1806
                    else{
1807
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1808
                        av_log(s->avctx, AV_LOG_DEBUG, "X");
1809
                    }
1810

    
1811
                    //segmentation
1812
                    if(IS_8X8(mb_type))
1813
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1814
                    else if(IS_16X8(mb_type))
1815
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1816
                    else if(IS_8X16(mb_type))
1817
                        av_log(s->avctx, AV_LOG_DEBUG, "|");
1818
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1819
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1820
                    else
1821
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1822

    
1823

    
1824
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1825
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1826
                    else
1827
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1828
                }
1829
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1830
            }
1831
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1832
        }
1833
    }
1834

    
1835
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1836
        const int shift= 1 + s->quarter_sample;
1837
        int mb_y;
1838
        uint8_t *ptr;
1839
        int i;
1840
        int h_chroma_shift, v_chroma_shift;
1841
        const int width = s->avctx->width;
1842
        const int height= s->avctx->height;
1843
        const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1844
        const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1845
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1846

    
1847
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1848
        for(i=0; i<3; i++){
1849
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1850
            pict->data[i]= s->visualization_buffer[i];
1851
        }
1852
        pict->type= FF_BUFFER_TYPE_COPY;
1853
        ptr= pict->data[0];
1854

    
1855
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1856
            int mb_x;
1857
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1858
                const int mb_index= mb_x + mb_y*s->mb_stride;
1859
                if((s->avctx->debug_mv) && pict->motion_val){
1860
                  int type;
1861
                  for(type=0; type<3; type++){
1862
                    int direction = 0;
1863
                    switch (type) {
1864
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1865
                                continue;
1866
                              direction = 0;
1867
                              break;
1868
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1869
                                continue;
1870
                              direction = 0;
1871
                              break;
1872
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1873
                                continue;
1874
                              direction = 1;
1875
                              break;
1876
                    }
1877
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1878
                        continue;
1879

    
1880
                    if(IS_8X8(pict->mb_type[mb_index])){
1881
                      int i;
1882
                      for(i=0; i<4; i++){
1883
                        int sx= mb_x*16 + 4 + 8*(i&1);
1884
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1885
                        int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1886
                        int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1887
                        int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1888
                        draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1889
                      }
1890
                    }else if(IS_16X8(pict->mb_type[mb_index])){
1891
                      int i;
1892
                      for(i=0; i<2; i++){
1893
                        int sx=mb_x*16 + 8;
1894
                        int sy=mb_y*16 + 4 + 8*i;
1895
                        int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1896
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1897
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1898

    
1899
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1900
                            my*=2;
1901

    
1902
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1903
                      }
1904
                    }else if(IS_8X16(pict->mb_type[mb_index])){
1905
                      int i;
1906
                      for(i=0; i<2; i++){
1907
                        int sx=mb_x*16 + 4 + 8*i;
1908
                        int sy=mb_y*16 + 8;
1909
                        int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1910
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1911
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1912

    
1913
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1914
                            my*=2;
1915

    
1916
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1917
                      }
1918
                    }else{
1919
                      int sx= mb_x*16 + 8;
1920
                      int sy= mb_y*16 + 8;
1921
                      int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1922
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1923
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1924
                      draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1925
                    }
1926
                  }
1927
                }
1928
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1929
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1930
                    int y;
1931
                    for(y=0; y<8; y++){
1932
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1933
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1934
                    }
1935
                }
1936
                if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1937
                    int mb_type= pict->mb_type[mb_index];
1938
                    uint64_t u,v;
1939
                    int y;
1940
#define COLOR(theta, r)\
1941
u= (int)(128 + r*cos(theta*3.141592/180));\
1942
v= (int)(128 + r*sin(theta*3.141592/180));
1943

    
1944

    
1945
                    u=v=128;
1946
                    if(IS_PCM(mb_type)){
1947
                        COLOR(120,48)
1948
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1949
                        COLOR(30,48)
1950
                    }else if(IS_INTRA4x4(mb_type)){
1951
                        COLOR(90,48)
1952
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1953
//                        COLOR(120,48)
1954
                    }else if(IS_DIRECT(mb_type)){
1955
                        COLOR(150,48)
1956
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1957
                        COLOR(170,48)
1958
                    }else if(IS_GMC(mb_type)){
1959
                        COLOR(190,48)
1960
                    }else if(IS_SKIP(mb_type)){
1961
//                        COLOR(180,48)
1962
                    }else if(!USES_LIST(mb_type, 1)){
1963
                        COLOR(240,48)
1964
                    }else if(!USES_LIST(mb_type, 0)){
1965
                        COLOR(0,48)
1966
                    }else{
1967
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1968
                        COLOR(300,48)
1969
                    }
1970

    
1971
                    u*= 0x0101010101010101ULL;
1972
                    v*= 0x0101010101010101ULL;
1973
                    for(y=0; y<8; y++){
1974
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1975
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1976
                    }
1977

    
1978
                    //segmentation
1979
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1980
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1981
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1982
                    }
1983
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1984
                        for(y=0; y<16; y++)
1985
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1986
                    }
1987
                    if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1988
                        int dm= 1 << (mv_sample_log2-2);
1989
                        for(i=0; i<4; i++){
1990
                            int sx= mb_x*16 + 8*(i&1);
1991
                            int sy= mb_y*16 + 8*(i>>1);
1992
                            int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1993
                            //FIXME bidir
1994
                            int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1995
                            if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1996
                                for(y=0; y<8; y++)
1997
                                    pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1998
                            if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1999
                                *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
2000
                        }
2001
                    }
2002

    
2003
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
2004
                        // hmm
2005
                    }
2006
                }
2007
                s->mbskip_table[mb_index]=0;
2008
            }
2009
        }
2010
    }
2011
}
2012

    
2013
#ifdef CONFIG_ENCODERS
2014

    
2015
static int get_sae(uint8_t *src, int ref, int stride){
2016
    int x,y;
2017
    int acc=0;
2018

    
2019
    for(y=0; y<16; y++){
2020
        for(x=0; x<16; x++){
2021
            acc+= ABS(src[x+y*stride] - ref);
2022
        }
2023
    }
2024

    
2025
    return acc;
2026
}
2027

    
2028
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
2029
    int x, y, w, h;
2030
    int acc=0;
2031

    
2032
    w= s->width &~15;
2033
    h= s->height&~15;
2034

    
2035
    for(y=0; y<h; y+=16){
2036
        for(x=0; x<w; x+=16){
2037
            int offset= x + y*stride;
2038
            int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
2039
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
2040
            int sae = get_sae(src + offset, mean, stride);
2041

    
2042
            acc+= sae + 500 < sad;
2043
        }
2044
    }
2045
    return acc;
2046
}
2047

    
2048

    
2049
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2050
    AVFrame *pic=NULL;
2051
    int64_t pts;
2052
    int i;
2053
    const int encoding_delay= s->max_b_frames;
2054
    int direct=1;
2055

    
2056
    if(pic_arg){
2057
        pts= pic_arg->pts;
2058
        pic_arg->display_picture_number= s->input_picture_number++;
2059

    
2060
        if(pts != AV_NOPTS_VALUE){
2061
            if(s->user_specified_pts != AV_NOPTS_VALUE){
2062
                int64_t time= pts;
2063
                int64_t last= s->user_specified_pts;
2064

    
2065
                if(time <= last){
2066
                    av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts);
2067
                    return -1;
2068
                }
2069
            }
2070
            s->user_specified_pts= pts;
2071
        }else{
2072
            if(s->user_specified_pts != AV_NOPTS_VALUE){
2073
                s->user_specified_pts=
2074
                pts= s->user_specified_pts + 1;
2075
                av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts);
2076
            }else{
2077
                pts= pic_arg->display_picture_number;
2078
            }
2079
        }
2080
    }
2081

    
2082
  if(pic_arg){
2083
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2084
    if(pic_arg->linesize[0] != s->linesize) direct=0;
2085
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2086
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2087

    
2088
//    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
2089

    
2090
    if(direct){
2091
        i= ff_find_unused_picture(s, 1);
2092

    
2093
        pic= (AVFrame*)&s->picture[i];
2094
        pic->reference= 3;
2095

    
2096
        for(i=0; i<4; i++){
2097
            pic->data[i]= pic_arg->data[i];
2098
            pic->linesize[i]= pic_arg->linesize[i];
2099
        }
2100
        alloc_picture(s, (Picture*)pic, 1);
2101
    }else{
2102
        i= ff_find_unused_picture(s, 0);
2103

    
2104
        pic= (AVFrame*)&s->picture[i];
2105
        pic->reference= 3;
2106

    
2107
        alloc_picture(s, (Picture*)pic, 0);
2108

    
2109
        if(   pic->data[0] + INPLACE_OFFSET == pic_arg->data[0]
2110
           && pic->data[1] + INPLACE_OFFSET == pic_arg->data[1]
2111
           && pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){
2112
       // empty
2113
        }else{
2114
            int h_chroma_shift, v_chroma_shift;
2115
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2116

    
2117
            for(i=0; i<3; i++){
2118
                int src_stride= pic_arg->linesize[i];
2119
                int dst_stride= i ? s->uvlinesize : s->linesize;
2120
                int h_shift= i ? h_chroma_shift : 0;
2121
                int v_shift= i ? v_chroma_shift : 0;
2122
                int w= s->width >>h_shift;
2123
                int h= s->height>>v_shift;
2124
                uint8_t *src= pic_arg->data[i];
2125
                uint8_t *dst= pic->data[i] + INPLACE_OFFSET;
2126

    
2127
                if(src_stride==dst_stride)
2128
                    memcpy(dst, src, src_stride*h);
2129
                else{
2130
                    while(h--){
2131
                        memcpy(dst, src, w);
2132
                        dst += dst_stride;
2133
                        src += src_stride;
2134
                    }
2135
                }
2136
            }
2137
        }
2138
    }
2139
    copy_picture_attributes(s, pic, pic_arg);
2140
    pic->pts= pts; //we set this here to avoid modifiying pic_arg
2141
  }
2142

    
2143
    /* shift buffer entries */
2144
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2145
        s->input_picture[i-1]= s->input_picture[i];
2146

    
2147
    s->input_picture[encoding_delay]= (Picture*)pic;
2148

    
2149
    return 0;
2150
}
2151

    
2152
static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2153
    int x, y, plane;
2154
    int score=0;
2155
    int64_t score64=0;
2156

    
2157
    for(plane=0; plane<3; plane++){
2158
        const int stride= p->linesize[plane];
2159
        const int bw= plane ? 1 : 2;
2160
        for(y=0; y<s->mb_height*bw; y++){
2161
            for(x=0; x<s->mb_width*bw; x++){
2162
                int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16;
2163
                int v= s->dsp.frame_skip_cmp[1](s, p->data[plane] + 8*(x + y*stride)+off, ref->data[plane] + 8*(x + y*stride), stride, 8);
2164

    
2165
                switch(s->avctx->frame_skip_exp){
2166
                    case 0: score= FFMAX(score, v); break;
2167
                    case 1: score+= ABS(v);break;
2168
                    case 2: score+= v*v;break;
2169
                    case 3: score64+= ABS(v*v*(int64_t)v);break;
2170
                    case 4: score64+= v*v*(int64_t)(v*v);break;
2171
                }
2172
            }
2173
        }
2174
    }
2175

    
2176
    if(score) score64= score;
2177

    
2178
    if(score64 < s->avctx->frame_skip_threshold)
2179
        return 1;
2180
    if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2181
        return 1;
2182
    return 0;
2183
}
2184

    
2185
static int estimate_best_b_count(MpegEncContext *s){
2186
    AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id);
2187
    AVCodecContext *c= avcodec_alloc_context();
2188
    AVFrame input[FF_MAX_B_FRAMES+2];
2189
    const int scale= s->avctx->brd_scale;
2190
    int i, j, out_size, p_lambda, b_lambda, lambda2;
2191
    int outbuf_size= s->width * s->height; //FIXME
2192
    uint8_t *outbuf= av_malloc(outbuf_size);
2193
    int64_t best_rd= INT64_MAX;
2194
    int best_b_count= -1;
2195

    
2196
    assert(scale>=0 && scale <=3);
2197

    
2198
//    emms_c();
2199
    p_lambda= s->last_lambda_for[P_TYPE]; //s->next_picture_ptr->quality;
2200
    b_lambda= s->last_lambda_for[B_TYPE]; //p_lambda *ABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
2201
    if(!b_lambda) b_lambda= p_lambda; //FIXME we should do this somewhere else
2202
    lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT;
2203

    
2204
    c->width = s->width >> scale;
2205
    c->height= s->height>> scale;
2206
    c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
2207
    c->flags|= s->avctx->flags & CODEC_FLAG_QPEL;
2208
    c->mb_decision= s->avctx->mb_decision;
2209
    c->me_cmp= s->avctx->me_cmp;
2210
    c->mb_cmp= s->avctx->mb_cmp;
2211
    c->me_sub_cmp= s->avctx->me_sub_cmp;
2212
    c->pix_fmt = PIX_FMT_YUV420P;
2213
    c->time_base= s->avctx->time_base;
2214
    c->max_b_frames= s->max_b_frames;
2215

    
2216
    if (avcodec_open(c, codec) < 0)
2217
        return -1;
2218

    
2219
    for(i=0; i<s->max_b_frames+2; i++){
2220
        int ysize= c->width*c->height;
2221
        int csize= (c->width/2)*(c->height/2);
2222
        Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr;
2223

    
2224
        if(pre_input_ptr)
2225
            pre_input= *pre_input_ptr;
2226

    
2227
        if(pre_input.type != FF_BUFFER_TYPE_SHARED && i){
2228
            pre_input.data[0]+=INPLACE_OFFSET;
2229
            pre_input.data[1]+=INPLACE_OFFSET;
2230
            pre_input.data[2]+=INPLACE_OFFSET;
2231
        }
2232

    
2233
        avcodec_get_frame_defaults(&input[i]);
2234
        input[i].data[0]= av_malloc(ysize + 2*csize);
2235
        input[i].data[1]= input[i].data[0] + ysize;
2236
        input[i].data[2]= input[i].data[1] + csize;
2237
        input[i].linesize[0]= c->width;
2238
        input[i].linesize[1]=
2239
        input[i].linesize[2]= c->width/2;
2240

    
2241
        if(!i || s->input_picture[i-1]){
2242
            s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height);
2243
            s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1], pre_input.data[1], pre_input.linesize[1], c->width>>1, c->height>>1);
2244
            s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2], pre_input.data[2], pre_input.linesize[2], c->width>>1, c->height>>1);
2245
        }
2246
    }
2247

    
2248
    for(j=0; j<s->max_b_frames+1; j++){
2249
        int64_t rd=0;
2250

    
2251
        if(!s->input_picture[j])
2252
            break;
2253

    
2254
        c->error[0]= c->error[1]= c->error[2]= 0;
2255

    
2256
        input[0].pict_type= I_TYPE;
2257
        input[0].quality= 1 * FF_QP2LAMBDA;
2258
        out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
2259
//        rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2260

    
2261
        for(i=0; i<s->max_b_frames+1; i++){
2262
            int is_p= i % (j+1) == j || i==s->max_b_frames;
2263

    
2264
            input[i+1].pict_type= is_p ? P_TYPE : B_TYPE;
2265
            input[i+1].quality= is_p ? p_lambda : b_lambda;
2266
            out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]);
2267
            rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2268
        }
2269

    
2270
        /* get the delayed frames */
2271
        while(out_size){
2272
            out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
2273
            rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2274
        }
2275

    
2276
        rd += c->error[0] + c->error[1] + c->error[2];
2277

    
2278
        if(rd < best_rd){
2279
            best_rd= rd;
2280
            best_b_count= j;
2281
        }
2282
    }
2283

    
2284
    av_freep(&outbuf);
2285
    avcodec_close(c);
2286
    av_freep(&c);
2287

    
2288
    for(i=0; i<s->max_b_frames+2; i++){
2289
        av_freep(&input[i].data[0]);
2290
    }
2291

    
2292
    return best_b_count;
2293
}
2294

    
2295
static void select_input_picture(MpegEncContext *s){
2296
    int i;
2297

    
2298
    for(i=1; i<MAX_PICTURE_COUNT; i++)
2299
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2300
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2301

    
2302
    /* set next picture type & ordering */
2303
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2304
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2305
            s->reordered_input_picture[0]= s->input_picture[0];
2306
            s->reordered_input_picture[0]->pict_type= I_TYPE;
2307
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2308
        }else{
2309
            int b_frames;
2310

    
2311
            if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2312
                if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2313
                //FIXME check that te gop check above is +-1 correct
2314
//av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2315

    
2316
                    if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2317
                        for(i=0; i<4; i++)
2318
                            s->input_picture[0]->data[i]= NULL;
2319
                        s->input_picture[0]->type= 0;
2320
                    }else{
2321
                        assert(   s->input_picture[0]->type==FF_BUFFER_TYPE_USER
2322
                               || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2323

    
2324
                        s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2325
                    }
2326

    
2327
                    emms_c();
2328
                    ff_vbv_update(s, 0);
2329

    
2330
                    goto no_output_pic;
2331
                }
2332
            }
2333

    
2334
            if(s->flags&CODEC_FLAG_PASS2){
2335
                for(i=0; i<s->max_b_frames+1; i++){
2336
                    int pict_num= s->input_picture[0]->display_picture_number + i;
2337

    
2338
                    if(pict_num >= s->rc_context.num_entries)
2339
                        break;
2340
                    if(!s->input_picture[i]){
2341
                        s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2342
                        break;
2343
                    }
2344

    
2345
                    s->input_picture[i]->pict_type=
2346
                        s->rc_context.entry[pict_num].new_pict_type;
2347
                }
2348
            }
2349

    
2350
            if(s->avctx->b_frame_strategy==0){
2351
                b_frames= s->max_b_frames;
2352
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
2353
            }else if(s->avctx->b_frame_strategy==1){
2354
                for(i=1; i<s->max_b_frames+1; i++){
2355
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2356
                        s->input_picture[i]->b_frame_score=
2357
                            get_intra_count(s, s->input_picture[i  ]->data[0],
2358
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
2359
                    }
2360
                }
2361
                for(i=0; i<s->max_b_frames+1; i++){
2362
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2363
                }
2364

    
2365
                b_frames= FFMAX(0, i-1);
2366

    
2367
                /* reset scores */
2368
                for(i=0; i<b_frames+1; i++){
2369
                    s->input_picture[i]->b_frame_score=0;
2370
                }
2371
            }else if(s->avctx->b_frame_strategy==2){
2372
                b_frames= estimate_best_b_count(s);
2373
            }else{
2374
                av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2375
                b_frames=0;
2376
            }
2377

    
2378
            emms_c();
2379
//static int b_count=0;
2380
//b_count+= b_frames;
2381
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2382

    
2383
            for(i= b_frames - 1; i>=0; i--){
2384
                int type= s->input_picture[i]->pict_type;
2385
                if(type && type != B_TYPE)
2386
                    b_frames= i;
2387
            }
2388
            if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2389
                av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
2390
            }
2391

    
2392
            if(s->picture_in_gop_number + b_frames >= s->gop_size){
2393
              if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2394
                    b_frames= s->gop_size - s->picture_in_gop_number - 1;
2395
              }else{
2396
                if(s->flags & CODEC_FLAG_CLOSED_GOP)
2397
                    b_frames=0;
2398
                s->input_picture[b_frames]->pict_type= I_TYPE;
2399
              }
2400
            }
2401

    
2402
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2403
               && b_frames
2404
               && s->input_picture[b_frames]->pict_type== I_TYPE)
2405
                b_frames--;
2406

    
2407
            s->reordered_input_picture[0]= s->input_picture[b_frames];
2408
            if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2409
                s->reordered_input_picture[0]->pict_type= P_TYPE;
2410
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2411
            for(i=0; i<b_frames; i++){
2412
                s->reordered_input_picture[i+1]= s->input_picture[i];
2413
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2414
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2415
            }
2416
        }
2417
    }
2418
no_output_pic:
2419
    if(s->reordered_input_picture[0]){
2420
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2421

    
2422
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2423

    
2424
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2425
            // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable
2426

    
2427
            int i= ff_find_unused_picture(s, 0);
2428
            Picture *pic= &s->picture[i];
2429

    
2430
            /* mark us unused / free shared pic */
2431
            for(i=0; i<4; i++)
2432
                s->reordered_input_picture[0]->data[i]= NULL;
2433
            s->reordered_input_picture[0]->type= 0;
2434

    
2435
            pic->reference              = s->reordered_input_picture[0]->reference;
2436

    
2437
            alloc_picture(s, pic, 0);
2438

    
2439
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2440

    
2441
            s->current_picture_ptr= pic;
2442
        }else{
2443
            // input is not a shared pix -> reuse buffer for current_pix
2444

    
2445
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2446
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2447

    
2448
            s->current_picture_ptr= s->reordered_input_picture[0];
2449
            for(i=0; i<4; i++){
2450
                s->new_picture.data[i]+= INPLACE_OFFSET;
2451
            }
2452
        }
2453
        copy_picture(&s->current_picture, s->current_picture_ptr);
2454

    
2455
        s->picture_number= s->new_picture.display_picture_number;
2456
//printf("dpn:%d\n", s->picture_number);
2457
    }else{
2458
       memset(&s->new_picture, 0, sizeof(Picture));
2459
    }
2460
}
2461

    
2462
int MPV_encode_picture(AVCodecContext *avctx,
2463
                       unsigned char *buf, int buf_size, void *data)
2464
{
2465
    MpegEncContext *s = avctx->priv_data;
2466
    AVFrame *pic_arg = data;
2467
    int i, stuffing_count;
2468

    
2469
    if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUVJ420P){
2470
        av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2471
        return -1;
2472
    }
2473

    
2474
    for(i=0; i<avctx->thread_count; i++){
2475
        int start_y= s->thread_context[i]->start_mb_y;
2476
        int   end_y= s->thread_context[i]->  end_mb_y;
2477
        int h= s->mb_height;
2478
        uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h);
2479
        uint8_t *end  = buf + (size_t)(((int64_t) buf_size)*  end_y/h);
2480

    
2481
        init_put_bits(&s->thread_context[i]->pb, start, end - start);
2482
    }
2483

    
2484
    s->picture_in_gop_number++;
2485

    
2486
    if(load_input_picture(s, pic_arg) < 0)
2487
        return -1;
2488

    
2489
    select_input_picture(s);
2490

    
2491
    /* output? */
2492
    if(s->new_picture.data[0]){
2493
        s->pict_type= s->new_picture.pict_type;
2494
//emms_c();
2495
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2496
        MPV_frame_start(s, avctx);
2497

    
2498
        encode_picture(s, s->picture_number);
2499

    
2500
        avctx->real_pict_num  = s->picture_number;
2501
        avctx->header_bits = s->header_bits;
2502
        avctx->mv_bits     = s->mv_bits;
2503
        avctx->misc_bits   = s->misc_bits;
2504
        avctx->i_tex_bits  = s->i_tex_bits;
2505
        avctx->p_tex_bits  = s->p_tex_bits;
2506
        avctx->i_count     = s->i_count;
2507
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2508
        avctx->skip_count  = s->skip_count;
2509

    
2510
        MPV_frame_end(s);
2511

    
2512
        if (s->out_format == FMT_MJPEG)
2513
            mjpeg_picture_trailer(s);
2514

    
2515
        if(s->flags&CODEC_FLAG_PASS1)
2516
            ff_write_pass1_stats(s);
2517

    
2518
        for(i=0; i<4; i++){
2519
            s->current_picture_ptr->error[i]= s->current_picture.error[i];
2520
            avctx->error[i] += s->current_picture_ptr->error[i];
2521
        }
2522

    
2523
        if(s->flags&CODEC_FLAG_PASS1)
2524
            assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2525
        flush_put_bits(&s->pb);
2526
        s->frame_bits  = put_bits_count(&s->pb);
2527

    
2528
        stuffing_count= ff_vbv_update(s, s->frame_bits);
2529
        if(stuffing_count){
2530
            if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2531
                av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2532
                return -1;
2533
            }
2534

    
2535
            switch(s->codec_id){
2536
            case CODEC_ID_MPEG1VIDEO:
2537
            case CODEC_ID_MPEG2VIDEO:
2538
                while(stuffing_count--){
2539
                    put_bits(&s->pb, 8, 0);
2540
                }
2541
            break;
2542
            case CODEC_ID_MPEG4:
2543
                put_bits(&s->pb, 16, 0);
2544
                put_bits(&s->pb, 16, 0x1C3);
2545
                stuffing_count -= 4;
2546
                while(stuffing_count--){
2547
                    put_bits(&s->pb, 8, 0xFF);
2548
                }
2549
            break;
2550
            default:
2551
                av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2552
            }
2553
            flush_put_bits(&s->pb);
2554
            s->frame_bits  = put_bits_count(&s->pb);
2555
        }
2556

    
2557
        /* update mpeg1/2 vbv_delay for CBR */
2558
        if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2559
           && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2560
            int vbv_delay;
2561

    
2562
            assert(s->repeat_first_field==0);
2563

    
2564
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2565
            assert(vbv_delay < 0xFFFF);
2566

    
2567
            s->vbv_delay_ptr[0] &= 0xF8;
2568
            s->vbv_delay_ptr[0] |= vbv_delay>>13;
2569
            s->vbv_delay_ptr[1]  = vbv_delay>>5;
2570
            s->vbv_delay_ptr[2] &= 0x07;
2571
            s->vbv_delay_ptr[2] |= vbv_delay<<3;
2572
        }
2573
        s->total_bits += s->frame_bits;
2574
        avctx->frame_bits  = s->frame_bits;
2575
    }else{
2576
        assert((pbBufPtr(&s->pb) == s->pb.buf));
2577
        s->frame_bits=0;
2578
    }
2579
    assert((s->frame_bits&7)==0);
2580

    
2581
    return s->frame_bits/8;
2582
}
2583

    
2584
#endif //CONFIG_ENCODERS
2585

    
2586
static inline void gmc1_motion(MpegEncContext *s,
2587
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2588
                               uint8_t **ref_picture)
2589
{
2590
    uint8_t *ptr;
2591
    int offset, src_x, src_y, linesize, uvlinesize;
2592
    int motion_x, motion_y;
2593
    int emu=0;
2594

    
2595
    motion_x= s->sprite_offset[0][0];
2596
    motion_y= s->sprite_offset[0][1];
2597
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2598
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2599
    motion_x<<=(3-s->sprite_warping_accuracy);
2600
    motion_y<<=(3-s->sprite_warping_accuracy);
2601
    src_x = clip(src_x, -16, s->width);
2602
    if (src_x == s->width)
2603
        motion_x =0;
2604
    src_y = clip(src_y, -16, s->height);
2605
    if (src_y == s->height)
2606
        motion_y =0;
2607

    
2608
    linesize = s->linesize;
2609
    uvlinesize = s->uvlinesize;
2610

    
2611
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2612

    
2613
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2614
        if(   (unsigned)src_x >= s->h_edge_pos - 17
2615
           || (unsigned)src_y >= s->v_edge_pos - 17){
2616
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2617
            ptr= s->edge_emu_buffer;
2618
        }
2619
    }
2620

    
2621
    if((motion_x|motion_y)&7){
2622
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2623
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2624
    }else{
2625
        int dxy;
2626

    
2627
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2628
        if (s->no_rounding){
2629
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2630
        }else{
2631
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2632
        }
2633
    }
2634

    
2635
    if(s->flags&CODEC_FLAG_GRAY) return;
2636

    
2637
    motion_x= s->sprite_offset[1][0];
2638
    motion_y= s->sprite_offset[1][1];
2639
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2640
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2641
    motion_x<<=(3-s->sprite_warping_accuracy);
2642
    motion_y<<=(3-s->sprite_warping_accuracy);
2643
    src_x = clip(src_x, -8, s->width>>1);
2644
    if (src_x == s->width>>1)
2645
        motion_x =0;
2646
    src_y = clip(src_y, -8, s->height>>1);
2647
    if (src_y == s->height>>1)
2648
        motion_y =0;
2649

    
2650
    offset = (src_y * uvlinesize) + src_x;
2651
    ptr = ref_picture[1] + offset;
2652
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2653
        if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2654
           || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2655
            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);
2656
            ptr= s->edge_emu_buffer;
2657
            emu=1;
2658
        }
2659
    }
2660
    s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2661

    
2662
    ptr = ref_picture[2] + offset;
2663
    if(emu){
2664
        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);
2665
        ptr= s->edge_emu_buffer;
2666
    }
2667
    s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2668

    
2669
    return;
2670
}
2671

    
2672
static inline void gmc_motion(MpegEncContext *s,
2673
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2674
                               uint8_t **ref_picture)
2675
{
2676
    uint8_t *ptr;
2677
    int linesize, uvlinesize;
2678
    const int a= s->sprite_warping_accuracy;
2679
    int ox, oy;
2680

    
2681
    linesize = s->linesize;
2682
    uvlinesize = s->uvlinesize;
2683

    
2684
    ptr = ref_picture[0];
2685

    
2686
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2687
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2688

    
2689
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2690
           ox,
2691
           oy,
2692
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2693
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2694
           a+1, (1<<(2*a+1)) - s->no_rounding,
2695
           s->h_edge_pos, s->v_edge_pos);
2696
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2697
           ox + s->sprite_delta[0][0]*8,
2698
           oy + s->sprite_delta[1][0]*8,
2699
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2700
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2701
           a+1, (1<<(2*a+1)) - s->no_rounding,
2702
           s->h_edge_pos, s->v_edge_pos);
2703

    
2704
    if(s->flags&CODEC_FLAG_GRAY) return;
2705

    
2706
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2707
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2708

    
2709
    ptr = ref_picture[1];
2710
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2711
           ox,
2712
           oy,
2713
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2714
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2715
           a+1, (1<<(2*a+1)) - s->no_rounding,
2716
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2717

    
2718
    ptr = ref_picture[2];
2719
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2720
           ox,
2721
           oy,
2722
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2723
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2724
           a+1, (1<<(2*a+1)) - s->no_rounding,
2725
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2726
}
2727

    
2728
/**
2729
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2730
 * @param buf destination buffer
2731
 * @param src source buffer
2732
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2733
 * @param block_w width of block
2734
 * @param block_h height of block
2735
 * @param src_x x coordinate of the top left sample of the block in the source buffer
2736
 * @param src_y y coordinate of the top left sample of the block in the source buffer
2737
 * @param w width of the source buffer
2738
 * @param h height of the source buffer
2739
 */
2740
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2741
                                    int src_x, int src_y, int w, int h){
2742
    int x, y;
2743
    int start_y, start_x, end_y, end_x;
2744

    
2745
    if(src_y>= h){
2746
        src+= (h-1-src_y)*linesize;
2747
        src_y=h-1;
2748
    }else if(src_y<=-block_h){
2749
        src+= (1-block_h-src_y)*linesize;
2750
        src_y=1-block_h;
2751
    }
2752
    if(src_x>= w){
2753
        src+= (w-1-src_x);
2754
        src_x=w-1;
2755
    }else if(src_x<=-block_w){
2756
        src+= (1-block_w-src_x);
2757
        src_x=1-block_w;
2758
    }
2759

    
2760
    start_y= FFMAX(0, -src_y);
2761
    start_x= FFMAX(0, -src_x);
2762
    end_y= FFMIN(block_h, h-src_y);
2763
    end_x= FFMIN(block_w, w-src_x);
2764

    
2765
    // copy existing part
2766
    for(y=start_y; y<end_y; y++){
2767
        for(x=start_x; x<end_x; x++){
2768
            buf[x + y*linesize]= src[x + y*linesize];
2769
        }
2770
    }
2771

    
2772
    //top
2773
    for(y=0; y<start_y; y++){
2774
        for(x=start_x; x<end_x; x++){
2775
            buf[x + y*linesize]= buf[x + start_y*linesize];
2776
        }
2777
    }
2778

    
2779
    //bottom
2780
    for(y=end_y; y<block_h; y++){
2781
        for(x=start_x; x<end_x; x++){
2782
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2783
        }
2784
    }
2785

    
2786
    for(y=0; y<block_h; y++){
2787
       //left
2788
        for(x=0; x<start_x; x++){
2789
            buf[x + y*linesize]= buf[start_x + y*linesize];
2790
        }
2791

    
2792
       //right
2793
        for(x=end_x; x<block_w; x++){
2794
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2795
        }
2796
    }
2797
}
2798

    
2799
static inline int hpel_motion(MpegEncContext *s,
2800
                                  uint8_t *dest, uint8_t *src,
2801
                                  int field_based, int field_select,
2802
                                  int src_x, int src_y,
2803
                                  int width, int height, int stride,
2804
                                  int h_edge_pos, int v_edge_pos,
2805
                                  int w, int h, op_pixels_func *pix_op,
2806
                                  int motion_x, int motion_y)
2807
{
2808
    int dxy;
2809
    int emu=0;
2810

    
2811
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2812
    src_x += motion_x >> 1;
2813
    src_y += motion_y >> 1;
2814

    
2815
    /* WARNING: do no forget half pels */
2816
    src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2817
    if (src_x == width)
2818
        dxy &= ~1;
2819
    src_y = clip(src_y, -16, height);
2820
    if (src_y == height)
2821
        dxy &= ~2;
2822
    src += src_y * stride + src_x;
2823

    
2824
    if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2825
        if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2826
           || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2827
            ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2828
                             src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2829
            src= s->edge_emu_buffer;
2830
            emu=1;
2831
        }
2832
    }
2833
    if(field_select)
2834
        src += s->linesize;
2835
    pix_op[dxy](dest, src, stride, h);
2836
    return emu;
2837
}
2838

    
2839
static inline int hpel_motion_lowres(MpegEncContext *s,
2840
                                  uint8_t *dest, uint8_t *src,
2841
                                  int field_based, int field_select,
2842
                                  int src_x, int src_y,
2843
                                  int width, int height, int stride,
2844
                                  int h_edge_pos, int v_edge_pos,
2845
                                  int w, int h, h264_chroma_mc_func *pix_op,
2846
                                  int motion_x, int motion_y)
2847
{
2848
    const int lowres= s->avctx->lowres;
2849
    const int s_mask= (2<<lowres)-1;
2850
    int emu=0;
2851
    int sx, sy;
2852

    
2853
    if(s->quarter_sample){
2854
        motion_x/=2;
2855
        motion_y/=2;
2856
    }
2857

    
2858
    sx= motion_x & s_mask;
2859
    sy= motion_y & s_mask;
2860
    src_x += motion_x >> (lowres+1);
2861
    src_y += motion_y >> (lowres+1);
2862

    
2863
    src += src_y * stride + src_x;
2864

    
2865
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
2866
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2867
        ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2868
                            src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2869
        src= s->edge_emu_buffer;
2870
        emu=1;
2871
    }
2872

    
2873
    sx <<= 2 - lowres;
2874
    sy <<= 2 - lowres;
2875
    if(field_select)
2876
        src += s->linesize;
2877
    pix_op[lowres](dest, src, stride, h, sx, sy);
2878
    return emu;
2879
}
2880

    
2881
/* apply one mpeg motion vector to the three components */
2882
static always_inline void mpeg_motion(MpegEncContext *s,
2883
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2884
                               int field_based, int bottom_field, int field_select,
2885
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2886
                               int motion_x, int motion_y, int h)
2887
{
2888
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2889
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2890

    
2891
#if 0
2892
if(s->quarter_sample)
2893
{
2894
    motion_x>>=1;
2895
    motion_y>>=1;
2896
}
2897
#endif
2898

    
2899
    v_edge_pos = s->v_edge_pos >> field_based;
2900
    linesize   = s->current_picture.linesize[0] << field_based;
2901
    uvlinesize = s->current_picture.linesize[1] << field_based;
2902

    
2903
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2904
    src_x = s->mb_x* 16               + (motion_x >> 1);
2905
    src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2906

    
2907
    if (s->out_format == FMT_H263) {
2908
        if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2909
            mx = (motion_x>>1)|(motion_x&1);
2910
            my = motion_y >>1;
2911
            uvdxy = ((my & 1) << 1) | (mx & 1);
2912
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2913
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2914
        }else{
2915
            uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2916
            uvsrc_x = src_x>>1;
2917
            uvsrc_y = src_y>>1;
2918
        }
2919
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2920
        mx = motion_x / 4;
2921
        my = motion_y / 4;
2922
        uvdxy = 0;
2923
        uvsrc_x = s->mb_x*8 + mx;
2924
        uvsrc_y = s->mb_y*8 + my;
2925
    } else {
2926
        if(s->chroma_y_shift){
2927
            mx = motion_x / 2;
2928
            my = motion_y / 2;
2929
            uvdxy = ((my & 1) << 1) | (mx & 1);
2930
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2931
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2932
        } else {
2933
            if(s->chroma_x_shift){
2934
            //Chroma422
2935
                mx = motion_x / 2;
2936
                uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2937
                uvsrc_x = s->mb_x* 8           + (mx >> 1);
2938
                uvsrc_y = src_y;
2939
            } else {
2940
            //Chroma444
2941
                uvdxy = dxy;
2942
                uvsrc_x = src_x;
2943
                uvsrc_y = src_y;
2944
            }
2945
        }
2946
    }
2947

    
2948
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2949
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2950
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2951

    
2952
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2953
       || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
2954
            if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2955
               s->codec_id == CODEC_ID_MPEG1VIDEO){
2956
                av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2957
                return ;
2958
            }
2959
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2960
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2961
            ptr_y = s->edge_emu_buffer;
2962
            if(!(s->flags&CODEC_FLAG_GRAY)){
2963
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2964
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
2965
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2966
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
2967
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2968
                ptr_cb= uvbuf;
2969
                ptr_cr= uvbuf+16;
2970
            }
2971
    }
2972

    
2973
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2974
        dest_y += s->linesize;
2975
        dest_cb+= s->uvlinesize;
2976
        dest_cr+= s->uvlinesize;
2977
    }
2978

    
2979
    if(field_select){
2980
        ptr_y += s->linesize;
2981
        ptr_cb+= s->uvlinesize;
2982
        ptr_cr+= s->uvlinesize;
2983
    }
2984

    
2985
    pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2986

    
2987
    if(!(s->flags&CODEC_FLAG_GRAY)){
2988
        pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2989
        pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2990
    }
2991
#if defined(CONFIG_H261_ENCODER) || defined(CONFIG_H261_DECODER)
2992
    if(s->out_format == FMT_H261){
2993
        ff_h261_loop_filter(s);
2994
    }
2995
#endif
2996
}
2997

    
2998
/* apply one mpeg motion vector to the three components */
2999
static always_inline void mpeg_motion_lowres(MpegEncContext *s,
3000
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3001
                               int field_based, int bottom_field, int field_select,
3002
                               uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
3003
                               int motion_x, int motion_y, int h)
3004
{
3005
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3006
    int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
3007
    const int lowres= s->avctx->lowres;
3008
    const int block_s= 8>>lowres;
3009
    const int s_mask= (2<<lowres)-1;
3010
    const int h_edge_pos = s->h_edge_pos >> lowres;
3011
    const int v_edge_pos = s->v_edge_pos >> lowres;
3012
    linesize   = s->current_picture.linesize[0] << field_based;
3013
    uvlinesize = s->current_picture.linesize[1] << field_based;
3014

    
3015
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
3016
        motion_x/=2;
3017
        motion_y/=2;
3018
    }
3019

    
3020
    if(field_based){
3021
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
3022
    }
3023

    
3024
    sx= motion_x & s_mask;
3025
    sy= motion_y & s_mask;
3026
    src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
3027
    src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
3028

    
3029
    if (s->out_format == FMT_H263) {
3030
        uvsx = ((motion_x>>1) & s_mask) | (sx&1);
3031
        uvsy = ((motion_y>>1) & s_mask) | (sy&1);
3032
        uvsrc_x = src_x>>1;
3033
        uvsrc_y = src_y>>1;
3034
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
3035
        mx = motion_x / 4;
3036
        my = motion_y / 4;
3037
        uvsx = (2*mx) & s_mask;
3038
        uvsy = (2*my) & s_mask;
3039
        uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
3040
        uvsrc_y = s->mb_y*block_s               + (my >> lowres);
3041
    } else {
3042
        mx = motion_x / 2;
3043
        my = motion_y / 2;
3044
        uvsx = mx & s_mask;
3045
        uvsy = my & s_mask;
3046
        uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
3047
        uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
3048
    }
3049

    
3050
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
3051
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3052
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3053

    
3054
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
3055
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
3056
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3057
                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
3058
            ptr_y = s->edge_emu_buffer;
3059
            if(!(s->flags&CODEC_FLAG_GRAY)){
3060
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3061
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
3062
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3063
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3064
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3065
                ptr_cb= uvbuf;
3066
                ptr_cr= uvbuf+16;
3067
            }
3068
    }
3069

    
3070
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3071
        dest_y += s->linesize;
3072
        dest_cb+= s->uvlinesize;
3073
        dest_cr+= s->uvlinesize;
3074
    }
3075

    
3076
    if(field_select){
3077
        ptr_y += s->linesize;
3078
        ptr_cb+= s->uvlinesize;
3079
        ptr_cr+= s->uvlinesize;
3080
    }
3081

    
3082
    sx <<= 2 - lowres;
3083
    sy <<= 2 - lowres;
3084
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
3085

    
3086
    if(!(s->flags&CODEC_FLAG_GRAY)){
3087
        uvsx <<= 2 - lowres;
3088
        uvsy <<= 2 - lowres;
3089
        pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3090
        pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3091
    }
3092
    //FIXME h261 lowres loop filter
3093
}
3094

    
3095
//FIXME move to dsputil, avg variant, 16x16 version
3096
static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
3097
    int x;
3098
    uint8_t * const top   = src[1];
3099
    uint8_t * const left  = src[2];
3100
    uint8_t * const mid   = src[0];
3101
    uint8_t * const right = src[3];
3102
    uint8_t * const bottom= src[4];
3103
#define OBMC_FILTER(x, t, l, m, r, b)\
3104
    dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
3105
#define OBMC_FILTER4(x, t, l, m, r, b)\
3106
    OBMC_FILTER(x         , t, l, m, r, b);\
3107
    OBMC_FILTER(x+1       , t, l, m, r, b);\
3108
    OBMC_FILTER(x  +stride, t, l, m, r, b);\
3109
    OBMC_FILTER(x+1+stride, t, l, m, r, b);
3110

    
3111
    x=0;
3112
    OBMC_FILTER (x  , 2, 2, 4, 0, 0);
3113
    OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
3114
    OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
3115
    OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
3116
    OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
3117
    OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
3118
    x+= stride;
3119
    OBMC_FILTER (x  , 1, 2, 5, 0, 0);
3120
    OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
3121
    OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
3122
    OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
3123
    x+= stride;
3124
    OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
3125
    OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
3126
    OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
3127
    OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
3128
    x+= 2*stride;
3129
    OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
3130
    OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
3131
    OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
3132
    OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
3133
    x+= 2*stride;
3134
    OBMC_FILTER (x  , 0, 2, 5, 0, 1);
3135
    OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
3136
    OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
3137
    OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
3138
    OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
3139
    OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
3140
    x+= stride;
3141
    OBMC_FILTER (x  , 0, 2, 4, 0, 2);
3142
    OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
3143
    OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
3144
    OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
3145
}
3146

    
3147
/* obmc for 1 8x8 luma block */
3148
static inline void obmc_motion(MpegEncContext *s,
3149
                               uint8_t *dest, uint8_t *src,
3150
                               int src_x, int src_y,
3151
                               op_pixels_func *pix_op,
3152
                               int16_t mv[5][2]/* mid top left right bottom*/)
3153
#define MID    0
3154
{
3155
    int i;
3156
    uint8_t *ptr[5];
3157

    
3158
    assert(s->quarter_sample==0);
3159

    
3160
    for(i=0; i<5; i++){
3161
        if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
3162
            ptr[i]= ptr[MID];
3163
        }else{
3164
            ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
3165
            hpel_motion(s, ptr[i], src, 0, 0,
3166
                        src_x, src_y,
3167
                        s->width, s->height, s->linesize,
3168
                        s->h_edge_pos, s->v_edge_pos,
3169
                        8, 8, pix_op,
3170
                        mv[i][0], mv[i][1]);
3171
        }
3172
    }
3173

    
3174
    put_obmc(dest, ptr, s->linesize);
3175
}
3176

    
3177
static inline void qpel_motion(MpegEncContext *s,
3178
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3179
                               int field_based, int bottom_field, int field_select,
3180
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3181
                               qpel_mc_func (*qpix_op)[16],
3182
                               int motion_x, int motion_y, int h)
3183
{
3184
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3185
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3186

    
3187
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3188
    src_x = s->mb_x *  16                 + (motion_x >> 2);
3189
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3190

    
3191
    v_edge_pos = s->v_edge_pos >> field_based;
3192
    linesize = s->linesize << field_based;
3193
    uvlinesize = s->uvlinesize << field_based;
3194

    
3195
    if(field_based){
3196
        mx= motion_x/2;
3197
        my= motion_y>>1;
3198
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3199
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
3200
        mx= (motion_x>>1) + rtab[motion_x&7];
3201
        my= (motion_y>>1) + rtab[motion_y&7];
3202
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3203
        mx= (motion_x>>1)|(motion_x&1);
3204
        my= (motion_y>>1)|(motion_y&1);
3205
    }else{
3206
        mx= motion_x/2;
3207
        my= motion_y/2;
3208
    }
3209
    mx= (mx>>1)|(mx&1);
3210
    my= (my>>1)|(my&1);
3211

    
3212
    uvdxy= (mx&1) | ((my&1)<<1);
3213
    mx>>=1;
3214
    my>>=1;
3215

    
3216
    uvsrc_x = s->mb_x *  8                 + mx;
3217
    uvsrc_y = s->mb_y * (8 >> field_based) + my;
3218

    
3219
    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
3220
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3221
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3222

    
3223
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
3224
       || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
3225
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3226
                         src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3227
        ptr_y= s->edge_emu_buffer;
3228
        if(!(s->flags&CODEC_FLAG_GRAY)){
3229
            uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3230
            ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
3231
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3232
            ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
3233
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3234
            ptr_cb= uvbuf;
3235
            ptr_cr= uvbuf + 16;
3236
        }
3237
    }
3238

    
3239
    if(!field_based)
3240
        qpix_op[0][dxy](dest_y, ptr_y, linesize);
3241
    else{
3242
        if(bottom_field){
3243
            dest_y += s->linesize;
3244
            dest_cb+= s->uvlinesize;
3245
            dest_cr+= s->uvlinesize;
3246
        }
3247

    
3248
        if(field_select){
3249
            ptr_y  += s->linesize;
3250
            ptr_cb += s->uvlinesize;
3251
            ptr_cr += s->uvlinesize;
3252
        }
3253
        //damn interlaced mode
3254
        //FIXME boundary mirroring is not exactly correct here
3255
        qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
3256
        qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3257
    }
3258
    if(!(s->flags&CODEC_FLAG_GRAY)){
3259
        pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3260
        pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3261
    }
3262
}
3263

    
3264
inline int ff_h263_round_chroma(int x){
3265
    if (x >= 0)
3266
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3267
    else {
3268
        x = -x;
3269
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3270
    }
3271
}
3272

    
3273
/**
3274
 * h263 chorma 4mv motion compensation.
3275
 */
3276
static inline void chroma_4mv_motion(MpegEncContext *s,
3277
                                     uint8_t *dest_cb, uint8_t *dest_cr,
3278
                                     uint8_t **ref_picture,
3279
                                     op_pixels_func *pix_op,
3280
                                     int mx, int my){
3281
    int dxy, emu=0, src_x, src_y, offset;
3282
    uint8_t *ptr;
3283

    
3284
    /* In case of 8X8, we construct a single chroma motion vector
3285
       with a special rounding */
3286
    mx= ff_h263_round_chroma(mx);
3287
    my= ff_h263_round_chroma(my);
3288

    
3289
    dxy = ((my & 1) << 1) | (mx & 1);
3290
    mx >>= 1;
3291
    my >>= 1;
3292

    
3293
    src_x = s->mb_x * 8 + mx;
3294
    src_y = s->mb_y * 8 + my;
3295
    src_x = clip(src_x, -8, s->width/2);
3296
    if (src_x == s->width/2)
3297
        dxy &= ~1;
3298
    src_y = clip(src_y, -8, s->height/2);
3299
    if (src_y == s->height/2)
3300
        dxy &= ~2;
3301

    
3302
    offset = (src_y * (s->uvlinesize)) + src_x;
3303
    ptr = ref_picture[1] + offset;
3304
    if(s->flags&CODEC_FLAG_EMU_EDGE){
3305
        if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3306
           || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3307
            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);
3308
            ptr= s->edge_emu_buffer;
3309
            emu=1;
3310
        }
3311
    }
3312
    pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3313

    
3314
    ptr = ref_picture[2] + offset;
3315
    if(emu){
3316
        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);
3317
        ptr= s->edge_emu_buffer;
3318
    }
3319
    pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3320
}
3321

    
3322
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3323
                                     uint8_t *dest_cb, uint8_t *dest_cr,
3324
                                     uint8_t **ref_picture,
3325
                                     h264_chroma_mc_func *pix_op,
3326
                                     int mx, int my){
3327
    const int lowres= s->avctx->lowres;
3328
    const int block_s= 8>>lowres;
3329
    const int s_mask= (2<<lowres)-1;
3330
    const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3331
    const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3332
    int emu=0, src_x, src_y, offset, sx, sy;
3333
    uint8_t *ptr;
3334

    
3335
    if(s->quarter_sample){
3336
        mx/=2;
3337
        my/=2;
3338
    }
3339

    
3340
    /* In case of 8X8, we construct a single chroma motion vector
3341
       with a special rounding */
3342
    mx= ff_h263_round_chroma(mx);
3343
    my= ff_h263_round_chroma(my);
3344

    
3345
    sx= mx & s_mask;
3346
    sy= my & s_mask;
3347
    src_x = s->mb_x*block_s + (mx >> (lowres+1));
3348
    src_y = s->mb_y*block_s + (my >> (lowres+1));
3349

    
3350
    offset = src_y * s->uvlinesize + src_x;
3351
    ptr = ref_picture[1] + offset;
3352
    if(s->flags&CODEC_FLAG_EMU_EDGE){
3353
        if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3354
           || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3355
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3356
            ptr= s->edge_emu_buffer;
3357
            emu=1;
3358
        }
3359
    }
3360
    sx <<= 2 - lowres;
3361
    sy <<= 2 - lowres;
3362
    pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3363

    
3364
    ptr = ref_picture[2] + offset;
3365
    if(emu){
3366
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3367
        ptr= s->edge_emu_buffer;
3368
    }
3369
    pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3370
}
3371

    
3372
static inline void prefetch_motion(MpegEncContext *s, uint8_t **pix, int dir){
3373
    /* fetch pixels for estimated mv 4 macroblocks ahead
3374
     * optimized for 64byte cache lines */
3375
    const int shift = s->quarter_sample ? 2 : 1;
3376
    const int mx= (s->mv[dir][0][0]>>shift) + 16*s->mb_x + 8;
3377
    const int my= (s->mv[dir][0][1]>>shift) + 16*s->mb_y;
3378
    int off= mx + (my + (s->mb_x&3)*4)*s->linesize + 64;
3379
    s->dsp.prefetch(pix[0]+off, s->linesize, 4);
3380
    off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;
3381
    s->dsp.prefetch(pix[1]+off, pix[2]-pix[1], 2);
3382
}
3383

    
3384
/**
3385
 * motion compensation of a single macroblock
3386
 * @param s context
3387
 * @param dest_y luma destination pointer
3388
 * @param dest_cb chroma cb/u destination pointer
3389
 * @param dest_cr chroma cr/v destination pointer
3390
 * @param dir direction (0->forward, 1->backward)
3391
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3392
 * @param pic_op halfpel motion compensation function (average or put normally)
3393
 * @param pic_op qpel motion compensation function (average or put normally)
3394
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3395
 */
3396
static inline void MPV_motion(MpegEncContext *s,
3397
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3398
                              int dir, uint8_t **ref_picture,
3399
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3400
{
3401
    int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3402
    int mb_x, mb_y, i;
3403
    uint8_t *ptr, *dest;
3404

    
3405
    mb_x = s->mb_x;
3406
    mb_y = s->mb_y;
3407

    
3408
    prefetch_motion(s, ref_picture, dir);
3409

    
3410
    if(s->obmc && s->pict_type != B_TYPE){
3411
        int16_t mv_cache[4][4][2];
3412
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
3413
        const int mot_stride= s->b8_stride;
3414
        const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3415

    
3416
        assert(!s->mb_skipped);
3417

    
3418
        memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
3419
        memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3420
        memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3421

    
3422
        if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3423
            memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3424
        }else{
3425
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3426
        }
3427

    
3428
        if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3429
            *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3430
            *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3431
        }else{
3432
            *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3433
            *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3434
        }
3435

    
3436
        if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3437
            *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3438
            *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3439
        }else{
3440
            *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3441
            *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3442
        }
3443

    
3444
        mx = 0;
3445
        my = 0;
3446
        for(i=0;i<4;i++) {
3447
            const int x= (i&1)+1;
3448
            const int y= (i>>1)+1;
3449
            int16_t mv[5][2]= {
3450
                {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
3451
                {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3452
                {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3453
                {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3454
                {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3455
            //FIXME cleanup
3456
            obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3457
                        ref_picture[0],
3458
                        mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3459
                        pix_op[1],
3460
                        mv);
3461

    
3462
            mx += mv[0][0];
3463
            my += mv[0][1];
3464
        }
3465
        if(!(s->flags&CODEC_FLAG_GRAY))
3466
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3467

    
3468
        return;
3469
    }
3470

    
3471
    switch(s->mv_type) {
3472
    case MV_TYPE_16X16:
3473
        if(s->mcsel){
3474
            if(s->real_sprite_warping_points==1){
3475
                gmc1_motion(s, dest_y, dest_cb, dest_cr,
3476
                            ref_picture);
3477
            }else{
3478
                gmc_motion(s, dest_y, dest_cb, dest_cr,
3479
                            ref_picture);
3480
            }
3481
        }else if(s->quarter_sample){
3482
            qpel_motion(s, dest_y, dest_cb, dest_cr,
3483
                        0, 0, 0,
3484
                        ref_picture, pix_op, qpix_op,
3485
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3486
        }else if(s->mspel){
3487
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3488
                        ref_picture, pix_op,
3489
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3490
        }else
3491
        {
3492
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3493
                        0, 0, 0,
3494
                        ref_picture, pix_op,
3495
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3496
        }
3497
        break;
3498
    case MV_TYPE_8X8:
3499
        mx = 0;
3500
        my = 0;
3501
        if(s->quarter_sample){
3502
            for(i=0;i<4;i++) {
3503
                motion_x = s->mv[dir][i][0];
3504
                motion_y = s->mv[dir][i][1];
3505

    
3506
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3507
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3508
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3509

    
3510
                /* WARNING: do no forget half pels */
3511
                src_x = clip(src_x, -16, s->width);
3512
                if (src_x == s->width)
3513
                    dxy &= ~3;
3514
                src_y = clip(src_y, -16, s->height);
3515
                if (src_y == s->height)
3516
                    dxy &= ~12;
3517

    
3518
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3519
                if(s->flags&CODEC_FLAG_EMU_EDGE){
3520
                    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8
3521
                       || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3522
                        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);
3523
                        ptr= s->edge_emu_buffer;
3524
                    }
3525
                }
3526
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3527
                qpix_op[1][dxy](dest, ptr, s->linesize);
3528

    
3529
                mx += s->mv[dir][i][0]/2;
3530
                my += s->mv[dir][i][1]/2;
3531
            }
3532
        }else{
3533
            for(i=0;i<4;i++) {
3534
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3535
                            ref_picture[0], 0, 0,
3536
                            mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3537
                            s->width, s->height, s->linesize,
3538
                            s->h_edge_pos, s->v_edge_pos,
3539
                            8, 8, pix_op[1],
3540
                            s->mv[dir][i][0], s->mv[dir][i][1]);
3541

    
3542
                mx += s->mv[dir][i][0];
3543
                my += s->mv[dir][i][1];
3544
            }
3545
        }
3546

    
3547
        if(!(s->flags&CODEC_FLAG_GRAY))
3548
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3549
        break;
3550
    case MV_TYPE_FIELD:
3551
        if (s->picture_structure == PICT_FRAME) {
3552
            if(s->quarter_sample){
3553
                for(i=0; i<2; i++){
3554
                    qpel_motion(s, dest_y, dest_cb, dest_cr,
3555
                                1, i, s->field_select[dir][i],
3556
                                ref_picture, pix_op, qpix_op,
3557
                                s->mv[dir][i][0], s->mv[dir][i][1], 8);
3558
                }
3559
            }else{
3560
                /* top field */
3561
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3562
                            1, 0, s->field_select[dir][0],
3563
                            ref_picture, pix_op,
3564
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
3565
                /* bottom field */
3566
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3567
                            1, 1, s->field_select[dir][1],
3568
                            ref_picture, pix_op,
3569
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
3570
            }
3571
        } else {
3572
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3573
                ref_picture= s->current_picture_ptr->data;
3574
            }
3575

    
3576
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3577
                        0, 0, s->field_select[dir][0],
3578
                        ref_picture, pix_op,
3579
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3580
        }
3581
        break;
3582
    case MV_TYPE_16X8:
3583
        for(i=0; i<2; i++){
3584
            uint8_t ** ref2picture;
3585

    
3586
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3587
                ref2picture= ref_picture;
3588
            }else{
3589
                ref2picture= s->current_picture_ptr->data;
3590
            }
3591

    
3592
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3593
                        0, 0, s->field_select[dir][i],
3594
                        ref2picture, pix_op,
3595
                        s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3596

    
3597
            dest_y += 16*s->linesize;
3598
            dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3599
            dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3600
        }
3601
        break;
3602
    case MV_TYPE_DMV:
3603
        if(s->picture_structure == PICT_FRAME){
3604
            for(i=0; i<2; i++){
3605
                int j;
3606
                for(j=0; j<2; j++){
3607
                    mpeg_motion(s, dest_y, dest_cb, dest_cr,
3608
                                1, j, j^i,
3609
                                ref_picture, pix_op,
3610
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3611
                }
3612
                pix_op = s->dsp.avg_pixels_tab;
3613
            }
3614
        }else{
3615
            for(i=0; i<2; i++){
3616
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3617
                            0, 0, s->picture_structure != i+1,
3618
                            ref_picture, pix_op,
3619
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3620

    
3621
                // after put we make avg of the same block
3622
                pix_op=s->dsp.avg_pixels_tab;
3623

    
3624
                //opposite parity is always in the same frame if this is second field
3625
                if(!s->first_field){
3626
                    ref_picture = s->current_picture_ptr->data;
3627
                }
3628
            }
3629
        }
3630
    break;
3631
    default: assert(0);
3632
    }
3633
}
3634

    
3635
/**
3636
 * motion compensation of a single macroblock
3637
 * @param s context
3638
 * @param dest_y luma destination pointer
3639
 * @param dest_cb chroma cb/u destination pointer
3640
 * @param dest_cr chroma cr/v destination pointer
3641
 * @param dir direction (0->forward, 1->backward)
3642
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3643
 * @param pic_op halfpel motion compensation function (average or put normally)
3644
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3645
 */
3646
static inline void MPV_motion_lowres(MpegEncContext *s,
3647
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3648
                              int dir, uint8_t **ref_picture,
3649
                              h264_chroma_mc_func *pix_op)
3650
{
3651
    int mx, my;
3652
    int mb_x, mb_y, i;
3653
    const int lowres= s->avctx->lowres;
3654
    const int block_s= 8>>lowres;
3655

    
3656
    mb_x = s->mb_x;
3657
    mb_y = s->mb_y;
3658

    
3659
    switch(s->mv_type) {
3660
    case MV_TYPE_16X16:
3661
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3662
                    0, 0, 0,
3663
                    ref_picture, pix_op,
3664
                    s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3665
        break;
3666
    case MV_TYPE_8X8:
3667
        mx = 0;
3668
        my = 0;
3669
            for(i=0;i<4;i++) {
3670
                hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
3671
                            ref_picture[0], 0, 0,
3672
                            (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
3673
                            s->width, s->height, s->linesize,
3674
                            s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
3675
                            block_s, block_s, pix_op,
3676
                            s->mv[dir][i][0], s->mv[dir][i][1]);
3677

    
3678
                mx += s->mv[dir][i][0];
3679
                my += s->mv[dir][i][1];
3680
            }
3681

    
3682
        if(!(s->flags&CODEC_FLAG_GRAY))
3683
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
3684
        break;
3685
    case MV_TYPE_FIELD:
3686
        if (s->picture_structure == PICT_FRAME) {
3687
            /* top field */
3688
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3689
                        1, 0, s->field_select[dir][0],
3690
                        ref_picture, pix_op,
3691
                        s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3692
            /* bottom field */
3693
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3694
                        1, 1, s->field_select[dir][1],
3695
                        ref_picture, pix_op,
3696
                        s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3697
        } else {
3698
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3699
                ref_picture= s->current_picture_ptr->data;
3700
            }
3701

    
3702
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3703
                        0, 0, s->field_select[dir][0],
3704
                        ref_picture, pix_op,
3705
                        s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3706
        }
3707
        break;
3708
    case MV_TYPE_16X8:
3709
        for(i=0; i<2; i++){
3710
            uint8_t ** ref2picture;
3711

    
3712
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3713
                ref2picture= ref_picture;
3714
            }else{
3715
                ref2picture= s->current_picture_ptr->data;
3716
            }
3717

    
3718
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3719
                        0, 0, s->field_select[dir][i],
3720
                        ref2picture, pix_op,
3721
                        s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
3722

    
3723
            dest_y += 2*block_s*s->linesize;
3724
            dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3725
            dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3726
        }
3727
        break;
3728
    case MV_TYPE_DMV:
3729
        if(s->picture_structure == PICT_FRAME){
3730
            for(i=0; i<2; i++){
3731
                int j;
3732
                for(j=0; j<2; j++){
3733
                    mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3734
                                1, j, j^i,
3735
                                ref_picture, pix_op,
3736
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
3737
                }
3738
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3739
            }
3740
        }else{
3741
            for(i=0; i<2; i++){
3742
                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3743
                            0, 0, s->picture_structure != i+1,
3744
                            ref_picture, pix_op,
3745
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
3746

    
3747
                // after put we make avg of the same block
3748
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3749

    
3750
                //opposite parity is always in the same frame if this is second field
3751
                if(!s->first_field){
3752
                    ref_picture = s->current_picture_ptr->data;
3753
                }
3754
            }
3755
        }
3756
    break;
3757
    default: assert(0);
3758
    }
3759
}
3760

    
3761
/* put block[] to dest[] */
3762
static inline void put_dct(MpegEncContext *s,
3763
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3764
{
3765
    s->dct_unquantize_intra(s, block, i, qscale);
3766
    s->dsp.idct_put (dest, line_size, block);
3767
}
3768

    
3769
/* add block[] to dest[] */
3770
static inline void add_dct(MpegEncContext *s,
3771
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
3772
{
3773
    if (s->block_last_index[i] >= 0) {
3774
        s->dsp.idct_add (dest, line_size, block);
3775
    }
3776
}
3777

    
3778
static inline void add_dequant_dct(MpegEncContext *s,
3779
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3780
{
3781
    if (s->block_last_index[i] >= 0) {
3782
        s->dct_unquantize_inter(s, block, i, qscale);
3783

    
3784
        s->dsp.idct_add (dest, line_size, block);
3785
    }
3786
}
3787

    
3788
/**
3789
 * cleans dc, ac, coded_block for the current non intra MB
3790
 */
3791
void ff_clean_intra_table_entries(MpegEncContext *s)
3792
{
3793
    int wrap = s->b8_stride;
3794
    int xy = s->block_index[0];
3795

    
3796
    s->dc_val[0][xy           ] =
3797
    s->dc_val[0][xy + 1       ] =
3798
    s->dc_val[0][xy     + wrap] =
3799
    s->dc_val[0][xy + 1 + wrap] = 1024;
3800
    /* ac pred */
3801
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
3802
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3803
    if (s->msmpeg4_version>=3) {
3804
        s->coded_block[xy           ] =
3805
        s->coded_block[xy + 1       ] =
3806
        s->coded_block[xy     + wrap] =
3807
        s->coded_block[xy + 1 + wrap] = 0;
3808
    }
3809
    /* chroma */
3810
    wrap = s->mb_stride;
3811
    xy = s->mb_x + s->mb_y * wrap;
3812
    s->dc_val[1][xy] =
3813
    s->dc_val[2][xy] = 1024;
3814
    /* ac pred */
3815
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3816
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3817

    
3818
    s->mbintra_table[xy]= 0;
3819
}
3820

    
3821
/* generic function called after a macroblock has been parsed by the
3822
   decoder or after it has been encoded by the encoder.
3823

3824
   Important variables used:
3825
   s->mb_intra : true if intra macroblock
3826
   s->mv_dir   : motion vector direction
3827
   s->mv_type  : motion vector type
3828
   s->mv       : motion vector
3829
   s->interlaced_dct : true if interlaced dct used (mpeg2)
3830
 */
3831
static always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
3832
{
3833
    int mb_x, mb_y;
3834
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3835
#ifdef HAVE_XVMC
3836
    if(s->avctx->xvmc_acceleration){
3837
        XVMC_decode_mb(s);//xvmc uses pblocks
3838
        return;
3839
    }
3840
#endif
3841

    
3842
    mb_x = s->mb_x;
3843
    mb_y = s->mb_y;
3844

    
3845
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3846
       /* save DCT coefficients */
3847
       int i,j;
3848
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3849
       for(i=0; i<6; i++)
3850
           for(j=0; j<64; j++)
3851
               *dct++ = block[i][s->dsp.idct_permutation[j]];
3852
    }
3853

    
3854
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3855

    
3856
    /* update DC predictors for P macroblocks */
3857
    if (!s->mb_intra) {
3858
        if (s->h263_pred || s->h263_aic) {
3859
            if(s->mbintra_table[mb_xy])
3860
                ff_clean_intra_table_entries(s);
3861
        } else {
3862
            s->last_dc[0] =
3863
            s->last_dc[1] =
3864
            s->last_dc[2] = 128 << s->intra_dc_precision;
3865
        }
3866
    }
3867
    else if (s->h263_pred || s->h263_aic)
3868
        s->mbintra_table[mb_xy]=1;
3869

    
3870
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3871
        uint8_t *dest_y, *dest_cb, *dest_cr;
3872
        int dct_linesize, dct_offset;
3873
        op_pixels_func (*op_pix)[4];
3874
        qpel_mc_func (*op_qpix)[16];
3875
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
3876
        const int uvlinesize= s->current_picture.linesize[1];
3877
        const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3878
        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3879

    
3880
        /* avoid copy if macroblock skipped in last frame too */
3881
        /* skip only during decoding as we might trash the buffers during encoding a bit */
3882
        if(!s->encoding){
3883
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3884
            const int age= s->current_picture.age;
3885

    
3886
            assert(age);
3887

    
3888
            if (s->mb_skipped) {
3889
                s->mb_skipped= 0;
3890
                assert(s->pict_type!=I_TYPE);
3891

    
3892
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
3893
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3894

    
3895
                /* if previous was skipped too, then nothing to do !  */
3896
                if (*mbskip_ptr >= age && s->current_picture.reference){
3897
                    return;
3898
                }
3899
            } else if(!s->current_picture.reference){
3900
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3901
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3902
            } else{
3903
                *mbskip_ptr = 0; /* not skipped */
3904
            }
3905
        }
3906

    
3907
        dct_linesize = linesize << s->interlaced_dct;
3908
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3909

    
3910
        if(readable){
3911
            dest_y=  s->dest[0];
3912
            dest_cb= s->dest[1];
3913
            dest_cr= s->dest[2];
3914
        }else{
3915
            dest_y = s->b_scratchpad;
3916
            dest_cb= s->b_scratchpad+16*linesize;
3917
            dest_cr= s->b_scratchpad+32*linesize;
3918
        }
3919

    
3920
        if (!s->mb_intra) {
3921
            /* motion handling */
3922
            /* decoding or more than one mb_type (MC was already done otherwise) */
3923
            if(!s->encoding){
3924
                if(lowres_flag){
3925
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
3926

    
3927
                    if (s->mv_dir & MV_DIR_FORWARD) {
3928
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
3929
                        op_pix = s->dsp.avg_h264_chroma_pixels_tab;
3930
                    }
3931
                    if (s->mv_dir & MV_DIR_BACKWARD) {
3932
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
3933
                    }
3934
                }else{
3935
                    if ((!s->no_rounding) || s->pict_type==B_TYPE){
3936
                        op_pix = s->dsp.put_pixels_tab;
3937
                        op_qpix= s->dsp.put_qpel_pixels_tab;
3938
                    }else{
3939
                        op_pix = s->dsp.put_no_rnd_pixels_tab;
3940
                        op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3941
                    }
3942
                    if (s->mv_dir & MV_DIR_FORWARD) {
3943
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3944
                        op_pix = s->dsp.avg_pixels_tab;
3945
                        op_qpix= s->dsp.avg_qpel_pixels_tab;
3946
                    }
3947
                    if (s->mv_dir & MV_DIR_BACKWARD) {
3948
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3949
                    }
3950
                }
3951
            }
3952

    
3953
            /* skip dequant / idct if we are really late ;) */
3954
            if(s->hurry_up>1) goto skip_idct;
3955
            if(s->avctx->skip_idct){
3956
                if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == B_TYPE)
3957
                   ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != I_TYPE)
3958
                   || s->avctx->skip_idct >= AVDISCARD_ALL)
3959
                    goto skip_idct;
3960
            }
3961

    
3962
            /* add dct residue */
3963
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3964
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3965
                add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3966
                add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3967
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3968
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3969

    
3970
                if(!(s->flags&CODEC_FLAG_GRAY)){
3971
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3972
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3973
                }
3974
            } else if(s->codec_id != CODEC_ID_WMV2){
3975
                add_dct(s, block[0], 0, dest_y                          , dct_linesize);
3976
                add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
3977
                add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
3978
                add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3979

    
3980
                if(!(s->flags&CODEC_FLAG_GRAY)){
3981
                    if(s->chroma_y_shift){//Chroma420
3982
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
3983
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
3984
                    }else{
3985
                        //chroma422
3986
                        dct_linesize = uvlinesize << s->interlaced_dct;
3987
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3988

    
3989
                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
3990
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
3991
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
3992
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
3993
                        if(!s->chroma_x_shift){//Chroma444
3994
                            add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
3995
                            add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
3996
                            add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
3997
                            add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
3998
                        }
3999
                    }
4000
                }//fi gray
4001
            }
4002
            else{
4003
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
4004
            }
4005
        } else {
4006
            /* dct only in intra block */
4007
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
4008
                put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
4009
                put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
4010
                put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
4011
                put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
4012

    
4013
                if(!(s->flags&CODEC_FLAG_GRAY)){
4014
                    put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
4015
                    put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
4016
                }
4017
            }else{
4018
                s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
4019
                s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
4020
                s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
4021
                s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
4022

    
4023
                if(!(s->flags&CODEC_FLAG_GRAY)){
4024
                    if(s->chroma_y_shift){
4025
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
4026
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
4027
                    }else{
4028

    
4029
                        dct_linesize = uvlinesize << s->interlaced_dct;
4030
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
4031

    
4032
                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
4033
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
4034
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
4035
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
4036
                        if(!s->chroma_x_shift){//Chroma444
4037
                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
4038
                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
4039
                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
4040
                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
4041
                        }
4042
                    }
4043
                }//gray
4044
            }
4045
        }
4046
skip_idct:
4047
        if(!readable){
4048
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
4049
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
4050
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
4051
        }
4052
    }
4053
}
4054

    
4055
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
4056
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
4057
    else                  MPV_decode_mb_internal(s, block, 0);
4058
}
4059

    
4060
#ifdef CONFIG_ENCODERS
4061

    
4062
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
4063
{
4064
    static const char tab[64]=
4065
        {3,2,2,1,1,1,1,1,
4066
         1,1,1,1,1,1,1,1,
4067
         1,1,1,1,1,1,1,1,
4068
         0,0,0,0,0,0,0,0,
4069
         0,0,0,0,0,0,0,0,
4070
         0,0,0,0,0,0,0,0,
4071
         0,0,0,0,0,0,0,0,
4072
         0,0,0,0,0,0,0,0};
4073
    int score=0;
4074
    int run=0;
4075
    int i;
4076
    DCTELEM *block= s->block[n];
4077
    const int last_index= s->block_last_index[n];
4078
    int skip_dc;
4079

    
4080
    if(threshold<0){
4081
        skip_dc=0;
4082
        threshold= -threshold;
4083
    }else
4084
        skip_dc=1;
4085

    
4086
    /* are all which we could set to zero are allready zero? */
4087
    if(last_index<=skip_dc - 1) return;
4088

    
4089
    for(i=0; i<=last_index; i++){
4090
        const int j = s->intra_scantable.permutated[i];
4091
        const int level = ABS(block[j]);
4092
        if(level==1){
4093
            if(skip_dc && i==0) continue;
4094
            score+= tab[run];
4095
            run=0;
4096
        }else if(level>1){
4097
            return;
4098
        }else{
4099
            run++;
4100
        }
4101
    }
4102
    if(score >= threshold) return;
4103
    for(i=skip_dc; i<=last_index; i++){
4104
        const int j = s->intra_scantable.permutated[i];
4105
        block[j]=0;
4106
    }
4107
    if(block[0]) s->block_last_index[n]= 0;
4108
    else         s->block_last_index[n]= -1;
4109
}
4110

    
4111
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
4112
{
4113
    int i;
4114
    const int maxlevel= s->max_qcoeff;
4115
    const int minlevel= s->min_qcoeff;
4116
    int overflow=0;
4117

    
4118
    if(s->mb_intra){
4119
        i=1; //skip clipping of intra dc
4120
    }else
4121
        i=0;
4122

    
4123
    for(;i<=last_index; i++){
4124
        const int j= s->intra_scantable.permutated[i];
4125
        int level = block[j];
4126

    
4127
        if     (level>maxlevel){
4128
            level=maxlevel;
4129
            overflow++;
4130
        }else if(level<minlevel){
4131
            level=minlevel;
4132
            overflow++;
4133
        }
4134

    
4135
        block[j]= level;
4136
    }
4137

    
4138
    if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
4139
        av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel);
4140
}
4141

    
4142
#endif //CONFIG_ENCODERS
4143

    
4144
/**
4145
 *
4146
 * @param h is the normal height, this will be reduced automatically if needed for the last row
4147
 */
4148
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
4149
    if (s->avctx->draw_horiz_band) {
4150
        AVFrame *src;
4151
        int offset[4];
4152

    
4153
        if(s->picture_structure != PICT_FRAME){
4154
            h <<= 1;
4155
            y <<= 1;
4156
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
4157
        }
4158

    
4159
        h= FFMIN(h, s->avctx->height - y);
4160

    
4161
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
4162
            src= (AVFrame*)s->current_picture_ptr;
4163
        else if(s->last_picture_ptr)
4164
            src= (AVFrame*)s->last_picture_ptr;
4165
        else
4166
            return;
4167

    
4168
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
4169
            offset[0]=
4170
            offset[1]=
4171
            offset[2]=
4172
            offset[3]= 0;
4173
        }else{
4174
            offset[0]= y * s->linesize;;
4175
            offset[1]=
4176
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
4177
            offset[3]= 0;
4178
        }
4179

    
4180
        emms_c();
4181

    
4182
        s->avctx->draw_horiz_band(s->avctx, src, offset,
4183
                                  y, s->picture_structure, h);
4184
    }
4185
}
4186

    
4187
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
4188
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
4189
    const int uvlinesize= s->current_picture.linesize[1];
4190
    const int mb_size= 4 - s->avctx->lowres;
4191

    
4192
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
4193
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
4194
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
4195
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
4196
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
4197
    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;
4198
    //block_index is not used by mpeg2, so it is not affected by chroma_format
4199

    
4200
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
4201
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4202
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4203

    
4204
    if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
4205
    {
4206
        s->dest[0] += s->mb_y *   linesize << mb_size;
4207
        s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4208
        s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4209
    }
4210
}
4211

    
4212
#ifdef CONFIG_ENCODERS
4213

    
4214
static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
4215
    int x, y;
4216
//FIXME optimize
4217
    for(y=0; y<8; y++){
4218
        for(x=0; x<8; x++){
4219
            int x2, y2;
4220
            int sum=0;
4221
            int sqr=0;
4222
            int count=0;
4223

    
4224
            for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
4225
                for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
4226
                    int v= ptr[x2 + y2*stride];
4227
                    sum += v;
4228
                    sqr += v*v;
4229
                    count++;
4230
                }
4231
            }
4232
            weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
4233
        }
4234
    }
4235
}
4236

    
4237
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
4238
{
4239
    int16_t weight[6][64];
4240
    DCTELEM orig[6][64];
4241
    const int mb_x= s->mb_x;
4242
    const int mb_y= s->mb_y;
4243
    int i;
4244
    int skip_dct[6];
4245
    int dct_offset   = s->linesize*8; //default for progressive frames
4246
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
4247
    int wrap_y, wrap_c;
4248

    
4249
    for(i=0; i<6; i++) skip_dct[i]=0;
4250

    
4251
    if(s->adaptive_quant){
4252
        const int last_qp= s->qscale;
4253
        const int mb_xy= mb_x + mb_y*s->mb_stride;
4254

    
4255
        s->lambda= s->lambda_table[mb_xy];
4256
        update_qscale(s);
4257

    
4258
        if(!(s->flags&CODEC_FLAG_QP_RD)){
4259
            s->dquant= s->qscale - last_qp;
4260

    
4261
            if(s->out_format==FMT_H263){
4262
                s->dquant= clip(s->dquant, -2, 2); //FIXME RD
4263

    
4264
                if(s->codec_id==CODEC_ID_MPEG4){
4265
                    if(!s->mb_intra){
4266
                        if(s->pict_type == B_TYPE){
4267
                            if(s->dquant&1)
4268
                                s->dquant= (s->dquant/2)*2;
4269
                            if(s->mv_dir&MV_DIRECT)
4270
                                s->dquant= 0;
4271
                        }
4272
                        if(s->mv_type==MV_TYPE_8X8)
4273
                            s->dquant=0;
4274
                    }
4275
                }
4276
            }
4277
        }
4278
        ff_set_qscale(s, last_qp + s->dquant);
4279
    }else if(s->flags&CODEC_FLAG_QP_RD)
4280
        ff_set_qscale(s, s->qscale + s->dquant);
4281

    
4282
    wrap_y = s->linesize;
4283
    wrap_c = s->uvlinesize;
4284
    ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
4285
    ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
4286
    ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
4287

    
4288
    if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
4289
        uint8_t *ebuf= s->edge_emu_buffer + 32;
4290
        ff_emulated_edge_mc(ebuf            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
4291
        ptr_y= ebuf;
4292
        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);
4293
        ptr_cb= ebuf+18*wrap_y;
4294
        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);
4295
        ptr_cr= ebuf+18*wrap_y+8;
4296
    }
4297

    
4298
    if (s->mb_intra) {
4299
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4300
            int progressive_score, interlaced_score;
4301

    
4302
            s->interlaced_dct=0;
4303
            progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8)
4304
                              +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
4305

    
4306
            if(progressive_score > 0){
4307
                interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8)
4308
                                  +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
4309
                if(progressive_score > interlaced_score){
4310
                    s->interlaced_dct=1;
4311

    
4312
                    dct_offset= wrap_y;
4313
                    wrap_y<<=1;
4314
                }
4315
            }
4316
        }
4317

    
4318
        s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
4319
        s->dsp.get_pixels(s->block[1], ptr_y              + 8, wrap_y);
4320
        s->dsp.get_pixels(s->block[2], ptr_y + dct_offset    , wrap_y);
4321
        s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
4322

    
4323
        if(s->flags&CODEC_FLAG_GRAY){
4324
            skip_dct[4]= 1;
4325
            skip_dct[5]= 1;
4326
        }else{
4327
            s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
4328
            s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
4329
        }
4330
    }else{
4331
        op_pixels_func (*op_pix)[4];
4332
        qpel_mc_func (*op_qpix)[16];
4333
        uint8_t *dest_y, *dest_cb, *dest_cr;
4334

    
4335
        dest_y  = s->dest[0];
4336
        dest_cb = s->dest[1];
4337
        dest_cr = s->dest[2];
4338

    
4339
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
4340
            op_pix = s->dsp.put_pixels_tab;
4341
            op_qpix= s->dsp.put_qpel_pixels_tab;
4342
        }else{
4343
            op_pix = s->dsp.put_no_rnd_pixels_tab;
4344
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
4345
        }
4346

    
4347
        if (s->mv_dir & MV_DIR_FORWARD) {
4348
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
4349
            op_pix = s->dsp.avg_pixels_tab;
4350
            op_qpix= s->dsp.avg_qpel_pixels_tab;
4351
        }
4352
        if (s->mv_dir & MV_DIR_BACKWARD) {
4353
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
4354
        }
4355

    
4356
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4357
            int progressive_score, interlaced_score;
4358

    
4359
            s->interlaced_dct=0;
4360
            progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8)
4361
                              +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
4362

    
4363
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
4364

    
4365
            if(progressive_score>0){
4366
                interlaced_score = s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y*2, 8)
4367
                                  +s->dsp.ildct_cmp[0](s, dest_y + wrap_y  , ptr_y + wrap_y  , wrap_y*2, 8);
4368

    
4369
                if(progressive_score > interlaced_score){
4370
                    s->interlaced_dct=1;
4371

    
4372
                    dct_offset= wrap_y;
4373
                    wrap_y<<=1;
4374
                }
4375
            }
4376
        }
4377

    
4378
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
4379
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
4380
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
4381
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
4382

    
4383
        if(s->flags&CODEC_FLAG_GRAY){
4384
            skip_dct[4]= 1;
4385
            skip_dct[5]= 1;
4386
        }else{
4387
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
4388
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
4389
        }
4390
        /* pre quantization */
4391
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
4392
            //FIXME optimize
4393
            if(s->dsp.sad[1](NULL, ptr_y               , dest_y               , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
4394
            if(s->dsp.sad[1](NULL, ptr_y            + 8, dest_y            + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
4395
            if(s->dsp.sad[1](NULL, ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
4396
            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;
4397
            if(s->dsp.sad[1](NULL, ptr_cb              , dest_cb              , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
4398
            if(s->dsp.sad[1](NULL, ptr_cr              , dest_cr              , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
4399
        }
4400
    }
4401

    
4402
    if(s->avctx->quantizer_noise_shaping){
4403
        if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y                 , wrap_y);
4404
        if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y              + 8, wrap_y);
4405
        if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset    , wrap_y);
4406
        if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
4407
        if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb                , wrap_c);
4408
        if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr                , wrap_c);
4409
        memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*6);
4410
    }
4411

    
4412
    /* DCT & quantize */
4413
    assert(s->out_format!=FMT_MJPEG || s->qscale==8);
4414
    {
4415
        for(i=0;i<6;i++) {
4416
            if(!skip_dct[i]){
4417
                int overflow;
4418
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
4419
            // FIXME we could decide to change to quantizer instead of clipping
4420
            // JS: I don't think that would be a good idea it could lower quality instead
4421
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
4422
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
4423
            }else
4424
                s->block_last_index[i]= -1;
4425
        }
4426
        if(s->avctx->quantizer_noise_shaping){
4427
            for(i=0;i<6;i++) {
4428
                if(!skip_dct[i]){
4429
                    s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
4430
                }
4431
            }
4432
        }
4433

    
4434
        if(s->luma_elim_threshold && !s->mb_intra)
4435
            for(i=0; i<4; i++)
4436
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
4437
        if(s->chroma_elim_threshold && !s->mb_intra)
4438
            for(i=4; i<6; i++)
4439
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
4440

    
4441
        if(s->flags & CODEC_FLAG_CBP_RD){
4442
            for(i=0;i<6;i++) {
4443
                if(s->block_last_index[i] == -1)
4444
                    s->coded_score[i]= INT_MAX/256;
4445
            }
4446
        }
4447
    }
4448

    
4449
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
4450
        s->block_last_index[4]=
4451
        s->block_last_index[5]= 0;
4452
        s->block[4][0]=
4453
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
4454
    }
4455

    
4456
    //non c quantize code returns incorrect block_last_index FIXME
4457
    if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
4458
        for(i=0; i<6; i++){
4459
            int j;
4460
            if(s->block_last_index[i]>0){
4461
                for(j=63; j>0; j--){
4462
                    if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
4463
                }
4464
                s->block_last_index[i]= j;
4465
            }
4466
        }
4467
    }
4468

    
4469
    /* huffman encode */
4470
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
4471
    case CODEC_ID_MPEG1VIDEO:
4472
    case CODEC_ID_MPEG2VIDEO:
4473
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
4474
    case CODEC_ID_MPEG4:
4475
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4476
    case CODEC_ID_MSMPEG4V2:
4477
    case CODEC_ID_MSMPEG4V3:
4478
    case CODEC_ID_WMV1:
4479
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4480
    case CODEC_ID_WMV2:
4481
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
4482
#ifdef CONFIG_H261_ENCODER
4483
    case CODEC_ID_H261:
4484
        ff_h261_encode_mb(s, s->block, motion_x, motion_y); break;
4485
#endif
4486
    case CODEC_ID_H263:
4487
    case CODEC_ID_H263P:
4488
    case CODEC_ID_FLV1:
4489
    case CODEC_ID_RV10:
4490
    case CODEC_ID_RV20:
4491
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
4492
    case CODEC_ID_MJPEG:
4493
        mjpeg_encode_mb(s, s->block); break;
4494
    default:
4495
        assert(0);
4496
    }
4497
}
4498

    
4499
#endif //CONFIG_ENCODERS
4500

    
4501
void ff_mpeg_flush(AVCodecContext *avctx){
4502
    int i;
4503
    MpegEncContext *s = avctx->priv_data;
4504

    
4505
    if(s==NULL || s->picture==NULL)
4506
        return;
4507

    
4508
    for(i=0; i<MAX_PICTURE_COUNT; i++){
4509
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
4510
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
4511
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
4512
    }
4513
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
4514

    
4515
    s->mb_x= s->mb_y= 0;
4516

    
4517
    s->parse_context.state= -1;
4518
    s->parse_context.frame_start_found= 0;
4519
    s->parse_context.overread= 0;
4520
    s->parse_context.overread_index= 0;
4521
    s->parse_context.index= 0;
4522
    s->parse_context.last_index= 0;
4523
    s->bitstream_buffer_size=0;
4524
}
4525

    
4526
#ifdef CONFIG_ENCODERS
4527
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4528
{
4529
    const uint16_t *srcw= (uint16_t*)src;
4530
    int words= length>>4;
4531
    int bits= length&15;
4532
    int i;
4533

    
4534
    if(length==0) return;
4535

    
4536
    if(words < 16){
4537
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4538
    }else if(put_bits_count(pb)&7){
4539
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4540
    }else{
4541
        for(i=0; put_bits_count(pb)&31; i++)
4542
            put_bits(pb, 8, src[i]);
4543
        flush_put_bits(pb);
4544
        memcpy(pbBufPtr(pb), src+i, 2*words-i);
4545
        skip_put_bytes(pb, 2*words-i);
4546
    }
4547

    
4548
    put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
4549
}
4550

    
4551
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
4552
    int i;
4553

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

    
4556
    /* mpeg1 */
4557
    d->mb_skip_run= s->mb_skip_run;
4558
    for(i=0; i<3; i++)
4559
        d->last_dc[i]= s->last_dc[i];
4560

    
4561
    /* statistics */
4562
    d->mv_bits= s->mv_bits;
4563
    d->i_tex_bits= s->i_tex_bits;
4564
    d->p_tex_bits= s->p_tex_bits;
4565
    d->i_count= s->i_count;
4566
    d->f_count= s->f_count;
4567
    d->b_count= s->b_count;
4568
    d->skip_count= s->skip_count;
4569
    d->misc_bits= s->misc_bits;
4570
    d->last_bits= 0;
4571

    
4572
    d->mb_skipped= 0;
4573
    d->qscale= s->qscale;
4574
    d->dquant= s->dquant;
4575
}
4576

    
4577
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
4578
    int i;
4579

    
4580
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
4581
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4582

    
4583
    /* mpeg1 */
4584
    d->mb_skip_run= s->mb_skip_run;
4585
    for(i=0; i<3; i++)
4586
        d->last_dc[i]= s->last_dc[i];
4587

    
4588
    /* statistics */
4589
    d->mv_bits= s->mv_bits;
4590
    d->i_tex_bits= s->i_tex_bits;
4591
    d->p_tex_bits= s->p_tex_bits;
4592
    d->i_count= s->i_count;
4593
    d->f_count= s->f_count;
4594
    d->b_count= s->b_count;
4595
    d->skip_count= s->skip_count;
4596
    d->misc_bits= s->misc_bits;
4597

    
4598
    d->mb_intra= s->mb_intra;
4599
    d->mb_skipped= s->mb_skipped;
4600
    d->mv_type= s->mv_type;
4601
    d->mv_dir= s->mv_dir;
4602
    d->pb= s->pb;
4603
    if(s->data_partitioning){
4604
        d->pb2= s->pb2;
4605
        d->tex_pb= s->tex_pb;
4606
    }
4607
    d->block= s->block;
4608
    for(i=0; i<6; i++)
4609
        d->block_last_index[i]= s->block_last_index[i];
4610
    d->interlaced_dct= s->interlaced_dct;
4611
    d->qscale= s->qscale;
4612
}
4613

    
4614
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
4615
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
4616
                           int *dmin, int *next_block, int motion_x, int motion_y)
4617
{
4618
    int score;
4619
    uint8_t *dest_backup[3];
4620

    
4621
    copy_context_before_encode(s, backup, type);
4622

    
4623
    s->block= s->blocks[*next_block];
4624
    s->pb= pb[*next_block];
4625
    if(s->data_partitioning){
4626
        s->pb2   = pb2   [*next_block];
4627
        s->tex_pb= tex_pb[*next_block];
4628
    }
4629

    
4630
    if(*next_block){
4631
        memcpy(dest_backup, s->dest, sizeof(s->dest));
4632
        s->dest[0] = s->rd_scratchpad;
4633
        s->dest[1] = s->rd_scratchpad + 16*s->linesize;
4634
        s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
4635
        assert(s->linesize >= 32); //FIXME
4636
    }
4637

    
4638
    encode_mb(s, motion_x, motion_y);
4639

    
4640
    score= put_bits_count(&s->pb);
4641
    if(s->data_partitioning){
4642
        score+= put_bits_count(&s->pb2);
4643
        score+= put_bits_count(&s->tex_pb);
4644
    }
4645

    
4646
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
4647
        MPV_decode_mb(s, s->block);
4648

    
4649
        score *= s->lambda2;
4650
        score += sse_mb(s) << FF_LAMBDA_SHIFT;
4651
    }
4652

    
4653
    if(*next_block){
4654
        memcpy(s->dest, dest_backup, sizeof(s->dest));
4655
    }
4656

    
4657
    if(score<*dmin){
4658
        *dmin= score;
4659
        *next_block^=1;
4660

    
4661
        copy_context_after_encode(best, s, type);
4662
    }
4663
}
4664

    
4665
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
4666
    uint32_t *sq = squareTbl + 256;
4667
    int acc=0;
4668
    int x,y;
4669

    
4670