Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ f66e4f5f

History | View | Annotate | Download (251 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 file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 * Lesser General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 *
22
 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
23
 */
24

    
25
/**
26
 * @file mpegvideo.c
27
 * The simplest mpeg encoder (well, it was the simplest!).
28
 */
29

    
30
#include "avcodec.h"
31
#include "dsputil.h"
32
#include "mpegvideo.h"
33
#include "faandct.h"
34
#include <limits.h>
35

    
36
#ifdef USE_FASTMEMCPY
37
#include "libvo/fastmemcpy.h"
38
#endif
39

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

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

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

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

    
77

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

    
81
//#define DEBUG
82

    
83

    
84
/* for jpeg fast DCT */
85
#define CONST_BITS 14
86

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

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

    
104
static const uint8_t ff_default_chroma_qscale_table[32]={
105
//  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
106
    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
107
};
108

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

    
113
enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
114

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

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

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

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

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

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

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

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

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

    
201
    st->scantable= src_scantable;
202

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

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

    
221
#ifdef CONFIG_ENCODERS
222
void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix){
223
    int i;
224

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

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

    
238
    assert(p<=end);
239
    if(p>=end)
240
        return end;
241

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

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

    
259
    p= FFMIN(p, end)-4;
260
    *state=  be2me_32(unaligned32(p));
261

    
262
    return p+4;
263
}
264

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

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

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

    
301
#ifdef CONFIG_ENCODERS
302
    s->fast_dct_quantize= s->dct_quantize;
303

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

    
308
#endif //CONFIG_ENCODERS
309

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

    
323
    return 0;
324
}
325

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

    
331
#ifdef CONFIG_ENCODERS
332
static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
333
    int i;
334

    
335
    dst->pict_type              = src->pict_type;
336
    dst->quality                = src->quality;
337
    dst->coded_picture_number   = src->coded_picture_number;
338
    dst->display_picture_number = src->display_picture_number;
339
//    dst->reference              = src->reference;
340
    dst->pts                    = src->pts;
341
    dst->interlaced_frame       = src->interlaced_frame;
342
    dst->top_field_first        = src->top_field_first;
343

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

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

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

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

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

    
383
    if(shared){
384
        assert(pic->data[0]);
385
        assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
386
        pic->type= FF_BUFFER_TYPE_SHARED;
387
    }else{
388
        int r;
389

    
390
        assert(!pic->data[0]);
391

    
392
        r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
393

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

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

    
404
        if(pic->linesize[1] != pic->linesize[2]){
405
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
406
            return -1;
407
        }
408

    
409
        s->linesize  = pic->linesize[0];
410
        s->uvlinesize= pic->linesize[1];
411
    }
412

    
413
    if(pic->qscale_table==NULL){
414
        if (s->encoding) {
415
            CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
416
            CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
417
            CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
418
        }
419

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

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

    
452
    return 0;
453
fail: //for the CHECKED_ALLOCZ macro
454
    return -1;
455
}
456

    
457
/**
458
 * deallocates a picture
459
 */
460
static void free_picture(MpegEncContext *s, Picture *pic){
461
    int i;
462

    
463
    if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
464
        s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
465
    }
466

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

    
481
    if(pic->type == FF_BUFFER_TYPE_SHARED){
482
        for(i=0; i<4; i++){
483
            pic->base[i]=
484
            pic->data[i]= NULL;
485
        }
486
        pic->type= 0;
487
    }
488
}
489

    
490
static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
491
    int i;
492

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

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

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

    
520
static void free_duplicate_context(MpegEncContext *s){
521
    if(s==NULL) return;
522

    
523
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
524
    av_freep(&s->me.scratchpad);
525
    s->rd_scratchpad=
526
    s->b_scratchpad=
527
    s->obmc_scratchpad= NULL;
528

    
529
    av_freep(&s->dct_error_sum);
530
    av_freep(&s->me.map);
531
    av_freep(&s->me.score_map);
532
    av_freep(&s->blocks);
533
    s->block= NULL;
534
}
535

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

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

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

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

    
603
    s->coded_picture_number = 0;
604
    s->picture_number = 0;
605
    s->input_picture_number = 0;
606

    
607
    s->picture_in_gop_number = 0;
608

    
609
    s->f_code = 1;
610
    s->b_code = 1;
611
}
612

    
613
/**
614
 * sets the given MpegEncContext to defaults for decoding.
615
 * the changed fields will not depend upon the prior state of the MpegEncContext.
616
 */
617
void MPV_decode_defaults(MpegEncContext *s){
618
    MPV_common_defaults(s);
619
}
620

    
621
/**
622
 * sets the given MpegEncContext to defaults for encoding.
623
 * the changed fields will not depend upon the prior state of the MpegEncContext.
624
 */
625

    
626
#ifdef CONFIG_ENCODERS
627
static void MPV_encode_defaults(MpegEncContext *s){
628
    static int done=0;
629

    
630
    MPV_common_defaults(s);
631

    
632
    if(!done){
633
        int i;
634
        done=1;
635

    
636
        default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
637
        memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
638

    
639
        for(i=-16; i<16; i++){
640
            default_fcode_tab[i + MAX_MV]= 1;
641
        }
642
    }
643
    s->me.mv_penalty= default_mv_penalty;
644
    s->fcode_tab= default_fcode_tab;
645
}
646
#endif //CONFIG_ENCODERS
647

    
648
/**
649
 * init common structure for both encoder and decoder.
650
 * this assumes that some variables like width/height are already set
651
 */
652
int MPV_common_init(MpegEncContext *s)
653
{
654
    int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
655

    
656
    s->mb_height = (s->height + 15) / 16;
657

    
658
    if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
659
        av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
660
        return -1;
661
    }
662

    
663
    if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
664
        return -1;
665

    
666
    dsputil_init(&s->dsp, s->avctx);
667
    DCT_common_init(s);
668

    
669
    s->flags= s->avctx->flags;
670
    s->flags2= s->avctx->flags2;
671

    
672
    s->mb_width  = (s->width  + 15) / 16;
673
    s->mb_stride = s->mb_width + 1;
674
    s->b8_stride = s->mb_width*2 + 1;
675
    s->b4_stride = s->mb_width*4 + 1;
676
    mb_array_size= s->mb_height * s->mb_stride;
677
    mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
678

    
679
    /* set chroma shifts */
680
    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
681
                                                    &(s->chroma_y_shift) );
682

    
683
    /* set default edge pos, will be overriden in decode_header if needed */
684
    s->h_edge_pos= s->mb_width*16;
685
    s->v_edge_pos= s->mb_height*16;
686

    
687
    s->mb_num = s->mb_width * s->mb_height;
688

    
689
    s->block_wrap[0]=
690
    s->block_wrap[1]=
691
    s->block_wrap[2]=
692
    s->block_wrap[3]= s->b8_stride;
693
    s->block_wrap[4]=
694
    s->block_wrap[5]= s->mb_stride;
695

    
696
    y_size = s->b8_stride * (2 * s->mb_height + 1);
697
    c_size = s->mb_stride * (s->mb_height + 1);
698
    yc_size = y_size + 2 * c_size;
699

    
700
    /* convert fourcc to upper case */
701
    s->codec_tag=          toupper( s->avctx->codec_tag     &0xFF)
702
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
703
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
704
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
705

    
706
    s->stream_codec_tag=          toupper( s->avctx->stream_codec_tag     &0xFF)
707
                               + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
708
                               + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
709
                               + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
710

    
711
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
712

    
713
    CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
714
    for(y=0; y<s->mb_height; y++){
715
        for(x=0; x<s->mb_width; x++){
716
            s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
717
        }
718
    }
719
    s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
720

    
721
    if (s->encoding) {
722
        /* Allocate MV tables */
723
        CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
724
        CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
725
        CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
726
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
727
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
728
        CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
729
        s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
730
        s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
731
        s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
732
        s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
733
        s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
734
        s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
735

    
736
        if(s->msmpeg4_version){
737
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
738
        }
739
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
740

    
741
        /* Allocate MB type table */
742
        CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint16_t)) //needed for encoding
743

    
744
        CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
745

    
746
        CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
747
        CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
748
        CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
749
        CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
750
        CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
751
        CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
752

    
753
        if(s->avctx->noise_reduction){
754
            CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
755
        }
756
    }
757
    CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
758

    
759
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
760

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

    
784
        /* cbp values */
785
        CHECKED_ALLOCZ(s->coded_block_base, y_size);
786
        s->coded_block= s->coded_block_base + s->b8_stride + 1;
787

    
788
        /* cbp, ac_pred, pred_dir */
789
        CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
790
        CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
791
    }
792

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

    
804
    /* which mb is a intra block */
805
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
806
    memset(s->mbintra_table, 1, mb_array_size);
807

    
808
    /* init macroblock skip table */
809
    CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
810
    //Note the +1 is for a quicker mpeg4 slice_end detection
811
    CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
812

    
813
    s->parse_context.state= -1;
814
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
815
       s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
816
       s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
817
       s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
818
    }
819

    
820
    s->context_initialized = 1;
821

    
822
    s->thread_context[0]= s;
823
    for(i=1; i<s->avctx->thread_count; i++){
824
        s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
825
        memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
826
    }
827

    
828
    for(i=0; i<s->avctx->thread_count; i++){
829
        if(init_duplicate_context(s->thread_context[i], s) < 0)
830
           goto fail;
831
        s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
832
        s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
833
    }
834

    
835
    return 0;
836
 fail:
837
    MPV_common_end(s);
838
    return -1;
839
}
840

    
841
/* init common structure for both encoder and decoder */
842
void MPV_common_end(MpegEncContext *s)
843
{
844
    int i, j, k;
845

    
846
    for(i=0; i<s->avctx->thread_count; i++){
847
        free_duplicate_context(s->thread_context[i]);
848
    }
849
    for(i=1; i<s->avctx->thread_count; i++){
850
        av_freep(&s->thread_context[i]);
851
    }
852

    
853
    av_freep(&s->parse_context.buffer);
854
    s->parse_context.buffer_size=0;
855

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

    
882
    av_freep(&s->dc_val_base);
883
    av_freep(&s->ac_val_base);
884
    av_freep(&s->coded_block_base);
885
    av_freep(&s->mbintra_table);
886
    av_freep(&s->cbp_table);
887
    av_freep(&s->pred_dir_table);
888

    
889
    av_freep(&s->mbskip_table);
890
    av_freep(&s->prev_pict_types);
891
    av_freep(&s->bitstream_buffer);
892
    s->allocated_bitstream_buffer_size=0;
893

    
894
    av_freep(&s->avctx->stats_out);
895
    av_freep(&s->ac_stats);
896
    av_freep(&s->error_status_table);
897
    av_freep(&s->mb_index2xy);
898
    av_freep(&s->lambda_table);
899
    av_freep(&s->q_intra_matrix);
900
    av_freep(&s->q_inter_matrix);
901
    av_freep(&s->q_intra_matrix16);
902
    av_freep(&s->q_inter_matrix16);
903
    av_freep(&s->input_picture);
904
    av_freep(&s->reordered_input_picture);
905
    av_freep(&s->dct_offset);
906

    
907
    if(s->picture){
908
        for(i=0; i<MAX_PICTURE_COUNT; i++){
909
            free_picture(s, &s->picture[i]);
910
        }
911
    }
912
    av_freep(&s->picture);
913
    s->context_initialized = 0;
914
    s->last_picture_ptr=
915
    s->next_picture_ptr=
916
    s->current_picture_ptr= NULL;
917
    s->linesize= s->uvlinesize= 0;
918

    
919
    for(i=0; i<3; i++)
920
        av_freep(&s->visualization_buffer[i]);
921

    
922
    avcodec_default_free_buffers(s->avctx);
923
}
924

    
925
#ifdef CONFIG_ENCODERS
926

    
927
/* init video encoder */
928
int MPV_encode_init(AVCodecContext *avctx)
929
{
930
    MpegEncContext *s = avctx->priv_data;
931
    int i;
932
    int chroma_h_shift, chroma_v_shift;
933

    
934
    MPV_encode_defaults(s);
935

    
936
    switch (avctx->codec_id) {
937
    case CODEC_ID_MPEG2VIDEO:
938
        if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P){
939
            av_log(avctx, AV_LOG_ERROR, "only YUV420 and YUV422 are supported\n");
940
            return -1;
941
        }
942
        break;
943
    case CODEC_ID_LJPEG:
944
    case CODEC_ID_MJPEG:
945
        if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUVJ422P &&
946
           ((avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P) || avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL)){
947
            av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
948
            return -1;
949
        }
950
        break;
951
    default:
952
        if(avctx->pix_fmt != PIX_FMT_YUV420P){
953
            av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
954
            return -1;
955
        }
956
    }
957

    
958
    switch (avctx->pix_fmt) {
959
    case PIX_FMT_YUVJ422P:
960
    case PIX_FMT_YUV422P:
961
        s->chroma_format = CHROMA_422;
962
        break;
963
    case PIX_FMT_YUVJ420P:
964
    case PIX_FMT_YUV420P:
965
    default:
966
        s->chroma_format = CHROMA_420;
967
        break;
968
    }
969

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

    
993
    if (s->gop_size <= 1) {
994
        s->intra_only = 1;
995
        s->gop_size = 12;
996
    } else {
997
        s->intra_only = 0;
998
    }
999

    
1000
    s->me_method = avctx->me_method;
1001

    
1002
    /* Fixed QSCALE */
1003
    s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
1004

    
1005
    s->adaptive_quant= (   s->avctx->lumi_masking
1006
                        || s->avctx->dark_masking
1007
                        || s->avctx->temporal_cplx_masking
1008
                        || s->avctx->spatial_cplx_masking
1009
                        || s->avctx->p_masking
1010
                        || s->avctx->border_masking
1011
                        || (s->flags&CODEC_FLAG_QP_RD))
1012
                       && !s->fixed_qscale;
1013

    
1014
    s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
1015
    s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
1016
    s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
1017
    s->intra_vlc_format= !!(s->flags2 & CODEC_FLAG2_INTRA_VLC);
1018

    
1019
    if(avctx->rc_max_rate && !avctx->rc_buffer_size){
1020
        av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
1021
        return -1;
1022
    }
1023

    
1024
    if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
1025
        av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
1026
    }
1027

    
1028
    if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
1029
        av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
1030
        return -1;
1031
    }
1032

    
1033
    if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
1034
        av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
1035
        return -1;
1036
    }
1037

    
1038
    if(   s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
1039
       && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
1040
       && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
1041

    
1042
        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");
1043
    }
1044

    
1045
    if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
1046
       && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
1047
        av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
1048
        return -1;
1049
    }
1050

    
1051
    if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
1052
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n");
1053
        return -1;
1054
    }
1055

    
1056
    if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
1057
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
1058
        return -1;
1059
    }
1060

    
1061
    if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
1062
        av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
1063
        return -1;
1064
    }
1065

    
1066
    if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
1067
        av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
1068
        return -1;
1069
    }
1070

    
1071
    if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
1072
        av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
1073
        return -1;
1074
    }
1075

    
1076
    if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
1077
       && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1078
        av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1079
        return -1;
1080
    }
1081

    
1082
    if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1083
        av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n");
1084
        return -1;
1085
    }
1086

    
1087
    if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1088
        av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1089
        return -1;
1090
    }
1091

    
1092
    if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1093
        av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1094
        return -1;
1095
    }
1096

    
1097
    if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1098
        av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet, set threshold to 1000000000\n");
1099
        return -1;
1100
    }
1101

    
1102
    if((s->flags2 & CODEC_FLAG2_INTRA_VLC) && s->codec_id != CODEC_ID_MPEG2VIDEO){
1103
        av_log(avctx, AV_LOG_ERROR, "intra vlc table not supported by codec\n");
1104
        return -1;
1105
    }
1106

    
1107
    if(s->flags & CODEC_FLAG_LOW_DELAY){
1108
        if (s->codec_id != CODEC_ID_MPEG2VIDEO && s->codec_id != CODEC_ID_MPEG1VIDEO){
1109
            av_log(avctx, AV_LOG_ERROR, "low delay forcing is only available for mpeg1/2\n");
1110
            return -1;
1111
        }
1112
        if (s->max_b_frames != 0){
1113
            av_log(avctx, AV_LOG_ERROR, "b frames cannot be used with low delay\n");
1114
            return -1;
1115
        }
1116
    }
