Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 15025553

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

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

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

    
1337
    s->encoding = 1;
1338

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

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

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

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

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

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

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

    
1395
    return 0;
1396
}
1397

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

    
1402
    ff_rate_control_uninit(s);
1403

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

    
1408
    av_freep(&avctx->extradata);
1409

    
1410
    return 0;
1411
}
1412

    
1413
#endif //CONFIG_ENCODERS
1414

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1649
        update_noise_reduction(s);
1650
    }
1651

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1863

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

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

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

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

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

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

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

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

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

    
1984

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

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

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

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

    
2053
#ifdef CONFIG_ENCODERS
2054

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

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

    
2065
    return acc;
2066
}
2067

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

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

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

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

    
2088

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2192
    return 0;
2193
}
2194

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

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

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

    
2219
    if(score) score64= score;
2220

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2334
    return best_b_count;
2335
}
2336

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

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

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

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

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

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

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

    
2372
                    goto no_output_pic;
2373
                }
2374
            }
2375

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2522
    s->picture_in_gop_number++;
2523

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

    
2527
    select_input_picture(s);
2528

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

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

    
2549
        MPV_frame_end(s);
2550

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2654
#endif //CONFIG_ENCODERS
2655

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

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

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

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

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

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

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

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

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

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

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

    
2739
    return;
2740
}
2741

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

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

    
2754
    ptr = ref_picture[0];
2755

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2933
    src += src_y * stride + src_x;
2934

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3478
    prefetch_motion(s, ref_picture, dir);
3479

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

    
3486
        assert(!s->mb_skipped);
3487

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

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

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

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

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

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

    
3538
        return;
3539
    }
3540

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3956
            assert(age);
3957

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4147
#ifdef CONFIG_ENCODERS
4148

    
4149
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
4150
{
4151
    static const char tab[64]=
4152
        {3,2,2,1,1,1,1,1,
4153
         1,1,1,1,1,1,1,1,
4154
         1,1,1,1,1,1,1,1,
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
         0,0,0,0,0,0,0,0};
4160
    int score=0;
4161
    int run=0;
4162
    int i;
4163
    DCTELEM *block= s->block[n];
4164
    const int last_index= s->block_last_index[n];
4165
    int skip_dc;
4166

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

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

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

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

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

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

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

    
4222
        block[j]= level;
4223
    }
4224

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

    
4229
#endif //CONFIG_ENCODERS
4230

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

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

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

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

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

    
4267
        emms_c();
4268

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

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

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

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

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

    
4299
#ifdef CONFIG_ENCODERS
4300

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4613
#endif //CONFIG_ENCODERS
4614

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

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

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

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

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

    
4641
#ifdef CONFIG_ENCODERS
4642
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4643
{
4644
    const uint16_t *srcw= (uint16_t*)