Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ cf329752

History | View | Annotate | Download (252 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 "msmpeg4.h"
34
#include "faandct.h"
35
#include <limits.h>
36

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

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

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

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

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

    
78

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

    
82
//#define DEBUG
83

    
84

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

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

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

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

    
110
#ifdef CONFIG_ENCODERS
111
static uint8_t default_mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
112
static uint8_t default_fcode_tab[MAX_MV*2+1];
113

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

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

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

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

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

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

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

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

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

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

    
202
    st->scantable= src_scantable;
203

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

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

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

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

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

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

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

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

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

    
263
    return p+4;
264
}
265

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

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

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

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

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

    
309
#endif //CONFIG_ENCODERS
310

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

    
324
    return 0;
325
}
326

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
608
    s->picture_in_gop_number = 0;
609

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

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

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

    
627
#ifdef CONFIG_ENCODERS
628
static void MPV_encode_defaults(MpegEncContext *s){
629
    int i;
630
    MPV_common_defaults(s);
631

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

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

    
648
    s->mb_height = (s->height + 15) / 16;
649

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

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

    
658
    dsputil_init(&s->dsp, s->avctx);
659
    DCT_common_init(s);
660

    
661
    s->flags= s->avctx->flags;
662
    s->flags2= s->avctx->flags2;
663

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

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

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

    
679
    s->mb_num = s->mb_width * s->mb_height;
680

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

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

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

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

    
703
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
704

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

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

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

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

    
736
        CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
737

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

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

    
751
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
752

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

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

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

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

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

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

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

    
812
    s->context_initialized = 1;
813

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

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

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

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

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

    
845
    av_freep(&s->parse_context.buffer);
846
    s->parse_context.buffer_size=0;
847

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

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

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

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

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

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

    
914
    avcodec_default_free_buffers(s->avctx);
915
}
916

    
917
#ifdef CONFIG_ENCODERS
918

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

    
926
    MPV_encode_defaults(s);
927

    
928
    switch (avctx->codec_id) {
929
    case CODEC_ID_MPEG2VIDEO:
930
        if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P){
931
            av_log(avctx, AV_LOG_ERROR, "only YUV420 and YUV422 are supported\n");
932
            return -1;
933
        }
934
        break;
935
    case CODEC_ID_LJPEG:
936
    case CODEC_ID_MJPEG:
937
        if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUVJ422P &&
938
           ((avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P) || avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL)){
939
            av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
940
            return -1;
941
        }
942
        break;
943
    default:
944
        if(avctx->pix_fmt != PIX_FMT_YUV420P){
945
            av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
946
            return -1;
947
        }
948
    }
949

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

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

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

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

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

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

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

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

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

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

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

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

    
1035
        av_log(avctx, AV_LOG_INFO, "Warning vbv_delay will be set to 0xFFFF (=VBR) as the specified vbv buffer is too large for the given bitrate!\n");
1036
    }
1037

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

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

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

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

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

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

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

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

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

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

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

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

    
1100
    if(s->flags & CODEC_FLAG_LOW_DELAY){
1101
        if (s->codec_id != CODEC_ID_MPEG2VIDEO && s->codec_id != CODEC_ID_MPEG1VIDEO){
1102
            av_log(avctx, AV_LOG_ERROR, "low delay forcing is only available for mpeg1/2\n");
1103
            return -1;
1104
        }
1105
        if (s->max_b_frames != 0){
1106
            av_log(avctx, AV_LOG_ERROR, "b frames cannot be used with low delay\n");
1107
            return -1;
1108
        }
1109
    }
1110

    
1111
    if(s->q_scale_type == 1){
1112
        if(s->codec_id != CODEC_ID_MPEG2VIDEO){
1113
            av_log(avctx, AV_LOG_ERROR, "non linear quant is only available for mpeg2\n");
1114
            return -1;
1115
        }
1116
        if(avctx->qmax > 12){
1117
            av_log(avctx, AV_LOG_ERROR, "non linear quant only supports qmax <= 12 currently\n");
1118
            return -1;
1119
        }
1120
    }
1121

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

    
1129
    if(s->avctx->thread_count > 1)
1130
        s->rtp_mode= 1;