1117

    
1118
    if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1119
       && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1120
       && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1121
        av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1122
        return -1;
1123
    }
1124

    
1125
    if(s->avctx->thread_count > 1)
1126
        s->rtp_mode= 1;
1127

    
1128
    if(!avctx->time_base.den || !avctx->time_base.num){
1129
        av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1130
        return -1;
1131
    }
1132

    
1133
    i= (INT_MAX/2+128)>>8;
1134
    if(avctx->me_threshold >= i){
1135
        av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1136
        return -1;
1137
    }
1138
    if(avctx->mb_threshold >= i){
1139
        av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1140
        return -1;
1141
    }
1142

    
1143
    if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
1144
        av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n");
1145
        avctx->b_frame_strategy = 0;
1146
    }
1147

    
1148
    i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
1149
    if(i > 1){
1150
        av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1151
        avctx->time_base.den /= i;
1152
        avctx->time_base.num /= i;
1153
//        return -1;
1154
    }
1155

    
1156
    if(s->codec_id==CODEC_ID_MJPEG){
1157
        s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1158
        s->inter_quant_bias= 0;
1159
    }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1160
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1161
        s->inter_quant_bias= 0;
1162
    }else{
1163
        s->intra_quant_bias=0;
1164
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1165
    }
1166

    
1167
    if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1168
        s->intra_quant_bias= avctx->intra_quant_bias;
1169
    if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1170
        s->inter_quant_bias= avctx->inter_quant_bias;
1171

    
1172
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1173

    
1174
    if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
1175
        av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1176
        return -1;
1177
    }
1178
    s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1179

    
1180
    switch(avctx->codec->id) {
1181
    case CODEC_ID_MPEG1VIDEO:
1182
        s->out_format = FMT_MPEG1;
1183
        s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY);
1184
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1185
        break;
1186
    case CODEC_ID_MPEG2VIDEO:
1187
        s->out_format = FMT_MPEG1;
1188
        s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY);
1189
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1190
        s->rtp_mode= 1;
1191
        break;
1192
    case CODEC_ID_LJPEG:
1193
    case CODEC_ID_JPEGLS:
1194
    case CODEC_ID_MJPEG:
1195
        s->out_format = FMT_MJPEG;
1196
        s->intra_only = 1; /* force intra only for jpeg */
1197
        s->mjpeg_write_tables = avctx->codec->id != CODEC_ID_JPEGLS;
1198
        s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1199
        s->mjpeg_vsample[0] = 2;
1200
        s->mjpeg_vsample[1] = 2>>chroma_v_shift;
1201
        s->mjpeg_vsample[2] = 2>>chroma_v_shift;
1202
        s->mjpeg_hsample[0] = 2;
1203
        s->mjpeg_hsample[1] = 2>>chroma_h_shift;
1204
        s->mjpeg_hsample[2] = 2>>chroma_h_shift;
1205
        if (mjpeg_init(s) < 0)
1206
            return -1;
1207
        avctx->delay=0;
1208
        s->low_delay=1;
1209
        break;
1210
#ifdef CONFIG_H261_ENCODER
1211
    case CODEC_ID_H261:
1212
        if (ff_h261_get_picture_format(s->width, s->height) < 0) {
1213
            av_log(avctx, AV_LOG_ERROR, "The specified picture size of %dx%d is not valid for the H.261 codec.\nValid sizes are 176x144, 352x288\n", s->width, s->height);
1214
            return -1;
1215
        }
1216
        s->out_format = FMT_H261;
1217
        avctx->delay=0;
1218
        s->low_delay=1;
1219
        break;
1220
#endif
1221
    case CODEC_ID_H263:
1222
        if (h263_get_picture_format(s->width, s->height) == 7) {
1223
            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);
1224
            return -1;
1225
        }
1226
        s->out_format = FMT_H263;
1227
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1228
        avctx->delay=0;
1229
        s->low_delay=1;
1230
        break;
1231
    case CODEC_ID_H263P:
1232
        s->out_format = FMT_H263;
1233
        s->h263_plus = 1;
1234
        /* Fx */
1235
        s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1236
        s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1237
        s->modified_quant= s->h263_aic;
1238
        s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1239
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1240
        s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1241
        s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1242
        s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1243

    
1244
        /* /Fx */
1245
        /* These are just to be sure */
1246
        avctx->delay=0;
1247
        s->low_delay=1;
1248
        break;
1249
    case CODEC_ID_FLV1:
1250
        s->out_format = FMT_H263;
1251
        s->h263_flv = 2; /* format = 1; 11-bit codes */
1252
        s->unrestricted_mv = 1;
1253
        s->rtp_mode=0; /* don't allow GOB */
1254
        avctx->delay=0;
1255
        s->low_delay=1;
1256
        break;
1257
    case CODEC_ID_RV10:
1258
        s->out_format = FMT_H263;
1259
        avctx->delay=0;
1260
        s->low_delay=1;
1261
        break;
1262
    case CODEC_ID_RV20:
1263
        s->out_format = FMT_H263;
1264
        avctx->delay=0;
1265
        s->low_delay=1;
1266
        s->modified_quant=1;
1267
        s->h263_aic=1;
1268
        s->h263_plus=1;
1269
        s->loop_filter=1;
1270
        s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1271
        break;
1272
    case CODEC_ID_MPEG4:
1273
        s->out_format = FMT_H263;
1274
        s->h263_pred = 1;
1275
        s->unrestricted_mv = 1;
1276
        s->low_delay= s->max_b_frames ? 0 : 1;
1277
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1278
        break;
1279
    case CODEC_ID_MSMPEG4V1:
1280
        s->out_format = FMT_H263;
1281
        s->h263_msmpeg4 = 1;
1282
        s->h263_pred = 1;
1283
        s->unrestricted_mv = 1;
1284
        s->msmpeg4_version= 1;
1285
        avctx->delay=0;
1286
        s->low_delay=1;
1287
        break;
1288
    case CODEC_ID_MSMPEG4V2:
1289
        s->out_format = FMT_H263;
1290
        s->h263_msmpeg4 = 1;
1291
        s->h263_pred = 1;
1292
        s->unrestricted_mv = 1;
1293
        s->msmpeg4_version= 2;
1294
        avctx->delay=0;
1295
        s->low_delay=1;
1296
        break;
1297
    case CODEC_ID_MSMPEG4V3:
1298
        s->out_format = FMT_H263;
1299
        s->h263_msmpeg4 = 1;
1300
        s->h263_pred = 1;
1301
        s->unrestricted_mv = 1;
1302
        s->msmpeg4_version= 3;
1303
        s->flipflop_rounding=1;
1304
        avctx->delay=0;
1305
        s->low_delay=1;
1306
        break;
1307
    case CODEC_ID_WMV1:
1308
        s->out_format = FMT_H263;
1309
        s->h263_msmpeg4 = 1;
1310
        s->h263_pred = 1;
1311
        s->unrestricted_mv = 1;
1312
        s->msmpeg4_version= 4;
1313
        s->flipflop_rounding=1;
1314
        avctx->delay=0;
1315
        s->low_delay=1;
1316
        break;
1317
    case CODEC_ID_WMV2:
1318
        s->out_format = FMT_H263;
1319
        s->h263_msmpeg4 = 1;
1320
        s->h263_pred = 1;
1321
        s->unrestricted_mv = 1;
1322
        s->msmpeg4_version= 5;
1323
        s->flipflop_rounding=1;
1324
        avctx->delay=0;
1325
        s->low_delay=1;
1326
        break;
1327
    default:
1328
        return -1;
1329
    }
1330

    
1331
    avctx->has_b_frames= !s->low_delay;
1332

    
1333
    s->encoding = 1;
1334

    
1335
    /* init */
1336
    if (MPV_common_init(s) < 0)
1337
        return -1;
1338

    
1339
    if(s->modified_quant)
1340
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1341
    s->progressive_frame=
1342
    s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN));
1343
    s->quant_precision=5;
1344

    
1345
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1346
    ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1347

    
1348
#ifdef CONFIG_H261_ENCODER
1349
    if (s->out_format == FMT_H261)
1350
        ff_h261_encode_init(s);
1351
#endif
1352
    if (s->out_format == FMT_H263)
1353
        h263_encode_init(s);
1354
    if(s->msmpeg4_version)
1355
        ff_msmpeg4_encode_init(s);
1356
    if (s->out_format == FMT_MPEG1)
1357
        ff_mpeg1_encode_init(s);
1358

    
1359
    /* init q matrix */
1360
    for(i=0;i<64;i++) {
1361
        int j= s->dsp.idct_permutation[i];
1362
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1363
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1364
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1365
        }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1366
            s->intra_matrix[j] =
1367
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1368
        }else
1369
        { /* mpeg1/2 */
1370
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1371
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1372
        }
1373
        if(s->avctx->intra_matrix)
1374
            s->intra_matrix[j] = s->avctx->intra_matrix[i];
1375
        if(s->avctx->inter_matrix)
1376
            s->inter_matrix[j] = s->avctx->inter_matrix[i];
1377
    }
1378

    
1379
    /* precompute matrix */
1380
    /* for mjpeg, we do include qscale in the matrix */
1381
    if (s->out_format != FMT_MJPEG) {
1382
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1383
                       s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1384
        convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1385
                       s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1386
    }
1387

    
1388
    if(ff_rate_control_init(s) < 0)
1389
        return -1;
1390

    
1391
    return 0;
1392
}
1393

    
1394
int MPV_encode_end(AVCodecContext *avctx)
1395
{
1396
    MpegEncContext *s = avctx->priv_data;
1397

    
1398
    ff_rate_control_uninit(s);
1399

    
1400
    MPV_common_end(s);
1401
    if (s->out_format == FMT_MJPEG)
1402
        mjpeg_close(s);
1403

    
1404
    av_freep(&avctx->extradata);
1405

    
1406
    return 0;
1407
}
1408

    
1409
#endif //CONFIG_ENCODERS
1410

    
1411
void init_rl(RLTable *rl, int use_static)
1412
{
1413
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1414
    uint8_t index_run[MAX_RUN+1];
1415
    int last, run, level, start, end, i;
1416

    
1417
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
1418
    if(use_static && rl->max_level[0])
1419
        return;
1420

    
1421
    /* compute max_level[], max_run[] and index_run[] */
1422
    for(last=0;last<2;last++) {
1423
        if (last == 0) {
1424
            start = 0;
1425
            end = rl->last;
1426
        } else {
1427
            start = rl->last;
1428
            end = rl->n;
1429
        }
1430

    
1431
        memset(max_level, 0, MAX_RUN + 1);
1432
        memset(max_run, 0, MAX_LEVEL + 1);
1433
        memset(index_run, rl->n, MAX_RUN + 1);
1434
        for(i=start;i<end;i++) {
1435
            run = rl->table_run[i];
1436
            level = rl->table_level[i];
1437
            if (index_run[run] == rl->n)
1438
                index_run[run] = i;
1439
            if (level > max_level[run])
1440
                max_level[run] = level;
1441
            if (run > max_run[level])
1442
                max_run[level] = run;
1443
        }
1444
        if(use_static)
1445
            rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1446
        else
1447
            rl->max_level[last] = av_malloc(MAX_RUN + 1);
1448
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1449
        if(use_static)
1450
            rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1451
        else
1452
            rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1453
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1454
        if(use_static)
1455
            rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1456
        else
1457
            rl->index_run[last] = av_malloc(MAX_RUN + 1);
1458
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1459
    }
1460
}
1461

    
1462
/* draw the edges of width 'w' of an image of size width, height */
1463
//FIXME check that this is ok for mpeg4 interlaced
1464
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1465
{
1466
    uint8_t *ptr, *last_line;
1467
    int i;
1468

    
1469
    last_line = buf + (height - 1) * wrap;
1470
    for(i=0;i<w;i++) {
1471
        /* top and bottom */
1472
        memcpy(buf - (i + 1) * wrap, buf, width);
1473
        memcpy(last_line + (i + 1) * wrap, last_line, width);
1474
    }
1475
    /* left and right */
1476
    ptr = buf;
1477
    for(i=0;i<height;i++) {
1478
        memset(ptr - w, ptr[0], w);
1479
        memset(ptr + width, ptr[width-1], w);
1480
        ptr += wrap;
1481
    }
1482
    /* corners */
1483
    for(i=0;i<w;i++) {
1484
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1485
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1486
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1487
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1488
    }
1489
}
1490

    
1491
int ff_find_unused_picture(MpegEncContext *s, int shared){
1492
    int i;
1493

    
1494
    if(shared){
1495
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1496
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1497
        }
1498
    }else{
1499
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1500
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1501
        }
1502
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1503
            if(s->picture[i].data[0]==NULL) return i;
1504
        }
1505
    }
1506

    
1507
    assert(0);
1508
    return -1;
1509
}
1510

    
1511
static void update_noise_reduction(MpegEncContext *s){
1512
    int intra, i;
1513

    
1514
    for(intra=0; intra<2; intra++){
1515
        if(s->dct_count[intra] > (1<<16)){
1516
            for(i=0; i<64; i++){
1517
                s->dct_error_sum[intra][i] >>=1;
1518
            }
1519
            s->dct_count[intra] >>= 1;
1520
        }
1521

    
1522
        for(i=0; i<64; i++){
1523
            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);
1524
        }
1525
    }
1526
}
1527

    
1528
/**
1529
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1530
 */
1531
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1532
{
1533
    int i;
1534
    AVFrame *pic;
1535
    s->mb_skipped = 0;
1536

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

    
1539
    /* mark&release old frames */
1540
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1541
      if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1542
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1543

    
1544
        /* release forgotten pictures */
1545
        /* if(mpeg124/h263) */
1546
        if(!s->encoding){
1547
            for(i=0; i<MAX_PICTURE_COUNT; i++){
1548
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1549
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1550
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1551
                }
1552
            }
1553
        }
1554
      }
1555
    }
1556
alloc:
1557
    if(!s->encoding){
1558
        /* release non reference frames */
1559
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1560
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1561
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1562
            }
1563
        }
1564

    
1565
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1566
            pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1567
        else{
1568
            i= ff_find_unused_picture(s, 0);
1569
            pic= (AVFrame*)&s->picture[i];
1570
        }
1571

    
1572
        pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1573
                        && !s->dropable ? 3 : 0;
1574

    
1575
        pic->coded_picture_number= s->coded_picture_number++;
1576

    
1577
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1578
            return -1;
1579

    
1580
        s->current_picture_ptr= (Picture*)pic;
1581
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1582
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1583
    }
1584

    
1585
    s->current_picture_ptr->pict_type= s->pict_type;
1586
//    if(s->flags && CODEC_FLAG_QSCALE)
1587
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1588
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1589

    
1590
    copy_picture(&s->current_picture, s->current_picture_ptr);
1591

    
1592
    if (s->pict_type != B_TYPE) {
1593
        s->last_picture_ptr= s->next_picture_ptr;
1594
        if(!s->dropable)
1595
            s->next_picture_ptr= s->current_picture_ptr;
1596
    }
1597
/*    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,
1598
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
1599
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
1600
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1601
        s->pict_type, s->dropable);*/
1602

    
1603
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1604
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1605

    
1606
    if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && !s->dropable){
1607
        av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1608
        assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference
1609
        goto alloc;
1610
    }
1611

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

    
1614
    if(s->picture_structure!=PICT_FRAME){
1615
        int i;
1616
        for(i=0; i<4; i++){
1617
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1618
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1619
            }
1620
            s->current_picture.linesize[i] *= 2;
1621
            s->last_picture.linesize[i] *=2;
1622
            s->next_picture.linesize[i] *=2;
1623
        }
1624
    }
1625

    
1626
    s->hurry_up= s->avctx->hurry_up;
1627
    s->error_resilience= avctx->error_resilience;
1628

    
1629
    /* set dequantizer, we can't do it during init as it might change for mpeg4
1630
       and we can't do it in the header decode as init isnt called for mpeg4 there yet */
1631
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1632
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1633
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1634
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1635
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1636
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1637
    }else{
1638
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1639
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1640
    }
