Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 4156a436

History | View | Annotate | Download (246 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 "libvo/fastmemcpy.h"
36
#endif
37

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

    
41
#ifdef CONFIG_ENCODERS
42
static int 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*21*2); //(width + edge + align)*interlaced*MBsize*tolerance
491
    s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
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
    switch (avctx->codec_id) {
931
    case CODEC_ID_MPEG2VIDEO:
932
        if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P){
933
            av_log(avctx, AV_LOG_ERROR, "only YUV420 and YUV422 are supported\n");
934
            return -1;
935
        }
936
        break;
937
    case CODEC_ID_LJPEG:
938
    case CODEC_ID_MJPEG:
939
        if(avctx->pix_fmt != PIX_FMT_YUVJ420P && (avctx->pix_fmt != PIX_FMT_YUV420P || avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL)){
940
            av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
941
            return -1;
942
        }
943
        break;
944
    default:
945
        if(avctx->pix_fmt != PIX_FMT_YUV420P){
946
            av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
947
            return -1;
948
        }
949
    }
950

    
951
    switch (avctx->pix_fmt) {
952
    case PIX_FMT_YUVJ422P:
953
    case PIX_FMT_YUV422P:
954
        s->chroma_format = CHROMA_422;
955
        break;
956
    case PIX_FMT_YUVJ420P:
957
    case PIX_FMT_YUV420P:
958
    default:
959
        s->chroma_format = CHROMA_420;
960
        break;
961
    }
962

    
963
    s->bit_rate = avctx->bit_rate;
964
    s->width = avctx->width;
965
    s->height = avctx->height;
966
    if(avctx->gop_size > 600 && avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){
967
        av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
968
        avctx->gop_size=600;
969
    }
970
    s->gop_size = avctx->gop_size;
971
    s->avctx = avctx;
972
    s->flags= avctx->flags;
973
    s->flags2= avctx->flags2;
974
    s->max_b_frames= avctx->max_b_frames;
975
    s->codec_id= avctx->codec->id;
976
    s->luma_elim_threshold  = avctx->luma_elim_threshold;
977
    s->chroma_elim_threshold= avctx->chroma_elim_threshold;
978
    s->strict_std_compliance= avctx->strict_std_compliance;
979
    s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
980
    s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
981
    s->mpeg_quant= avctx->mpeg_quant;
982
    s->rtp_mode= !!avctx->rtp_payload_size;
983
    s->intra_dc_precision= avctx->intra_dc_precision;
984
    s->user_specified_pts = AV_NOPTS_VALUE;
985

    
986
    if (s->gop_size <= 1) {
987
        s->intra_only = 1;
988
        s->gop_size = 12;
989
    } else {
990
        s->intra_only = 0;
991
    }
992

    
993
    s->me_method = avctx->me_method;
994

    
995
    /* Fixed QSCALE */
996
    s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
997

    
998
    s->adaptive_quant= (   s->avctx->lumi_masking
999
                        || s->avctx->dark_masking
1000
                        || s->avctx->temporal_cplx_masking
1001
                        || s->avctx->spatial_cplx_masking
1002
                        || s->avctx->p_masking
1003
                        || s->avctx->border_masking
1004
                        || (s->flags&CODEC_FLAG_QP_RD))
1005
                       && !s->fixed_qscale;
1006

    
1007
    s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
1008
    s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
1009
    s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
1010
    s->intra_vlc_format= !!(s->flags2 & CODEC_FLAG2_INTRA_VLC);
1011

    
1012
    if(avctx->rc_max_rate && !avctx->rc_buffer_size){
1013
        av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
1014
        return -1;
1015
    }
1016

    
1017
    if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
1018
        av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
1019
    }
1020

    
1021
    if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
1022
        av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
1023
        return -1;
1024
    }
1025

    
1026
    if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
1027
        av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
1028
        return -1;
1029
    }
1030

    
1031
    if(   s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
1032
       && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
1033
       && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
1034

    
1035
        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");
1036
    }
1037

    
1038
    if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
1039
       && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
1040
        av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
1041
        return -1;
1042
    }
1043

    
1044
    if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
1045
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n");
1046
        return -1;
1047
    }
1048

    
1049
    if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
1050
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
1051
        return -1;
1052
    }
1053

    
1054
    if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
1055
        av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
1056
        return -1;
1057
    }
1058

    
1059
    if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
1060
        av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
1061
        return -1;
1062
    }
1063

    
1064
    if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
1065
        av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
1066
        return -1;
1067
    }
1068

    
1069
    if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
1070
       && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1071
        av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1072
        return -1;
1073
    }
1074

    
1075
    if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1076
        av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n");
1077
        return -1;
1078
    }
1079

    
1080
    if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1081
        av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1082
        return -1;
1083
    }
1084

    
1085
    if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1086
        av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1087
        return -1;
1088
    }
1089

    
1090
    if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1091
        av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
1092
        return -1;
1093
    }
1094

    
1095
    if((s->flags2 & CODEC_FLAG2_INTRA_VLC) && s->codec_id != CODEC_ID_MPEG2VIDEO){
1096
        av_log(avctx, AV_LOG_ERROR, "intra vlc table not supported by codec\n");
1097
        return -1;
1098
    }
1099

    
1100
    if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1101
       && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1102
       && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1103
        av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1104
        return -1;
1105
    }
1106

    
1107
    if(s->avctx->thread_count > 1)
1108
        s->rtp_mode= 1;
1109

    
1110
    if(!avctx->time_base.den || !avctx->time_base.num){
1111
        av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1112
        return -1;
1113
    }
1114

    
1115
    i= (INT_MAX/2+128)>>8;
1116
    if(avctx->me_threshold >= i){
1117
        av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1118
        return -1;
1119
    }
1120
    if(avctx->mb_threshold >= i){
1121
        av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1122
        return -1;
1123
    }
1124

    
1125
    if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
1126
        av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n");
1127
        avctx->b_frame_strategy = 0;
1128
    }
1129

    
1130
    i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
1131
    if(i > 1){
1132
        av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1133
        avctx->time_base.den /= i;
1134
        avctx->time_base.num /= i;
1135
//        return -1;
1136
    }
1137

    
1138
    if(s->codec_id==CODEC_ID_MJPEG){
1139
        s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1140
        s->inter_quant_bias= 0;
1141
    }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1142
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1143
        s->inter_quant_bias= 0;
1144
    }else{
1145
        s->intra_quant_bias=0;
1146
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1147
    }
1148

    
1149
    if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1150
        s->intra_quant_bias= avctx->intra_quant_bias;
1151
    if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1152
        s->inter_quant_bias= avctx->inter_quant_bias;
1153

    
1154
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1155

    
1156
    if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
1157
        av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1158
        return -1;
1159
    }
1160
    s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1161

    
1162
    switch(avctx->codec->id) {
1163
    case CODEC_ID_MPEG1VIDEO:
1164
        s->out_format = FMT_MPEG1;
1165
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1166
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1167
        break;
1168
    case CODEC_ID_MPEG2VIDEO:
1169
        s->out_format = FMT_MPEG1;
1170
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1171
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1172
        s->rtp_mode= 1;
1173
        break;
1174
    case CODEC_ID_LJPEG:
1175
    case CODEC_ID_JPEGLS:
1176
    case CODEC_ID_MJPEG:
1177
        s->out_format = FMT_MJPEG;
1178
        s->intra_only = 1; /* force intra only for jpeg */
1179
        s->mjpeg_write_tables = avctx->codec->id != CODEC_ID_JPEGLS;
1180
        s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1181
        s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1182
        s->mjpeg_vsample[1] = 1;
1183
        s->mjpeg_vsample[2] = 1;
1184
        s->mjpeg_hsample[0] = 1<<chroma_h_shift;
1185
        s->mjpeg_hsample[1] = 1;
1186
        s->mjpeg_hsample[2] = 1;
1187
        if (mjpeg_init(s) < 0)
1188
            return -1;
1189
        avctx->delay=0;
1190
        s->low_delay=1;
1191
        break;
1192
    case CODEC_ID_H261:
1193
        s->out_format = FMT_H261;
1194
        avctx->delay=0;
1195
        s->low_delay=1;
1196
        break;
1197
    case CODEC_ID_H263:
1198
        if (h263_get_picture_format(s->width, s->height) == 7) {
1199
            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);
1200
            return -1;
1201
        }
1202
        s->out_format = FMT_H263;
1203
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1204
        avctx->delay=0;
1205
        s->low_delay=1;
1206
        break;
1207
    case CODEC_ID_H263P:
1208
        s->out_format = FMT_H263;
1209
        s->h263_plus = 1;
1210
        /* Fx */
1211
        s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1212
        s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1213
        s->modified_quant= s->h263_aic;
1214
        s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1215
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1216
        s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1217
        s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1218
        s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1219

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

    
1307
    avctx->has_b_frames= !s->low_delay;
1308

    
1309
    s->encoding = 1;
1310

    
1311
    /* init */
1312
    if (MPV_common_init(s) < 0)
1313
        return -1;
1314

    
1315
    if(s->modified_quant)
1316
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1317
    s->progressive_frame=
1318
    s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1319
    s->quant_precision=5;
1320

    
1321
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1322
    ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1323

    
1324
#ifdef CONFIG_H261_ENCODER
1325
    if (s->out_format == FMT_H261)
1326
        ff_h261_encode_init(s);
1327
#endif
1328
    if (s->out_format == FMT_H263)
1329
        h263_encode_init(s);
1330
    if(s->msmpeg4_version)
1331
        ff_msmpeg4_encode_init(s);
1332
    if (s->out_format == FMT_MPEG1)
1333
        ff_mpeg1_encode_init(s);
1334

    
1335
    /* init q matrix */
1336
    for(i=0;i<64;i++) {
1337
        int j= s->dsp.idct_permutation[i];
1338
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1339
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1340
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1341
        }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1342
            s->intra_matrix[j] =
1343
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1344
        }else
1345
        { /* mpeg1/2 */
1346
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1347
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1348
        }
1349
        if(s->avctx->intra_matrix)
1350
            s->intra_matrix[j] = s->avctx->intra_matrix[i];
1351
        if(s->avctx->inter_matrix)
1352
            s->inter_matrix[j] = s->avctx->inter_matrix[i];
1353
    }
1354

    
1355
    /* precompute matrix */
1356
    /* for mjpeg, we do include qscale in the matrix */
1357
    if (s->out_format != FMT_MJPEG) {
1358
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1359
                       s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1360
        convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1361
                       s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1362
    }
1363

    
1364
    if(ff_rate_control_init(s) < 0)
1365
        return -1;
1366

    
1367
    return 0;
1368
}
1369

    
1370
int MPV_encode_end(AVCodecContext *avctx)
1371
{
1372
    MpegEncContext *s = avctx->priv_data;
1373

    
1374
    ff_rate_control_uninit(s);
1375

    
1376
    MPV_common_end(s);
1377
    if (s->out_format == FMT_MJPEG)
1378
        mjpeg_close(s);
1379

    
1380
    av_freep(&avctx->extradata);
1381

    
1382
    return 0;
1383
}
1384

    
1385
#endif //CONFIG_ENCODERS
1386

    
1387
void init_rl(RLTable *rl, int use_static)
1388
{
1389
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1390
    uint8_t index_run[MAX_RUN+1];
1391
    int last, run, level, start, end, i;
1392

    
1393
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
1394
    if(use_static && rl->max_level[0])
1395
        return;
1396

    
1397
    /* compute max_level[], max_run[] and index_run[] */
1398
    for(last=0;last<2;last++) {
1399
        if (last == 0) {
1400
            start = 0;
1401
            end = rl->last;
1402
        } else {
1403
            start = rl->last;
1404
            end = rl->n;
1405
        }
1406

    
1407
        memset(max_level, 0, MAX_RUN + 1);
1408
        memset(max_run, 0, MAX_LEVEL + 1);
1409
        memset(index_run, rl->n, MAX_RUN + 1);
1410
        for(i=start;i<end;i++) {
1411
            run = rl->table_run[i];
1412
            level = rl->table_level[i];
1413
            if (index_run[run] == rl->n)
1414
                index_run[run] = i;
1415
            if (level > max_level[run])
1416
                max_level[run] = level;
1417
            if (run > max_run[level])
1418
                max_run[level] = run;
1419
        }
1420
        if(use_static)
1421
            rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1422
        else
1423
            rl->max_level[last] = av_malloc(MAX_RUN + 1);
1424
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1425
        if(use_static)
1426
            rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1427
        else
1428
            rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1429
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1430
        if(use_static)
1431
            rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1432
        else
1433
            rl->index_run[last] = av_malloc(MAX_RUN + 1);
1434
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1435
    }
1436
}
1437

    
1438
/* draw the edges of width 'w' of an image of size width, height */
1439
//FIXME check that this is ok for mpeg4 interlaced
1440
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1441
{
1442
    uint8_t *ptr, *last_line;
1443
    int i;
1444

    
1445
    last_line = buf + (height - 1) * wrap;
1446
    for(i=0;i<w;i++) {
1447
        /* top and bottom */
1448
        memcpy(buf - (i + 1) * wrap, buf, width);
1449
        memcpy(last_line + (i + 1) * wrap, last_line, width);
1450
    }
1451
    /* left and right */
1452
    ptr = buf;
1453
    for(i=0;i<height;i++) {
1454
        memset(ptr - w, ptr[0], w);
1455
        memset(ptr + width, ptr[width-1], w);
1456
        ptr += wrap;
1457
    }
1458
    /* corners */
1459
    for(i=0;i<w;i++) {
1460
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1461
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1462
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1463
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1464
    }
1465
}
1466

    
1467
int ff_find_unused_picture(MpegEncContext *s, int shared){
1468
    int i;
1469

    
1470
    if(shared){
1471
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1472
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1473
        }
1474
    }else{
1475
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1476
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1477
        }
