Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 2d974017

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 "fastmemcpy.h"
36
#endif
37

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

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

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

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

    
75

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

    
79
//#define DEBUG
80

    
81

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
199
    st->scantable= src_scantable;
200

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

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

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

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

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

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

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

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

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

    
260
    return p+4;
261
}
262

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

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

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

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

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

    
306
#endif //CONFIG_ENCODERS
307

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

    
321
    return 0;
322
}
323

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
601
    s->picture_in_gop_number = 0;
602

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

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

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

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

    
624
    MPV_common_defaults(s);
625

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
814
    s->context_initialized = 1;
815

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

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

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

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

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

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

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

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

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

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

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

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

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

    
919
#ifdef CONFIG_ENCODERS
920

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

    
928
    MPV_encode_defaults(s);
929

    
930
    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_ERROR, "b_frame_strategy must be 0 on the second pass\n");
1127
        return -1;
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
#ifdef STATS
1375
    print_stats();
1376
#endif
1377

    
1378
    ff_rate_control_uninit(s);
1379

    
1380
    MPV_common_end(s);
1381
    if (s->out_format == FMT_MJPEG)
1382
        mjpeg_close(s);
1383

    
1384
    av_freep(&avctx->extradata);
1385

    
1386
    return 0;
1387
}
1388

    
1389
#endif //CONFIG_ENCODERS
1390

    
1391
void init_rl(RLTable *rl, int use_static)
1392
{
1393
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1394
    uint8_t index_run[MAX_RUN+1];
1395
    int last, run, level, start, end, i;
1396

    
1397
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
1398
    if(use_static && rl->max_level[0])
1399
        return;
1400

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

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

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

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

    
1471
int ff_find_unused_picture(MpegEncContext *s, int shared){
1472
    int i;
1473

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

    
1487
    assert(0);
1488
    return -1;
1489
}
1490

    
1491
static void update_noise_reduction(MpegEncContext *s){
1492
    int intra, i;
1493

    
1494
    for(intra=0; intra<2; intra++){
1495
        if(s->dct_count[intra] > (1<<16)){
1496
            for(i=0; i<64; i++){
1497
                s->dct_error_sum[intra][i] >>=1;
1498
            }
1499
            s->dct_count[intra] >>= 1;
1500
        }
1501

    
1502
        for(i=0; i<64; i++){
1503
            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);
1504
        }
1505
    }
1506
}
1507

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

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

    
1519
    /* mark&release old frames */
1520
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1521
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1522

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

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

    
1550
        pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1551
                        && !s->dropable ? 3 : 0;
1552

    
1553
        pic->coded_picture_number= s->coded_picture_number++;
1554

    
1555
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1556
            return -1;
1557

    
1558
        s->current_picture_ptr= (Picture*)pic;
1559
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1560
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1561
    }
1562

    
1563
    s->current_picture_ptr->pict_type= s->pict_type;
1564
//    if(s->flags && CODEC_FLAG_QSCALE)
1565
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1566
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1567

    
1568
    copy_picture(&s->current_picture, s->current_picture_ptr);
1569

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

    
1582
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1583
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1584

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

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

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

    
1606
    s->hurry_up= s->avctx->hurry_up;
1607
    s->error_resilience= avctx->error_resilience;
1608

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

    
1622
    if(s->dct_error_sum){
1623
        assert(s->avctx->noise_reduction && s->encoding);
1624

    
1625
        update_noise_reduction(s);
1626
    }
1627

    
1628
#ifdef HAVE_XVMC
1629
    if(s->avctx->xvmc_acceleration)
1630
        return XVMC_field_start(s, avctx);
1631
#endif
1632
    return 0;
1633
}
1634

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

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

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

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

    
1696
    sx= clip(sx, 0, w-1);
1697
    sy= clip(sy, 0, h-1);
1698
    ex= clip(ex, 0, w-1);
1699
    ey= clip(ey, 0, h-1);
1700

    
1701
    buf[sy*stride + sx]+= color;
1702

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

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

    
1745
    sx= clip(sx, -100, w+100);
1746
    sy= clip(sy, -100, h+100);
1747
    ex= clip(ex, -100, w+100);