1641

    
1642
    if(s->dct_error_sum){
1643
        assert(s->avctx->noise_reduction && s->encoding);
1644

    
1645
        update_noise_reduction(s);
1646
    }
1647

    
1648
#ifdef HAVE_XVMC
1649
    if(s->avctx->xvmc_acceleration)
1650
        return XVMC_field_start(s, avctx);
1651
#endif
1652
    return 0;
1653
}
1654

    
1655
/* generic function for encode/decode called after a frame has been coded/decoded */
1656
void MPV_frame_end(MpegEncContext *s)
1657
{
1658
    int i;
1659
    /* draw edge for correct motion prediction if outside */
1660
#ifdef HAVE_XVMC
1661
//just to make sure that all data is rendered.
1662
    if(s->avctx->xvmc_acceleration){
1663
        XVMC_field_end(s);
1664
    }else
1665
#endif
1666
    if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1667
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1668
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1669
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1670
    }
1671
    emms_c();
1672

    
1673
    s->last_pict_type    = s->pict_type;
1674
    s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1675
    if(s->pict_type!=B_TYPE){
1676
        s->last_non_b_pict_type= s->pict_type;
1677
    }
1678
#if 0
1679
        /* copy back current_picture variables */
1680
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1681
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1682
            s->picture[i]= s->current_picture;
1683
            break;
1684
        }
1685
    }
1686
    assert(i<MAX_PICTURE_COUNT);
1687
#endif
1688

    
1689
    if(s->encoding){
1690
        /* release non-reference frames */
1691
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1692
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1693
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1694
            }
1695
        }
1696
    }
1697
    // clear copies, to avoid confusion
1698
#if 0
1699
    memset(&s->last_picture, 0, sizeof(Picture));
1700
    memset(&s->next_picture, 0, sizeof(Picture));
1701
    memset(&s->current_picture, 0, sizeof(Picture));
1702
#endif
1703
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1704
}
1705

    
1706
/**
1707
 * draws an line from (ex, ey) -> (sx, sy).
1708
 * @param w width of the image
1709
 * @param h height of the image
1710
 * @param stride stride/linesize of the image
1711
 * @param color color of the arrow
1712
 */
1713
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1714
    int x, y, fr, f;
1715

    
1716
    sx= av_clip(sx, 0, w-1);
1717
    sy= av_clip(sy, 0, h-1);
1718
    ex= av_clip(ex, 0, w-1);
1719
    ey= av_clip(ey, 0, h-1);
1720

    
1721
    buf[sy*stride + sx]+= color;
1722

    
1723
    if(FFABS(ex - sx) > FFABS(ey - sy)){
1724
        if(sx > ex){
1725
            FFSWAP(int, sx, ex);
1726
            FFSWAP(int, sy, ey);
1727
        }
1728
        buf+= sx + sy*stride;
1729
        ex-= sx;
1730
        f= ((ey-sy)<<16)/ex;
1731
        for(x= 0; x <= ex; x++){
1732
            y = (x*f)>>16;
1733
            fr= (x*f)&0xFFFF;
1734
            buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1735
            buf[(y+1)*stride + x]+= (color*         fr )>>16;
1736
        }
1737
    }else{
1738
        if(sy > ey){
1739
            FFSWAP(int, sx, ex);
1740
            FFSWAP(int, sy, ey);
1741
        }
1742
        buf+= sx + sy*stride;
1743
        ey-= sy;
1744
        if(ey) f= ((ex-sx)<<16)/ey;
1745
        else   f= 0;
1746
        for(y= 0; y <= ey; y++){
1747
            x = (y*f)>>16;
1748
            fr= (y*f)&0xFFFF;
1749
            buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;;
1750
            buf[y*stride + x+1]+= (color*         fr )>>16;;
1751
        }
1752
    }
1753
}
1754

    
1755
/**
1756
 * draws an arrow from (ex, ey) -> (sx, sy).
1757
 * @param w width of the image
1758
 * @param h height of the image
1759
 * @param stride stride/linesize of the image
1760
 * @param color color of the arrow
1761
 */
1762
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1763
    int dx,dy;
1764

    
1765
    sx= av_clip(sx, -100, w+100);
1766
    sy= av_clip(sy, -100, h+100);
1767
    ex= av_clip(ex, -100, w+100);
1768
    ey= av_clip(ey, -100, h+100);
1769

    
1770
    dx= ex - sx;
1771
    dy= ey - sy;
1772

    
1773
    if(dx*dx + dy*dy > 3*3){
1774
        int rx=  dx + dy;
1775
        int ry= -dx + dy;
1776
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1777

    
1778
        //FIXME subpixel accuracy
1779
        rx= ROUNDED_DIV(rx*3<<4, length);
1780
        ry= ROUNDED_DIV(ry*3<<4, length);
1781

    
1782
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1783
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1784
    }
1785
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1786
}
1787

    
1788
/**
1789
 * prints debuging info for the given picture.
1790
 */
1791
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1792

    
1793
    if(!pict || !pict->mb_type) return;
1794

    
1795
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1796
        int x,y;
1797

    
1798
        av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1799
        switch (pict->pict_type) {
1800
            case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1801
            case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1802
            case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1803
            case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1804
            case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1805
            case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1806
        }
1807
        for(y=0; y<s->mb_height; y++){
1808
            for(x=0; x<s->mb_width; x++){
1809
                if(s->avctx->debug&FF_DEBUG_SKIP){
1810
                    int count= s->mbskip_table[x + y*s->mb_stride];
1811
                    if(count>9) count=9;
1812
                    av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1813
                }
1814
                if(s->avctx->debug&FF_DEBUG_QP){
1815
                    av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1816
                }
1817
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1818
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
1819
                    //Type & MV direction
1820
                    if(IS_PCM(mb_type))
1821
                        av_log(s->avctx, AV_LOG_DEBUG, "P");
1822
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1823
                        av_log(s->avctx, AV_LOG_DEBUG, "A");
1824
                    else if(IS_INTRA4x4(mb_type))
1825
                        av_log(s->avctx, AV_LOG_DEBUG, "i");
1826
                    else if(IS_INTRA16x16(mb_type))
1827
                        av_log(s->avctx, AV_LOG_DEBUG, "I");
1828
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1829
                        av_log(s->avctx, AV_LOG_DEBUG, "d");
1830
                    else if(IS_DIRECT(mb_type))
1831
                        av_log(s->avctx, AV_LOG_DEBUG, "D");
1832
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1833
                        av_log(s->avctx, AV_LOG_DEBUG, "g");
1834
                    else if(IS_GMC(mb_type))
1835
                        av_log(s->avctx, AV_LOG_DEBUG, "G");
1836
                    else if(IS_SKIP(mb_type))
1837
                        av_log(s->avctx, AV_LOG_DEBUG, "S");
1838
                    else if(!USES_LIST(mb_type, 1))
1839
                        av_log(s->avctx, AV_LOG_DEBUG, ">");
1840
                    else if(!USES_LIST(mb_type, 0))
1841
                        av_log(s->avctx, AV_LOG_DEBUG, "<");
1842
                    else{
1843
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1844
                        av_log(s->avctx, AV_LOG_DEBUG, "X");
1845
                    }
1846

    
1847
                    //segmentation
1848
                    if(IS_8X8(mb_type))
1849
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1850
                    else if(IS_16X8(mb_type))
1851
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1852
                    else if(IS_8X16(mb_type))
1853
                        av_log(s->avctx, AV_LOG_DEBUG, "|");
1854
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1855
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1856
                    else
1857
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1858

    
1859

    
1860
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1861
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1862
                    else
1863
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1864
                }
1865
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1866
            }
1867
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1868
        }
1869
    }
1870

    
1871
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1872
        const int shift= 1 + s->quarter_sample;
1873
        int mb_y;
1874
        uint8_t *ptr;
1875
        int i;
1876
        int h_chroma_shift, v_chroma_shift;
1877
        const int width = s->avctx->width;
1878
        const int height= s->avctx->height;
1879
        const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1880
        const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1881
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1882

    
1883
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1884
        for(i=0; i<3; i++){
1885
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1886
            pict->data[i]= s->visualization_buffer[i];
1887
        }
1888
        pict->type= FF_BUFFER_TYPE_COPY;
1889
        ptr= pict->data[0];
1890

    
1891
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1892
            int mb_x;
1893
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1894
                const int mb_index= mb_x + mb_y*s->mb_stride;
1895
                if((s->avctx->debug_mv) && pict->motion_val){
1896
                  int type;
1897
                  for(type=0; type<3; type++){
1898
                    int direction = 0;
1899
                    switch (type) {
1900
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1901
                                continue;
1902
                              direction = 0;
1903
                              break;
1904
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1905
                                continue;
1906
                              direction = 0;
1907
                              break;
1908
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1909
                                continue;
1910
                              direction = 1;
1911
                              break;
1912
                    }
1913
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1914
                        continue;
1915

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

    
1935
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1936
                            my*=2;
1937

    
1938
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1939
                      }
1940
                    }else if(IS_8X16(pict->mb_type[mb_index])){
1941
                      int i;
1942
                      for(i=0; i<2; i++){
1943
                        int sx=mb_x*16 + 4 + 8*i;
1944
                        int sy=mb_y*16 + 8;
1945
                        int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1946
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1947
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1948

    
1949
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1950
                            my*=2;
1951

    
1952
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1953
                      }
1954
                    }else{
1955
                      int sx= mb_x*16 + 8;
1956
                      int sy= mb_y*16 + 8;
1957
                      int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1958
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1959
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1960
                      draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1961
                    }
1962
                  }
1963
                }
1964
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1965
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1966
                    int y;
1967
                    for(y=0; y<8; y++){
1968
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1969
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1970
                    }
1971
                }
1972
                if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1973
                    int mb_type= pict->mb_type[mb_index];
1974
                    uint64_t u,v;
1975
                    int y;
1976
#define COLOR(theta, r)\
1977
u= (int)(128 + r*cos(theta*3.141592/180));\
1978
v= (int)(128 + r*sin(theta*3.141592/180));
1979

    
1980

    
1981
                    u=v=128;
1982
                    if(IS_PCM(mb_type)){
1983
                        COLOR(120,48)
1984
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1985
                        COLOR(30,48)
1986
                    }else if(IS_INTRA4x4(mb_type)){
1987
                        COLOR(90,48)
1988
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1989
//                        COLOR(120,48)
1990
                    }else if(IS_DIRECT(mb_type)){
1991
                        COLOR(150,48)
1992
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1993
                        COLOR(170,48)
1994
                    }else if(IS_GMC(mb_type)){
1995
                        COLOR(190,48)
1996
                    }else if(IS_SKIP(mb_type)){
1997
//                        COLOR(180,48)
1998
                    }else if(!USES_LIST(mb_type, 1)){
1999
                        COLOR(240,48)
2000
                    }else if(!USES_LIST(mb_type, 0)){
2001
                        COLOR(0,48)
2002
                    }else{
2003
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
2004
                        COLOR(300,48)
2005
                    }
2006

    
2007
                    u*= 0x0101010101010101ULL;
2008
                    v*= 0x0101010101010101ULL;
2009
                    for(y=0; y<8; y++){
2010
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
2011
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
2012
                    }
2013

    
2014
                    //segmentation
2015
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
2016
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
2017
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
2018
                    }
2019
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
2020
                        for(y=0; y<16; y++)
2021
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
2022
                    }
2023
                    if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
2024
                        int dm= 1 << (mv_sample_log2-2);
2025
                        for(i=0; i<4; i++){
2026
                            int sx= mb_x*16 + 8*(i&1);
2027
                            int sy= mb_y*16 + 8*(i>>1);
2028
                            int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
2029
                            //FIXME bidir
2030
                            int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
2031
                            if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
2032
                                for(y=0; y<8; y++)
2033
                                    pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
2034
                            if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
2035
                                *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
2036
                        }
2037
                    }
2038

    
2039
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
2040
                        // hmm
2041
                    }
2042
                }
2043
                s->mbskip_table[mb_index]=0;
2044
            }
2045
        }
2046
    }
2047
}
2048

    
2049
#ifdef CONFIG_ENCODERS
2050

    
2051
static int get_sae(uint8_t *src, int ref, int stride){
2052
    int x,y;
2053
    int acc=0;
2054

    
2055
    for(y=0; y<16; y++){
2056
        for(x=0; x<16; x++){
2057
            acc+= FFABS(src[x+y*stride] - ref);
2058
        }
2059
    }
2060

    
2061
    return acc;
2062
}
2063

    
2064
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
2065
    int x, y, w, h;
2066
    int acc=0;
2067

    
2068
    w= s->width &~15;
2069
    h= s->height&~15;
2070

    
2071
    for(y=0; y<h; y+=16){
2072
        for(x=0; x<w; x+=16){
2073
            int offset= x + y*stride;
2074
            int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
2075
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
2076
            int sae = get_sae(src + offset, mean, stride);
2077

    
2078
            acc+= sae + 500 < sad;
2079
        }
2080
    }
2081
    return acc;
2082
}
2083

    
2084

    
2085
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2086
    AVFrame *pic=NULL;
2087
    int64_t pts;
2088
    int i;
2089
    const int encoding_delay= s->max_b_frames;
2090
    int direct=1;
2091

    
2092
    if(pic_arg){
2093
        pts= pic_arg->pts;
2094
        pic_arg->display_picture_number= s->input_picture_number++;
2095

    
2096
        if(pts != AV_NOPTS_VALUE){
2097
            if(s->user_specified_pts != AV_NOPTS_VALUE){
2098
                int64_t time= pts;
2099
                int64_t last= s->user_specified_pts;
2100

    
2101
                if(time <= last){
2102
                    av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts);
2103
                    return -1;
2104
                }
2105
            }
2106
            s->user_specified_pts= pts;
2107
        }else{
2108
            if(s->user_specified_pts != AV_NOPTS_VALUE){
2109
                s->user_specified_pts=
2110
                pts= s->user_specified_pts + 1;
2111
                av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts);
2112
            }else{
2113
                pts= pic_arg->display_picture_number;
2114
            }
2115
        }
2116
    }
2117

    
2118
  if(pic_arg){
2119
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2120
    if(pic_arg->linesize[0] != s->linesize) direct=0;
2121
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2122
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2123

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

    
2126
    if(direct){
2127
        i= ff_find_unused_picture(s, 1);
2128

    
2129
        pic= (AVFrame*)&s->picture[i];
2130
        pic->reference= 3;
2131

    
2132
        for(i=0; i<4; i++){
2133
            pic->data[i]= pic_arg->data[i];
2134
            pic->linesize[i]= pic_arg->linesize[i];
2135
        }
2136
        alloc_picture(s, (Picture*)pic, 1);
2137
    }else{
2138
        i= ff_find_unused_picture(s, 0);
2139

    
2140
        pic= (AVFrame*)&s->picture[i];
2141
        pic->reference= 3;
2142

    
2143
        alloc_picture(s, (Picture*)pic, 0);
2144

    
2145
        if(   pic->data[0] + INPLACE_OFFSET == pic_arg->data[0]
2146
           && pic->data[1] + INPLACE_OFFSET == pic_arg->data[1]
2147
           && pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){
2148
       // empty
2149
        }else{
2150
            int h_chroma_shift, v_chroma_shift;
2151
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2152

    
2153
            for(i=0; i<3; i++){
2154
                int src_stride= pic_arg->linesize[i];
2155
                int dst_stride= i ? s->uvlinesize : s->linesize;
2156
                int h_shift= i ? h_chroma_shift : 0;
2157
                int v_shift= i ? v_chroma_shift : 0;
2158
                int w= s->width >>h_shift;
2159
                int h= s->height>>v_shift;
2160
                uint8_t *src= pic_arg->data[i];
2161
                uint8_t *dst= pic->data[i];
2162

    
2163
                if(!s->avctx->rc_buffer_size)
2164
                    dst +=INPLACE_OFFSET;
2165

    
2166
                if(src_stride==dst_stride)
2167
                    memcpy(dst, src, src_stride*h);
2168
                else{
2169
                    while(h--){
2170
                        memcpy(dst, src, w);
2171
                        dst += dst_stride;
2172
                        src += src_stride;
2173
                    }
2174
                }
2175
            }
2176
        }
2177
    }
2178
    copy_picture_attributes(s, pic, pic_arg);
2179
    pic->pts= pts; //we set this here to avoid modifiying pic_arg
2180
  }