1478
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1479
            if(s->picture[i].data[0]==NULL) return i;
1480
        }
1481
    }
1482

    
1483
    assert(0);
1484
    return -1;
1485
}
1486

    
1487
static void update_noise_reduction(MpegEncContext *s){
1488
    int intra, i;
1489

    
1490
    for(intra=0; intra<2; intra++){
1491
        if(s->dct_count[intra] > (1<<16)){
1492
            for(i=0; i<64; i++){
1493
                s->dct_error_sum[intra][i] >>=1;
1494
            }
1495
            s->dct_count[intra] >>= 1;
1496
        }
1497

    
1498
        for(i=0; i<64; i++){
1499
            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);
1500
        }
1501
    }
1502
}
1503

    
1504
/**
1505
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1506
 */
1507
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1508
{
1509
    int i;
1510
    AVFrame *pic;
1511
    s->mb_skipped = 0;
1512

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

    
1515
    /* mark&release old frames */
1516
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1517
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1518

    
1519
        /* release forgotten pictures */
1520
        /* if(mpeg124/h263) */
1521
        if(!s->encoding){
1522
            for(i=0; i<MAX_PICTURE_COUNT; i++){
1523
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1524
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1525
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1526
                }
1527
            }
1528
        }
1529
    }
1530
alloc:
1531
    if(!s->encoding){
1532
        /* release non reference frames */
1533
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1534
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1535
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1536
            }
1537
        }
1538

    
1539
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1540
            pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1541
        else{
1542
            i= ff_find_unused_picture(s, 0);
1543
            pic= (AVFrame*)&s->picture[i];
1544
        }
1545

    
1546
        pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1547
                        && !s->dropable ? 3 : 0;
1548

    
1549
        pic->coded_picture_number= s->coded_picture_number++;
1550

    
1551
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1552
            return -1;
1553

    
1554
        s->current_picture_ptr= (Picture*)pic;
1555
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1556
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1557
    }
1558

    
1559
    s->current_picture_ptr->pict_type= s->pict_type;
1560
//    if(s->flags && CODEC_FLAG_QSCALE)
1561
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1562
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1563

    
1564
    copy_picture(&s->current_picture, s->current_picture_ptr);
1565

    
1566
  if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1567
    if (s->pict_type != B_TYPE) {
1568
        s->last_picture_ptr= s->next_picture_ptr;
1569
        if(!s->dropable)
1570
            s->next_picture_ptr= s->current_picture_ptr;
1571
    }
1572
/*    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,
1573
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
1574
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
1575
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1576
        s->pict_type, s->dropable);*/
1577

    
1578
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1579
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1580

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

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

    
1589
    if(s->picture_structure!=PICT_FRAME){
1590
        int i;
1591
        for(i=0; i<4; i++){
1592
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1593
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1594
            }
1595
            s->current_picture.linesize[i] *= 2;
1596
            s->last_picture.linesize[i] *=2;
1597
            s->next_picture.linesize[i] *=2;
1598
        }
1599
    }
1600
  }
1601

    
1602
    s->hurry_up= s->avctx->hurry_up;
1603
    s->error_resilience= avctx->error_resilience;
1604

    
1605
    /* set dequantizer, we can't do it during init as it might change for mpeg4
1606
       and we can't do it in the header decode as init isnt called for mpeg4 there yet */
1607
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1608
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1609
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1610
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1611
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1612
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1613
    }else{
1614
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1615
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1616
    }
1617

    
1618
    if(s->dct_error_sum){
1619
        assert(s->avctx->noise_reduction && s->encoding);
1620

    
1621
        update_noise_reduction(s);
1622
    }
1623

    
1624
#ifdef HAVE_XVMC
1625
    if(s->avctx->xvmc_acceleration)
1626
        return XVMC_field_start(s, avctx);
1627
#endif
1628
    return 0;
1629
}
1630

    
1631
/* generic function for encode/decode called after a frame has been coded/decoded */
1632
void MPV_frame_end(MpegEncContext *s)
1633
{
1634
    int i;
1635
    /* draw edge for correct motion prediction if outside */
1636
#ifdef HAVE_XVMC
1637
//just to make sure that all data is rendered.
1638
    if(s->avctx->xvmc_acceleration){
1639
        XVMC_field_end(s);
1640
    }else
1641
#endif
1642
    if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1643
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1644
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1645
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1646
    }
1647
    emms_c();
1648

    
1649
    s->last_pict_type    = s->pict_type;
1650
    s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1651
    if(s->pict_type!=B_TYPE){
1652
        s->last_non_b_pict_type= s->pict_type;
1653
    }
1654
#if 0
1655
        /* copy back current_picture variables */
1656
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1657
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1658
            s->picture[i]= s->current_picture;
1659
            break;
1660
        }
1661
    }
1662
    assert(i<MAX_PICTURE_COUNT);
1663
#endif
1664

    
1665
    if(s->encoding){
1666
        /* release non-reference frames */
1667
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1668
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1669
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1670
            }
1671
        }
1672
    }
1673
    // clear copies, to avoid confusion
1674
#if 0
1675
    memset(&s->last_picture, 0, sizeof(Picture));
1676
    memset(&s->next_picture, 0, sizeof(Picture));
1677
    memset(&s->current_picture, 0, sizeof(Picture));
1678
#endif
1679
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1680
}
1681

    
1682
/**
1683
 * draws an line from (ex, ey) -> (sx, sy).
1684
 * @param w width of the image
1685
 * @param h height of the image
1686
 * @param stride stride/linesize of the image
1687
 * @param color color of the arrow
1688
 */
1689
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1690
    int x, y, fr, f;
1691

    
1692
    sx= clip(sx, 0, w-1);
1693
    sy= clip(sy, 0, h-1);
1694
    ex= clip(ex, 0, w-1);
1695
    ey= clip(ey, 0, h-1);
1696

    
1697
    buf[sy*stride + sx]+= color;
1698

    
1699
    if(ABS(ex - sx) > ABS(ey - sy)){
1700
        if(sx > ex){
1701
            SWAP(int, sx, ex);
1702
            SWAP(int, sy, ey);
1703
        }
1704
        buf+= sx + sy*stride;
1705
        ex-= sx;
1706
        f= ((ey-sy)<<16)/ex;
1707
        for(x= 0; x <= ex; x++){
1708
            y = (x*f)>>16;
1709
            fr= (x*f)&0xFFFF;
1710
            buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1711
            buf[(y+1)*stride + x]+= (color*         fr )>>16;
1712
        }
1713
    }else{
1714
        if(sy > ey){
1715
            SWAP(int, sx, ex);
1716
            SWAP(int, sy, ey);
1717
        }
1718
        buf+= sx + sy*stride;
1719
        ey-= sy;
1720
        if(ey) f= ((ex-sx)<<16)/ey;
1721
        else   f= 0;
1722
        for(y= 0; y <= ey; y++){
1723
            x = (y*f)>>16;
1724
            fr= (y*f)&0xFFFF;
1725
            buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;;
1726
            buf[y*stride + x+1]+= (color*         fr )>>16;;
1727
        }
1728
    }
1729
}
1730

    
1731
/**
1732
 * draws an arrow from (ex, ey) -> (sx, sy).
1733
 * @param w width of the image
1734
 * @param h height of the image
1735
 * @param stride stride/linesize of the image
1736
 * @param color color of the arrow
1737
 */
1738
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1739
    int dx,dy;
1740

    
1741
    sx= clip(sx, -100, w+100);
1742
    sy= clip(sy, -100, h+100);
1743
    ex= clip(ex, -100, w+100);
1744
    ey= clip(ey, -100, h+100);
1745

    
1746
    dx= ex - sx;
1747
    dy= ey - sy;
1748

    
1749
    if(dx*dx + dy*dy > 3*3){
1750
        int rx=  dx + dy;
1751
        int ry= -dx + dy;
1752
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1753

    
1754
        //FIXME subpixel accuracy
1755
        rx= ROUNDED_DIV(rx*3<<4, length);
1756
        ry= ROUNDED_DIV(ry*3<<4, length);
1757

    
1758
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1759
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1760
    }
1761
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1762
}
1763

    
1764
/**
1765
 * prints debuging info for the given picture.
1766
 */
1767
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1768

    
1769
    if(!pict || !pict->mb_type) return;
1770

    
1771
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1772
        int x,y;
1773

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

    
1823
                    //segmentation
1824
                    if(IS_8X8(mb_type))
1825
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1826
                    else if(IS_16X8(mb_type))
1827
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1828
                    else if(IS_8X16(mb_type))
1829
                        av_log(s->avctx, AV_LOG_DEBUG, "|");
1830
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1831
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1832
                    else
1833
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1834

    
1835

    
1836
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1837
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1838
                    else
1839
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1840
                }
1841
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1842
            }
1843
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1844
        }
1845
    }
1846

    
1847
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1848
        const int shift= 1 + s->quarter_sample;
1849
        int mb_y;
1850
        uint8_t *ptr;
1851
        int i;
1852
        int h_chroma_shift, v_chroma_shift;
1853
        const int width = s->avctx->width;
1854
        const int height= s->avctx->height;
1855
        const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1856
        const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1857
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1858

    
1859
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1860
        for(i=0; i<3; i++){
1861
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1862
            pict->data[i]= s->visualization_buffer[i];
1863
        }
1864
        pict->type= FF_BUFFER_TYPE_COPY;
1865
        ptr= pict->data[0];
1866

    
1867
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1868
            int mb_x;
1869
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1870
                const int mb_index= mb_x + mb_y*s->mb_stride;
1871
                if((s->avctx->debug_mv) && pict->motion_val){
1872
                  int type;
1873
                  for(type=0; type<3; type++){
1874
                    int direction = 0;
1875
                    switch (type) {
1876
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1877
                                continue;
1878
                              direction = 0;
1879
                              break;
1880
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1881
                                continue;
1882
                              direction = 0;
1883
                              break;
1884
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1885
                                continue;
1886
                              direction = 1;
1887
                              break;
1888
                    }
1889
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1890
                        continue;
1891

    
1892
                    if(IS_8X8(pict->mb_type[mb_index])){
1893
                      int i;
1894
                      for(i=0; i<4; i++){
1895
                        int sx= mb_x*16 + 4 + 8*(i&1);
1896
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1897
                        int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1898
                        int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1899
                        int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1900
                        draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1901
                      }
1902
                    }else if(IS_16X8(pict->mb_type[mb_index])){
1903
                      int i;
1904
                      for(i=0; i<2; i++){
1905
                        int sx=mb_x*16 + 8;
1906
                        int sy=mb_y*16 + 4 + 8*i;
1907
                        int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1908
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1909
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1910

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

    
1914
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1915
                      }
1916
                    }else if(IS_8X16(pict->mb_type[mb_index])){
1917
                      int i;
1918
                      for(i=0; i<2; i++){
1919
                        int sx=mb_x*16 + 4 + 8*i;
1920
                        int sy=mb_y*16 + 8;
1921
                        int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1922
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1923
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1924

    
1925
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1926
                            my*=2;
1927

    
1928
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1929
                      }
1930
                    }else{
1931
                      int sx= mb_x*16 + 8;
1932
                      int sy= mb_y*16 + 8;
1933
                      int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1934
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1935
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1936
                      draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1937
                    }
1938
                  }
1939
                }
1940
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1941
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1942
                    int y;
1943
                    for(y=0; y<8; y++){
1944
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1945
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1946
                    }
1947
                }
1948
                if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1949
                    int mb_type= pict->mb_type[mb_index];
1950
                    uint64_t u,v;
1951
                    int y;
1952
#define COLOR(theta, r)\
1953
u= (int)(128 + r*cos(theta*3.141592/180));\
1954
v= (int)(128 + r*sin(theta*3.141592/180));
1955

    
1956

    
1957
                    u=v=128;
1958
                    if(IS_PCM(mb_type)){
1959
                        COLOR(120,48)
1960
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1961
                        COLOR(30,48)
1962
                    }else if(IS_INTRA4x4(mb_type)){
1963
                        COLOR(90,48)
1964
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1965
//                        COLOR(120,48)
1966
                    }else if(IS_DIRECT(mb_type)){
1967
                        COLOR(150,48)
1968
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1969
                        COLOR(170,48)
1970
                    }else if(IS_GMC(mb_type)){
1971
                        COLOR(190,48)
1972
                    }else if(IS_SKIP(mb_type)){
1973
//                        COLOR(180,48)
1974
                    }else if(!USES_LIST(mb_type, 1)){
1975
                        COLOR(240,48)
1976
                    }else if(!USES_LIST(mb_type, 0)){
1977
                        COLOR(0,48)
1978
                    }else{
1979
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1980
                        COLOR(300,48)
1981
                    }
