Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 70724cba

History | View | Annotate | Download (252 KB)

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

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

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

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

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

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

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

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

    
78

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

    
82
//#define DEBUG
83

    
84

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
202
    st->scantable= src_scantable;
203

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

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

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

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

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

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

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

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

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

    
263
    return p+4;
264
}
265

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

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

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

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

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

    
309
#endif //CONFIG_ENCODERS
310

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

    
324
    return 0;
325
}
326

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
608
    s->picture_in_gop_number = 0;
609

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
812
    s->context_initialized = 1;
813

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

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

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

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

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

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

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

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

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

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

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

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

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

    
917
#ifdef CONFIG_ENCODERS
918

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

    
926
    MPV_encode_defaults(s);
927

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1335
    s->encoding = 1;
1336

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

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

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

    
1350
    if (ENABLE_H261_ENCODER && s->out_format == FMT_H261)
1351
        ff_h261_encode_init(s);
1352
    if (s->out_format == FMT_H263)
1353
        h263_encode_init(s);
1354
    if (ENABLE_MSMPEG4_ENCODER && s->msmpeg4_version)
1355
        ff_msmpeg4_encode_init(s);
1356
    if (s->out_format == FMT_MPEG1)
1357
        ff_mpeg1_encode_init(s);
1358

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

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

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

    
1391
    return 0;
1392
}
1393

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

    
1398
    ff_rate_control_uninit(s);
1399

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

    
1404
    av_freep(&avctx->extradata);
1405

    
1406
    return 0;
1407
}
1408

    
1409
#endif //CONFIG_ENCODERS
1410

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

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

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

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

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

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

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

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

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

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

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

    
1522
        for(i=0; i<64; i++){
1523
            s->dct_offset[intra][i]= (s->avctx->noise_reduction * s->dct_count[intra] + s->dct_error_sum[intra][i]/2) / (s->dct_error_sum[intra][i]+1);
1524
        }
1525
    }
1526
}
1527

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

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

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

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

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

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

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

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

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

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

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

    
1592
    if (s->pict_type != B_TYPE) {
1593
        s->last_picture_ptr= s->next_picture_ptr;
1594
        if(!s->dropable)
1595
            s->next_picture_ptr= s->current_picture_ptr;
1596
    }
1597
/*    av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n", s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1598
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
1599
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
1600
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1601
        s->pict_type, s->dropable);*/
1602

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

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

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

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

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

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

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

    
1645
        update_noise_reduction(s);
1646
    }
1647

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1859

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

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

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

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

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

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

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

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

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

    
1980

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

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

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

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

    
2049
#ifdef CONFIG_ENCODERS
2050

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

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

    
2061
    return acc;
2062
}
2063

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

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

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

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

    
2084

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2188
    return 0;
2189
}
2190

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

    
2196
    for(plane=0; plane<3; plane++){
2197
        const int stride= p->linesize[plane];
2198
        const int bw= plane ? 1 : 2;
2199
        for(y=0; y<s->mb_height*bw; y++){
2200
            for(x=0; x<s->mb_width*bw; x++){
2201
                int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16;
2202
                int v= s->dsp.frame_skip_cmp[1](s, p->data[plane] + 8*(x + y*stride)+off, ref->data[plane] + 8*(x + y*stride), stride, 8);
2203

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

    
2215
    if(score) score64= score;
2216

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

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

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

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

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

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

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

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

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

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

    
2280
            s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height);
2281
            s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1], pre_input.data[1], pre_input.linesize[1], c->width>>1, c->height>>1);
2282
            s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2], pre_input.data[2], pre_input.linesize[2], c->width>>1, c->height>>1);
2283
        }
2284
    }
2285

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

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

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

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

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

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

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

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

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

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

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

    
2330
    return best_b_count;
2331
}
2332

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

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

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

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

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

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

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

    
2368
                    goto no_output_pic;
2369
                }
2370
            }
2371

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2518
    s->picture_in_gop_number++;
2519

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

    
2523
    select_input_picture(s);
2524

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

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

    
2545
        MPV_frame_end(s);
2546

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2650
#endif //CONFIG_ENCODERS
2651

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

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

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

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

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

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

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

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

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

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

    
2728
    ptr = ref_picture[2] + offset;
2729
    if(emu){
2730
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2731
        ptr= s->edge_emu_buffer;
2732
    }
2733
    s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2734

    
2735
    return;
2736
}
2737

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

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

    
2750
    ptr = ref_picture[0];
2751

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2929
    src += src_y * stride + src_x;
2930

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3222
    assert(s->quarter_sample==0);
3223

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

    
3238
    put_obmc(dest, ptr, s->linesize);
3239
}
3240

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

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

    
3255
    v_edge_pos = s->v_edge_pos >> field_based;
3256
    linesize = s->linesize << field_based;
3257
    uvlinesize = s->uvlinesize << field_based;
3258

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

    
3276
    uvdxy= (mx&1) | ((my&1)<<1);
3277
    mx>>=1;
3278
    my>>=1;
3279

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

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

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

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

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

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

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

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

    
3353
    dxy = ((my & 1) << 1) | (mx & 1);
3354
    mx >>= 1;
3355
    my >>= 1;
3356

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

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

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

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

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

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

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

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

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

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

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

    
3469
    mb_x = s->mb_x;
3470
    mb_y = s->mb_y;
3471

    
3472
    prefetch_motion(s, ref_picture, dir);
3473

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

    
3480
        assert(!s->mb_skipped);
3481

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

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

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

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

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

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

    
3532
        return;
3533
    }
3534

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3720
    mb_x = s->mb_x;
3721
    mb_y = s->mb_y;
3722

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3882
    s->mbintra_table[xy]= 0;
3883
}
3884

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

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

    
3906
    mb_x = s->mb_x;
3907
    mb_y = s->mb_y;
3908

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

    
3918
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3919

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

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

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

    
3950
            assert(age);
3951

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4141
#ifdef CONFIG_ENCODERS
4142

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

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

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

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

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

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

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

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

    
4216
        block[j]= level;
4217
    }
4218

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

    
4223
#endif //CONFIG_ENCODERS
4224

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

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

    
4240
        h= FFMIN(h, s->avctx->height - y);
4241

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

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

    
4261
        emms_c();
4262

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

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

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

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

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

    
4293
#ifdef CONFIG_ENCODERS
4294

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

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

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

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

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

    
4336
        s->lambda= s->lambda_table[mb_xy];
4337
        update_qscale(s);
4338

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4449
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
4450

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

    
4455
                if(progressive_score > interlaced_score){
4456
                    s->interlaced_dct=1;
4457

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

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

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

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

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

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

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

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

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

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

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

    
4610
#endif //CONFIG_ENCODERS
4611

    
4612
void ff_mpeg_flush(AVCodecContext *avctx){
4613
    int i;
4614
    MpegEncContext *s = avctx->priv_data;
4615

    
4616
    if(s==NULL || s->picture==NULL)
4617
        return;
4618

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

    
4626
    s->mb_x= s->mb_y= 0;
4627

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

    
4638
#ifdef CONFIG_ENCODERS
4639
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4640
{
4641
    const uint16_t *srcw= (uint16_t*)src;
4642
    int words= length>>4;
4643
    int