2181

    
2182
    /* shift buffer entries */
2183
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2184
        s->input_picture[i-1]= s->input_picture[i];
2185

    
2186
    s->input_picture[encoding_delay]= (Picture*)pic;
2187

    
2188
    return 0;
2189
}
2190

    
2191
static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2192
    int x, y, plane;
2193
    int score=0;
2194
    int64_t score64=0;
2195

    
2196
    for(plane=0; plane<3; plane++){
2197
        const int stride= p->linesize[plane];
2198
        const int bw= plane ? 1 : 2;
2199
        for(y=0; y<s->mb_height*bw; y++){
2200
            for(x=0; x<s->mb_width*bw; x++){
2201
                int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16;
2202
                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);
2203

    
2204
                switch(s->avctx->frame_skip_exp){
2205
                    case 0: score= FFMAX(score, v); break;
2206
                    case 1: score+= FFABS(v);break;
2207
                    case 2: score+= v*v;break;
2208
                    case 3: score64+= FFABS(v*v*(int64_t)v);break;
2209
                    case 4: score64+= v*v*(int64_t)(v*v);break;
2210
                }
2211
            }
2212
        }
2213
    }
2214

    
2215
    if(score) score64= score;
2216

    
2217
    if(score64 < s->avctx->frame_skip_threshold)
2218
        return 1;
2219
    if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2220
        return 1;
2221
    return 0;
2222
}
2223

    
2224
static int estimate_best_b_count(MpegEncContext *s){
2225
    AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id);
2226
    AVCodecContext *c= avcodec_alloc_context();
2227
    AVFrame input[FF_MAX_B_FRAMES+2];
2228
    const int scale= s->avctx->brd_scale;
2229
    int i, j, out_size, p_lambda, b_lambda, lambda2;
2230
    int outbuf_size= s->width * s->height; //FIXME
2231
    uint8_t *outbuf= av_malloc(outbuf_size);
2232
    int64_t best_rd= INT64_MAX;
2233
    int best_b_count= -1;
2234

    
2235
    assert(scale>=0 && scale <=3);
2236

    
2237
//    emms_c();
2238
    p_lambda= s->last_lambda_for[P_TYPE]; //s->next_picture_ptr->quality;
2239
    b_lambda= s->last_lambda_for[B_TYPE]; //p_lambda *FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
2240
    if(!b_lambda) b_lambda= p_lambda; //FIXME we should do this somewhere else
2241
    lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT;
2242

    
2243
    c->width = s->width >> scale;
2244
    c->height= s->height>> scale;
2245
    c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
2246
    c->flags|= s->avctx->flags & CODEC_FLAG_QPEL;
2247
    c->mb_decision= s->avctx->mb_decision;
2248
    c->me_cmp= s->avctx->me_cmp;
2249
    c->mb_cmp= s->avctx->mb_cmp;
2250
    c->me_sub_cmp= s->avctx->me_sub_cmp;
2251
    c->pix_fmt = PIX_FMT_YUV420P;
2252
    c->time_base= s->avctx->time_base;
2253
    c->max_b_frames= s->max_b_frames;
2254

    
2255
    if (avcodec_open(c, codec) < 0)
2256
        return -1;
2257

    
2258
    for(i=0; i<s->max_b_frames+2; i++){
2259
        int ysize= c->width*c->height;
2260
        int csize= (c->width/2)*(c->height/2);
2261
        Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr;
2262

    
2263
        avcodec_get_frame_defaults(&input[i]);
2264
        input[i].data[0]= av_malloc(ysize + 2*csize);
2265
        input[i].data[1]= input[i].data[0] + ysize;
2266
        input[i].data[2]= input[i].data[1] + csize;
2267
        input[i].linesize[0]= c->width;
2268
        input[i].linesize[1]=
2269
        input[i].linesize[2]= c->width/2;
2270

    
2271
        if(pre_input_ptr && (!i || s->input_picture[i-1])) {
2272
            pre_input= *pre_input_ptr;
2273

    
2274
            if(pre_input.type != FF_BUFFER_TYPE_SHARED && i) {
2275
                pre_input.data[0]+=INPLACE_OFFSET;
2276
                pre_input.data[1]+=INPLACE_OFFSET;
2277
                pre_input.data[2]+=INPLACE_OFFSET;
2278
            }
2279

    
2280
            s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height);
2281
            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);
2282
            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);
2283
        }
2284
    }
2285

    
2286
    for(j=0; j<s->max_b_frames+1; j++){
2287
        int64_t rd=0;
2288

    
2289
        if(!s->input_picture[j])
2290
            break;
2291

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

    
2294
        input[0].pict_type= I_TYPE;
2295
        input[0].quality= 1 * FF_QP2LAMBDA;
2296
        out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
2297
//        rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2298

    
2299
        for(i=0; i<s->max_b_frames+1; i++){
2300
            int is_p= i % (j+1) == j || i==s->max_b_frames;
2301

    
2302
            input[i+1].pict_type= is_p ? P_TYPE : B_TYPE;
2303
            input[i+1].quality= is_p ? p_lambda : b_lambda;
2304
            out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]);
2305
            rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2306
        }
2307

    
2308
        /* get the delayed frames */
2309
        while(out_size){
2310
            out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
2311
            rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2312
        }
2313

    
2314
        rd += c->error[0] + c->error[1] + c->error[2];
2315

    
2316
        if(rd < best_rd){
2317
            best_rd= rd;
2318
            best_b_count= j;
2319
        }
2320
    }
2321

    
2322
    av_freep(&outbuf);
2323
    avcodec_close(c);
2324
    av_freep(&c);
2325

    
2326
    for(i=0; i<s->max_b_frames+2; i++){
2327
        av_freep(&input[i].data[0]);
2328
    }
2329

    
2330
    return best_b_count;
2331
}
2332

    
2333
static void select_input_picture(MpegEncContext *s){
2334
    int i;
2335

    
2336
    for(i=1; i<MAX_PICTURE_COUNT; i++)
2337
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2338
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2339

    
2340
    /* set next picture type & ordering */
2341
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2342
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2343
            s->reordered_input_picture[0]= s->input_picture[0];
2344
            s->reordered_input_picture[0]->pict_type= I_TYPE;
2345
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2346
        }else{
2347
            int b_frames;
2348

    
2349
            if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2350
                if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2351
                //FIXME check that te gop check above is +-1 correct
2352
//av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2353

    
2354
                    if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2355
                        for(i=0; i<4; i++)
2356
                            s->input_picture[0]->data[i]= NULL;
2357
                        s->input_picture[0]->type= 0;
2358
                    }else{
2359
                        assert(   s->input_picture[0]->type==FF_BUFFER_TYPE_USER
2360
                               || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2361

    
2362
                        s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2363
                    }
2364

    
2365
                    emms_c();
2366
                    ff_vbv_update(s, 0);
2367

    
2368
                    goto no_output_pic;
2369
                }
2370
            }
2371

    
2372
            if(s->flags&CODEC_FLAG_PASS2){
2373
                for(i=0; i<s->max_b_frames+1; i++){
2374
                    int pict_num= s->input_picture[0]->display_picture_number + i;
2375

    
2376
                    if(pict_num >= s->rc_context.num_entries)
2377
                        break;
2378
                    if(!s->input_picture[i]){
2379
                        s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2380
                        break;
2381
                    }
2382

    
2383
                    s->input_picture[i]->pict_type=
2384
                        s->rc_context.entry[pict_num].new_pict_type;
2385
                }
2386
            }
2387

    
2388
            if(s->avctx->b_frame_strategy==0){
2389
                b_frames= s->max_b_frames;
2390
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
2391
            }else if(s->avctx->b_frame_strategy==1){
2392
                for(i=1; i<s->max_b_frames+1; i++){
2393
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2394
                        s->input_picture[i]->b_frame_score=
2395
                            get_intra_count(s, s->input_picture[i  ]->data[0],
2396
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
2397
                    }
2398
                }
2399
                for(i=0; i<s->max_b_frames+1; i++){
2400
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/s->avctx->b_sensitivity) break;
2401
                }
2402

    
2403
                b_frames= FFMAX(0, i-1);
2404

    
2405
                /* reset scores */
2406
                for(i=0; i<b_frames+1; i++){
2407
                    s->input_picture[i]->b_frame_score=0;
2408
                }
2409
            }else if(s->avctx->b_frame_strategy==2){
2410
                b_frames= estimate_best_b_count(s);
2411
            }else{
2412
                av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2413
                b_frames=0;
2414
            }
2415

    
2416
            emms_c();
2417
//static int b_count=0;
2418
//b_count+= b_frames;
2419
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2420

    
2421
            for(i= b_frames - 1; i>=0; i--){
2422
                int type= s->input_picture[i]->pict_type;
2423
                if(type && type != B_TYPE)
2424
                    b_frames= i;
2425
            }
2426
            if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2427
                av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
2428
            }
2429

    
2430
            if(s->picture_in_gop_number + b_frames >= s->gop_size){
2431
              if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2432
                    b_frames= s->gop_size - s->picture_in_gop_number - 1;
2433
              }else{
2434
                if(s->flags & CODEC_FLAG_CLOSED_GOP)
2435
                    b_frames=0;
2436
                s->input_picture[b_frames]->pict_type= I_TYPE;
2437
              }
2438
            }
2439

    
2440
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2441
               && b_frames
2442
               && s->input_picture[b_frames]->pict_type== I_TYPE)
2443
                b_frames--;
2444

    
2445
            s->reordered_input_picture[0]= s->input_picture[b_frames];
2446
            if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2447
                s->reordered_input_picture[0]->pict_type= P_TYPE;
2448
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2449
            for(i=0; i<b_frames; i++){
2450
                s->reordered_input_picture[i+1]= s->input_picture[i];
2451
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2452
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2453
            }
2454
        }
2455
    }
2456
no_output_pic:
2457
    if(s->reordered_input_picture[0]){
2458
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2459

    
2460
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2461

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

    
2465
            int i= ff_find_unused_picture(s, 0);
2466
            Picture *pic= &s->picture[i];
2467

    
2468
            pic->reference              = s->reordered_input_picture[0]->reference;
2469
            alloc_picture(s, pic, 0);
2470

    
2471
            /* mark us unused / free shared pic */
2472
            if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_INTERNAL)
2473
                s->avctx->release_buffer(s->avctx, (AVFrame*)s->reordered_input_picture[0]);
2474
            for(i=0; i<4; i++)
2475
                s->reordered_input_picture[0]->data[i]= NULL;
2476
            s->reordered_input_picture[0]->type= 0;
2477

    
2478
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2479

    
2480
            s->current_picture_ptr= pic;
2481
        }else{
2482
            // input is not a shared pix -> reuse buffer for current_pix
2483

    
2484
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2485
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2486

    
2487
            s->current_picture_ptr= s->reordered_input_picture[0];
2488
            for(i=0; i<4; i++){
2489
                s->new_picture.data[i]+= INPLACE_OFFSET;
2490
            }
2491
        }
2492
        copy_picture(&s->current_picture, s->current_picture_ptr);
2493

    
2494
        s->picture_number= s->new_picture.display_picture_number;
2495
//printf("dpn:%d\n", s->picture_number);
2496
    }else{
2497
       memset(&s->new_picture, 0, sizeof(Picture));
2498
    }
2499
}
2500

    
2501
int MPV_encode_picture(AVCodecContext *avctx,
2502
                       unsigned char *buf, int buf_size, void *data)
2503
{
2504
    MpegEncContext *s = avctx->priv_data;
2505
    AVFrame *pic_arg = data;
2506
    int i, stuffing_count;
2507

    
2508
    for(i=0; i<avctx->thread_count; i++){
2509
        int start_y= s->thread_context[i]->start_mb_y;
2510
        int   end_y= s->thread_context[i]->  end_mb_y;
2511
        int h= s->mb_height;
2512
        uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h);
2513
        uint8_t *end  = buf + (size_t)(((int64_t) buf_size)*  end_y/h);
2514

    
2515
        init_put_bits(&s->thread_context[i]->pb, start, end - start);
2516
    }
2517

    
2518
    s->picture_in_gop_number++;
2519

    
2520
    if(load_input_picture(s, pic_arg) < 0)
2521
        return -1;
2522

    
2523
    select_input_picture(s);
2524

    
2525
    /* output? */
2526
    if(s->new_picture.data[0]){
2527
        s->pict_type= s->new_picture.pict_type;
2528
//emms_c();
2529
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2530
        MPV_frame_start(s, avctx);
2531
vbv_retry:
2532
        if (encode_picture(s, s->picture_number) < 0)
2533
            return -1;
2534

    
2535
        avctx->real_pict_num  = s->picture_number;
2536
        avctx->header_bits = s->header_bits;
2537
        avctx->mv_bits     = s->mv_bits;
2538
        avctx->misc_bits   = s->misc_bits;
2539
        avctx->i_tex_bits  = s->i_tex_bits;
2540
        avctx->p_tex_bits  = s->p_tex_bits;
2541
        avctx->i_count     = s->i_count;
2542
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2543
        avctx->skip_count  = s->skip_count;
2544

    
2545
        MPV_frame_end(s);
2546

    
2547
        if (s->out_format == FMT_MJPEG)
2548
            mjpeg_picture_trailer(s);
2549

    
2550
        if(avctx->rc_buffer_size){
2551
            RateControlContext *rcc= &s->rc_context;
2552
            int max_size= rcc->buffer_index/3;
2553

    
2554
            if(put_bits_count(&s->pb) > max_size && s->lambda < s->avctx->lmax){
2555
                s->next_lambda= FFMAX(s->lambda+1, s->lambda*(s->qscale+1) / s->qscale);
2556
                if(s->adaptive_quant){
2557
                    int i;
2558
                    for(i=0; i<s->mb_height*s->mb_stride; i++)
2559
                        s->lambda_table[i]= FFMAX(s->lambda_table[i]+1, s->lambda_table[i]*(s->qscale+1) / s->qscale);
2560
                }
2561
                s->mb_skipped = 0;        //done in MPV_frame_start()
2562
                if(s->pict_type==P_TYPE){ //done in encode_picture() so we must undo it
2563
                    if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
2564
                        s->no_rounding ^= 1;
2565
                }
2566
                if(s->pict_type!=B_TYPE){
2567
                    s->time_base= s->last_time_base;
2568
                    s->last_non_b_time= s->time - s->pp_time;
2569
                }
2570
//                av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda);
2571
                for(i=0; i<avctx->thread_count; i++){
2572
                    PutBitContext *pb= &s->thread_context[i]->pb;
2573
                    init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
2574
                }
2575
                goto vbv_retry;
2576
            }
2577

    
2578
            assert(s->avctx->rc_max_rate);
2579
        }
2580

    
2581
        if(s->flags&CODEC_FLAG_PASS1)
2582
            ff_write_pass1_stats(s);
2583

    
2584
        for(i=0; i<4; i++){
2585
            s->current_picture_ptr->error[i]= s->current_picture.error[i];
2586
            avctx->error[i] += s->current_picture_ptr->error[i];
2587
        }
2588

    
2589
        if(s->flags&CODEC_FLAG_PASS1)
2590
            assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2591
        flush_put_bits(&s->pb);
2592
        s->frame_bits  = put_bits_count(&s->pb);
2593

    
2594
        stuffing_count= ff_vbv_update(s, s->frame_bits);
2595
        if(stuffing_count){
2596
            if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2597
                av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2598
                return -1;
2599
            }
2600

    
2601
            switch(s->codec_id){
2602
            case CODEC_ID_MPEG1VIDEO:
2603
            case CODEC_ID_MPEG2VIDEO:
2604
                while(stuffing_count--){
2605
                    put_bits(&s->pb, 8, 0);
2606
                }
2607
            break;
2608
            case CODEC_ID_MPEG4:
2609
                put_bits(&s->pb, 16, 0);
2610
                put_bits(&s->pb, 16, 0x1C3);
2611
                stuffing_count -= 4;
2612
                while(stuffing_count--){
2613
                    put_bits(&s->pb, 8, 0xFF);
2614
                }
2615
            break;
2616
            default:
2617
                av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2618
            }
2619
            flush_put_bits(&s->pb);
2620
            s->frame_bits  = put_bits_count(&s->pb);
2621
        }