1982

    
1983
                    u*= 0x0101010101010101ULL;
1984
                    v*= 0x0101010101010101ULL;
1985
                    for(y=0; y<8; y++){
1986
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1987
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1988
                    }
1989

    
1990
                    //segmentation
1991
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1992
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1993
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1994
                    }
1995
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1996
                        for(y=0; y<16; y++)
1997
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1998
                    }
1999
                    if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
2000
                        int dm= 1 << (mv_sample_log2-2);
2001
                        for(i=0; i<4; i++){
2002
                            int sx= mb_x*16 + 8*(i&1);
2003
                            int sy= mb_y*16 + 8*(i>>1);
2004
                            int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
2005
                            //FIXME bidir
2006
                            int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
2007
                            if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
2008
                                for(y=0; y<8; y++)
2009
                                    pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
2010
                            if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
2011
                                *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
2012
                        }
2013
                    }
2014

    
2015
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
2016
                        // hmm
2017
                    }
2018
                }
2019
                s->mbskip_table[mb_index]=0;
2020
            }
2021
        }
2022
    }
2023
}
2024

    
2025
#ifdef CONFIG_ENCODERS
2026

    
2027
static int get_sae(uint8_t *src, int ref, int stride){
2028
    int x,y;
2029
    int acc=0;
2030

    
2031
    for(y=0; y<16; y++){
2032
        for(x=0; x<16; x++){
2033
            acc+= ABS(src[x+y*stride] - ref);
2034
        }
2035
    }
2036

    
2037
    return acc;
2038
}
2039

    
2040
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
2041
    int x, y, w, h;
2042
    int acc=0;
2043

    
2044
    w= s->width &~15;
2045
    h= s->height&~15;
2046

    
2047
    for(y=0; y<h; y+=16){
2048
        for(x=0; x<w; x+=16){
2049
            int offset= x + y*stride;
2050
            int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
2051
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
2052
            int sae = get_sae(src + offset, mean, stride);
2053

    
2054
            acc+= sae + 500 < sad;
2055
        }
2056
    }
2057
    return acc;
2058
}
2059

    
2060

    
2061
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2062
    AVFrame *pic=NULL;
2063
    int64_t pts;
2064
    int i;
2065
    const int encoding_delay= s->max_b_frames;
2066
    int direct=1;
2067

    
2068
    if(pic_arg){
2069
        pts= pic_arg->pts;
2070
        pic_arg->display_picture_number= s->input_picture_number++;
2071

    
2072
        if(pts != AV_NOPTS_VALUE){
2073
            if(s->user_specified_pts != AV_NOPTS_VALUE){
2074
                int64_t time= pts;
2075
                int64_t last= s->user_specified_pts;
2076

    
2077
                if(time <= last){
2078
                    av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts);
2079
                    return -1;
2080
                }
2081
            }
2082
            s->user_specified_pts= pts;
2083
        }else{
2084
            if(s->user_specified_pts != AV_NOPTS_VALUE){
2085
                s->user_specified_pts=
2086
                pts= s->user_specified_pts + 1;
2087
                av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts);
2088
            }else{
2089
                pts= pic_arg->display_picture_number;
2090
            }
2091
        }
2092
    }
2093

    
2094
  if(pic_arg){
2095
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2096
    if(pic_arg->linesize[0] != s->linesize) direct=0;
2097
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2098
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2099

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

    
2102
    if(direct){
2103
        i= ff_find_unused_picture(s, 1);
2104

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

    
2108
        for(i=0; i<4; i++){
2109
            pic->data[i]= pic_arg->data[i];
2110
            pic->linesize[i]= pic_arg->linesize[i];
2111
        }
2112
        alloc_picture(s, (Picture*)pic, 1);
2113
    }else{
2114
        i= ff_find_unused_picture(s, 0);
2115

    
2116
        pic= (AVFrame*)&s->picture[i];
2117
        pic->reference= 3;
2118

    
2119
        alloc_picture(s, (Picture*)pic, 0);
2120

    
2121
        if(   pic->data[0] + INPLACE_OFFSET == pic_arg->data[0]
2122
           && pic->data[1] + INPLACE_OFFSET == pic_arg->data[1]
2123
           && pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){
2124
       // empty
2125
        }else{
2126
            int h_chroma_shift, v_chroma_shift;
2127
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2128

    
2129
            for(i=0; i<3; i++){
2130
                int src_stride= pic_arg->linesize[i];
2131
                int dst_stride= i ? s->uvlinesize : s->linesize;
2132
                int h_shift= i ? h_chroma_shift : 0;
2133
                int v_shift= i ? v_chroma_shift : 0;
2134
                int w= s->width >>h_shift;
2135
                int h= s->height>>v_shift;
2136
                uint8_t *src= pic_arg->data[i];
2137
                uint8_t *dst= pic->data[i] + INPLACE_OFFSET;
2138

    
2139
                if(src_stride==dst_stride)
2140
                    memcpy(dst, src, src_stride*h);
2141
                else{
2142
                    while(h--){
2143
                        memcpy(dst, src, w);
2144
                        dst += dst_stride;
2145
                        src += src_stride;
2146
                    }
2147
                }
2148
            }
2149
        }
2150
    }
2151
    copy_picture_attributes(s, pic, pic_arg);
2152
    pic->pts= pts; //we set this here to avoid modifiying pic_arg
2153
  }
2154

    
2155
    /* shift buffer entries */
2156
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2157
        s->input_picture[i-1]= s->input_picture[i];
2158

    
2159
    s->input_picture[encoding_delay]= (Picture*)pic;
2160

    
2161
    return 0;
2162
}
2163

    
2164
static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2165
    int x, y, plane;
2166
    int score=0;
2167
    int64_t score64=0;
2168

    
2169
    for(plane=0; plane<3; plane++){
2170
        const int stride= p->linesize[plane];
2171
        const int bw= plane ? 1 : 2;
2172
        for(y=0; y<s->mb_height*bw; y++){
2173
            for(x=0; x<s->mb_width*bw; x++){
2174
                int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16;
2175
                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);
2176

    
2177
                switch(s->avctx->frame_skip_exp){
2178
                    case 0: score= FFMAX(score, v); break;
2179
                    case 1: score+= ABS(v);break;
2180
                    case 2: score+= v*v;break;
2181
                    case 3: score64+= ABS(v*v*(int64_t)v);break;
2182
                    case 4: score64+= v*v*(int64_t)(v*v);break;
2183
                }
2184
            }
2185
        }
2186
    }
2187

    
2188
    if(score) score64= score;
2189

    
2190
    if(score64 < s->avctx->frame_skip_threshold)
2191
        return 1;
2192
    if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2193
        return 1;
2194
    return 0;
2195
}
2196

    
2197
static int estimate_best_b_count(MpegEncContext *s){
2198
    AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id);
2199
    AVCodecContext *c= avcodec_alloc_context();
2200
    AVFrame input[FF_MAX_B_FRAMES+2];
2201
    const int scale= s->avctx->brd_scale;
2202
    int i, j, out_size, p_lambda, b_lambda, lambda2;
2203
    int outbuf_size= s->width * s->height; //FIXME
2204
    uint8_t *outbuf= av_malloc(outbuf_size);
2205
    int64_t best_rd= INT64_MAX;
2206
    int best_b_count= -1;
2207

    
2208
    assert(scale>=0 && scale <=3);
2209

    
2210
//    emms_c();
2211
    p_lambda= s->last_lambda_for[P_TYPE]; //s->next_picture_ptr->quality;
2212
    b_lambda= s->last_lambda_for[B_TYPE]; //p_lambda *ABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
2213
    if(!b_lambda) b_lambda= p_lambda; //FIXME we should do this somewhere else
2214
    lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT;
2215

    
2216
    c->width = s->width >> scale;
2217
    c->height= s->height>> scale;
2218
    c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
2219
    c->flags|= s->avctx->flags & CODEC_FLAG_QPEL;
2220
    c->mb_decision= s->avctx->mb_decision;
2221
    c->me_cmp= s->avctx->me_cmp;
2222
    c->mb_cmp= s->avctx->mb_cmp;
2223
    c->me_sub_cmp= s->avctx->me_sub_cmp;
2224
    c->pix_fmt = PIX_FMT_YUV420P;
2225
    c->time_base= s->avctx->time_base;
2226
    c->max_b_frames= s->max_b_frames;
2227

    
2228
    if (avcodec_open(c, codec) < 0)
2229
        return -1;
2230

    
2231
    for(i=0; i<s->max_b_frames+2; i++){
2232
        int ysize= c->width*c->height;
2233
        int csize= (c->width/2)*(c->height/2);
2234
        Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr;
2235

    
2236
        if(pre_input_ptr)
2237
            pre_input= *pre_input_ptr;
2238

    
2239
        if(pre_input.type != FF_BUFFER_TYPE_SHARED && i){
2240
            pre_input.data[0]+=INPLACE_OFFSET;
2241
            pre_input.data[1]+=INPLACE_OFFSET;
2242
            pre_input.data[2]+=INPLACE_OFFSET;
2243
        }
2244

    
2245
        avcodec_get_frame_defaults(&input[i]);
2246
        input[i].data[0]= av_malloc(ysize + 2*csize);
2247
        input[i].data[1]= input[i].data[0] + ysize;
2248
        input[i].data[2]= input[i].data[1] + csize;
2249
        input[i].linesize[0]= c->width;
2250
        input[i].linesize[1]=
2251
        input[i].linesize[2]= c->width/2;
2252

    
2253
        if(!i || s->input_picture[i-1]){
2254
            s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height);
2255
            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);
2256
            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);
2257
        }
2258
    }
2259

    
2260
    for(j=0; j<s->max_b_frames+1; j++){
2261
        int64_t rd=0;
2262

    
2263
        if(!s->input_picture[j])
2264
            break;
2265

    
2266
        c->error[0]= c->error[1]= c->error[2]= 0;
2267

    
2268
        input[0].pict_type= I_TYPE;
2269
        input[0].quality= 1 * FF_QP2LAMBDA;
2270
        out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
2271
//        rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2272

    
2273
        for(i=0; i<s->max_b_frames+1; i++){
2274
            int is_p= i % (j+1) == j || i==s->max_b_frames;
2275

    
2276
            input[i+1].pict_type= is_p ? P_TYPE : B_TYPE;
2277
            input[i+1].quality= is_p ? p_lambda : b_lambda;
2278
            out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]);
2279
            rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2280
        }
2281

    
2282
        /* get the delayed frames */
2283
        while(out_size){
2284
            out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
2285
            rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2286
        }
2287

    
2288
        rd += c->error[0] + c->error[1] + c->error[2];
2289

    
2290
        if(rd < best_rd){
2291
            best_rd= rd;
2292
            best_b_count= j;
2293
        }
2294
    }
2295

    
2296
    av_freep(&outbuf);
2297
    avcodec_close(c);
2298
    av_freep(&c);
2299

    
2300
    for(i=0; i<s->max_b_frames+2; i++){
2301
        av_freep(&input[i].data[0]);
2302
    }
2303

    
2304
    return best_b_count;
2305
}
2306

    
2307
static void select_input_picture(MpegEncContext *s){
2308
    int i;
2309

    
2310
    for(i=1; i<MAX_PICTURE_COUNT; i++)
2311
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2312
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2313

    
2314
    /* set next picture type & ordering */
2315
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2316
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2317
            s->reordered_input_picture[0]= s->input_picture[0];
2318
            s->reordered_input_picture[0]->pict_type= I_TYPE;
2319
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2320
        }else{
2321
            int b_frames;
2322

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

    
2328
                    if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2329
                        for(i=0; i<4; i++)
2330
                            s->input_picture[0]->data[i]= NULL;
2331
                        s->input_picture[0]->type= 0;
2332
                    }else{
2333
                        assert(   s->input_picture[0]->type==FF_BUFFER_TYPE_USER
2334
                               || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2335

    
2336
                        s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2337
                    }
2338

    
2339
                    emms_c();
2340
                    ff_vbv_update(s, 0);
2341

    
2342
                    goto no_output_pic;
2343
                }
2344
            }
2345

    
2346
            if(s->flags&CODEC_FLAG_PASS2){
2347
                for(i=0; i<s->max_b_frames+1; i++){
2348
                    int pict_num= s->input_picture[0]->display_picture_number + i;
2349

    
2350
                    if(pict_num >= s->rc_context.num_entries)
2351
                        break;
2352
                    if(!s->input_picture[i]){
2353
                        s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2354
                        break;
2355
                    }
2356

    
2357
                    s->input_picture[i]->pict_type=
2358
                        s->rc_context.entry[pict_num].new_pict_type;
2359
                }
2360
            }