1131

    
1132
    if(!avctx->time_base.den || !avctx->time_base.num){
1133
        av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1134
        return -1;
1135
    }
1136

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

    
1147
    if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
1148
        av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n");
1149
        avctx->b_frame_strategy = 0;
1150
    }
1151

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

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

    
1171
    if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1172
        s->intra_quant_bias= avctx->intra_quant_bias;
1173
    if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1174
        s->inter_quant_bias= avctx->inter_quant_bias;
1175

    
1176
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1177

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

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

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

    
1334
    avctx->has_b_frames= !s->low_delay;
1335

    
1336
    s->encoding = 1;
1337

    
1338
    /* init */
1339
    if (MPV_common_init(s) < 0)
1340
        return -1;
1341

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

    
1348
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1349
    ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1350

    
1351
#ifdef CONFIG_H261_ENCODER
1352
    if (s->out_format == FMT_H261)
1353
        ff_h261_encode_init(s);
1354
#endif
1355
    if (s->out_format == FMT_H263)
1356
        h263_encode_init(s);
1357
    if (ENABLE_MSMPEG4_ENCODER && s->msmpeg4_version)
1358
        ff_msmpeg4_encode_init(s);
1359
    if (s->out_format == FMT_MPEG1)
1360
        ff_mpeg1_encode_init(s);
1361

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

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

    
1391
    if(ff_rate_control_init(s) < 0)
1392
        return -1;
1393

    
1394
    return 0;
1395
}
1396

    
1397
int MPV_encode_end(AVCodecContext *avctx)
1398
{
1399
    MpegEncContext *s = avctx->priv_data;
1400

    
1401
    ff_rate_control_uninit(s);
1402

    
1403
    MPV_common_end(s);
1404
    if (s->out_format == FMT_MJPEG)
1405
        mjpeg_close(s);
1406

    
1407
    av_freep(&avctx->extradata);
1408

    
1409
    return 0;
1410
}
1411

    
1412
#endif //CONFIG_ENCODERS
1413

    
1414
void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
1415
{
1416
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1417
    uint8_t index_run[MAX_RUN+1];
1418
    int last, run, level, start, end, i;
1419

    
1420
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
1421
    if(static_store && rl->max_level[0])
1422
        return;
1423

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

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

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

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

    
1494
int ff_find_unused_picture(MpegEncContext *s, int shared){
1495
    int i;
1496

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

    
1510
    assert(0);
1511
    return -1;
1512
}
1513

    
1514
static void update_noise_reduction(MpegEncContext *s){
1515
    int intra, i;
1516

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

    
1525
        for(i=0; i<64; i++){
1526
            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);
1527
        }
1528
    }
1529
}
1530

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

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

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

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

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

    
1575
        pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1576
                        && !s->dropable ? 3 : 0;
1577

    
1578
        pic->coded_picture_number= s->coded_picture_number++;
1579

    
1580
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1581
            return -1;
1582

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

    
1588
    s->current_picture_ptr->pict_type= s->pict_type;
1589
//    if(s->flags && CODEC_FLAG_QSCALE)
1590
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1591
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1592

    
1593
    copy_picture(&s->current_picture, s->current_picture_ptr);
1594

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

    
1606
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1607
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1608

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

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

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

    
1629
    s->hurry_up= s->avctx->hurry_up;
1630
    s->error_resilience= avctx->error_resilience;
1631

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

    
1645
    if(s->dct_error_sum){
1646
        assert(s->avctx->noise_reduction && s->encoding);
1647

    
1648
        update_noise_reduction(s);
1649
    }
1650

    
1651
#ifdef HAVE_XVMC
1652
    if(s->avctx->xvmc_acceleration)
1653
        return XVMC_field_start(s, avctx);
1654
#endif
1655
    return 0;
1656
}
1657

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

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

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

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

    
1719
    sx= av_clip(sx, 0, w-1);
1720
    sy= av_clip(sy, 0, h-1);
1721
    ex= av_clip(ex, 0, w-1);
1722
    ey= av_clip(ey, 0, h-1);
1723

    
1724
    buf[sy*stride + sx]+= color;
1725

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

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

    
1768
    sx= av_clip(sx, -100, w+100);
1769
    sy= av_clip(sy, -100, h+100);