2622

    
2623
        /* update mpeg1/2 vbv_delay for CBR */
2624
        if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2625
           && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2626
            int vbv_delay;
2627

    
2628
            assert(s->repeat_first_field==0);
2629

    
2630
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2631
            assert(vbv_delay < 0xFFFF);
2632

    
2633
            s->vbv_delay_ptr[0] &= 0xF8;
2634
            s->vbv_delay_ptr[0] |= vbv_delay>>13;
2635
            s->vbv_delay_ptr[1]  = vbv_delay>>5;
2636
            s->vbv_delay_ptr[2] &= 0x07;
2637
            s->vbv_delay_ptr[2] |= vbv_delay<<3;
2638
        }
2639
        s->total_bits += s->frame_bits;
2640
        avctx->frame_bits  = s->frame_bits;
2641
    }else{
2642
        assert((pbBufPtr(&s->pb) == s->pb.buf));
2643
        s->frame_bits=0;
2644
    }
2645
    assert((s->frame_bits&7)==0);
2646

    
2647
    return s->frame_bits/8;
2648
}
2649

    
2650
#endif //CONFIG_ENCODERS
2651

    
2652
static inline void gmc1_motion(MpegEncContext *s,
2653
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2654
                               uint8_t **ref_picture)
2655
{
2656
    uint8_t *ptr;
2657
    int offset, src_x, src_y, linesize, uvlinesize;
2658
    int motion_x, motion_y;
2659
    int emu=0;
2660

    
2661
    motion_x= s->sprite_offset[0][0];
2662
    motion_y= s->sprite_offset[0][1];
2663
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2664
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2665
    motion_x<<=(3-s->sprite_warping_accuracy);
2666
    motion_y<<=(3-s->sprite_warping_accuracy);
2667
    src_x = av_clip(src_x, -16, s->width);
2668
    if (src_x == s->width)
2669
        motion_x =0;
2670
    src_y = av_clip(src_y, -16, s->height);
2671
    if (src_y == s->height)
2672
        motion_y =0;
2673

    
2674
    linesize = s->linesize;
2675
    uvlinesize = s->uvlinesize;
2676

    
2677
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2678

    
2679
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2680
        if(   (unsigned)src_x >= s->h_edge_pos - 17
2681
           || (unsigned)src_y >= s->v_edge_pos - 17){
2682
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2683
            ptr= s->edge_emu_buffer;
2684
        }
2685
    }
2686

    
2687
    if((motion_x|motion_y)&7){
2688
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2689
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2690
    }else{
2691
        int dxy;
2692

    
2693
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2694
        if (s->no_rounding){
2695
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2696
        }else{
2697
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2698
        }
2699
    }
2700

    
2701
    if(s->flags&CODEC_FLAG_GRAY) return;
2702

    
2703
    motion_x= s->sprite_offset[1][0];
2704
    motion_y= s->sprite_offset[1][1];
2705
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2706
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2707
    motion_x<<=(3-s->sprite_warping_accuracy);
2708
    motion_y<<=(3-s->sprite_warping_accuracy);
2709
    src_x = av_clip(src_x, -8, s->width>>1);
2710
    if (src_x == s->width>>1)
2711
        motion_x =0;
2712
    src_y = av_clip(src_y, -8, s->height>>1);
2713
    if (src_y == s->height>>1)
2714
        motion_y =0;
2715

    
2716
    offset = (src_y * uvlinesize) + src_x;
2717
    ptr = ref_picture[1] + offset;
2718
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2719
        if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2720
           || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2721
            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);
2722
            ptr= s->edge_emu_buffer;
2723
            emu=1;
2724
        }
2725
    }
2726
    s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2727

    
2728
    ptr = ref_picture[2] + offset;
2729
    if(emu){
2730
        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);
2731
        ptr= s->edge_emu_buffer;
2732
    }
2733
    s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2734

    
2735
    return;
2736
}
2737

    
2738
static inline void gmc_motion(MpegEncContext *s,
2739
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2740
                               uint8_t **ref_picture)
2741
{
2742
    uint8_t *ptr;
2743
    int linesize, uvlinesize;
2744
    const int a= s->sprite_warping_accuracy;
2745
    int ox, oy;
2746

    
2747
    linesize = s->linesize;
2748
    uvlinesize = s->uvlinesize;
2749

    
2750
    ptr = ref_picture[0];
2751

    
2752
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2753
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2754

    
2755
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2756
           ox,
2757
           oy,
2758
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2759
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2760
           a+1, (1<<(2*a+1)) - s->no_rounding,
2761
           s->h_edge_pos, s->v_edge_pos);
2762
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2763
           ox + s->sprite_delta[0][0]*8,
2764
           oy + s->sprite_delta[1][0]*8,
2765
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2766
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2767
           a+1, (1<<(2*a+1)) - s->no_rounding,
2768
           s->h_edge_pos, s->v_edge_pos);
2769

    
2770
    if(s->flags&CODEC_FLAG_GRAY) return;
2771

    
2772
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2773
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2774

    
2775
    ptr = ref_picture[1];
2776
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2777
           ox,
2778
           oy,
2779
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2780
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2781
           a+1, (1<<(2*a+1)) - s->no_rounding,
2782
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2783

    
2784
    ptr = ref_picture[2];
2785
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2786
           ox,
2787
           oy,
2788
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2789
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2790
           a+1, (1<<(2*a+1)) - s->no_rounding,
2791
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2792
}
2793

    
2794
/**
2795
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2796
 * @param buf destination buffer
2797
 * @param src source buffer
2798
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2799
 * @param block_w width of block
2800
 * @param block_h height of block
2801
 * @param src_x x coordinate of the top left sample of the block in the source buffer
2802
 * @param src_y y coordinate of the top left sample of the block in the source buffer
2803
 * @param w width of the source buffer
2804
 * @param h height of the source buffer
2805
 */
2806
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2807
                                    int src_x, int src_y, int w, int h){
2808
    int x, y;
2809
    int start_y, start_x, end_y, end_x;
2810

    
2811
    if(src_y>= h){
2812
        src+= (h-1-src_y)*linesize;
2813
        src_y=h-1;
2814
    }else if(src_y<=-block_h){
2815
        src+= (1-block_h-src_y)*linesize;
2816
        src_y=1-block_h;
2817
    }
2818
    if(src_x>= w){
2819
        src+= (w-1-src_x);
2820
        src_x=w-1;
2821
    }else if(src_x<=-block_w){
2822
        src+= (1-block_w-src_x);
2823
        src_x=1-block_w;
2824
    }
2825

    
2826
    start_y= FFMAX(0, -src_y);
2827
    start_x= FFMAX(0, -src_x);
2828
    end_y= FFMIN(block_h, h-src_y);
2829
    end_x= FFMIN(block_w, w-src_x);
2830

    
2831
    // copy existing part
2832
    for(y=start_y; y<end_y; y++){
2833
        for(x=start_x; x<end_x; x++){
2834
            buf[x + y*linesize]= src[x + y*linesize];
2835
        }
2836
    }
2837

    
2838
    //top
2839
    for(y=0; y<start_y; y++){
2840
        for(x=start_x; x<end_x; x++){
2841
            buf[x + y*linesize]= buf[x + start_y*linesize];
2842
        }
2843
    }
2844

    
2845
    //bottom
2846
    for(y=end_y; y<block_h; y++){
2847
        for(x=start_x; x<end_x; x++){
2848
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2849
        }
2850
    }
2851

    
2852
    for(y=0; y<block_h; y++){
2853
       //left
2854
        for(x=0; x<start_x; x++){
2855
            buf[x + y*linesize]= buf[start_x + y*linesize];
2856
        }
2857

    
2858
       //right
2859
        for(x=end_x; x<block_w; x++){
2860
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2861
        }
2862
    }
2863
}
2864

    
2865
static inline int hpel_motion(MpegEncContext *s,
2866
                                  uint8_t *dest, uint8_t *src,
2867
                                  int field_based, int field_select,
2868
                                  int src_x, int src_y,
2869
                                  int width, int height, int stride,
2870
                                  int h_edge_pos, int v_edge_pos,
2871
                                  int w, int h, op_pixels_func *pix_op,
2872
                                  int motion_x, int motion_y)
2873
{
2874
    int dxy;
2875
    int emu=0;
2876

    
2877
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2878
    src_x += motion_x >> 1;
2879
    src_y += motion_y >> 1;
2880

    
2881
    /* WARNING: do no forget half pels */
2882
    src_x = av_clip(src_x, -16, width); //FIXME unneeded for emu?
2883
    if (src_x == width)
2884
        dxy &= ~1;
2885
    src_y = av_clip(src_y, -16, height);
2886
    if (src_y == height)
2887
        dxy &= ~2;
2888
    src += src_y * stride + src_x;
2889

    
2890
    if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2891
        if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2892
           || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2893
            ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2894
                             src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2895
            src= s->edge_emu_buffer;
2896
            emu=1;
2897
        }
2898
    }
2899
    if(field_select)
2900
        src += s->linesize;
2901
    pix_op[dxy](dest, src, stride, h);
2902
    return emu;
2903
}
2904

    
2905
static inline int hpel_motion_lowres(MpegEncContext *s,
2906
                                  uint8_t *dest, uint8_t *src,
2907
                                  int field_based, int field_select,
2908
                                  int src_x, int src_y,
2909
                                  int width, int height, int stride,
2910
                                  int h_edge_pos, int v_edge_pos,
2911
                                  int w, int h, h264_chroma_mc_func *pix_op,
2912
                                  int motion_x, int motion_y)
2913
{
2914
    const int lowres= s->avctx->lowres;
2915
    const int s_mask= (2<<lowres)-1;
2916
    int emu=0;
2917
    int sx, sy;
2918

    
2919
    if(s->quarter_sample){
2920
        motion_x/=2;
2921
        motion_y/=2;
2922
    }
2923

    
2924
    sx= motion_x & s_mask;
2925
    sy= motion_y & s_mask;
2926
    src_x += motion_x >> (lowres+1);
2927
    src_y += motion_y >> (lowres+1);
2928

    
2929
    src += src_y * stride + src_x;
2930

    
2931
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
2932
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2933
        ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2934
                            src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2935
        src= s->edge_emu_buffer;
2936
        emu=1;
2937
    }
2938

    
2939
    sx <<= 2 - lowres;
2940
    sy <<= 2 - lowres;
2941
    if(field_select)
2942
        src += s->linesize;
2943
    pix_op[lowres](dest, src, stride, h, sx, sy);
2944
    return emu;
2945
}
2946

    
2947
/* apply one mpeg motion vector to the three components */
2948
static av_always_inline void mpeg_motion(MpegEncContext *s,
2949
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2950
                               int field_based, int bottom_field, int field_select,
2951
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2952
                               int motion_x, int motion_y, int h)
2953
{
2954
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2955
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2956

    
2957
#if 0
2958
if(s->quarter_sample)
2959
{
2960
    motion_x>>=1;
2961
    motion_y>>=1;
2962
}
2963
#endif
2964

    
2965
    v_edge_pos = s->v_edge_pos >> field_based;
2966
    linesize   = s->current_picture.linesize[0] << field_based;
2967
    uvlinesize = s->current_picture.linesize[1] << field_based;
2968

    
2969
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2970
    src_x = s->mb_x* 16               + (motion_x >> 1);
2971
    src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2972

    
2973
    if (s->out_format == FMT_H263) {
2974
        if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2975
            mx = (motion_x>>1)|(motion_x&1);
2976
            my = motion_y >>1;
2977
            uvdxy = ((my & 1) << 1) | (mx & 1);
2978
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2979
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2980
        }else{
2981
            uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2982
            uvsrc_x = src_x>>1;
2983
            uvsrc_y = src_y>>1;
2984
        }
2985
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2986
        mx = motion_x / 4;
2987
        my = motion_y / 4;
2988
        uvdxy = 0;
2989
        uvsrc_x = s->mb_x*8 + mx;
2990
        uvsrc_y = s->mb_y*8 + my;
2991
    } else {
2992
        if(s->chroma_y_shift){
2993
            mx = motion_x / 2;
2994
            my = motion_y / 2;
2995
            uvdxy = ((my & 1) << 1) | (mx & 1);
2996
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2997
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2998
        } else {
2999
            if(s->chroma_x_shift){
3000
            //Chroma422
3001
                mx = motion_x / 2;
3002
                uvdxy = ((motion_y & 1) << 1) | (mx & 1);
3003
                uvsrc_x = s->mb_x* 8           + (mx >> 1);
3004
                uvsrc_y = src_y;
3005
            } else {
3006
            //Chroma444
3007
                uvdxy = dxy;
3008
                uvsrc_x = src_x;
3009
                uvsrc_y = src_y;
3010
            }
3011
        }
3012
    }
3013

    
3014
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
3015
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3016
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3017

    
3018
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
3019
       || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
3020
            if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
3021
               s->codec_id == CODEC_ID_MPEG1VIDEO){
3022
                av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
3023
                return ;
3024
            }
3025
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3026
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3027
            ptr_y = s->edge_emu_buffer;
3028
            if(!(s->flags&CODEC_FLAG_GRAY)){
3029
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3030
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
3031
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3032
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3033
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3034
                ptr_cb= uvbuf;
3035
                ptr_cr= uvbuf+16;
3036
            }
3037
    }
3038

    
3039
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3040
        dest_y += s->linesize;
3041
        dest_cb+= s->uvlinesize;
3042
        dest_cr+= s->uvlinesize;
3043
    }
3044

    
3045
    if(field_select){
3046
        ptr_y += s->linesize;
3047
        ptr_cb+= s->uvlinesize;
3048
        ptr_cr+= s->uvlinesize;
3049
    }
3050

    
3051
    pix_op[0][dxy](dest_y, ptr_y, linesize, h);
3052

    
3053
    if(!(s->flags&CODEC_FLAG_GRAY)){
3054
        pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
3055
        pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
3056
    }
3057
#if defined(CONFIG_H261_ENCODER) || defined(CONFIG_H261_DECODER)
3058
    if(s->out_format == FMT_H261){
3059
        ff_h261_loop_filter(s);
3060
    }
3061
#endif
3062
}
3063

    
3064
/* apply one mpeg motion vector to the three components */
3065
static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
3066
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3067
                               int field_based, int bottom_field, int field_select,
3068
                               uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
3069
                               int motion_x, int motion_y, int h)
3070
{
3071
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3072
    int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
3073
    const int lowres= s->avctx->lowres;
3074
    const int block_s= 8>>lowres;
3075
    const int s_mask= (2<<lowres)-1;
3076
    const int h_edge_pos = s->h_edge_pos >> lowres;
3077
    const int v_edge_pos = s->v_edge_pos >> lowres;
3078
    linesize   = s->current_picture.linesize[0] << field_based;
3079
    uvlinesize = s->current_picture.linesize[1] << field_based;
3080

    
3081
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
3082
        motion_x/=2;
3083
        motion_y/=2;
3084
    }
3085

    
3086
    if(field_based){
3087
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
3088
    }
3089

    
3090
    sx= motion_x & s_mask;
3091
    sy= motion_y & s_mask;
3092
    src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
3093
    src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
3094

    
3095
    if (s->out_format == FMT_H263) {
3096
        uvsx = ((motion_x>>1) & s_mask) | (sx&1);
3097
        uvsy = ((motion_y>>1) & s_mask) | (sy&1);
3098
        uvsrc_x = src_x>>1;
3099
        uvsrc_y = src_y>>1;
3100
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
3101
        mx = motion_x / 4;
3102
        my = motion_y / 4;
3103
        uvsx = (2*mx) & s_mask;
3104
        uvsy = (2*my) & s_mask;
3105
        uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
3106
        uvsrc_y = s->mb_y*block_s               + (my >> lowres);
3107
    } else {
3108
        mx = motion_x / 2;
3109
        my = motion_y / 2;
3110
        uvsx = mx & s_mask;
3111
        uvsy = my & s_mask;
3112
        uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
3113
        uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
3114
    }
3115

    
3116
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
3117
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3118
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3119

    
3120
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
3121
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
3122
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3123
                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
3124
            ptr_y = s->edge_emu_buffer;