2361

    
2362
            if(s->avctx->b_frame_strategy==0){
2363
                b_frames= s->max_b_frames;
2364
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
2365
            }else if(s->avctx->b_frame_strategy==1){
2366
                for(i=1; i<s->max_b_frames+1; i++){
2367
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2368
                        s->input_picture[i]->b_frame_score=
2369
                            get_intra_count(s, s->input_picture[i  ]->data[0],
2370
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
2371
                    }
2372
                }
2373
                for(i=0; i<s->max_b_frames+1; i++){
2374
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/s->avctx->b_sensitivity) break;
2375
                }
2376

    
2377
                b_frames= FFMAX(0, i-1);
2378

    
2379
                /* reset scores */
2380
                for(i=0; i<b_frames+1; i++){
2381
                    s->input_picture[i]->b_frame_score=0;
2382
                }
2383
            }else if(s->avctx->b_frame_strategy==2){
2384
                b_frames= estimate_best_b_count(s);
2385
            }else{
2386
                av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2387
                b_frames=0;
2388
            }
2389

    
2390
            emms_c();
2391
//static int b_count=0;
2392
//b_count+= b_frames;
2393
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2394

    
2395
            for(i= b_frames - 1; i>=0; i--){
2396
                int type= s->input_picture[i]->pict_type;
2397
                if(type && type != B_TYPE)
2398
                    b_frames= i;
2399
            }
2400
            if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2401
                av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
2402
            }
2403

    
2404
            if(s->picture_in_gop_number + b_frames >= s->gop_size){
2405
              if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2406
                    b_frames= s->gop_size - s->picture_in_gop_number - 1;
2407
              }else{
2408
                if(s->flags & CODEC_FLAG_CLOSED_GOP)
2409
                    b_frames=0;
2410
                s->input_picture[b_frames]->pict_type= I_TYPE;
2411
              }
2412
            }
2413

    
2414
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2415
               && b_frames
2416
               && s->input_picture[b_frames]->pict_type== I_TYPE)
2417
                b_frames--;
2418

    
2419
            s->reordered_input_picture[0]= s->input_picture[b_frames];
2420
            if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2421
                s->reordered_input_picture[0]->pict_type= P_TYPE;
2422
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2423
            for(i=0; i<b_frames; i++){
2424
                s->reordered_input_picture[i+1]= s->input_picture[i];
2425
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2426
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2427
            }
2428
        }
2429
    }
2430
no_output_pic:
2431
    if(s->reordered_input_picture[0]){
2432
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2433

    
2434
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2435

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

    
2439
            int i= ff_find_unused_picture(s, 0);
2440
            Picture *pic= &s->picture[i];
2441

    
2442
            /* mark us unused / free shared pic */
2443
            for(i=0; i<4; i++)
2444
                s->reordered_input_picture[0]->data[i]= NULL;
2445
            s->reordered_input_picture[0]->type= 0;
2446

    
2447
            pic->reference              = s->reordered_input_picture[0]->reference;
2448

    
2449
            alloc_picture(s, pic, 0);
2450

    
2451
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2452

    
2453
            s->current_picture_ptr= pic;
2454
        }else{
2455
            // input is not a shared pix -> reuse buffer for current_pix
2456

    
2457
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2458
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2459

    
2460
            s->current_picture_ptr= s->reordered_input_picture[0];
2461
            for(i=0; i<4; i++){
2462
                s->new_picture.data[i]+= INPLACE_OFFSET;
2463
            }
2464
        }
2465
        copy_picture(&s->current_picture, s->current_picture_ptr);
2466

    
2467
        s->picture_number= s->new_picture.display_picture_number;
2468
//printf("dpn:%d\n", s->picture_number);
2469
    }else{
2470
       memset(&s->new_picture, 0, sizeof(Picture));
2471
    }
2472
}
2473

    
2474
int MPV_encode_picture(AVCodecContext *avctx,
2475
                       unsigned char *buf, int buf_size, void *data)
2476
{
2477
    MpegEncContext *s = avctx->priv_data;
2478
    AVFrame *pic_arg = data;
2479
    int i, stuffing_count;
2480

    
2481
    for(i=0; i<avctx->thread_count; i++){
2482
        int start_y= s->thread_context[i]->start_mb_y;
2483
        int   end_y= s->thread_context[i]->  end_mb_y;
2484
        int h= s->mb_height;
2485
        uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h);
2486
        uint8_t *end  = buf + (size_t)(((int64_t) buf_size)*  end_y/h);
2487

    
2488
        init_put_bits(&s->thread_context[i]->pb, start, end - start);
2489
    }
2490

    
2491
    s->picture_in_gop_number++;
2492

    
2493
    if(load_input_picture(s, pic_arg) < 0)
2494
        return -1;
2495

    
2496
    select_input_picture(s);
2497

    
2498
    /* output? */
2499
    if(s->new_picture.data[0]){
2500
        s->pict_type= s->new_picture.pict_type;
2501
//emms_c();
2502
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2503
        MPV_frame_start(s, avctx);
2504

    
2505
        if (encode_picture(s, s->picture_number) < 0)
2506
            return -1;
2507

    
2508
        avctx->real_pict_num  = s->picture_number;
2509
        avctx->header_bits = s->header_bits;
2510
        avctx->mv_bits     = s->mv_bits;
2511
        avctx->misc_bits   = s->misc_bits;
2512
        avctx->i_tex_bits  = s->i_tex_bits;
2513
        avctx->p_tex_bits  = s->p_tex_bits;
2514
        avctx->i_count     = s->i_count;
2515
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2516
        avctx->skip_count  = s->skip_count;
2517

    
2518
        MPV_frame_end(s);
2519

    
2520
        if (s->out_format == FMT_MJPEG)
2521
            mjpeg_picture_trailer(s);
2522

    
2523
        if(s->flags&CODEC_FLAG_PASS1)
2524
            ff_write_pass1_stats(s);
2525

    
2526
        for(i=0; i<4; i++){
2527
            s->current_picture_ptr->error[i]= s->current_picture.error[i];
2528
            avctx->error[i] += s->current_picture_ptr->error[i];
2529
        }
2530

    
2531
        if(s->flags&CODEC_FLAG_PASS1)
2532
            assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2533
        flush_put_bits(&s->pb);
2534
        s->frame_bits  = put_bits_count(&s->pb);
2535

    
2536
        stuffing_count= ff_vbv_update(s, s->frame_bits);
2537
        if(stuffing_count){
2538
            if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2539
                av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2540
                return -1;
2541
            }
2542

    
2543
            switch(s->codec_id){
2544
            case CODEC_ID_MPEG1VIDEO:
2545
            case CODEC_ID_MPEG2VIDEO:
2546
                while(stuffing_count--){
2547
                    put_bits(&s->pb, 8, 0);
2548
                }
2549
            break;
2550
            case CODEC_ID_MPEG4:
2551
                put_bits(&s->pb, 16, 0);
2552
                put_bits(&s->pb, 16, 0x1C3);
2553
                stuffing_count -= 4;
2554
                while(stuffing_count--){
2555
                    put_bits(&s->pb, 8, 0xFF);
2556
                }
2557
            break;
2558
            default:
2559
                av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2560
            }
2561
            flush_put_bits(&s->pb);
2562
            s->frame_bits  = put_bits_count(&s->pb);
2563
        }
2564

    
2565
        /* update mpeg1/2 vbv_delay for CBR */
2566
        if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2567
           && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2568
            int vbv_delay;
2569

    
2570
            assert(s->repeat_first_field==0);
2571

    
2572
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2573
            assert(vbv_delay < 0xFFFF);
2574

    
2575
            s->vbv_delay_ptr[0] &= 0xF8;
2576
            s->vbv_delay_ptr[0] |= vbv_delay>>13;
2577
            s->vbv_delay_ptr[1]  = vbv_delay>>5;
2578
            s->vbv_delay_ptr[2] &= 0x07;
2579
            s->vbv_delay_ptr[2] |= vbv_delay<<3;
2580
        }
2581
        s->total_bits += s->frame_bits;
2582
        avctx->frame_bits  = s->frame_bits;
2583
    }else{
2584
        assert((pbBufPtr(&s->pb) == s->pb.buf));
2585
        s->frame_bits=0;
2586
    }
2587
    assert((s->frame_bits&7)==0);
2588

    
2589
    return s->frame_bits/8;
2590
}
2591

    
2592
#endif //CONFIG_ENCODERS
2593

    
2594
static inline void gmc1_motion(MpegEncContext *s,
2595
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2596
                               uint8_t **ref_picture)
2597
{
2598
    uint8_t *ptr;
2599
    int offset, src_x, src_y, linesize, uvlinesize;
2600
    int motion_x, motion_y;
2601
    int emu=0;
2602

    
2603
    motion_x= s->sprite_offset[0][0];
2604
    motion_y= s->sprite_offset[0][1];
2605
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2606
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2607
    motion_x<<=(3-s->sprite_warping_accuracy);
2608
    motion_y<<=(3-s->sprite_warping_accuracy);
2609
    src_x = clip(src_x, -16, s->width);
2610
    if (src_x == s->width)
2611
        motion_x =0;
2612
    src_y = clip(src_y, -16, s->height);
2613
    if (src_y == s->height)
2614
        motion_y =0;
2615

    
2616
    linesize = s->linesize;
2617
    uvlinesize = s->uvlinesize;
2618

    
2619
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2620

    
2621
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2622
        if(   (unsigned)src_x >= s->h_edge_pos - 17
2623
           || (unsigned)src_y >= s->v_edge_pos - 17){
2624
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2625
            ptr= s->edge_emu_buffer;
2626
        }
2627
    }
2628

    
2629
    if((motion_x|motion_y)&7){
2630
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2631
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2632
    }else{
2633
        int dxy;
2634

    
2635
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2636
        if (s->no_rounding){
2637
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2638
        }else{
2639
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2640
        }
2641
    }
2642

    
2643
    if(s->flags&CODEC_FLAG_GRAY) return;
2644

    
2645
    motion_x= s->sprite_offset[1][0];
2646
    motion_y= s->sprite_offset[1][1];
2647
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2648
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2649
    motion_x<<=(3-s->sprite_warping_accuracy);
2650
    motion_y<<=(3-s->sprite_warping_accuracy);
2651
    src_x = clip(src_x, -8, s->width>>1);
2652
    if (src_x == s->width>>1)
2653
        motion_x =0;
2654
    src_y = clip(src_y, -8, s->height>>1);
2655
    if (src_y == s->height>>1)
2656
        motion_y =0;
2657

    
2658
    offset = (src_y * uvlinesize) + src_x;
2659
    ptr = ref_picture[1] + offset;
2660
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2661
        if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2662
           || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2663
            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);
2664
            ptr= s->edge_emu_buffer;
2665
            emu=1;
2666
        }
2667
    }
2668
    s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2669

    
2670
    ptr = ref_picture[2] + offset;
2671
    if(emu){
2672
        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);
2673
        ptr= s->edge_emu_buffer;
2674
    }
2675
    s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2676

    
2677
    return;
2678
}
2679

    
2680
static inline void gmc_motion(MpegEncContext *s,
2681
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2682
                               uint8_t **ref_picture)
2683
{
2684
    uint8_t *ptr;
2685
    int linesize, uvlinesize;
2686
    const int a= s->sprite_warping_accuracy;
2687
    int ox, oy;
2688

    
2689
    linesize = s->linesize;
2690
    uvlinesize = s->uvlinesize;
2691

    
2692
    ptr = ref_picture[0];
2693

    
2694
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2695
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2696

    
2697
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2698
           ox,
2699
           oy,
2700
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2701
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2702
           a+1, (1<<(2*a+1)) - s->no_rounding,
2703
           s->h_edge_pos, s->v_edge_pos);
2704
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2705
           ox + s->sprite_delta[0][0]*8,
2706
           oy + s->sprite_delta[1][0]*8,
2707
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2708
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2709
           a+1, (1<<(2*a+1)) - s->no_rounding,
2710
           s->h_edge_pos, s->v_edge_pos);
2711

    
2712
    if(s->flags&CODEC_FLAG_GRAY) return;
2713

    
2714
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2715
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2716

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

    
2726
    ptr = ref_picture[2];
2727
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2728
           ox,
2729
           oy,
2730
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2731
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2732
           a+1, (1<<(2*a+1)) - s->no_rounding,
2733
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2734
}
2735

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

    
2753
    if(src_y>= h){
2754
        src+= (h-1-src_y)*linesize;
2755
        src_y=h-1;
2756
    }else if(src_y<=-block_h){
2757
        src+= (1-block_h-src_y)*linesize;
2758
        src_y=1-block_h;
2759
    }
2760
    if(src_x>= w){
2761
        src+= (w-1-src_x);
2762
        src_x=w-1;
2763
    }else if(src_x<=-block_w){
2764
        src+= (1-block_w-src_x);
2765
        src_x=1-block_w;
2766
    }
2767

    
2768
    start_y= FFMAX(0, -src_y);
2769
    start_x= FFMAX(0, -src_x);
2770
    end_y= FFMIN(block_h, h-src_y);
2771
    end_x= FFMIN(block_w, w-src_x);
2772

    
2773
    // copy existing part
2774
    for(y=start_y; y<end_y; y++){
2775
        for(x=start_x; x<end_x; x++){
2776
            buf[x + y*linesize]= src[x + y*linesize];
2777
        }
2778
    }
2779

    
2780
    //top