1748
    ey= clip(ey, -100, h+100);
1749

    
1750
    dx= ex - sx;
1751
    dy= ey - sy;
1752

    
1753
    if(dx*dx + dy*dy > 3*3){
1754
        int rx=  dx + dy;
1755
        int ry= -dx + dy;
1756
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1757

    
1758
        //FIXME subpixel accuracy
1759
        rx= ROUNDED_DIV(rx*3<<4, length);
1760
        ry= ROUNDED_DIV(ry*3<<4, length);
1761

    
1762
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1763
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1764
    }
1765
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1766
}
1767

    
1768
/**
1769
 * prints debuging info for the given picture.
1770
 */
1771
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1772

    
1773
    if(!pict || !pict->mb_type) return;
1774

    
1775
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1776
        int x,y;
1777

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

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

    
1839

    
1840
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1841
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1842
                    else
1843
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1844
                }
1845
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1846
            }
1847
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1848
        }
1849
    }
1850

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

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

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

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

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

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

    
1929
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1930
                            my*=2;
1931

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

    
1960

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

    
1987
                    u*= 0x0101010101010101ULL;
1988
                    v*= 0x0101010101010101ULL;
1989
                    for(y=0; y<8; y++){
1990
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1991
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1992
                    }
1993

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

    
2019
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
2020
                        // hmm
2021
                    }
2022
                }
2023
                s->mbskip_table[mb_index]=0;
2024
            }
2025
        }
2026
    }
2027
}
2028

    
2029
#ifdef CONFIG_ENCODERS
2030

    
2031
static int get_sae(uint8_t *src, int ref, int stride){
2032
    int x,y;
2033
    int acc=0;
2034

    
2035
    for(y=0; y<16; y++){
2036
        for(x=0; x<16; x++){
2037
            acc+= ABS(src[x+y*stride] - ref);
2038
        }
2039
    }
2040

    
2041
    return acc;
2042
}
2043

    
2044
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
2045
    int x, y, w, h;
2046
    int acc=0;
2047

    
2048
    w= s->width &~15;
2049
    h= s->height&~15;
2050

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

    
2058
            acc+= sae + 500 < sad;
2059
        }
2060
    }
2061
    return acc;
2062
}
2063

    
2064

    
2065
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2066
    AVFrame *pic=NULL;
2067
    int64_t pts;
2068
    int i;
2069
    const int encoding_delay= s->max_b_frames;
2070
    int direct=1;