3125
            if(!(s->flags&CODEC_FLAG_GRAY)){
3126
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3127
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
3128
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3129
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3130
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3131
                ptr_cb= uvbuf;
3132
                ptr_cr= uvbuf+16;
3133
            }
3134
    }
3135

    
3136
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3137
        dest_y += s->linesize;
3138
        dest_cb+= s->uvlinesize;
3139
        dest_cr+= s->uvlinesize;
3140
    }
3141

    
3142
    if(field_select){
3143
        ptr_y += s->linesize;
3144
        ptr_cb+= s->uvlinesize;
3145
        ptr_cr+= s->uvlinesize;
3146
    }
3147

    
3148
    sx <<= 2 - lowres;
3149
    sy <<= 2 - lowres;
3150
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
3151

    
3152
    if(!(s->flags&CODEC_FLAG_GRAY)){
3153
        uvsx <<= 2 - lowres;
3154
        uvsy <<= 2 - lowres;
3155
        pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3156
        pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3157
    }
3158
    //FIXME h261 lowres loop filter
3159
}
3160

    
3161
//FIXME move to dsputil, avg variant, 16x16 version
3162
static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
3163
    int x;
3164
    uint8_t * const top   = src[1];
3165
    uint8_t * const left  = src[2];
3166
    uint8_t * const mid   = src[0];
3167
    uint8_t * const right = src[3];
3168
    uint8_t * const bottom= src[4];
3169
#define OBMC_FILTER(x, t, l, m, r, b)\
3170
    dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
3171
#define OBMC_FILTER4(x, t, l, m, r, b)\
3172
    OBMC_FILTER(x         , t, l, m, r, b);\
3173
    OBMC_FILTER(x+1       , t, l, m, r, b);\
3174
    OBMC_FILTER(x  +stride, t, l, m, r, b);\
3175
    OBMC_FILTER(x+1+stride, t, l, m, r, b);
3176

    
3177
    x=0;
3178
    OBMC_FILTER (x  , 2, 2, 4, 0, 0);
3179
    OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
3180
    OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
3181
    OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
3182
    OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
3183
    OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
3184
    x+= stride;
3185
    OBMC_FILTER (x  , 1, 2, 5, 0, 0);
3186
    OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
3187
    OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
3188
    OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
3189
    x+= stride;
3190
    OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
3191
    OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
3192
    OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
3193
    OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
3194
    x+= 2*stride;
3195
    OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
3196
    OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
3197
    OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
3198
    OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
3199
    x+= 2*stride;
3200
    OBMC_FILTER (x  , 0, 2, 5, 0, 1);
3201
    OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
3202
    OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
3203
    OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
3204
    OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
3205
    OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
3206
    x+= stride;
3207
    OBMC_FILTER (x  , 0, 2, 4, 0, 2);
3208
    OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
3209
    OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
3210
    OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
3211
}
3212

    
3213
/* obmc for 1 8x8 luma block */
3214
static inline void obmc_motion(MpegEncContext *s,
3215
                               uint8_t *dest, uint8_t *src,
3216
                               int src_x, int src_y,
3217
                               op_pixels_func *pix_op,
3218
                               int16_t mv[5][2]/* mid top left right bottom*/)
3219
#define MID    0
3220
{
3221
    int i;
3222
    uint8_t *ptr[5];
3223

    
3224
    assert(s->quarter_sample==0);
3225

    
3226
    for(i=0; i<5; i++){
3227
        if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
3228
            ptr[i]= ptr[MID];
3229
        }else{
3230
            ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
3231
            hpel_motion(s, ptr[i], src, 0, 0,
3232
                        src_x, src_y,
3233
                        s->width, s->height, s->linesize,
3234
                        s->h_edge_pos, s->v_edge_pos,
3235
                        8, 8, pix_op,
3236
                        mv[i][0], mv[i][1]);
3237
        }
3238
    }
3239

    
3240
    put_obmc(dest, ptr, s->linesize);
3241
}
3242

    
3243
static inline void qpel_motion(MpegEncContext *s,
3244
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3245
                               int field_based, int bottom_field, int field_select,
3246
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3247
                               qpel_mc_func (*qpix_op)[16],
3248
                               int motion_x, int motion_y, int h)
3249
{
3250
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3251
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3252

    
3253
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3254
    src_x = s->mb_x *  16                 + (motion_x >> 2);
3255
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3256

    
3257
    v_edge_pos = s->v_edge_pos >> field_based;
3258
    linesize = s->linesize << field_based;
3259
    uvlinesize = s->uvlinesize << field_based;
3260

    
3261
    if(field_based){
3262
        mx= motion_x/2;
3263
        my= motion_y>>1;
3264
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3265
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
3266
        mx= (motion_x>>1) + rtab[motion_x&7];
3267
        my= (motion_y>>1) + rtab[motion_y&7];
3268
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3269
        mx= (motion_x>>1)|(motion_x&1);
3270
        my= (motion_y>>1)|(motion_y&1);
3271
    }else{
3272
        mx= motion_x/2;
3273
        my= motion_y/2;
3274
    }
3275
    mx= (mx>>1)|(mx&1);
3276
    my= (my>>1)|(my&1);
3277

    
3278
    uvdxy= (mx&1) | ((my&1)<<1);
3279
    mx>>=1;
3280
    my>>=1;
3281

    
3282
    uvsrc_x = s->mb_x *  8                 + mx;
3283
    uvsrc_y = s->mb_y * (8 >> field_based) + my;
3284

    
3285
    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
3286
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3287
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3288

    
3289
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
3290
       || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
3291
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3292
                         src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3293
        ptr_y= s->edge_emu_buffer;
3294
        if(!(s->flags&CODEC_FLAG_GRAY)){
3295
            uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3296
            ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
3297
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3298
            ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
3299
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3300
            ptr_cb= uvbuf;
3301
            ptr_cr= uvbuf + 16;
3302
        }
3303
    }
3304

    
3305
    if(!field_based)
3306
        qpix_op[0][dxy](dest_y, ptr_y, linesize);
3307
    else{
3308
        if(bottom_field){
3309
            dest_y += s->linesize;
3310
            dest_cb+= s->uvlinesize;
3311
            dest_cr+= s->uvlinesize;
3312
        }
3313

    
3314
        if(field_select){
3315
            ptr_y  += s->linesize;
3316
            ptr_cb += s->uvlinesize;
3317
            ptr_cr += s->uvlinesize;
3318
        }
3319
        //damn interlaced mode
3320
        //FIXME boundary mirroring is not exactly correct here
3321
        qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
3322
        qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3323
    }
3324
    if(!(s->flags&CODEC_FLAG_GRAY)){
3325
        pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3326
        pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3327
    }
3328
}
3329

    
3330
inline int ff_h263_round_chroma(int x){
3331
    if (x >= 0)
3332
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3333
    else {
3334
        x = -x;
3335
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3336
    }
3337
}
3338

    
3339
/**
3340
 * h263 chorma 4mv motion compensation.
3341
 */
3342
static inline void chroma_4mv_motion(MpegEncContext *s,
3343
                                     uint8_t *dest_cb, uint8_t *dest_cr,
3344
                                     uint8_t **ref_picture,
3345
                                     op_pixels_func *pix_op,
3346
                                     int mx, int my){
3347
    int dxy, emu=0, src_x, src_y, offset;
3348
    uint8_t *ptr;
3349

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

    
3355
    dxy = ((my & 1) << 1) | (mx & 1);
3356
    mx >>= 1;
3357
    my >>= 1;
3358

    
3359
    src_x = s->mb_x * 8 + mx;
3360
    src_y = s->mb_y * 8 + my;
3361
    src_x = av_clip(src_x, -8, s->width/2);
3362
    if (src_x == s->width/2)
3363
        dxy &= ~1;
3364
    src_y = av_clip(src_y, -8, s->height/2);
3365
    if (src_y == s->height/2)
3366
        dxy &= ~2;
3367

    
3368
    offset = (src_y * (s->uvlinesize)) + src_x;
3369
    ptr = ref_picture[1] + offset;
3370
    if(s->flags&CODEC_FLAG_EMU_EDGE){
3371
        if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3372
           || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3373
            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);
3374
            ptr= s->edge_emu_buffer;
3375
            emu=1;
3376
        }
3377
    }
3378
    pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3379

    
3380
    ptr = ref_picture[2] + offset;
3381
    if(emu){
3382
        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);
3383
        ptr= s->edge_emu_buffer;
3384
    }
3385
    pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3386
}
3387

    
3388
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3389
                                     uint8_t *dest_cb, uint8_t *dest_cr,
3390
                                     uint8_t **ref_picture,
3391
                                     h264_chroma_mc_func *pix_op,
3392
                                     int mx, int my){
3393
    const int lowres= s->avctx->lowres;
3394
    const int block_s= 8>>lowres;
3395
    const int s_mask= (2<<lowres)-1;
3396
    const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3397
    const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3398
    int emu=0, src_x, src_y, offset, sx, sy;
3399
    uint8_t *ptr;
3400

    
3401
    if(s->quarter_sample){
3402
        mx/=2;
3403
        my/=2;
3404
    }
3405

    
3406
    /* In case of 8X8, we construct a single chroma motion vector
3407
       with a special rounding */
3408
    mx= ff_h263_round_chroma(mx);
3409
    my= ff_h263_round_chroma(my);
3410

    
3411
    sx= mx & s_mask;
3412
    sy= my & s_mask;
3413
    src_x = s->mb_x*block_s + (mx >> (lowres+1));
3414
    src_y = s->mb_y*block_s + (my >> (lowres+1));
3415

    
3416
    offset = src_y * s->uvlinesize + src_x;
3417
    ptr = ref_picture[1] + offset;
3418
    if(s->flags&CODEC_FLAG_EMU_EDGE){
3419
        if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3420
           || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3421
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3422
            ptr= s->edge_emu_buffer;
3423
            emu=1;
3424
        }
3425
    }
3426
    sx <<= 2 - lowres;
3427
    sy <<= 2 - lowres;
3428
    pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3429

    
3430
    ptr = ref_picture[2] + offset;
3431
    if(emu){
3432
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3433
        ptr= s->edge_emu_buffer;
3434
    }
3435
    pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3436
}
3437

    
3438
static inline void prefetch_motion(MpegEncContext *s, uint8_t **pix, int dir){
3439
    /* fetch pixels for estimated mv 4 macroblocks ahead
3440
     * optimized for 64byte cache lines */
3441
    const int shift = s->quarter_sample ? 2 : 1;
3442
    const int mx= (s->mv[dir][0][0]>>shift) + 16*s->mb_x + 8;
3443
    const int my= (s->mv[dir][0][1]>>shift) + 16*s->mb_y;
3444
    int off= mx + (my + (s->mb_x&3)*4)*s->linesize + 64;
3445
    s->dsp.prefetch(pix[0]+off, s->linesize, 4);
3446
    off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;
3447
    s->dsp.prefetch(pix[1]+off, pix[2]-pix[1], 2);
3448
}
3449

    
3450
/**
3451
 * motion compensation of a single macroblock
3452
 * @param s context
3453
 * @param dest_y luma destination pointer
3454
 * @param dest_cb chroma cb/u destination pointer
3455
 * @param dest_cr chroma cr/v destination pointer
3456
 * @param dir direction (0->forward, 1->backward)
3457
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3458
 * @param pic_op halfpel motion compensation function (average or put normally)
3459
 * @param pic_op qpel motion compensation function (average or put normally)
3460
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3461
 */
3462
static inline void MPV_motion(MpegEncContext *s,
3463
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3464
                              int dir, uint8_t **ref_picture,
3465
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3466
{
3467
    int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3468
    int mb_x, mb_y, i;
3469
    uint8_t *ptr, *dest;
3470

    
3471
    mb_x = s->mb_x;
3472
    mb_y = s->mb_y;
3473

    
3474
    prefetch_motion(s, ref_picture, dir);
3475

    
3476
    if(s->obmc && s->pict_type != B_TYPE){
3477
        int16_t mv_cache[4][4][2];
3478
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
3479
        const int mot_stride= s->b8_stride;
3480
        const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3481

    
3482
        assert(!s->mb_skipped);
3483

    
3484
        memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
3485
        memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3486
        memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3487

    
3488
        if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3489
            memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3490
        }else{
3491
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3492
        }
3493

    
3494
        if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3495
            *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3496
            *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3497
        }else{
3498
            *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3499
            *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3500
        }
3501

    
3502
        if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3503
            *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3504
            *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3505
        }else{
3506
            *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3507
            *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3508
        }
3509

    
3510
        mx = 0;
3511
        my = 0;
3512
        for(i=0;i<4;i++) {
3513
            const int x= (i&1)+1;
3514
            const int y= (i>>1)+1;
3515
            int16_t mv[5][2]= {
3516
                {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
3517
                {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3518
                {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3519
                {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3520
                {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3521
            //FIXME cleanup
3522
            obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3523
                        ref_picture[0],
3524
                        mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3525
                        pix_op[1],
3526
                        mv);
3527

    
3528
            mx += mv[0][0];
3529
            my += mv[0][1];
3530
        }
3531
        if(!(s->flags&CODEC_FLAG_GRAY))
3532
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3533

    
3534
        return;
3535
    }
3536

    
3537
    switch(s->mv_type) {
3538
    case MV_TYPE_16X16:
3539
        if(s->mcsel){
3540
            if(s->real_sprite_warping_points==1){
3541
                gmc1_motion(s, dest_y, dest_cb, dest_cr,
3542
                            ref_picture);
3543
            }else{
3544
                gmc_motion(s, dest_y, dest_cb, dest_cr,
3545
                            ref_picture);
3546
            }
3547
        }else if(s->quarter_sample){
3548
            qpel_motion(s, dest_y, dest_cb, dest_cr,
3549
                        0, 0, 0,
3550
                        ref_picture, pix_op, qpix_op,
3551
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3552
        }else if(s->mspel){
3553
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3554
                        ref_picture, pix_op,
3555
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3556
        }else
3557
        {
3558
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3559
                        0, 0, 0,
3560
                        ref_picture, pix_op,
3561
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3562
        }
3563
        break;
3564
    case MV_TYPE_8X8:
3565
        mx = 0;
3566
        my = 0;
3567
        if(s->quarter_sample){
3568
            for(i=0;i<4;i++) {
3569
                motion_x = s->mv[dir][i][0];
3570
                motion_y = s->mv[dir][i][1];
3571

    
3572
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3573
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3574
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3575

    
3576
                /* WARNING: do no forget half pels */
3577
                src_x = av_clip(src_x, -16, s->width);
3578
                if (src_x == s->width)
3579
                    dxy &= ~3;
3580
                src_y = av_clip(src_y, -16, s->height);
3581
                if (src_y == s->height)
3582
                    dxy &= ~12;
3583

    
3584
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3585
                if(s->flags&CODEC_FLAG_EMU_EDGE){
3586
                    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8
3587
                       || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3588
                        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);
3589
                        ptr= s->edge_emu_buffer;
3590
                    }
3591
                }
3592
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3593
                qpix_op[1][dxy](dest, ptr, s->linesize);
3594

    
3595
                mx += s->mv[dir][i][0]/2;
3596
                my += s->mv[dir][i][1]/2;
3597
            }
3598
        }else{
3599
            for(i=0;i<4;i++) {
3600
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3601
                            ref_picture[0], 0, 0,
3602
                            mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3603
                            s->width, s->height, s->linesize,
3604
                            s->h_edge_pos, s->v_edge_pos,
3605
                            8, 8, pix_op[1],
3606
                            s->mv[dir][i][0], s->mv[dir][i][1]);
3607

    
3608
                mx += s->mv[dir][i][0];
3609
                my += s->mv[dir][i][1];
3610
            }
3611
        }
3612

    
3613
        if(!(s->flags&CODEC_FLAG_GRAY))
3614
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3615
        break;
3616
    case MV_TYPE_FIELD:
3617
        if (s->picture_structure == PICT_FRAME) {
3618
            if(s->quarter_sample){
3619
                for(i=0; i<2; i++){
3620
                    qpel_motion(s, dest_y, dest_cb, dest_cr,
3621
                                1, i, s->field_select[dir][i],
3622
                                ref_picture, pix_op, qpix_op,
3623
                                s->mv[dir][i][0], s->mv[dir][i][1], 8);
3624
                }
3625
            }else{
3626
                /* top field */
3627
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3628
                            1, 0, s->field_select[dir][0],
3629
                            ref_picture, pix_op,
3630
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
3631
                /* bottom field */
3632
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3633
                            1, 1, s->field_select[dir][1],
3634
                            ref_picture, pix_op,
3635
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
3636
            }
3637
        } else {
3638
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3639
                ref_picture= s->current_picture_ptr->data;
3640
            }
3641

    
3642
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3643
                        0, 0, s->field_select[dir][0],
3644
                        ref_picture, pix_op,
3645
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3646
        }
3647
        break;
3648
    case MV_TYPE_16X8:
3649
        for(i=0; i<2; i++){
3650
            uint8_t ** ref2picture;
3651

    
3652
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3653
                ref2picture= ref_picture;
3654
            }else{
3655
                ref2picture= s->current_picture_ptr->data;
3656
            }
3657

    
3658
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3659
                        0, 0, s->field_select[dir][i],
3660
                        ref2picture, pix_op,
3661
                        s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3662

    
3663
            dest_y += 16*s->linesize;
3664
            dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3665
            dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3666
        }
3667
        break;
3668
    case MV_TYPE_DMV:
3669
        if(s->picture_structure == PICT_FRAME){
3670
            for(i=0; i<2; i++){
3671
                int j;
3672
                for(j=0; j<2; j++){
3673
                    mpeg_motion(s, dest_y, dest_cb, dest_cr,
3674
                                1, j, j^i,
3675
                                ref_picture, pix_op,
3676
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3677
                }
3678
                pix_op = s->dsp.avg_pixels_tab;
3679
            }
3680
        }else{
3681
            for(i=0; i<2; i++){
3682
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3683
                            0, 0, s->picture_structure != i+1,
3684
                            ref_picture, pix_op,
3685
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3686

    
3687
                // after put we make avg of the same block
3688
                pix_op=s->dsp.avg_pixels_tab;
3689

    
3690
                //opposite parity is always in the same frame if this is second field
3691
                if(!s->first_field){
3692
                    ref_picture = s->current_picture_ptr->data;
3693
                }
3694
            }
3695
        }
3696
    break;
3697
    default: assert(0);
3698
    }
3699
}
3700

    
3701
/**
3702
 * motion compensation of a single macroblock
3703
 * @param s context
3704
 * @param dest_y luma destination pointer
3705
 * @param dest_cb chroma cb/u destination pointer
3706
 * @param dest_cr chroma cr/v destination pointer
3707
 * @param dir direction (0->forward, 1->backward)
3708
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3709
 * @param pic_op halfpel motion compensation function (average or put normally)
3710
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3711
 */