2781
    for(y=0; y<start_y; y++){
2782
        for(x=start_x; x<end_x; x++){
2783
            buf[x + y*linesize]= buf[x + start_y*linesize];
2784
        }
2785
    }
2786

    
2787
    //bottom
2788
    for(y=end_y; y<block_h; y++){
2789
        for(x=start_x; x<end_x; x++){
2790
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2791
        }
2792
    }
2793

    
2794
    for(y=0; y<block_h; y++){
2795
       //left
2796
        for(x=0; x<start_x; x++){
2797
            buf[x + y*linesize]= buf[start_x + y*linesize];
2798
        }
2799

    
2800
       //right
2801
        for(x=end_x; x<block_w; x++){
2802
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2803
        }
2804
    }
2805
}
2806

    
2807
static inline int hpel_motion(MpegEncContext *s,
2808
                                  uint8_t *dest, uint8_t *src,
2809
                                  int field_based, int field_select,
2810
                                  int src_x, int src_y,
2811
                                  int width, int height, int stride,
2812
                                  int h_edge_pos, int v_edge_pos,
2813
                                  int w, int h, op_pixels_func *pix_op,
2814
                                  int motion_x, int motion_y)
2815
{
2816
    int dxy;
2817
    int emu=0;
2818

    
2819
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2820
    src_x += motion_x >> 1;
2821
    src_y += motion_y >> 1;
2822

    
2823
    /* WARNING: do no forget half pels */
2824
    src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2825
    if (src_x == width)
2826
        dxy &= ~1;
2827
    src_y = clip(src_y, -16, height);
2828
    if (src_y == height)
2829
        dxy &= ~2;
2830
    src += src_y * stride + src_x;
2831

    
2832
    if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2833
        if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2834
           || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2835
            ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2836
                             src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2837
            src= s->edge_emu_buffer;
2838
            emu=1;
2839
        }
2840
    }
2841
    if(field_select)
2842
        src += s->linesize;
2843
    pix_op[dxy](dest, src, stride, h);
2844
    return emu;
2845
}
2846

    
2847
static inline int hpel_motion_lowres(MpegEncContext *s,
2848
                                  uint8_t *dest, uint8_t *src,
2849
                                  int field_based, int field_select,
2850
                                  int src_x, int src_y,
2851
                                  int width, int height, int stride,
2852
                                  int h_edge_pos, int v_edge_pos,
2853
                                  int w, int h, h264_chroma_mc_func *pix_op,
2854
                                  int motion_x, int motion_y)
2855
{
2856
    const int lowres= s->avctx->lowres;
2857
    const int s_mask= (2<<lowres)-1;
2858
    int emu=0;
2859
    int sx, sy;
2860

    
2861
    if(s->quarter_sample){
2862
        motion_x/=2;
2863
        motion_y/=2;
2864
    }
2865

    
2866
    sx= motion_x & s_mask;
2867
    sy= motion_y & s_mask;
2868
    src_x += motion_x >> (lowres+1);
2869
    src_y += motion_y >> (lowres+1);
2870

    
2871
    src += src_y * stride + src_x;
2872

    
2873
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
2874
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2875
        ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2876
                            src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2877
        src= s->edge_emu_buffer;
2878
        emu=1;
2879
    }
2880

    
2881
    sx <<= 2 - lowres;
2882
    sy <<= 2 - lowres;
2883
    if(field_select)
2884
        src += s->linesize;
2885
    pix_op[lowres](dest, src, stride, h, sx, sy);
2886
    return emu;
2887
}
2888

    
2889
/* apply one mpeg motion vector to the three components */
2890
static always_inline void mpeg_motion(MpegEncContext *s,
2891
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2892
                               int field_based, int bottom_field, int field_select,
2893
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2894
                               int motion_x, int motion_y, int h)
2895
{
2896
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2897
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2898

    
2899
#if 0
2900
if(s->quarter_sample)
2901
{
2902
    motion_x>>=1;
2903
    motion_y>>=1;
2904
}
2905
#endif
2906

    
2907
    v_edge_pos = s->v_edge_pos >> field_based;
2908
    linesize   = s->current_picture.linesize[0] << field_based;
2909
    uvlinesize = s->current_picture.linesize[1] << field_based;
2910

    
2911
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2912
    src_x = s->mb_x* 16               + (motion_x >> 1);
2913
    src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2914

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

    
2956
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2957
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2958
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2959

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

    
2981
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2982
        dest_y += s->linesize;
2983
        dest_cb+= s->uvlinesize;
2984
        dest_cr+= s->uvlinesize;
2985
    }
2986

    
2987
    if(field_select){
2988
        ptr_y += s->linesize;
2989
        ptr_cb+= s->uvlinesize;
2990
        ptr_cr+= s->uvlinesize;
2991
    }
2992

    
2993
    pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2994

    
2995
    if(!(s->flags&CODEC_FLAG_GRAY)){
2996
        pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2997
        pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2998
    }
2999
#if defined(CONFIG_H261_ENCODER) || defined(CONFIG_H261_DECODER)
3000
    if(s->out_format == FMT_H261){
3001
        ff_h261_loop_filter(s);
3002
    }
3003
#endif
3004
}
3005

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

    
3023
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
3024
        motion_x/=2;
3025
        motion_y/=2;
3026
    }
3027

    
3028
    if(field_based){
3029
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
3030
    }
3031

    
3032
    sx= motion_x & s_mask;
3033
    sy= motion_y & s_mask;
3034
    src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
3035
    src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
3036

    
3037
    if (s->out_format == FMT_H263) {
3038
        uvsx = ((motion_x>>1) & s_mask) | (sx&1);
3039
        uvsy = ((motion_y>>1) & s_mask) | (sy&1);
3040
        uvsrc_x = src_x>>1;
3041
        uvsrc_y = src_y>>1;
3042
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
3043
        mx = motion_x / 4;
3044
        my = motion_y / 4;
3045
        uvsx = (2*mx) & s_mask;
3046
        uvsy = (2*my) & s_mask;
3047
        uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
3048
        uvsrc_y = s->mb_y*block_s               + (my >> lowres);
3049
    } else {
3050
        mx = motion_x / 2;
3051
        my = motion_y / 2;
3052
        uvsx = mx & s_mask;
3053
        uvsy = my & s_mask;
3054
        uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
3055
        uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
3056
    }
3057

    
3058
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
3059
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3060
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3061

    
3062
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
3063
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
3064
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3065
                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
3066
            ptr_y = s->edge_emu_buffer;
3067
            if(!(s->flags&CODEC_FLAG_GRAY)){
3068
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3069
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
3070
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3071
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3072
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3073
                ptr_cb= uvbuf;
3074
                ptr_cr= uvbuf+16;
3075
            }
3076
    }
3077

    
3078
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3079
        dest_y += s->linesize;
3080
        dest_cb+= s->uvlinesize;
3081
        dest_cr+= s->uvlinesize;
3082
    }
3083

    
3084
    if(field_select){
3085
        ptr_y += s->linesize;
3086
        ptr_cb+= s->uvlinesize;
3087
        ptr_cr+= s->uvlinesize;
3088
    }
3089

    
3090
    sx <<= 2 - lowres;
3091
    sy <<= 2 - lowres;
3092
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
3093

    
3094
    if(!(s->flags&CODEC_FLAG_GRAY)){
3095
        uvsx <<= 2 - lowres;
3096
        uvsy <<= 2 - lowres;
3097
        pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3098
        pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3099
    }
3100
    //FIXME h261 lowres loop filter
3101
}
3102

    
3103
//FIXME move to dsputil, avg variant, 16x16 version
3104
static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
3105
    int x;
3106
    uint8_t * const top   = src[1];
3107
    uint8_t * const left  = src[2];
3108
    uint8_t * const mid   = src[0];
3109
    uint8_t * const right = src[3];
3110
    uint8_t * const bottom= src[4];
3111
#define OBMC_FILTER(x, t, l, m, r, b)\
3112
    dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
3113
#define OBMC_FILTER4(x, t, l, m, r, b)\
3114
    OBMC_FILTER(x         , t, l, m, r, b);\
3115
    OBMC_FILTER(x+1       , t, l, m, r, b);\
3116
    OBMC_FILTER(x  +stride, t, l, m, r, b);\
3117
    OBMC_FILTER(x+1+stride, t, l, m, r, b);
3118

    
3119
    x=0;
3120
    OBMC_FILTER (x  , 2, 2, 4, 0, 0);
3121
    OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
3122
    OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
3123
    OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
3124
    OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
3125
    OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
3126
    x+= stride;
3127
    OBMC_FILTER (x  , 1, 2, 5, 0, 0);
3128
    OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
3129
    OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
3130
    OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
3131
    x+= stride;
3132
    OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
3133
    OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
3134
    OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
3135
    OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
3136
    x+= 2*stride;
3137
    OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
3138
    OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
3139
    OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
3140
    OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
3141
    x+= 2*stride;
3142
    OBMC_FILTER (x  , 0, 2, 5, 0, 1);
3143
    OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
3144
    OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
3145
    OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
3146
    OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
3147
    OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
3148
    x+= stride;
3149
    OBMC_FILTER (x  , 0, 2, 4, 0, 2);
3150
    OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
3151
    OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
3152
    OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
3153
}
3154

    
3155
/* obmc for 1 8x8 luma block */
3156
static inline void obmc_motion(MpegEncContext *s,
3157
                               uint8_t *dest, uint8_t *src,
3158
                               int src_x, int src_y,
3159
                               op_pixels_func *pix_op,
3160
                               int16_t mv[5][2]/* mid top left right bottom*/)
3161
#define MID    0
3162
{
3163
    int i;
3164
    uint8_t *ptr[5];
3165

    
3166
    assert(s->quarter_sample==0);
3167

    
3168
    for(i=0; i<5; i++){
3169
        if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
3170
            ptr[i]= ptr[MID];
3171
        }else{
3172
            ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
3173
            hpel_motion(s, ptr[i], src, 0, 0,
3174
                        src_x, src_y,
3175
                        s->width, s->height, s->linesize,
3176
                        s->h_edge_pos, s->v_edge_pos,
3177
                        8, 8, pix_op,
3178
                        mv[i][0], mv[i][1]);
3179
        }
3180
    }
3181

    
3182
    put_obmc(dest, ptr, s->linesize);
3183
}
3184

    
3185
static inline void qpel_motion(MpegEncContext *s,
3186
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3187
                               int field_based, int bottom_field, int field_select,
3188
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3189
                               qpel_mc_func (*qpix_op)[16],
3190
                               int motion_x, int motion_y, int h)
3191
{
3192
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3193
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3194

    
3195
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3196
    src_x = s->mb_x *  16                 + (motion_x >> 2);
3197
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3198

    
3199
    v_edge_pos = s->v_edge_pos >> field_based;
3200
    linesize = s->linesize << field_based;
3201
    uvlinesize = s->uvlinesize << field_based;
3202

    
3203
    if(field_based){
3204
        mx= motion_x/2;
3205
        my= motion_y>>1;
3206
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3207
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
3208
        mx= (motion_x>>1) + rtab[motion_x&7];
3209
        my= (motion_y>>1) + rtab[motion_y&7];
3210
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3211
        mx= (motion_x>>1)|(motion_x&1);
3212
        my= (motion_y>>1)|(motion_y&1);
3213
    }else{
3214
        mx= motion_x/2;
3215
        my= motion_y/2;
3216
    }
3217
    mx= (mx>>1)|(mx&1);
3218
    my= (my>>1)|(my&1);
3219

    
3220
    uvdxy= (mx&1) | ((my&1)<<1);
3221
    mx>>=1;
3222
    my>>=1;
3223

    
3224
    uvsrc_x = s->mb_x *  8                 + mx;
3225
    uvsrc_y = s->mb_y * (8 >> field_based) + my;
3226

    
3227
    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
3228
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3229
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3230

    
3231
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
3232
       || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
3233
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3234
                         src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3235
        ptr_y= s->edge_emu_buffer;
3236
        if(!(s->flags&CODEC_FLAG_GRAY)){
3237
            uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3238
            ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
3239
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3240
            ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
3241
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3242
            ptr_cb= uvbuf;
3243
            ptr_cr= uvbuf + 16;
3244
        }
3245
    }
3246

    
3247
    if(!field_based)
3248
        qpix_op[0][dxy](dest_y, ptr_y, linesize);
3249
    else{
3250
        if(bottom_field){
3251
            dest_y += s->linesize;
3252
            dest_cb+= s->uvlinesize;
3253
            dest_cr+= s->uvlinesize;
3254
        }
3255

    
3256
        if(field_select){
3257
            ptr_y  += s->linesize;
3258
            ptr_cb += s->uvlinesize;
3259
            ptr_cr += s->uvlinesize;
3260
        }
3261
        //damn interlaced mode
3262
        //FIXME boundary mirroring is not exactly correct here
3263
        qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
3264
        qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3265
    }
3266
    if(!(s->flags&CODEC_FLAG_GRAY)){
3267
        pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3268
        pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3269
    }
3270
}
3271

    
3272
inline int ff_h263_round_chroma(int x){
3273
    if (x >= 0)
3274
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3275
    else {
3276
        x = -x;
3277
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3278
    }
3279
}
3280

    
3281
/**
3282
 * h263 chorma 4mv motion compensation.
3283
 */