2071

    
2072
    if(pic_arg){
2073
        pts= pic_arg->pts;
2074
        pic_arg->display_picture_number= s->input_picture_number++;
2075

    
2076
        if(pts != AV_NOPTS_VALUE){
2077
            if(s->user_specified_pts != AV_NOPTS_VALUE){
2078
                int64_t time= pts;
2079
                int64_t last= s->user_specified_pts;
2080

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

    
2098
  if(pic_arg){
2099
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2100
    if(pic_arg->linesize[0] != s->linesize) direct=0;
2101
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2102
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2103

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

    
2106
    if(direct){
2107
        i= ff_find_unused_picture(s, 1);
2108

    
2109
        pic= (AVFrame*)&s->picture[i];
2110
        pic->reference= 3;
2111

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

    
2120
        pic= (AVFrame*)&s->picture[i];
2121
        pic->reference= 3;
2122

    
2123
        alloc_picture(s, (Picture*)pic, 0);
2124

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

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

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

    
2159
    /* shift buffer entries */
2160
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2161
        s->input_picture[i-1]= s->input_picture[i];
2162

    
2163
    s->input_picture[encoding_delay]= (Picture*)pic;
2164

    
2165
    return 0;
2166
}
2167

    
2168
static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2169
    int x, y, plane;
2170
    int score=0;
2171
    int64_t score64=0;
2172

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

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

    
2192
    if(score) score64= score;
2193

    
2194
    if(score64 < s->avctx->frame_skip_threshold)
2195
        return 1;
2196
    if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2197
        return 1;
2198
    return 0;
2199
}
2200

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

    
2212
    assert(scale>=0 && scale <=3);
2213

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

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

    
2232
    if (avcodec_open(c, codec) < 0)
2233
        return -1;
2234

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

    
2240
        if(pre_input_ptr)
2241
            pre_input= *pre_input_ptr;
2242

    
2243
        if(pre_input.type != FF_BUFFER_TYPE_SHARED && i){
2244
            pre_input.data[0]+=INPLACE_OFFSET;
2245
            pre_input.data[1]+=INPLACE_OFFSET;
2246
            pre_input.data[2]+=INPLACE_OFFSET;
2247
        }
2248

    
2249
        avcodec_get_frame_defaults(&input[i]);
2250
        input[i].data[0]= av_malloc(ysize + 2*csize);
2251
        input[i].data[1]= input[i].data[0] + ysize;
2252
        input[i].data[2]= input[i].data[1] + csize;
2253
        input[i].linesize[0]= c->width;
2254
        input[i].linesize[1]=
2255
        input[i].linesize[2]= c->width/2;
2256

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

    
2264
    for(j=0; j<s->max_b_frames+1; j++){
2265
        int64_t rd=0;
2266

    
2267
        if(!s->input_picture[j])
2268
            break;
2269

    
2270
        c->error[0]= c->error[1]= c->error[2]= 0;
2271

    
2272
        input[0].pict_type= I_TYPE;
2273
        input[0].quality= 1 * FF_QP2LAMBDA;
2274
        out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
2275
//        rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2276

    
2277
        for(i=0; i<s->max_b_frames+1; i++){
2278
            int is_p= i % (j+1) == j || i==s->max_b_frames;
2279

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

    
2286
        /* get the delayed frames */
2287
        while(out_size){
2288
            out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
2289
            rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2290
        }
2291

    
2292
        rd += c->error[0] + c->error[1] + c->error[2];
2293

    
2294
        if(rd < best_rd){
2295
            best_rd= rd;
2296
            best_b_count= j;
2297
        }
2298
    }
2299

    
2300
    av_freep(&outbuf);
2301
    avcodec_close(c);
2302
    av_freep(&c);
2303

    
2304
    for(i=0; i<s->max_b_frames+2; i++){
2305
        av_freep(&input[i].data[0]);
2306
    }
2307

    
2308
    return best_b_count;
2309
}
2310

    
2311
static void select_input_picture(MpegEncContext *s){
2312
    int i;
2313

    
2314
    for(i=1; i<MAX_PICTURE_COUNT; i++)
2315
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2316
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2317

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

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

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

    
2340
                        s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2341
                    }
2342

    
2343
                    emms_c();
2344
                    ff_vbv_update(s, 0);
2345

    
2346
                    goto no_output_pic;
2347
                }
2348
            }
2349

    
2350
            if(s->flags&CODEC_FLAG_PASS2){
2351
                for(i=0; i<s->max_b_frames+1; i++){
2352
                    int pict_num= s->input_picture[0]->display_picture_number + i;
2353

    
2354
                    if(pict_num >= s->rc_context.num_entries)
2355
                        break;
2356
                    if(!s->input_picture[i]){
2357
                        s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2358
                        break;
2359
                    }
2360

    
2361
                    s->input_picture[i]->pict_type=
2362
                        s->rc_context.entry[pict_num].new_pict_type;
2363
                }
2364
            }
2365

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

    
2381
                b_frames= FFMAX(0, i-1);
2382

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

    
2394
            emms_c();
2395
//static int b_count=0;
2396
//b_count+= b_frames;
2397
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2398

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

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

    
2418
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2419
               && b_frames
2420
               && s->input_picture[b_frames]->pict_type== I_TYPE)
2421
                b_frames--;
2422

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

    
2438
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2439

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

    
2443
            int i= ff_find_unused_picture(s, 0);
2444
            Picture *pic= &s->picture[i];
2445

    
2446
            /* mark us unused / free shared pic */
2447
            for(i=0; i<4; i++)
2448
                s->reordered_input_picture[0]->data[i]= NULL;
2449
            s->reordered_input_picture[0]->type= 0;
2450

    
2451
            pic->reference              = s->reordered_input_picture[0]->reference;
2452

    
2453
            alloc_picture(s, pic, 0);
2454

    
2455
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2456

    
2457
            s->current_picture_ptr= pic;