1770
    ex= av_clip(ex, -100, w+100);
1771
    ey= av_clip(ey, -100, h+100);
1772

    
1773
    dx= ex - sx;
1774
    dy= ey - sy;
1775

    
1776
    if(dx*dx + dy*dy > 3*3){
1777
        int rx=  dx + dy;
1778
        int ry= -dx + dy;
1779
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1780

    
1781
        //FIXME subpixel accuracy
1782
        rx= ROUNDED_DIV(rx*3<<4, length);
1783
        ry= ROUNDED_DIV(ry*3<<4, length);
1784

    
1785
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1786
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1787
    }
1788
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1789
}
1790

    
1791
/**
1792
 * prints debuging info for the given picture.
1793
 */
1794
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1795

    
1796
    if(!pict || !pict->mb_type) return;
1797

    
1798
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1799
        int x,y;
1800

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

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

    
1862

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

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

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

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

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

    
1938
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1939
                            my*=2;
1940

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

    
1952
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1953
                            my*=2;
1954

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

    
1983

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

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

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

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

    
2052
#ifdef CONFIG_ENCODERS
2053

    
2054
static int get_sae(uint8_t *src, int ref, int stride){
2055
    int x,y;
2056
    int acc=0;
2057

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

    
2064
    return acc;
2065
}
2066

    
2067
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
2068
    int x, y, w, h;
2069
    int acc=0;
2070

    
2071
    w= s->width &~15;
2072
    h= s->height&~15;
2073

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

    
2081
            acc+= sae + 500 < sad;
2082
        }
2083
    }
2084
    return acc;
2085
}
2086

    
2087

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

    
2095
    if(pic_arg){
2096
        pts= pic_arg->pts;
2097
        pic_arg->display_picture_number= s->input_picture_number++;
2098

    
2099
        if(pts != AV_NOPTS_VALUE){
2100
            if(s->user_specified_pts != AV_NOPTS_VALUE){
2101
                int64_t time= pts;
2102
                int64_t last= s->user_specified_pts;
2103

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

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

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

    
2129
    if(direct){
2130
        i= ff_find_unused_picture(s, 1);
2131

    
2132
        pic= (AVFrame*)&s->picture[i];
2133
        pic->reference= 3;
2134

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

    
2143
        pic= (AVFrame*)&s->picture[i];
2144
        pic->reference= 3;
2145

    
2146
        alloc_picture(s, (Picture*)pic, 0);
2147

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

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

    
2166
                if(!s->avctx->rc_buffer_size)
2167
                    dst +=INPLACE_OFFSET;
2168

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

    
2185
    /* shift buffer entries */
2186
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2187
        s->input_picture[i-1]= s->input_picture[i];
2188

    
2189
    s->input_picture[encoding_delay]= (Picture*)pic;
2190

    
2191
    return 0;
2192
}
2193

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

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

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

    
2218
    if(score) score64= score;
2219

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

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

    
2238
    assert(scale>=0 && scale <=3);
2239

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

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

    
2258
    if (avcodec_open(c, codec) < 0)
2259
        return -1;
2260

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

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

    
2274
        if(pre_input_ptr && (!i || s->input_picture[i-1])) {
2275
            pre_input= *pre_input_ptr;
2276

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

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

    
2289
    for(j=0; j<s->max_b_frames+1; j++){
2290
        int64_t rd=0;
2291

    
2292
        if(!s->input_picture[j])
2293
            break;
2294

    
2295
        c->error[0]= c->error[1]= c->error[2]= 0;
2296

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

    
2302
        for(i=0; i<s->max_b_frames+1; i++){
2303
            int is_p= i % (j+1) == j || i==s->max_b_frames;
2304

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

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

    
2317
        rd += c->error[0] + c->error[1] + c->error[2];
2318

    
2319
        if(rd < best_rd){
2320
            best_rd= rd;
2321
            best_b_count= j;
2322
        }
2323
    }
2324

    
2325
    av_freep(&outbuf);
2326
    avcodec_close(c);
2327
    av_freep(&c);
2328

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

    
2333
    return best_b_count;
2334
}
2335

    
2336
static void select_input_picture(MpegEncContext *s){
2337
    int i;
2338

    
2339
    for(i=1; i<MAX_PICTURE_COUNT; i++)
2340
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2341
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2342

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

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

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

    
2365
                        s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2366
                    }
2367

    
2368
                    emms_c();
2369
                    ff_vbv_update(s, 0);
2370

    
2371
                    goto no_output_pic;
2372
                }
2373
            }
2374

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

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

    
2386
                    s->input_picture[i]->pict_type=
2387
                        s->rc_context.entry[pict_num].new_pict_type;
2388
                }
2389
            }