3284
static inline void chroma_4mv_motion(MpegEncContext *s,
3285
                                     uint8_t *dest_cb, uint8_t *dest_cr,
3286
                                     uint8_t **ref_picture,
3287
                                     op_pixels_func *pix_op,
3288
                                     int mx, int my){
3289
    int dxy, emu=0, src_x, src_y, offset;
3290
    uint8_t *ptr;
3291

    
3292
    /* In case of 8X8, we construct a single chroma motion vector
3293
       with a special rounding */
3294
    mx= ff_h263_round_chroma(mx);
3295
    my= ff_h263_round_chroma(my);
3296

    
3297
    dxy = ((my & 1) << 1) | (mx & 1);
3298
    mx >>= 1;
3299
    my >>= 1;
3300

    
3301
    src_x = s->mb_x * 8 + mx;
3302
    src_y = s->mb_y * 8 + my;
3303
    src_x = clip(src_x, -8, s->width/2);
3304
    if (src_x == s->width/2)
3305
        dxy &= ~1;
3306
    src_y = clip(src_y, -8, s->height/2);
3307
    if (src_y == s->height/2)
3308
        dxy &= ~2;
3309

    
3310
    offset = (src_y * (s->uvlinesize)) + src_x;
3311
    ptr = ref_picture[1] + offset;
3312
    if(s->flags&CODEC_FLAG_EMU_EDGE){
3313
        if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3314
           || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3315
            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);
3316
            ptr= s->edge_emu_buffer;
3317
            emu=1;
3318
        }
3319
    }
3320
    pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3321

    
3322
    ptr = ref_picture[2] + offset;
3323
    if(emu){
3324
        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);
3325
        ptr= s->edge_emu_buffer;
3326
    }
3327
    pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3328
}
3329

    
3330
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3331
                                     uint8_t *dest_cb, uint8_t *dest_cr,
3332
                                     uint8_t **ref_picture,
3333
                                     h264_chroma_mc_func *pix_op,
3334
                                     int mx, int my){
3335
    const int lowres= s->avctx->lowres;
3336
    const int block_s= 8>>lowres;
3337
    const int s_mask= (2<<lowres)-1;
3338
    const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3339
    const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3340
    int emu=0, src_x, src_y, offset, sx, sy;
3341
    uint8_t *ptr;
3342

    
3343
    if(s->quarter_sample){
3344
        mx/=2;
3345
        my/=2;
3346
    }
3347

    
3348
    /* In case of 8X8, we construct a single chroma motion vector
3349
       with a special rounding */
3350
    mx= ff_h263_round_chroma(mx);
3351
    my= ff_h263_round_chroma(my);
3352

    
3353
    sx= mx & s_mask;
3354
    sy= my & s_mask;
3355
    src_x = s->mb_x*block_s + (mx >> (lowres+1));
3356
    src_y = s->mb_y*block_s + (my >> (lowres+1));
3357

    
3358
    offset = src_y * s->uvlinesize + src_x;
3359
    ptr = ref_picture[1] + offset;
3360
    if(s->flags&CODEC_FLAG_EMU_EDGE){
3361
        if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3362
           || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3363
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3364
            ptr= s->edge_emu_buffer;
3365
            emu=1;
3366
        }
3367
    }
3368
    sx <<= 2 - lowres;
3369
    sy <<= 2 - lowres;
3370
    pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3371

    
3372
    ptr = ref_picture[2] + offset;
3373
    if(emu){
3374
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3375
        ptr= s->edge_emu_buffer;
3376
    }
3377
    pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3378
}
3379

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

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

    
3413
    mb_x = s->mb_x;
3414
    mb_y = s->mb_y;
3415

    
3416
    prefetch_motion(s, ref_picture, dir);
3417

    
3418
    if(s->obmc && s->pict_type != B_TYPE){
3419
        int16_t mv_cache[4][4][2];
3420
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
3421
        const int mot_stride= s->b8_stride;
3422
        const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3423

    
3424
        assert(!s->mb_skipped);
3425

    
3426
        memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
3427
        memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3428
        memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3429

    
3430
        if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3431
            memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3432
        }else{
3433
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3434
        }
3435

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

    
3444
        if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3445
            *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3446
            *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3447
        }else{
3448
            *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3449
            *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3450
        }
3451

    
3452
        mx = 0;
3453
        my = 0;
3454
        for(i=0;i<4;i++) {
3455
            const int x= (i&1)+1;
3456
            const int y= (i>>1)+1;
3457
            int16_t mv[5][2]= {
3458
                {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
3459
                {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3460
                {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3461
                {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3462
                {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3463
            //FIXME cleanup
3464
            obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3465
                        ref_picture[0],
3466
                        mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3467
                        pix_op[1],
3468
                        mv);
3469

    
3470
            mx += mv[0][0];
3471
            my += mv[0][1];
3472
        }
3473
        if(!(s->flags&CODEC_FLAG_GRAY))
3474
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3475

    
3476
        return;
3477
    }
3478

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

    
3514
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3515
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3516
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3517

    
3518
                /* WARNING: do no forget half pels */
3519
                src_x = clip(src_x, -16, s->width);
3520
                if (src_x == s->width)
3521
                    dxy &= ~3;
3522
                src_y = clip(src_y, -16, s->height);
3523
                if (src_y == s->height)
3524
                    dxy &= ~12;
3525

    
3526
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3527
                if(s->flags&CODEC_FLAG_EMU_EDGE){
3528
                    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8
3529
                       || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3530
                        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);
3531
                        ptr= s->edge_emu_buffer;
3532
                    }
3533
                }
3534
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3535
                qpix_op[1][dxy](dest, ptr, s->linesize);
3536

    
3537
                mx += s->mv[dir][i][0]/2;
3538
                my += s->mv[dir][i][1]/2;
3539
            }
3540
        }else{
3541
            for(i=0;i<4;i++) {
3542
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3543
                            ref_picture[0], 0, 0,
3544
                            mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3545
                            s->width, s->height, s->linesize,
3546
                            s->h_edge_pos, s->v_edge_pos,
3547
                            8, 8, pix_op[1],
3548
                            s->mv[dir][i][0], s->mv[dir][i][1]);
3549

    
3550
                mx += s->mv[dir][i][0];
3551
                my += s->mv[dir][i][1];
3552
            }
3553
        }
3554

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

    
3584
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3585
                        0, 0, s->field_select[dir][0],
3586
                        ref_picture, pix_op,
3587
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3588
        }
3589
        break;
3590
    case MV_TYPE_16X8:
3591
        for(i=0; i<2; i++){
3592
            uint8_t ** ref2picture;
3593

    
3594
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3595
                ref2picture= ref_picture;
3596
            }else{
3597
                ref2picture= s->current_picture_ptr->data;
3598
            }
3599

    
3600
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3601
                        0, 0, s->field_select[dir][i],
3602
                        ref2picture, pix_op,
3603
                        s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3604

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

    
3629
                // after put we make avg of the same block
3630
                pix_op=s->dsp.avg_pixels_tab;
3631

    
3632
                //opposite parity is always in the same frame if this is second field
3633
                if(!s->first_field){
3634
                    ref_picture = s->current_picture_ptr->data;
3635
                }
3636
            }
3637
        }
3638
    break;
3639
    default: assert(0);
3640
    }
3641
}
3642

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

    
3664
    mb_x = s->mb_x;
3665
    mb_y = s->mb_y;
3666

    
3667
    switch(s->mv_type) {
3668
    case MV_TYPE_16X16:
3669
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3670
                    0, 0, 0,
3671
                    ref_picture, pix_op,
3672
                    s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3673
        break;
3674
    case MV_TYPE_8X8:
3675
        mx = 0;
3676
        my = 0;
3677
            for(i=0;i<4;i++) {
3678
                hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
3679
                            ref_picture[0], 0, 0,
3680
                            (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
3681
                            s->width, s->height, s->linesize,
3682
                            s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
3683
                            block_s, block_s, pix_op,
3684
                            s->mv[dir][i][0], s->mv[dir][i][1]);
3685

    
3686
                mx += s->mv[dir][i][0];
3687
                my += s->mv[dir][i][1];
3688
            }
3689

    
3690
        if(!(s->flags&CODEC_FLAG_GRAY))
3691
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
3692
        break;
3693
    case MV_TYPE_FIELD:
3694
        if (s->picture_structure == PICT_FRAME) {
3695
            /* top field */
3696
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3697
                        1, 0, s->field_select[dir][0],
3698
                        ref_picture, pix_op,
3699
                        s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3700
            /* bottom field */
3701
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3702
                        1, 1, s->field_select[dir][1],
3703
                        ref_picture, pix_op,
3704
                        s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3705
        } else {
3706
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3707
                ref_picture= s->current_picture_ptr->data;
3708
            }
3709

    
3710
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3711
                        0, 0, s->field_select[dir][0],
3712
                        ref_picture, pix_op,
3713
                        s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3714
        }
3715
        break;
3716
    case MV_TYPE_16X8:
3717
        for(i=0; i<2; i++){
3718
            uint8_t ** ref2picture;
3719

    
3720
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3721
                ref2picture= ref_picture;
3722
            }else{
3723
                ref2picture= s->current_picture_ptr->data;
3724
            }
3725

    
3726
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3727
                        0, 0, s->field_select[dir][i],
3728
                        ref2picture, pix_op,
3729
                        s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
3730

    
3731
            dest_y += 2*block_s*s->linesize;
3732
            dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3733
            dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3734
        }
3735
        break;
3736
    case MV_TYPE_DMV:
3737
        if(s->picture_structure == PICT_FRAME){
3738
            for(i=0; i<2; i++){
3739
                int j;
3740
                for(j=0; j<2; j++){
3741
                    mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3742
                                1, j, j^i,
3743
                                ref_picture, pix_op,
3744
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
3745
                }
3746
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3747
            }
3748
        }else{
3749
            for(i=0; i<2; i++){
3750
                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3751
                            0, 0, s->picture_structure != i+1,
3752
                            ref_picture, pix_op,
3753
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
3754

    
3755
                // after put we make avg of the same block
3756
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3757

    
3758
                //opposite parity is always in the same frame if this is second field
3759
                if(!s->first_field){
3760
                    ref_picture = s->current_picture_ptr->data;
3761
                }
3762
            }
3763
        }
3764
    break;
3765
    default: assert(0);
3766
    }