2458
        }else{
2459
            // input is not a shared pix -> reuse buffer for current_pix
2460

    
2461
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2462
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2463

    
2464
            s->current_picture_ptr= s->reordered_input_picture[0];
2465
            for(i=0; i<4; i++){
2466
                s->new_picture.data[i]+= INPLACE_OFFSET;
2467
            }
2468
        }
2469
        copy_picture(&s->current_picture, s->current_picture_ptr);
2470

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

    
2478
int MPV_encode_picture(AVCodecContext *avctx,
2479
                       unsigned char *buf, int buf_size, void *data)
2480
{
2481
    MpegEncContext *s = avctx->priv_data;
2482
    AVFrame *pic_arg = data;
2483
    int i, stuffing_count;
2484

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

    
2492
        init_put_bits(&s->thread_context[i]->pb, start, end - start);
2493
    }
2494

    
2495
    s->picture_in_gop_number++;
2496

    
2497
    if(load_input_picture(s, pic_arg) < 0)
2498
        return -1;
2499

    
2500
    select_input_picture(s);
2501

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

    
2509
        encode_picture(s, s->picture_number);
2510

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

    
2521
        MPV_frame_end(s);
2522

    
2523
        if (s->out_format == FMT_MJPEG)
2524
            mjpeg_picture_trailer(s);
2525

    
2526
        if(s->flags&CODEC_FLAG_PASS1)
2527
            ff_write_pass1_stats(s);
2528

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

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

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

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

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

    
2573
            assert(s->repeat_first_field==0);
2574

    
2575
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2576
            assert(vbv_delay < 0xFFFF);
2577

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

    
2592
    return s->frame_bits/8;
2593
}
2594

    
2595
#endif //CONFIG_ENCODERS
2596

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

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

    
2619
    linesize = s->linesize;
2620
    uvlinesize = s->uvlinesize;
2621

    
2622
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2623

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

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

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

    
2646
    if(s->flags&CODEC_FLAG_GRAY) return;
2647

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

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

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

    
2680
    return;
2681
}
2682

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

    
2692
    linesize = s->linesize;
2693
    uvlinesize = s->uvlinesize;
2694

    
2695
    ptr = ref_picture[0];
2696

    
2697
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2698
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2699

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

    
2715
    if(s->flags&CODEC_FLAG_GRAY) return;
2716

    
2717
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2718
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2719

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

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

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

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

    
2771
    start_y= FFMAX(0, -src_y);
2772
    start_x= FFMAX(0, -src_x);
2773
    end_y= FFMIN(block_h, h-src_y);
2774
    end_x= FFMIN(block_w, w-src_x);
2775

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

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

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

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

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

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

    
2822
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2823
    src_x += motion_x >> 1;
2824
    src_y += motion_y >> 1;
2825

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

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

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

    
2864
    if(s->quarter_sample){
2865
        motion_x/=2;
2866
        motion_y/=2;
2867
    }
2868

    
2869
    sx= motion_x & s_mask;
2870
    sy= motion_y & s_mask;
2871
    src_x += motion_x >> (lowres+1);
2872
    src_y += motion_y >> (lowres+1);
2873

    
2874
    src += src_y * stride + src_x;
2875

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

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

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

    
2902
#if 0
2903
if(s->quarter_sample)
2904
{
2905
    motion_x>>=1;
2906
    motion_y>>=1;
2907
}
2908
#endif
2909

    
2910
    v_edge_pos = s->v_edge_pos >> field_based;
2911
    linesize   = s->current_picture.linesize[0] << field_based;
2912
    uvlinesize = s->current_picture.linesize[1] << field_based;
2913

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

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

    
2959
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2960
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2961
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2962

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

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

    
2990
    if(field_select){
2991
        ptr_y += s->linesize;
2992
        ptr_cb+= s->uvlinesize;
2993
        ptr_cr+= s->uvlinesize;
2994
    }
2995

    
2996
    pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2997

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

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

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

    
3031
    if(field_based){
3032
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
3033
    }
3034

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

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

    
3061
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
3062
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3063
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3064

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

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

    
3087
    if(field_select){
3088
        ptr_y += s->linesize;
3089
        ptr_cb+= s->uvlinesize;
3090
        ptr_cr+= s->uvlinesize;
3091
    }