2390

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

    
2406
                b_frames= FFMAX(0, i-1);
2407

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

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

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

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

    
2443
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2444
               && b_frames
2445
               && s->input_picture[b_frames]->pict_type== I_TYPE)
2446
                b_frames--;
2447

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

    
2463
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2464

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

    
2468
            int i= ff_find_unused_picture(s, 0);
2469
            Picture *pic= &s->picture[i];
2470

    
2471
            pic->reference              = s->reordered_input_picture[0]->reference;
2472
            alloc_picture(s, pic, 0);
2473

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

    
2481
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2482

    
2483
            s->current_picture_ptr= pic;
2484
        }else{
2485
            // input is not a shared pix -> reuse buffer for current_pix
2486

    
2487
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2488
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2489

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

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

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

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

    
2518
        init_put_bits(&s->thread_context[i]->pb, start, end - start);
2519
    }
2520

    
2521
    s->picture_in_gop_number++;
2522

    
2523
    if(load_input_picture(s, pic_arg) < 0)
2524
        return -1;
2525

    
2526
    select_input_picture(s);
2527

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

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

    
2548
        MPV_frame_end(s);
2549

    
2550
        if (s->out_format == FMT_MJPEG)
2551
            mjpeg_picture_trailer(s);
2552

    
2553
        if(avctx->rc_buffer_size){
2554
            RateControlContext *rcc= &s->rc_context;
2555
            int max_size= rcc->buffer_index/3;
2556

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

    
2581
            assert(s->avctx->rc_max_rate);
2582
        }
2583

    
2584
        if(s->flags&CODEC_FLAG_PASS1)
2585
            ff_write_pass1_stats(s);
2586

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

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

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

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

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

    
2631
            assert(s->repeat_first_field==0);
2632

    
2633
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2634
            assert(vbv_delay < 0xFFFF);
2635

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

    
2650
    return s->frame_bits/8;
2651
}
2652

    
2653
#endif //CONFIG_ENCODERS
2654

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

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

    
2677
    linesize = s->linesize;
2678
    uvlinesize = s->uvlinesize;
2679

    
2680
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2681

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

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

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

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

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

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

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

    
2738
    return;
2739
}
2740

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

    
2750
    linesize = s->linesize;
2751
    uvlinesize = s->uvlinesize;
2752

    
2753
    ptr = ref_picture[0];
2754

    
2755
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2756
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2757

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

    
2773
    if(s->flags&CODEC_FLAG_GRAY) return;
2774

    
2775
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2776
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2777

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

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

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

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

    
2829
    start_y= FFMAX(0, -src_y);
2830
    start_x= FFMAX(0, -src_x);
2831
    end_y= FFMIN(block_h, h-src_y);
2832
    end_x= FFMIN(block_w, w-src_x);
2833

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

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

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

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

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

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

    
2880
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2881
    src_x += motion_x >> 1;
2882
    src_y += motion_y >> 1;
2883

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

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

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

    
2922
    if(s->quarter_sample){
2923
        motion_x/=2;
2924
        motion_y/=2;
2925
    }
2926

    
2927
    sx= motion_x & s_mask;
2928
    sy= motion_y & s_mask;
2929
    src_x += motion_x >> (lowres+1);
2930
    src_y += motion_y >> (lowres+1);
2931

    
2932
    src += src_y * stride + src_x;
2933

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

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

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

    
2960
#if 0
2961
if(s->quarter_sample)
2962
{
2963
    motion_x>>=1;
2964
    motion_y>>=1;
2965
}
2966
#endif
2967

    
2968
    v_edge_pos = s->v_edge_pos >> field_based;
2969
    linesize   = s->current_picture.linesize[0] << field_based;
2970
    uvlinesize = s->current_picture.linesize[1] << field_based;