3767
}
3768

    
3769
/* put block[] to dest[] */
3770
static inline void put_dct(MpegEncContext *s,
3771
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3772
{
3773
    s->dct_unquantize_intra(s, block, i, qscale);
3774
    s->dsp.idct_put (dest, line_size, block);
3775
}
3776

    
3777
/* add block[] to dest[] */
3778
static inline void add_dct(MpegEncContext *s,
3779
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
3780
{
3781
    if (s->block_last_index[i] >= 0) {
3782
        s->dsp.idct_add (dest, line_size, block);
3783
    }
3784
}
3785

    
3786
static inline void add_dequant_dct(MpegEncContext *s,
3787
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3788
{
3789
    if (s->block_last_index[i] >= 0) {
3790
        s->dct_unquantize_inter(s, block, i, qscale);
3791

    
3792
        s->dsp.idct_add (dest, line_size, block);
3793
    }
3794
}
3795

    
3796
/**
3797
 * cleans dc, ac, coded_block for the current non intra MB
3798
 */
3799
void ff_clean_intra_table_entries(MpegEncContext *s)
3800
{
3801
    int wrap = s->b8_stride;
3802
    int xy = s->block_index[0];
3803

    
3804
    s->dc_val[0][xy           ] =
3805
    s->dc_val[0][xy + 1       ] =
3806
    s->dc_val[0][xy     + wrap] =
3807
    s->dc_val[0][xy + 1 + wrap] = 1024;
3808
    /* ac pred */
3809
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
3810
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3811
    if (s->msmpeg4_version>=3) {
3812
        s->coded_block[xy           ] =
3813
        s->coded_block[xy + 1       ] =
3814
        s->coded_block[xy     + wrap] =
3815
        s->coded_block[xy + 1 + wrap] = 0;
3816
    }
3817
    /* chroma */
3818
    wrap = s->mb_stride;
3819
    xy = s->mb_x + s->mb_y * wrap;
3820
    s->dc_val[1][xy] =
3821
    s->dc_val[2][xy] = 1024;
3822
    /* ac pred */
3823
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3824
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3825

    
3826
    s->mbintra_table[xy]= 0;
3827
}
3828

    
3829
/* generic function called after a macroblock has been parsed by the
3830
   decoder or after it has been encoded by the encoder.
3831

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

    
3850
    mb_x = s->mb_x;
3851
    mb_y = s->mb_y;
3852

    
3853
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3854
       /* save DCT coefficients */
3855
       int i,j;
3856
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3857
       for(i=0; i<6; i++)
3858
           for(j=0; j<64; j++)
3859
               *dct++ = block[i][s->dsp.idct_permutation[j]];
3860
    }
3861

    
3862
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3863

    
3864
    /* update DC predictors for P macroblocks */
3865
    if (!s->mb_intra) {
3866
        if (s->h263_pred || s->h263_aic) {
3867
            if(s->mbintra_table[mb_xy])
3868
                ff_clean_intra_table_entries(s);
3869
        } else {
3870
            s->last_dc[0] =
3871
            s->last_dc[1] =
3872
            s->last_dc[2] = 128 << s->intra_dc_precision;
3873
        }
3874
    }
3875
    else if (s->h263_pred || s->h263_aic)
3876
        s->mbintra_table[mb_xy]=1;
3877

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

    
3888
        /* avoid copy if macroblock skipped in last frame too */
3889
        /* skip only during decoding as we might trash the buffers during encoding a bit */
3890
        if(!s->encoding){
3891
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3892
            const int age= s->current_picture.age;
3893

    
3894
            assert(age);
3895

    
3896
            if (s->mb_skipped) {
3897
                s->mb_skipped= 0;
3898
                assert(s->pict_type!=I_TYPE);
3899

    
3900
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
3901
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3902

    
3903
                /* if previous was skipped too, then nothing to do !  */
3904
                if (*mbskip_ptr >= age && s->current_picture.reference){
3905
                    return;
3906
                }
3907
            } else if(!s->current_picture.reference){
3908
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3909
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3910
            } else{
3911
                *mbskip_ptr = 0; /* not skipped */
3912
            }
3913
        }
3914

    
3915
        dct_linesize = linesize << s->interlaced_dct;
3916
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3917

    
3918
        if(readable){
3919
            dest_y=  s->dest[0];
3920
            dest_cb= s->dest[1];
3921
            dest_cr= s->dest[2];
3922
        }else{
3923
            dest_y = s->b_scratchpad;
3924
            dest_cb= s->b_scratchpad+16*linesize;
3925
            dest_cr= s->b_scratchpad+32*linesize;
3926
        }
3927

    
3928
        if (!s->mb_intra) {
3929
            /* motion handling */
3930
            /* decoding or more than one mb_type (MC was already done otherwise) */
3931
            if(!s->encoding){
3932
                if(lowres_flag){
3933
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
3934

    
3935
                    if (s->mv_dir & MV_DIR_FORWARD) {
3936
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
3937
                        op_pix = s->dsp.avg_h264_chroma_pixels_tab;
3938
                    }
3939
                    if (s->mv_dir & MV_DIR_BACKWARD) {
3940
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
3941
                    }
3942
                }else{
3943
                    if ((!s->no_rounding) || s->pict_type==B_TYPE){
3944
                        op_pix = s->dsp.put_pixels_tab;
3945
                        op_qpix= s->dsp.put_qpel_pixels_tab;
3946
                    }else{
3947
                        op_pix = s->dsp.put_no_rnd_pixels_tab;
3948
                        op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3949
                    }
3950
                    if (s->mv_dir & MV_DIR_FORWARD) {
3951
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3952
                        op_pix = s->dsp.avg_pixels_tab;
3953
                        op_qpix= s->dsp.avg_qpel_pixels_tab;
3954
                    }
3955
                    if (s->mv_dir & MV_DIR_BACKWARD) {
3956
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3957
                    }
3958
                }
3959
            }
3960

    
3961
            /* skip dequant / idct if we are really late ;) */
3962
            if(s->hurry_up>1) goto skip_idct;
3963
            if(s->avctx->skip_idct){
3964
                if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == B_TYPE)
3965
                   ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != I_TYPE)
3966
                   || s->avctx->skip_idct >= AVDISCARD_ALL)
3967
                    goto skip_idct;
3968
            }
3969

    
3970
            /* add dct residue */
3971
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3972
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3973
                add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3974
                add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3975
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3976
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3977

    
3978
                if(!(s->flags&CODEC_FLAG_GRAY)){
3979
                    if (s->chroma_y_shift){
3980
                        add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3981
                        add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3982
                    }else{
3983
                        dct_linesize >>= 1;
3984
                        dct_offset >>=1;
3985
                        add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
3986
                        add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
3987
                        add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
3988
                        add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
3989
                    }
3990
                }
3991
            } else if(s->codec_id != CODEC_ID_WMV2){
3992
                add_dct(s, block[0], 0, dest_y                          , dct_linesize);
3993
                add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
3994
                add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
3995
                add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3996

    
3997
                if(!(s->flags&CODEC_FLAG_GRAY)){
3998
                    if(s->chroma_y_shift){//Chroma420
3999
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
4000
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
4001
                    }else{
4002
                        //chroma422
4003
                        dct_linesize = uvlinesize << s->interlaced_dct;
4004
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
4005

    
4006
                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
4007
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
4008
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
4009
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
4010
                        if(!s->chroma_x_shift){//Chroma444
4011
                            add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
4012
                            add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
4013
                            add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
4014
                            add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
4015
                        }
4016
                    }
4017
                }//fi gray
4018
            }
4019
            else{
4020
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
4021
            }
4022
        } else {
4023
            /* dct only in intra block */
4024
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
4025
                put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
4026
                put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
4027
                put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
4028
                put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
4029

    
4030
                if(!(s->flags&CODEC_FLAG_GRAY)){
4031
                    if(s->chroma_y_shift){
4032
                        put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
4033
                        put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
4034
                    }else{
4035
                        dct_offset >>=1;
4036
                        dct_linesize >>=1;
4037
                        put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
4038
                        put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
4039
                        put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
4040
                        put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
4041
                    }
4042
                }
4043
            }else{
4044
                s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
4045
                s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
4046
                s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
4047
                s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
4048

    
4049
                if(!(s->flags&CODEC_FLAG_GRAY)){
4050
                    if(s->chroma_y_shift){
4051
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
4052
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
4053
                    }else{
4054

    
4055
                        dct_linesize = uvlinesize << s->interlaced_dct;
4056
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
4057

    
4058
                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
4059
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
4060
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
4061
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
4062
                        if(!s->chroma_x_shift){//Chroma444
4063
                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
4064
                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
4065
                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
4066
                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
4067
                        }
4068
                    }
4069
                }//gray
4070
            }
4071
        }
4072
skip_idct:
4073
        if(!readable){
4074
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
4075
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
4076
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
4077
        }
4078
    }
4079
}
4080

    
4081
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
4082
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
4083
    else                  MPV_decode_mb_internal(s, block, 0);
4084
}
4085

    
4086
#ifdef CONFIG_ENCODERS
4087

    
4088
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
4089
{
4090
    static const char tab[64]=
4091
        {3,2,2,1,1,1,1,1,
4092
         1,1,1,1,1,1,1,1,
4093
         1,1,1,1,1,1,1,1,
4094
         0,0,0,0,0,0,0,0,
4095
         0,0,0,0,0,0,0,0,
4096
         0,0,0,0,0,0,0,0,
4097
         0,0,0,0,0,0,0,0,
4098
         0,0,0,0,0,0,0,0};
4099
    int score=0;
4100
    int run=0;
4101
    int i;
4102
    DCTELEM *block= s->block[n];
4103
    const int last_index= s->block_last_index[n];
4104
    int skip_dc;
4105

    
4106
    if(threshold<0){
4107
        skip_dc=0;
4108
        threshold= -threshold;
4109
    }else
4110
        skip_dc=1;
4111

    
4112
    /* are all which we could set to zero are allready zero? */
4113
    if(last_index<=skip_dc - 1) return;
4114

    
4115
    for(i=0; i<=last_index; i++){
4116
        const int j = s->intra_scantable.permutated[i];
4117
        const int level = ABS(block[j]);
4118
        if(level==1){
4119
            if(skip_dc && i==0) continue;
4120
            score+= tab[run];
4121
            run=0;
4122
        }else if(level>1){
4123
            return;
4124
        }else{
4125
            run++;
4126
        }
4127
    }
4128
    if(score >= threshold) return;
4129
    for(i=skip_dc; i<=last_index; i++){
4130
        const int j = s->intra_scantable.permutated[i];
4131
        block[j]=0;
4132
    }
4133
    if(block[0]) s->block_last_index[n]= 0;
4134
    else         s->block_last_index[n]= -1;
4135
}
4136

    
4137
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
4138
{
4139
    int i;
4140
    const int maxlevel= s->max_qcoeff;
4141
    const int minlevel= s->min_qcoeff;
4142
    int overflow=0;
4143

    
4144
    if(s->mb_intra){
4145
        i=1; //skip clipping of intra dc
4146
    }else
4147
        i=0;
4148

    
4149
    for(;i<=last_index; i++){
4150
        const int j= s->intra_scantable.permutated[i];
4151
        int level = block[j];
4152

    
4153
        if     (level>maxlevel){
4154
            level=maxlevel;
4155
            overflow++;
4156
        }else if(level<minlevel){
4157
            level=minlevel;
4158
            overflow++;
4159
        }
4160

    
4161
        block[j]= level;
4162
    }
4163

    
4164
    if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
4165
        av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel);
4166
}
4167

    
4168
#endif //CONFIG_ENCODERS
4169

    
4170
/**
4171
 *
4172
 * @param h is the normal height, this will be reduced automatically if needed for the last row
4173
 */
4174
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
4175
    if (s->avctx->draw_horiz_band) {
4176
        AVFrame *src;
4177
        int offset[4];
4178

    
4179
        if(s->picture_structure != PICT_FRAME){
4180
            h <<= 1;
4181
            y <<= 1;
4182
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
4183
        }
4184

    
4185
        h= FFMIN(h, s->avctx->height - y);
4186

    
4187
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
4188
            src= (AVFrame*)s->current_picture_ptr;
4189
        else if(s->last_picture_ptr)
4190
            src= (AVFrame*)s->last_picture_ptr;
4191
        else
4192
            return;
4193

    
4194
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
4195
            offset[0]=
4196
            offset[1]=
4197
            offset[2]=
4198
            offset[3]= 0;
4199
        }else{
4200
            offset[0]= y * s->linesize;;
4201
            offset[1]=
4202
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
4203
            offset[3]= 0;
4204
        }
4205

    
4206
        emms_c();
4207

    
4208
        s->avctx->draw_horiz_band(s->avctx, src, offset,
4209
                                  y, s->picture_structure, h);
4210
    }
4211
}
4212

    
4213
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
4214
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
4215
    const int uvlinesize= s->current_picture.linesize[1];
4216
    const int mb_size= 4 - s->avctx->lowres;
4217

    
4218
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
4219
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
4220
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
4221
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
4222
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
4223
    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;
4224
    //block_index is not used by mpeg2, so it is not affected by chroma_format
4225

    
4226
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
4227
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4228
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4229

    
4230
    if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
4231
    {
4232
        s->dest[0] += s->mb_y *   linesize << mb_size;
4233
        s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4234
        s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4235
    }
4236
}
4237

    
4238
#ifdef CONFIG_ENCODERS
4239

    
4240
static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
4241
    int x, y;
4242
//FIXME optimize
4243
    for(y=0; y<8; y++){
4244
        for(x=0; x<8; x++){
4245
            int x2, y2;
4246
            int sum=0;
4247
            int sqr=0;
4248
            int count=0;
4249

    
4250
            for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
4251
                for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
4252
                    int v= ptr[x2 + y2*stride];
4253
                    sum += v;
4254
                    sqr += v*v;
4255
                    count++;
4256
                }
4257
            }
4258
            weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
4259
        }
4260
    }