3712
static inline void MPV_motion_lowres(MpegEncContext *s,
3713
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3714
                              int dir, uint8_t **ref_picture,
3715
                              h264_chroma_mc_func *pix_op)
3716
{
3717
    int mx, my;
3718
    int mb_x, mb_y, i;
3719
    const int lowres= s->avctx->lowres;
3720
    const int block_s= 8>>lowres;
3721

    
3722
    mb_x = s->mb_x;
3723
    mb_y = s->mb_y;
3724

    
3725
    switch(s->mv_type) {
3726
    case MV_TYPE_16X16:
3727
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3728
                    0, 0, 0,
3729
                    ref_picture, pix_op,
3730
                    s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3731
        break;
3732
    case MV_TYPE_8X8:
3733
        mx = 0;
3734
        my = 0;
3735
            for(i=0;i<4;i++) {
3736
                hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
3737
                            ref_picture[0], 0, 0,
3738
                            (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
3739
                            s->width, s->height, s->linesize,
3740
                            s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
3741
                            block_s, block_s, pix_op,
3742
                            s->mv[dir][i][0], s->mv[dir][i][1]);
3743

    
3744
                mx += s->mv[dir][i][0];
3745
                my += s->mv[dir][i][1];
3746
            }
3747

    
3748
        if(!(s->flags&CODEC_FLAG_GRAY))
3749
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
3750
        break;
3751
    case MV_TYPE_FIELD:
3752
        if (s->picture_structure == PICT_FRAME) {
3753
            /* top field */
3754
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3755
                        1, 0, s->field_select[dir][0],
3756
                        ref_picture, pix_op,
3757
                        s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3758
            /* bottom field */
3759
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3760
                        1, 1, s->field_select[dir][1],
3761
                        ref_picture, pix_op,
3762
                        s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3763
        } else {
3764
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3765
                ref_picture= s->current_picture_ptr->data;
3766
            }
3767

    
3768
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3769
                        0, 0, s->field_select[dir][0],
3770
                        ref_picture, pix_op,
3771
                        s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3772
        }
3773
        break;
3774
    case MV_TYPE_16X8:
3775
        for(i=0; i<2; i++){
3776
            uint8_t ** ref2picture;
3777

    
3778
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3779
                ref2picture= ref_picture;
3780
            }else{
3781
                ref2picture= s->current_picture_ptr->data;
3782
            }
3783

    
3784
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3785
                        0, 0, s->field_select[dir][i],
3786
                        ref2picture, pix_op,
3787
                        s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
3788

    
3789
            dest_y += 2*block_s*s->linesize;
3790
            dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3791
            dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3792
        }
3793
        break;
3794
    case MV_TYPE_DMV:
3795
        if(s->picture_structure == PICT_FRAME){
3796
            for(i=0; i<2; i++){
3797
                int j;
3798
                for(j=0; j<2; j++){
3799
                    mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3800
                                1, j, j^i,
3801
                                ref_picture, pix_op,
3802
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
3803
                }
3804
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3805
            }
3806
        }else{
3807
            for(i=0; i<2; i++){
3808
                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3809
                            0, 0, s->picture_structure != i+1,
3810
                            ref_picture, pix_op,
3811
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
3812

    
3813
                // after put we make avg of the same block
3814
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3815

    
3816
                //opposite parity is always in the same frame if this is second field
3817
                if(!s->first_field){
3818
                    ref_picture = s->current_picture_ptr->data;
3819
                }
3820
            }
3821
        }
3822
    break;
3823
    default: assert(0);
3824
    }
3825
}
3826

    
3827
/* put block[] to dest[] */
3828
static inline void put_dct(MpegEncContext *s,
3829
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3830
{
3831
    s->dct_unquantize_intra(s, block, i, qscale);
3832
    s->dsp.idct_put (dest, line_size, block);
3833
}
3834

    
3835
/* add block[] to dest[] */
3836
static inline void add_dct(MpegEncContext *s,
3837
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
3838
{
3839
    if (s->block_last_index[i] >= 0) {
3840
        s->dsp.idct_add (dest, line_size, block);
3841
    }
3842
}
3843

    
3844
static inline void add_dequant_dct(MpegEncContext *s,
3845
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3846
{
3847
    if (s->block_last_index[i] >= 0) {
3848
        s->dct_unquantize_inter(s, block, i, qscale);
3849

    
3850
        s->dsp.idct_add (dest, line_size, block);
3851
    }
3852
}
3853

    
3854
/**
3855
 * cleans dc, ac, coded_block for the current non intra MB
3856
 */
3857
void ff_clean_intra_table_entries(MpegEncContext *s)
3858
{
3859
    int wrap = s->b8_stride;
3860
    int xy = s->block_index[0];
3861

    
3862
    s->dc_val[0][xy           ] =
3863
    s->dc_val[0][xy + 1       ] =
3864
    s->dc_val[0][xy     + wrap] =
3865
    s->dc_val[0][xy + 1 + wrap] = 1024;
3866
    /* ac pred */
3867
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
3868
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3869
    if (s->msmpeg4_version>=3) {
3870
        s->coded_block[xy           ] =
3871
        s->coded_block[xy + 1       ] =
3872
        s->coded_block[xy     + wrap] =
3873
        s->coded_block[xy + 1 + wrap] = 0;
3874
    }
3875
    /* chroma */
3876
    wrap = s->mb_stride;
3877
    xy = s->mb_x + s->mb_y * wrap;
3878
    s->dc_val[1][xy] =
3879
    s->dc_val[2][xy] = 1024;
3880
    /* ac pred */
3881
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3882
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3883

    
3884
    s->mbintra_table[xy]= 0;
3885
}
3886

    
3887
/* generic function called after a macroblock has been parsed by the
3888
   decoder or after it has been encoded by the encoder.
3889

3890
   Important variables used:
3891
   s->mb_intra : true if intra macroblock
3892
   s->mv_dir   : motion vector direction
3893
   s->mv_type  : motion vector type
3894
   s->mv       : motion vector
3895
   s->interlaced_dct : true if interlaced dct used (mpeg2)
3896
 */
3897
static av_always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
3898
{
3899
    int mb_x, mb_y;
3900
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3901
#ifdef HAVE_XVMC
3902
    if(s->avctx->xvmc_acceleration){
3903
        XVMC_decode_mb(s);//xvmc uses pblocks
3904
        return;
3905
    }
3906
#endif
3907

    
3908
    mb_x = s->mb_x;
3909
    mb_y = s->mb_y;
3910

    
3911
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3912
       /* save DCT coefficients */
3913
       int i,j;
3914
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3915
       for(i=0; i<6; i++)
3916
           for(j=0; j<64; j++)
3917
               *dct++ = block[i][s->dsp.idct_permutation[j]];
3918
    }
3919

    
3920
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3921

    
3922
    /* update DC predictors for P macroblocks */
3923
    if (!s->mb_intra) {
3924
        if (s->h263_pred || s->h263_aic) {
3925
            if(s->mbintra_table[mb_xy])
3926
                ff_clean_intra_table_entries(s);
3927
        } else {
3928
            s->last_dc[0] =
3929
            s->last_dc[1] =
3930
            s->last_dc[2] = 128 << s->intra_dc_precision;
3931
        }
3932
    }
3933
    else if (s->h263_pred || s->h263_aic)
3934
        s->mbintra_table[mb_xy]=1;
3935

    
3936
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
3937
        uint8_t *dest_y, *dest_cb, *dest_cr;
3938
        int dct_linesize, dct_offset;
3939
        op_pixels_func (*op_pix)[4];
3940
        qpel_mc_func (*op_qpix)[16];
3941
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
3942
        const int uvlinesize= s->current_picture.linesize[1];
3943
        const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3944
        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3945

    
3946
        /* avoid copy if macroblock skipped in last frame too */
3947
        /* skip only during decoding as we might trash the buffers during encoding a bit */
3948
        if(!s->encoding){
3949
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3950
            const int age= s->current_picture.age;
3951

    
3952
            assert(age);
3953

    
3954
            if (s->mb_skipped) {
3955
                s->mb_skipped= 0;
3956
                assert(s->pict_type!=I_TYPE);
3957

    
3958
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
3959
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3960

    
3961
                /* if previous was skipped too, then nothing to do !  */
3962
                if (*mbskip_ptr >= age && s->current_picture.reference){
3963
                    return;
3964
                }
3965
            } else if(!s->current_picture.reference){
3966
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3967
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3968
            } else{
3969
                *mbskip_ptr = 0; /* not skipped */
3970
            }
3971
        }
3972

    
3973
        dct_linesize = linesize << s->interlaced_dct;
3974
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3975

    
3976
        if(readable){
3977
            dest_y=  s->dest[0];
3978
            dest_cb= s->dest[1];
3979
            dest_cr= s->dest[2];
3980
        }else{
3981
            dest_y = s->b_scratchpad;
3982
            dest_cb= s->b_scratchpad+16*linesize;
3983
            dest_cr= s->b_scratchpad+32*linesize;
3984
        }
3985

    
3986
        if (!s->mb_intra) {
3987
            /* motion handling */
3988
            /* decoding or more than one mb_type (MC was already done otherwise) */
3989
            if(!s->encoding){
3990
                if(lowres_flag){
3991
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
3992

    
3993
                    if (s->mv_dir & MV_DIR_FORWARD) {
3994
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
3995
                        op_pix = s->dsp.avg_h264_chroma_pixels_tab;
3996
                    }
3997
                    if (s->mv_dir & MV_DIR_BACKWARD) {
3998
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
3999
                    }
4000
                }else{
4001
                    op_qpix= s->me.qpel_put;
4002
                    if ((!s->no_rounding) || s->pict_type==B_TYPE){
4003
                        op_pix = s->dsp.put_pixels_tab;
4004
                    }else{
4005
                        op_pix = s->dsp.put_no_rnd_pixels_tab;
4006
                    }
4007
                    if (s->mv_dir & MV_DIR_FORWARD) {
4008
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
4009
                        op_pix = s->dsp.avg_pixels_tab;
4010
                        op_qpix= s->me.qpel_avg;
4011
                    }
4012
                    if (s->mv_dir & MV_DIR_BACKWARD) {
4013
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
4014
                    }
4015
                }
4016
            }
4017

    
4018
            /* skip dequant / idct if we are really late ;) */
4019
            if(s->hurry_up>1) goto skip_idct;
4020
            if(s->avctx->skip_idct){
4021
                if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == B_TYPE)
4022
                   ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != I_TYPE)
4023
                   || s->avctx->skip_idct >= AVDISCARD_ALL)
4024
                    goto skip_idct;
4025
            }
4026

    
4027
            /* add dct residue */
4028
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
4029
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
4030
                add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
4031
                add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
4032
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
4033
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
4034

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

    
4054
                if(!(s->flags&CODEC_FLAG_GRAY)){
4055
                    if(s->chroma_y_shift){//Chroma420
4056
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
4057
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
4058
                    }else{
4059
                        //chroma422
4060
                        dct_linesize = uvlinesize << s->interlaced_dct;
4061
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
4062

    
4063
                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
4064
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
4065
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
4066
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
4067
                        if(!s->chroma_x_shift){//Chroma444
4068
                            add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
4069
                            add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
4070
                            add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
4071
                            add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
4072
                        }
4073
                    }
4074
                }//fi gray
4075
            }
4076
            else{
4077
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
4078
            }
4079
        } else {
4080
            /* dct only in intra block */
4081
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
4082
                put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
4083
                put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
4084
                put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
4085
                put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
4086

    
4087
                if(!(s->flags&CODEC_FLAG_GRAY)){
4088
                    if(s->chroma_y_shift){
4089
                        put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
4090
                        put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
4091
                    }else{
4092
                        dct_offset >>=1;
4093
                        dct_linesize >>=1;
4094
                        put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
4095
                        put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
4096
                        put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
4097
                        put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
4098
                    }
4099
                }
4100
            }else{
4101
                s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
4102
                s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
4103
                s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
4104
                s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
4105

    
4106
                if(!(s->flags&CODEC_FLAG_GRAY)){
4107
                    if(s->chroma_y_shift){
4108
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
4109
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
4110
                    }else{
4111

    
4112
                        dct_linesize = uvlinesize << s->interlaced_dct;
4113
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
4114

    
4115
                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
4116
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
4117
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
4118
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
4119
                        if(!s->chroma_x_shift){//Chroma444
4120
                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
4121
                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
4122
                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
4123
                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
4124
                        }
4125
                    }
4126
                }//gray
4127
            }
4128
        }
4129
skip_idct:
4130
        if(!readable){
4131
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
4132
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
4133
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
4134
        }
4135
    }
4136
}
4137

    
4138
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
4139
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
4140
    else                  MPV_decode_mb_internal(s, block, 0);