2971

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

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

    
3017
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
3018
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3019
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3020

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

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

    
3048
    if(field_select){
3049
        ptr_y += s->linesize;
3050
        ptr_cb+= s->uvlinesize;
3051
        ptr_cr+= s->uvlinesize;
3052
    }
3053

    
3054
    pix_op[0][dxy](dest_y, ptr_y, linesize, h);
3055

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

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

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

    
3089
    if(field_based){
3090
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
3091
    }
3092

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

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

    
3119
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
3120
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3121
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3122

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

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

    
3145
    if(field_select){
3146
        ptr_y += s->linesize;
3147
        ptr_cb+= s->uvlinesize;
3148
        ptr_cr+= s->uvlinesize;
3149
    }
3150

    
3151
    sx <<= 2 - lowres;
3152
    sy <<= 2 - lowres;
3153
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
3154

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

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

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

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

    
3227
    assert(s->quarter_sample==0);
3228

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

    
3243
    put_obmc(dest, ptr, s->linesize);
3244
}
3245

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

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

    
3260
    v_edge_pos = s->v_edge_pos >> field_based;
3261
    linesize = s->linesize << field_based;
3262
    uvlinesize = s->uvlinesize << field_based;
3263

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

    
3281
    uvdxy= (mx&1) | ((my&1)<<1);
3282
    mx>>=1;
3283
    my>>=1;
3284

    
3285
    uvsrc_x = s->mb_x *  8                 + mx;
3286
    uvsrc_y = s->mb_y * (8 >> field_based) + my;
3287

    
3288
    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
3289
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3290
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3291

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

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

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

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

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

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

    
3358
    dxy = ((my & 1) << 1) | (mx & 1);
3359
    mx >>= 1;
3360
    my >>= 1;
3361

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

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

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

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

    
3404
    if(s->quarter_sample){
3405
        mx/=2;
3406
        my/=2;
3407
    }
3408

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

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

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

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

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

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

    
3474
    mb_x = s->mb_x;
3475
    mb_y = s->mb_y;
3476

    
3477
    prefetch_motion(s, ref_picture, dir);
3478

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

    
3485
        assert(!s->mb_skipped);
3486

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

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

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

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

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

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

    
3537
        return;
3538
    }
3539

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

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

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

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

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

    
3611
                mx += s->mv[dir][i][0];
3612
                my += s->mv[dir][i][1];
3613
            }
3614
        }
3615

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

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

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

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

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

    
3690
                // after put we make avg of the same block
3691
                pix_op=s->dsp.avg_pixels_tab;
3692

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

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

    
3725
    mb_x = s->mb_x;
3726
    mb_y = s->mb_y;
3727

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

    
3747
                mx += s->mv[dir][i][0];
3748
                my += s->mv[dir][i][1];
3749
            }
3750

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

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

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

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

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

    
3816
                // after put we make avg of the same block
3817
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3818

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

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

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

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

    
3853
        s->dsp.idct_add (dest, line_size, block);
3854
    }
3855
}
3856

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

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

    
3887
    s->mbintra_table[xy]= 0;
3888
}
3889

    
3890
/* generic function called after a macroblock has been parsed by the
3891
   decoder or after it has been encoded by the encoder.
3892

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

    
3911
    mb_x = s->mb_x;
3912
    mb_y = s->mb_y;
3913

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

    
3923
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3924

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

    
3939
    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
3940
        uint8_t *dest_y, *dest_cb, *dest_cr;
3941
        int dct_linesize, dct_offset;
3942
        op_pixels_func (*op_pix)[4];
3943
        qpel_mc_func (*op_qpix)[16];
3944
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
3945
        const int uvlinesize= s->current_picture.linesize[1];
3946
        const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3947
        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3948

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

    
3955
            assert(age);
3956

    
3957
            if (s->mb_skipped) {
3958
                s->mb_skipped= 0;
3959
                assert(s->pict_type!=I_TYPE);
3960

    
3961
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
3962
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3963

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

    
3976
        dct_linesize = linesize << s->interlaced_dct;
3977
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3978

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

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

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

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

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

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

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

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

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

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

    
4115
                        dct_linesize = uvlinesize << s->interlaced_dct;
4116
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
4117

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

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

    
4146
#ifdef CONFIG_ENCODERS
4147

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

    
4166
    if(threshold<0){
4167
        skip_dc=0;
4168
        threshold= -threshold;
4169
    }else
4170
        skip_dc=1;
4171

    
4172
    /* are all which we could set to zero are allready zero? */