4261
}
4262

    
4263
static always_inline void encode_mb_internal(MpegEncContext *s, int motion_x, int motion_y, int mb_block_height, int mb_block_count)
4264
{
4265
    int16_t weight[8][64];
4266
    DCTELEM orig[8][64];
4267
    const int mb_x= s->mb_x;
4268
    const int mb_y= s->mb_y;
4269
    int i;
4270
    int skip_dct[8];
4271
    int dct_offset   = s->linesize*8; //default for progressive frames
4272
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
4273
    int wrap_y, wrap_c;
4274

    
4275
    for(i=0; i<mb_block_count; i++) skip_dct[i]=0;
4276

    
4277
    if(s->adaptive_quant){
4278
        const int last_qp= s->qscale;
4279
        const int mb_xy= mb_x + mb_y*s->mb_stride;
4280

    
4281
        s->lambda= s->lambda_table[mb_xy];
4282
        update_qscale(s);
4283

    
4284
        if(!(s->flags&CODEC_FLAG_QP_RD)){
4285
            s->dquant= s->qscale - last_qp;
4286

    
4287
            if(s->out_format==FMT_H263){
4288
                s->dquant= clip(s->dquant, -2, 2); //FIXME RD
4289

    
4290
                if(s->codec_id==CODEC_ID_MPEG4){
4291
                    if(!s->mb_intra){
4292
                        if(s->pict_type == B_TYPE){
4293
                            if(s->dquant&1)
4294
                                s->dquant= (s->dquant/2)*2;
4295
                            if(s->mv_dir&MV_DIRECT)
4296
                                s->dquant= 0;
4297
                        }
4298
                        if(s->mv_type==MV_TYPE_8X8)
4299
                            s->dquant=0;
4300
                    }
4301
                }
4302
            }
4303
        }
4304
        ff_set_qscale(s, last_qp + s->dquant);
4305
    }else if(s->flags&CODEC_FLAG_QP_RD)
4306
        ff_set_qscale(s, s->qscale + s->dquant);
4307

    
4308
    wrap_y = s->linesize;
4309
    wrap_c = s->uvlinesize;
4310
    ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
4311
    ptr_cb = s->new_picture.data[1] + (mb_y * mb_block_height * wrap_c) + mb_x * 8;
4312
    ptr_cr = s->new_picture.data[2] + (mb_y * mb_block_height * wrap_c) + mb_x * 8;
4313

    
4314
    if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
4315
        uint8_t *ebuf= s->edge_emu_buffer + 32;
4316
        ff_emulated_edge_mc(ebuf            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
4317
        ptr_y= ebuf;
4318
        ff_emulated_edge_mc(ebuf+18*wrap_y  , ptr_cb, wrap_c, 8, mb_block_height, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
4319
        ptr_cb= ebuf+18*wrap_y;
4320
        ff_emulated_edge_mc(ebuf+18*wrap_y+8, ptr_cr, wrap_c, 8, mb_block_height, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
4321
        ptr_cr= ebuf+18*wrap_y+8;
4322
    }
4323

    
4324
    if (s->mb_intra) {
4325
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4326
            int progressive_score, interlaced_score;
4327

    
4328
            s->interlaced_dct=0;
4329
            progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8)
4330
                              +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
4331

    
4332
            if(progressive_score > 0){
4333
                interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8)
4334
                                  +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
4335
                if(progressive_score > interlaced_score){
4336
                    s->interlaced_dct=1;
4337

    
4338
                    dct_offset= wrap_y;
4339
                    wrap_y<<=1;
4340
                    if (s->chroma_format == CHROMA_422)
4341
                        wrap_c<<=1;
4342
                }
4343
            }
4344
        }
4345

    
4346
        s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
4347
        s->dsp.get_pixels(s->block[1], ptr_y              + 8, wrap_y);
4348
        s->dsp.get_pixels(s->block[2], ptr_y + dct_offset    , wrap_y);
4349
        s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
4350

    
4351
        if(s->flags&CODEC_FLAG_GRAY){
4352
            skip_dct[4]= 1;
4353
            skip_dct[5]= 1;
4354
        }else{
4355
            s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
4356
            s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
4357
            if(!s->chroma_y_shift){ /* 422 */
4358
                s->dsp.get_pixels(s->block[6], ptr_cb + (dct_offset>>1), wrap_c);
4359
                s->dsp.get_pixels(s->block[7], ptr_cr + (dct_offset>>1), wrap_c);
4360
            }
4361
        }
4362
    }else{
4363
        op_pixels_func (*op_pix)[4];
4364
        qpel_mc_func (*op_qpix)[16];
4365
        uint8_t *dest_y, *dest_cb, *dest_cr;
4366

    
4367
        dest_y  = s->dest[0];
4368
        dest_cb = s->dest[1];
4369
        dest_cr = s->dest[2];
4370

    
4371
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
4372
            op_pix = s->dsp.put_pixels_tab;
4373
            op_qpix= s->dsp.put_qpel_pixels_tab;
4374
        }else{
4375
            op_pix = s->dsp.put_no_rnd_pixels_tab;
4376
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
4377
        }
4378

    
4379
        if (s->mv_dir & MV_DIR_FORWARD) {
4380
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
4381
            op_pix = s->dsp.avg_pixels_tab;
4382
            op_qpix= s->dsp.avg_qpel_pixels_tab;
4383
        }
4384
        if (s->mv_dir & MV_DIR_BACKWARD) {
4385
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
4386
        }
4387

    
4388
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4389
            int progressive_score, interlaced_score;
4390

    
4391
            s->interlaced_dct=0;
4392
            progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8)
4393
                              +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
4394

    
4395
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
4396

    
4397
            if(progressive_score>0){
4398
                interlaced_score = s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y*2, 8)
4399
                                  +s->dsp.ildct_cmp[0](s, dest_y + wrap_y  , ptr_y + wrap_y  , wrap_y*2, 8);
4400

    
4401
                if(progressive_score > interlaced_score){
4402
                    s->interlaced_dct=1;
4403

    
4404
                    dct_offset= wrap_y;
4405
                    wrap_y<<=1;
4406
                    if (s->chroma_format == CHROMA_422)
4407
                        wrap_c<<=1;
4408
                }
4409
            }
4410
        }
4411

    
4412
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
4413
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
4414
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
4415
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
4416

    
4417
        if(s->flags&CODEC_FLAG_GRAY){
4418
            skip_dct[4]= 1;
4419
            skip_dct[5]= 1;
4420
        }else{
4421
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
4422
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
4423
            if(!s->chroma_y_shift){ /* 422 */
4424
                s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset>>1), dest_cb + (dct_offset>>1), wrap_c);
4425
                s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset>>1), dest_cr + (dct_offset>>1), wrap_c);
4426
            }
4427
        }
4428
        /* pre quantization */
4429
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
4430
            //FIXME optimize
4431
            if(s->dsp.sad[1](NULL, ptr_y               , dest_y               , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
4432
            if(s->dsp.sad[1](NULL, ptr_y            + 8, dest_y            + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
4433
            if(s->dsp.sad[1](NULL, ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
4434
            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;
4435
            if(s->dsp.sad[1](NULL, ptr_cb              , dest_cb              , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
4436
            if(s->dsp.sad[1](NULL, ptr_cr              , dest_cr              , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
4437
            if(!s->chroma_y_shift){ /* 422 */
4438
                if(s->dsp.sad[1](NULL, ptr_cb +(dct_offset>>1), dest_cb +(dct_offset>>1), wrap_c, 8) < 20*s->qscale) skip_dct[6]= 1;
4439
                if(s->dsp.sad[1](NULL, ptr_cr +(dct_offset>>1), dest_cr +(dct_offset>>1), wrap_c, 8) < 20*s->qscale) skip_dct[7]= 1;
4440
            }
4441
        }
4442
    }
4443

    
4444
    if(s->avctx->quantizer_noise_shaping){
4445
        if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y                 , wrap_y);
4446
        if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y              + 8, wrap_y);
4447
        if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset    , wrap_y);
4448
        if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
4449
        if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb                , wrap_c);
4450
        if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr                , wrap_c);
4451
        if(!s->chroma_y_shift){ /* 422 */
4452
            if(!skip_dct[6]) get_vissual_weight(weight[6], ptr_cb + (dct_offset>>1), wrap_c);
4453
            if(!skip_dct[7]) get_vissual_weight(weight[7], ptr_cr + (dct_offset>>1), wrap_c);
4454
        }
4455
        memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*mb_block_count);
4456
    }
4457

    
4458
    /* DCT & quantize */
4459
    assert(s->out_format!=FMT_MJPEG || s->qscale==8);
4460
    {
4461
        for(i=0;i<mb_block_count;i++) {
4462
            if(!skip_dct[i]){
4463
                int overflow;
4464
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
4465
            // FIXME we could decide to change to quantizer instead of clipping
4466
            // JS: I don't think that would be a good idea it could lower quality instead
4467
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
4468
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
4469
            }else
4470
                s->block_last_index[i]= -1;
4471
        }
4472
        if(s->avctx->quantizer_noise_shaping){
4473
            for(i=0;i<mb_block_count;i++) {
4474
                if(!skip_dct[i]){
4475
                    s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
4476
                }
4477
            }
4478
        }
4479

    
4480
        if(s->luma_elim_threshold && !s->mb_intra)
4481
            for(i=0; i<4; i++)
4482
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
4483
        if(s->chroma_elim_threshold && !s->mb_intra)
4484
            for(i=4; i<mb_block_count; i++)
4485
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
4486

    
4487
        if(s->flags & CODEC_FLAG_CBP_RD){
4488
            for(i=0;i<mb_block_count;i++) {
4489
                if(s->block_last_index[i] == -1)
4490
                    s->coded_score[i]= INT_MAX/256;
4491
            }
4492
        }
4493
    }
4494

    
4495
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
4496
        s->block_last_index[4]=
4497
        s->block_last_index[5]= 0;
4498
        s->block[4][0]=
4499
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
4500
    }
4501

    
4502
    //non c quantize code returns incorrect block_last_index FIXME
4503
    if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
4504
        for(i=0; i<mb_block_count; i++){
4505
            int j;
4506
            if(s->block_last_index[i]>0){
4507
                for(j=63; j>0; j--){
4508
                    if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
4509
                }
4510
                s->block_last_index[i]= j;
4511
            }
4512
        }
4513
    }
4514

    
4515
    /* huffman encode */
4516
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
4517
    case CODEC_ID_MPEG1VIDEO:
4518
    case CODEC_ID_MPEG2VIDEO:
4519
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
4520
    case CODEC_ID_MPEG4:
4521
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4522
    case CODEC_ID_MSMPEG4V2:
4523
    case CODEC_ID_MSMPEG4V3:
4524
    case CODEC_ID_WMV1:
4525
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4526
    case CODEC_ID_WMV2:
4527
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
4528
#ifdef CONFIG_H261_ENCODER
4529
    case CODEC_ID_H261:
4530
        ff_h261_encode_mb(s, s->block, motion_x, motion_y); break;
4531
#endif
4532
    case CODEC_ID_H263:
4533
    case CODEC_ID_H263P:
4534
    case CODEC_ID_FLV1:
4535
    case CODEC_ID_RV10:
4536
    case CODEC_ID_RV20:
4537
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
4538
    case CODEC_ID_MJPEG:
4539
        mjpeg_encode_mb(s, s->block); break;
4540
    default:
4541
        assert(0);
4542
    }
4543
}
4544

    
4545
static always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
4546
{
4547
    if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y,  8, 6);
4548
    else                                encode_mb_internal(s, motion_x, motion_y, 16, 8);
4549
}
4550

    
4551
#endif //CONFIG_ENCODERS
4552

    
4553
void ff_mpeg_flush(AVCodecContext *avctx){
4554
    int i;
4555
    MpegEncContext *s = avctx->priv_data;
4556

    
4557
    if(s==NULL || s->picture==NULL)
4558
        return;
4559

    
4560
    for(i=0; i<MAX_PICTURE_COUNT; i++){
4561
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
4562
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
4563
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
4564
    }
4565
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
4566

    
4567
    s->mb_x= s->mb_y= 0;
4568

    
4569
    s->parse_context.state= -1;
4570
    s->parse_context.frame_start_found= 0;
4571
    s->parse_context.overread= 0;
4572
    s->parse_context.overread_index= 0;
4573
    s->parse_context.index= 0;
4574
    s->parse_context.last_index= 0;
4575
    s->bitstream_buffer_size=0;
4576
}
4577

    
4578
#ifdef CONFIG_ENCODERS
4579
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4580
{
4581
    const uint16_t *srcw= (uint16_t*)src;
4582
    int words= length>>4;
4583
    int bits= length&15;
4584
    int i;
4585

    
4586
    if(length==0) return;
4587

    
4588
    if(words < 16){
4589
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4590
    }else if(put_bits_count(pb)&7){
4591
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4592
    }else{
4593
        for(i=0; put_bits_count(pb)&31; i++)
4594
            put_bits(pb, 8, src[i]);
4595
        flush_put_bits(pb);
4596
        memcpy(pbBufPtr(pb), src+i, 2*words-i);
4597
        skip_put_bytes(pb, 2*words-i);
4598
    }
4599

    
4600
    put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
4601
}
4602

    
4603
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
4604
    int i;
4605

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

    
4608
    /* mpeg1 */
4609
    d->mb_skip_run= s->mb_skip_run;
4610
    for(i=0; i<3; i++)
4611
        d->last_dc[i]= s->last_dc[i];
4612

    
4613
    /* statistics */
4614
    d->mv_bits= s->mv_bits;
4615
    d->i_tex_bits= s->i_tex_bits;
4616
    d->p_tex_bits= s->p_tex_bits;
4617
    d->i_count= s->i_count;
4618
    d->f_count= s->f_count;
4619
    d->b_count= s->b_count;
4620
    d->skip_count= s->skip_count;
4621
    d->misc_bits= s->misc_bits;
4622
    d->last_bits= 0;
4623

    
4624
    d->mb_skipped= 0;
4625
    d->qscale= s->qscale;
4626
    d->dquant= s->dquant;
4627
}
4628

    
4629
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
4630
    int i;
4631

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

    
4635
    /* mpeg1 */
4636
    d->mb_skip_run= s->mb_skip_run;
4637
    for(i=0; i<3; i++)
4638
        d->last_dc[i]= s->last_dc[i];
4639

    
4640
    /* statistics */
4641
    d->mv_bits= s->mv_bits;
4642
    d->i_tex_bits= s->i_tex_bits;
4643
    d->p_tex_bits= s->p_tex_bits;
4644
    d->i_count= s->i_count;
4645
    d->f_count= s->f_count;
4646
    d->b_count= s->b_count;
4647
    d->skip_count= s->skip_count;
4648
    d->misc_bits= s->misc_bits;
4649

    
4650
    d->mb_intra= s->mb_intra;
4651
    d->mb_skipped= s->mb_skipped;
4652
    d->mv_type= s->mv_type;
4653
    d->mv_dir= s->mv_dir;