4141
}
4142

    
4143
#ifdef CONFIG_ENCODERS
4144

    
4145
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
4146
{
4147
    static const char tab[64]=
4148
        {3,2,2,1,1,1,1,1,
4149
         1,1,1,1,1,1,1,1,
4150
         1,1,1,1,1,1,1,1,
4151
         0,0,0,0,0,0,0,0,
4152
         0,0,0,0,0,0,0,0,
4153
         0,0,0,0,0,0,0,0,
4154
         0,0,0,0,0,0,0,0,
4155
         0,0,0,0,0,0,0,0};
4156
    int score=0;
4157
    int run=0;
4158
    int i;
4159
    DCTELEM *block= s->block[n];
4160
    const int last_index= s->block_last_index[n];
4161
    int skip_dc;
4162

    
4163
    if(threshold<0){
4164
        skip_dc=0;
4165
        threshold= -threshold;
4166
    }else
4167
        skip_dc=1;
4168

    
4169
    /* are all which we could set to zero are allready zero? */
4170
    if(last_index<=skip_dc - 1) return;
4171

    
4172
    for(i=0; i<=last_index; i++){
4173
        const int j = s->intra_scantable.permutated[i];
4174
        const int level = FFABS(block[j]);
4175
        if(level==1){
4176
            if(skip_dc && i==0) continue;
4177
            score+= tab[run];
4178
            run=0;
4179
        }else if(level>1){
4180
            return;
4181
        }else{
4182
            run++;
4183
        }
4184
    }
4185
    if(score >= threshold) return;
4186
    for(i=skip_dc; i<=last_index; i++){
4187
        const int j = s->intra_scantable.permutated[i];
4188
        block[j]=0;
4189
    }
4190
    if(block[0]) s->block_last_index[n]= 0;
4191
    else         s->block_last_index[n]= -1;
4192
}
4193

    
4194
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
4195
{
4196
    int i;
4197
    const int maxlevel= s->max_qcoeff;
4198
    const int minlevel= s->min_qcoeff;
4199
    int overflow=0;
4200

    
4201
    if(s->mb_intra){
4202
        i=1; //skip clipping of intra dc
4203
    }else
4204
        i=0;
4205

    
4206
    for(;i<=last_index; i++){
4207
        const int j= s->intra_scantable.permutated[i];
4208
        int level = block[j];
4209

    
4210
        if     (level>maxlevel){
4211
            level=maxlevel;
4212
            overflow++;
4213
        }else if(level<minlevel){
4214
            level=minlevel;
4215
            overflow++;
4216
        }
4217

    
4218
        block[j]= level;
4219
    }
4220

    
4221
    if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
4222
        av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel);
4223
}
4224

    
4225
#endif //CONFIG_ENCODERS
4226

    
4227
/**
4228
 *
4229
 * @param h is the normal height, this will be reduced automatically if needed for the last row
4230
 */
4231
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
4232
    if (s->avctx->draw_horiz_band) {
4233
        AVFrame *src;
4234
        int offset[4];
4235

    
4236
        if(s->picture_structure != PICT_FRAME){
4237
            h <<= 1;
4238
            y <<= 1;
4239
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
4240
        }
4241

    
4242
        h= FFMIN(h, s->avctx->height - y);
4243

    
4244
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
4245
            src= (AVFrame*)s->current_picture_ptr;
4246
        else if(s->last_picture_ptr)
4247
            src= (AVFrame*)s->last_picture_ptr;
4248
        else
4249
            return;
4250

    
4251
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
4252
            offset[0]=
4253
            offset[1]=
4254
            offset[2]=
4255
            offset[3]= 0;
4256
        }else{
4257
            offset[0]= y * s->linesize;;
4258
            offset[1]=
4259
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
4260
            offset[3]= 0;
4261
        }
4262

    
4263
        emms_c();
4264

    
4265
        s->avctx->draw_horiz_band(s->avctx, src, offset,
4266
                                  y, s->picture_structure, h);
4267
    }
4268
}
4269

    
4270
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
4271
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
4272
    const int uvlinesize= s->current_picture.linesize[1];
4273
    const int mb_size= 4 - s->avctx->lowres;
4274

    
4275
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
4276
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
4277
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
4278
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
4279
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
4280
    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;
4281
    //block_index is not used by mpeg2, so it is not affected by chroma_format
4282

    
4283
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
4284
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4285
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4286

    
4287
    if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
4288
    {
4289
        s->dest[0] += s->mb_y *   linesize << mb_size;
4290
        s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4291
        s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4292
    }
4293
}
4294

    
4295
#ifdef CONFIG_ENCODERS
4296

    
4297
static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
4298
    int x, y;
4299
//FIXME optimize
4300
    for(y=0; y<8; y++){
4301
        for(x=0; x<8; x++){
4302
            int x2, y2;
4303
            int sum=0;
4304
            int sqr=0;
4305
            int count=0;
4306

    
4307
            for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
4308
                for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
4309
                    int v= ptr[x2 + y2*stride];
4310
                    sum += v;
4311
                    sqr += v*v;
4312
                    count++;
4313
                }
4314
            }
4315
            weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
4316
        }
4317
    }
4318
}
4319

    
4320
static av_always_inline void encode_mb_internal(MpegEncContext *s, int motion_x, int motion_y, int mb_block_height, int mb_block_count)
4321
{
4322
    int16_t weight[8][64];
4323
    DCTELEM orig[8][64];
4324
    const int mb_x= s->mb_x;
4325
    const int mb_y= s->mb_y;
4326
    int i;
4327
    int skip_dct[8];
4328
    int dct_offset   = s->linesize*8; //default for progressive frames
4329
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
4330
    int wrap_y, wrap_c;
4331

    
4332
    for(i=0; i<mb_block_count; i++) skip_dct[i]=s->skipdct;
4333

    
4334
    if(s->adaptive_quant){
4335
        const int last_qp= s->qscale;
4336
        const int mb_xy= mb_x + mb_y*s->mb_stride;
4337

    
4338
        s->lambda= s->lambda_table[mb_xy];
4339
        update_qscale(s);
4340

    
4341
        if(!(s->flags&CODEC_FLAG_QP_RD)){
4342
            s->qscale= s->current_picture_ptr->qscale_table[mb_xy];
4343
            s->dquant= s->qscale - last_qp;
4344

    
4345
            if(s->out_format==FMT_H263){
4346
                s->dquant= av_clip(s->dquant, -2, 2);
4347

    
4348
                if(s->codec_id==CODEC_ID_MPEG4){
4349
                    if(!s->mb_intra){
4350
                        if(s->pict_type == B_TYPE){
4351
                            if(s->dquant&1 || s->mv_dir&MV_DIRECT)
4352
                                s->dquant= 0;
4353
                        }
4354
                        if(s->mv_type==MV_TYPE_8X8)
4355
                            s->dquant=0;
4356
                    }
4357
                }
4358
            }
4359
        }
4360
        ff_set_qscale(s, last_qp + s->dquant);
4361
    }else if(s->flags&CODEC_FLAG_QP_RD)
4362
        ff_set_qscale(s, s->qscale + s->dquant);
4363

    
4364
    wrap_y = s->linesize;
4365
    wrap_c = s->uvlinesize;
4366
    ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
4367
    ptr_cb = s->new_picture.data[1] + (mb_y * mb_block_height * wrap_c) + mb_x * 8;
4368
    ptr_cr = s->new_picture.data[2] + (mb_y * mb_block_height * wrap_c) + mb_x * 8;
4369

    
4370
    if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
4371
        uint8_t *ebuf= s->edge_emu_buffer + 32;
4372
        ff_emulated_edge_mc(ebuf            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
4373
        ptr_y= ebuf;
4374
        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);
4375
        ptr_cb= ebuf+18*wrap_y;
4376
        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);
4377
        ptr_cr= ebuf+18*wrap_y+8;
4378
    }
4379

    
4380
    if (s->mb_intra) {
4381
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4382
            int progressive_score, interlaced_score;
4383

    
4384
            s->interlaced_dct=0;
4385
            progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8)
4386
                              +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
4387

    
4388
            if(progressive_score > 0){
4389
                interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8)
4390
                                  +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
4391
                if(progressive_score > interlaced_score){
4392
                    s->interlaced_dct=1;
4393

    
4394
                    dct_offset= wrap_y;
4395
                    wrap_y<<=1;
4396
                    if (s->chroma_format == CHROMA_422)
4397
                        wrap_c<<=1;
4398
                }
4399
            }
4400
        }
4401

    
4402
        s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
4403
        s->dsp.get_pixels(s->block[1], ptr_y              + 8, wrap_y);
4404
        s->dsp.get_pixels(s->block[2], ptr_y + dct_offset    , wrap_y);
4405
        s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
4406

    
4407
        if(s->flags&CODEC_FLAG_GRAY){
4408
            skip_dct[4]= 1;
4409
            skip_dct[5]= 1;
4410
        }else{
4411
            s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
4412
            s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
4413
            if(!s->chroma_y_shift){ /* 422 */
4414
                s->dsp.get_pixels(s->block[6], ptr_cb + (dct_offset>>1), wrap_c);
4415
                s->dsp.get_pixels(s->block[7], ptr_cr + (dct_offset>>1), wrap_c);
4416
            }
4417
        }
4418
    }else{
4419
        op_pixels_func (*op_pix)[4];
4420
        qpel_mc_func (*op_qpix)[16];
4421
        uint8_t *dest_y, *dest_cb, *dest_cr;
4422

    
4423
        dest_y  = s->dest[0];
4424
        dest_cb = s->dest[1];
4425
        dest_cr = s->dest[2];
4426

    
4427
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
4428
            op_pix = s->dsp.put_pixels_tab;
4429
            op_qpix= s->dsp.put_qpel_pixels_tab;
4430
        }else{
4431
            op_pix = s->dsp.put_no_rnd_pixels_tab;
4432
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
4433
        }
4434

    
4435
        if (s->mv_dir & MV_DIR_FORWARD) {
4436
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
4437
            op_pix = s->dsp.avg_pixels_tab;
4438
            op_qpix= s->dsp.avg_qpel_pixels_tab;
4439
        }
4440
        if (s->mv_dir & MV_DIR_BACKWARD) {
4441
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
4442
        }
4443

    
4444
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4445
            int progressive_score, interlaced_score;
4446

    
4447
            s->interlaced_dct=0;
4448
            progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8)
4449
                              +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
4450

    
4451
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
4452

    
4453
            if(progressive_score>0){
4454
                interlaced_score = s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y*2, 8)
4455
                                  +s->dsp.ildct_cmp[0](s, dest_y + wrap_y  , ptr_y + wrap_y  , wrap_y*2, 8);
4456

    
4457
                if(progressive_score > interlaced_score){
4458
                    s->interlaced_dct=1;
4459

    
4460
                    dct_offset= wrap_y;
4461
                    wrap_y<<=1;
4462
                    if (s->chroma_format == CHROMA_422)
4463
                        wrap_c<<=1;
4464
                }
4465
            }
4466
        }
4467

    
4468
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
4469
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
4470
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
4471
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
4472

    
4473
        if(s->flags&CODEC_FLAG_GRAY){
4474
            skip_dct[4]= 1;
4475
            skip_dct[5]= 1;
4476
        }else{
4477
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
4478
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
4479
            if(!s->chroma_y_shift){ /* 422 */
4480
                s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset>>1), dest_cb + (dct_offset>>1), wrap_c);
4481
                s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset>>1), dest_cr + (dct_offset>>1), wrap_c);
4482
            }
4483
        }
4484
        /* pre quantization */
4485
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
4486
            //FIXME optimize
4487
            if(s->dsp.sad[1](NULL, ptr_y               , dest_y               , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
4488
            if(s->dsp.sad[1](NULL, ptr_y            + 8, dest_y            + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
4489
            if(s->dsp.sad[1](NULL, ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
4490
            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;
4491
            if(s->dsp.sad[1](NULL, ptr_cb              , dest_cb              , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
4492
            if(s->dsp.sad[1](NULL, ptr_cr              , dest_cr              , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
4493
            if(!s->chroma_y_shift){ /* 422 */
4494
                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;
4495
                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;
4496
            }
4497
        }
4498
    }
4499

    
4500
    if(s->avctx->quantizer_noise_shaping){
4501
        if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y                 , wrap_y);
4502
        if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y              + 8, wrap_y);
4503
        if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset    , wrap_y);
4504
        if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
4505
        if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb                , wrap_c);
4506
        if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr                , wrap_c);
4507
        if(!s->chroma_y_shift){ /* 422 */
4508
            if(!skip_dct[6]) get_vissual_weight(weight[6], ptr_cb + (dct_offset>>1), wrap_c);
4509
            if(!skip_dct[7]) get_vissual_weight(weight[7], ptr_cr + (dct_offset>>1), wrap_c);
4510
        }
4511
        memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*mb_block_count);
4512
    }
4513

    
4514
    /* DCT & quantize */
4515
    assert(s->out_format!=FMT_MJPEG || s->qscale==8);
4516
    {
4517
        for(i=0;i<mb_block_count;i++) {
4518
            if(!skip_dct[i]){
4519
                int overflow;
4520
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
4521
            // FIXME we could decide to change to quantizer instead of clipping
4522
            // JS: I don't think that would be a good idea it could lower quality instead
4523
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
4524
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
4525
            }else
4526
                s->block_last_index[i]= -1;
4527
        }
4528
        if(s->avctx->quantizer_noise_shaping){
4529
            for(i=0;i<mb_block_count;i++) {
4530
                if(!skip_dct[i]){
4531
                    s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
4532
                }
4533
            }
4534
        }
4535

    
4536
        if(s->luma_elim_threshold && !s->mb_intra)
4537
            for(i=0; i<4; i++)
4538
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
4539
        if(s->chroma_elim_threshold && !s->mb_intra)
4540
            for(i=4; i<mb_block_count; i++)
4541
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
4542

    
4543
        if(s->flags & CODEC_FLAG_CBP_RD){
4544
            for(i=0;i<mb_block_count;i++) {
4545
                if(s->block_last_index[i] == -1)
4546
                    s->coded_score[i]= INT_MAX/256;
4547
            }
4548
        }
4549
    }
4550

    
4551
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
4552
        s->block_last_index[4]=
4553
        s->block_last_index[5]= 0;
4554
        s->block[4][0]=
4555
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
4556
    }
4557

    
4558
    //non c quantize code returns incorrect block_last_index FIXME
4559
    if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
4560
        for(i=0; i<mb_block_count; i++){
4561
            int j;
4562
            if(s->block_last_index[i]>0){
4563
                for(j=63; j>0; j--){
4564
                    if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
4565
                }
4566
                s->block_last_index[i]= j;
4567
            }
4568
        }
4569
    }
4570

    
4571
    /* huffman encode */
4572
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
4573
    case CODEC_ID_MPEG1VIDEO:
4574
    case CODEC_ID_MPEG2VIDEO:
4575
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
4576
    case CODEC_ID_MPEG4:
4577
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4578
    case CODEC_ID_MSMPEG4V2:
4579
    case CODEC_ID_MSMPEG4V3:
4580
    case CODEC_ID_WMV1:
4581
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4582
    case CODEC_ID_WMV2:
4583
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
4584
#ifdef CONFIG_H261_ENCODER
4585
    case CODEC_ID_H261:
4586
        ff_h261_encode_mb(s, s->block, motion_x, motion_y); break;
4587
#endif
4588
    case CODEC_ID_H263:
4589
    case CODEC_ID_H263P:
4590
    case CODEC_ID_FLV1:
4591
    case CODEC_ID_RV10:
4592
    case CODEC_ID_RV20:
4593
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
4594
    case CODEC_ID_MJPEG:
4595
        mjpeg_encode_mb(s, s->block); break;
4596
    default:
4597
        assert(0);
4598
    }
4599
}
4600

    
4601
static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
4602
{
4603
    if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y,  8, 6);
4604
    else                                encode_mb_internal(s, motion_x, motion_y, 16, 8);
4605
}
4606

    
4607
#endif //CONFIG_ENCODERS
4608

    
4609
void ff_mpeg_flush(AVCodecContext *avctx){
4610
    int i;
4611
    MpegEncContext *s = avctx->priv_data;
4612

    
4613
    if(s==NULL || s->picture==NULL)
4614
        return;
4615

    
4616
    for(i=0; i<MAX_PICTURE_COUNT; i++){
4617
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
4618
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
4619
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
4620
    }
4621
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
4622

    
4623
    s->mb_x= s->mb_y= 0;
4624

    
4625
    s->parse_context.state= -1;
4626
    s->parse_context.frame_start_found= 0;
4627
    s->parse_context.overread= 0;
4628
    s->parse_context.overread_index= 0;
4629
    s->parse_context.index= 0;
4630
    s->parse_context.last_index= 0;
4631
    s->bitstream_buffer_size=0;
4632
    s->pp_time=0;
4633
}
4634

    
4635
#ifdef CONFIG_ENCODERS
4636
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4637
{
4638
    const uint16_t *srcw= (uint16_t*)src;
4639
    int words= length>>4;
4640
    int bits= length&15;
4641
    int i;
4642

    
4643
    if(length==0) return;
4644

    
4645
    if(words < 16){
4646
        for(i=