4173
    if(last_index<=skip_dc - 1) return;
4174

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

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

    
4204
    if(s->mb_intra){
4205
        i=1; //skip clipping of intra dc
4206
    }else
4207
        i=0;
4208

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

    
4213
        if     (level>maxlevel){
4214
            level=maxlevel;
4215
            overflow++;
4216
        }else if(level<minlevel){
4217
            level=minlevel;
4218
            overflow++;
4219
        }
4220

    
4221
        block[j]= level;
4222
    }
4223

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

    
4228
#endif //CONFIG_ENCODERS
4229

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

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

    
4245
        h= FFMIN(h, s->avctx->height - y);
4246

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

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

    
4266
        emms_c();
4267

    
4268
        s->avctx->draw_horiz_band(s->avctx, src, offset,
4269
                                  y, s->picture_structure, h);
4270
    }
4271
}
4272

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

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

    
4286
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
4287
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4288
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4289

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

    
4298
#ifdef CONFIG_ENCODERS
4299

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

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

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

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

    
4337
    if(s->adaptive_quant){
4338
        const int last_qp= s->qscale;
4339
        const int mb_xy= mb_x + mb_y*s->mb_stride;
4340

    
4341
        s->lambda= s->lambda_table[mb_xy];
4342
        update_qscale(s);
4343

    
4344
        if(!(s->flags&CODEC_FLAG_QP_RD)){
4345
            s->qscale= s->current_picture_ptr->qscale_table[mb_xy];
4346
            s->dquant= s->qscale - last_qp;
4347

    
4348
            if(s->out_format==FMT_H263){
4349
                s->dquant= av_clip(s->dquant, -2, 2);
4350

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

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

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

    
4383
    if (s->mb_intra) {
4384
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4385
            int progressive_score, interlaced_score;
4386

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

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

    
4397
                    dct_offset= wrap_y;
4398
                    wrap_y<<=1;
4399
                    if (s->chroma_format == CHROMA_422)
4400
                        wrap_c<<=1;
4401
                }
4402
            }
4403
        }
4404

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

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

    
4426
        dest_y  = s->dest[0];
4427
        dest_cb = s->dest[1];
4428
        dest_cr = s->dest[2];
4429

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

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

    
4447
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4448
            int progressive_score, interlaced_score;
4449

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

    
4454
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
4455

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

    
4460
                if(progressive_score > interlaced_score){
4461
                    s->interlaced_dct=1;
4462

    
4463
                    dct_offset= wrap_y;
4464
                    wrap_y<<=1;
4465
                    if (s->chroma_format == CHROMA_422)
4466
                        wrap_c<<=1;
4467
                }
4468
            }
4469
        }
4470

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

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

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

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

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

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

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

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

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

    
4608
static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
4609
{
4610
    if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y,  8, 6);
4611
    else                                encode_mb_internal(s, motion_x, motion_y, 16, 8);
4612
}
4613

    
4614
#endif //CONFIG_ENCODERS
4615

    
4616
void ff_mpeg_flush(AVCodecContext *avctx){
4617
    int i;
4618
    MpegEncContext *s = avctx->priv_data;
4619

    
4620
    if(s==NULL || s->picture==NULL)
4621
        return;
4622

    
4623
    for(i=0; i<MAX_PICTURE_COUNT; i++){
4624
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
4625
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
4626
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
4627
    }
4628
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
4629

    
4630
    s->mb_x= s->mb_y= 0;
4631

    
4632
    s->parse_context.state= -1;
4633
    s->parse_context.frame_start_found= 0;
4634
    s->parse_context.overread= 0;
4635
    s->parse_context.overread_index= 0;
4636
    s->parse_context.index= 0;
4637
    s->parse_context.last_index= 0;
4638
    s->bitstream_buffer_size=0;
4639
    s->pp_time=0;
4640
}
4641

    
4642
#ifdef CONFIG_ENCODERS
4643
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4644
{
4645