3092

    
3093
    sx <<= 2 - lowres;
3094
    sy <<= 2 - lowres;
3095
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
3096

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

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

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

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

    
3169
    assert(s->quarter_sample==0);
3170

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

    
3185
    put_obmc(dest, ptr, s->linesize);
3186
}
3187

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

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

    
3202
    v_edge_pos = s->v_edge_pos >> field_based;
3203
    linesize = s->linesize << field_based;
3204
    uvlinesize = s->uvlinesize << field_based;
3205

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

    
3223
    uvdxy= (mx&1) | ((my&1)<<1);
3224
    mx>>=1;
3225
    my>>=1;
3226

    
3227
    uvsrc_x = s->mb_x *  8                 + mx;
3228
    uvsrc_y = s->mb_y * (8 >> field_based) + my;
3229

    
3230
    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
3231
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3232
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3233

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

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

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

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

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

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

    
3300
    dxy = ((my & 1) << 1) | (mx & 1);
3301
    mx >>= 1;
3302
    my >>= 1;
3303

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

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

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

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

    
3346
    if(s->quarter_sample){
3347
        mx/=2;
3348
        my/=2;
3349
    }
3350

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

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

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

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

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

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

    
3416
    mb_x = s->mb_x;
3417
    mb_y = s->mb_y;
3418

    
3419
    prefetch_motion(s, ref_picture, dir);
3420

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

    
3427
        assert(!s->mb_skipped);
3428

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

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

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

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

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

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

    
3479
        return;
3480
    }
3481

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

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

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

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

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

    
3553
                mx += s->mv[dir][i][0];
3554
                my += s->mv[dir][i][1];
3555
            }
3556
        }
3557

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

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

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

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

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

    
3632
                // after put we make avg of the same block
3633
                pix_op=s->dsp.avg_pixels_tab;
3634

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

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

    
3667
    mb_x = s->mb_x;
3668
    mb_y = s->mb_y;
3669

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

    
3689
                mx += s->mv[dir][i][0];
3690
                my += s->mv[dir][i][1];
3691
            }
3692

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

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

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

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

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

    
3758
                // after put we make avg of the same block
3759
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3760

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

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

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

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

    
3795
        s->dsp.idct_add (dest, line_size, block);
3796
    }
3797
}
3798

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

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

    
3829
    s->mbintra_table[xy]= 0;
3830
}
3831

    
3832
/* generic function called after a macroblock has been parsed by the
3833
   decoder or after it has been encoded by the encoder.
3834

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

    
3853
    mb_x = s->mb_x;
3854
    mb_y = s->mb_y;
3855

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

    
3865
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3866

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

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

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

    
3897
            assert(age);
3898

    
3899
            if (s->mb_skipped) {
3900
                s->mb_skipped= 0;
3901
                assert(s->pict_type!=I_TYPE);
3902

    
3903
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
3904
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3905

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

    
3918
        dct_linesize = linesize << s->interlaced_dct;
3919
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3920

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

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

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

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

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

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

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

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

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

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

    
4058
                        dct_linesize = uvlinesize << s->interlaced_dct;
4059
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
4060

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

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

    
4089
#ifdef CONFIG_ENCODERS
4090

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

    
4109
    if(threshold<0){
4110
        skip_dc=0;
4111
        threshold= -threshold;
4112
    }else
4113
        skip_dc=1;
4114

    
4115
    /* are all which we could set to zero are allready zero? */
4116
    if(last_index<=skip_dc - 1) return;
4117

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

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

    
4147
    if(s->mb_intra){
4148
        i=1; //skip clipping of intra dc
4149
    }else
4150
        i=0;
4151

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

    
4156
        if     (level>maxlevel){
4157
            level=maxlevel;
4158
            overflow++;
4159
        }else if(level<minlevel){
4160
            level=minlevel;
4161
            overflow++;
4162
        }
4163

    
4164
        block[j]= level;
4165
    }
4166

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

    
4171
#endif //CONFIG_ENCODERS
4172

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

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

    
4188
        h= FFMIN(h, s->avctx->height - y);
4189

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

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

    
4209
        emms_c();
4210

    
4211
        s->avctx->draw_horiz_band(s->avctx, src, offset,
4212
                                  y, s->picture_structure, h);
4213
    }
4214
}
4215

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

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

    
4229
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
4230
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4231
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4232

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

    
4241
#ifdef CONFIG_ENCODERS
4242

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

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

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

    
4278
    for(i=0; i<mb_block_count; i++) skip_dct[i]=0;
4279

    
4280
    if(s->adaptive_quant){
4281
        const int last_qp= s->qscale;
4282
        const int mb_xy= mb_x + mb_y*s->mb_stride;
4283

    
4284
        s->lambda= s->lambda_table[mb_xy];
4285
        update_qscale(s);
4286

    
4287
        if(!(s->flags&CODEC_FLAG_QP_RD)){
4288
            s->dquant= s->qscale - last_qp;
4289

    
4290
            if(s->out_format==FMT_H263){
4291
                s->dquant= clip(s->dquant, -2, 2); //FIXME RD
4292

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

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

    
4317
    if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
4318
        uint8_t *ebuf= s->edge_emu_buffer + 32;
4319
        ff_emulated_edge_mc(ebuf            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
4320
        ptr_y= ebuf;
4321
        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);
4322
        ptr_cb= ebuf+18*wrap_y;
4323
        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);
4324
        ptr_cr= ebuf+18*wrap_y+8;
4325
    }
4326

    
4327
    if (s->mb_intra) {
4328
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4329
            int progressive_score, interlaced_score;
4330

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

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

    
4341
                    dct_offset= wrap_y;
4342
                    wrap_y<<=1;
4343
                    if (s->chroma_format == CHROMA_422)
4344
                        wrap_c<<=1;
4345
                }
4346
            }
4347
        }
4348

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

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

    
4370
        dest_y  = s->dest[0];
4371
        dest_cb = s->dest[1];
4372
        dest_cr = s->dest[2];
4373

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

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

    
4391
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4392
            int progressive_score, interlaced_score;
4393

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

    
4398
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
4399

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

    
4404
                if(progressive_score > interlaced_score){
4405
                    s->interlaced_dct=1;
4406

    
4407
                    dct_offset= wrap_y;
4408
                    wrap_y<<=1;
4409
                    if (s->chroma_format == CHROMA_422)
4410
                        wrap_c<<=1;
4411
                }
4412
            }
4413
        }
4414

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

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

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

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

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

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

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

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

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

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

    
4554
#endif //CONFIG_ENCODERS
4555

    
4556
void ff_mpeg_flush(AVCodecContext *avctx){
4557
    int i;
4558
    MpegEncContext *s = avctx->priv_data;
4559

    
4560
    if(s==NULL || s->picture==NULL)
4561
        return;
4562

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

    
4570
    s->mb_x= s->mb_y= 0;
4571

    
4572
    s->parse_context.state= -1;
4573
    s->parse_context.frame_start_found= 0;
4574
    s->parse_context.overread= 0;
4575
    s->parse_context.overread_index= 0;
4576
    s->parse_context.index= 0;
4577
    s->parse_context.last_index= 0;
4578
    s->bitstream_buffer_size=0;
4579
}
4580

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

    
4589
    if(length==0) return;
4590

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

    
4603
    put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
4604
}
4605

    
4606
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
4607
    int i;
4608

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

    
4611
    /* mpeg1 */
4612
    d->mb_skip_run= s->mb_skip_run;
4613
    for(i=0; i<3; i++)
4614
        d->last_dc[i]= s->last_dc[i];
4615

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

    
4627
    d->mb_skipped= 0;
4628
    d->qscale= s->qscale;
4629
    d->dquant= s->dquant;
4630
}
4631

    
4632
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
4633
    int i;
4634

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

    
4638
    /* mpeg1 */
4639
    d->mb_skip_run= s->mb_skip_run;
4640
    for(i=0; i<3; i++)
4641
        d->last_dc[i]= s->last_dc[i];
4642

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

    
4653
    d->mb_intra= s->mb_intra;
4654
    d->mb_skipped= s->mb_skipped;
4655
    d->mv_type= s-&