Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ ec9ed85d

History | View | Annotate | Download (249 KB)

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

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

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

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

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

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

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

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

    
77

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

    
81
//#define DEBUG
82

    
83

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
201
    st->scantable= src_scantable;
202

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

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

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

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

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

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

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

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

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

    
262
    return p+4;
263
}
264

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

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

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

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

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

    
308
#endif //CONFIG_ENCODERS
309

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

    
323
    return 0;
324
}
325

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
607
    s->picture_in_gop_number = 0;
608

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

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

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

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

    
630
    MPV_common_defaults(s);
631

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
820
    s->context_initialized = 1;
821

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

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

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

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

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

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

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

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

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

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

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

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

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

    
925
#ifdef CONFIG_ENCODERS
926

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

    
934
    MPV_encode_defaults(s);
935

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1329
    avctx->has_b_frames= !s->low_delay;
1330

    
1331
    s->encoding = 1;
1332

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

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

    
1343
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1344
    ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1345

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

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

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

    
1386
    if(ff_rate_control_init(s) < 0)
1387
        return -1;
1388

    
1389
    return 0;
1390
}
1391

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

    
1396
    ff_rate_control_uninit(s);
1397

    
1398
    MPV_common_end(s);
1399
    if (s->out_format == FMT_MJPEG)
1400
        mjpeg_close(s);
1401

    
1402
    av_freep(&avctx->extradata);
1403

    
1404
    return 0;
1405
}
1406

    
1407
#endif //CONFIG_ENCODERS
1408

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

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

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

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

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

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

    
1489
int ff_find_unused_picture(MpegEncContext *s, int shared){
1490
    int i;
1491

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

    
1505
    assert(0);
1506
    return -1;
1507
}
1508

    
1509
static void update_noise_reduction(MpegEncContext *s){
1510
    int intra, i;
1511

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

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

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

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

    
1537
    /* mark&release old frames */
1538
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1539
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1540

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

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

    
1568
        pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1569
                        && !s->dropable ? 3 : 0;
1570

    
1571
        pic->coded_picture_number= s->coded_picture_number++;
1572

    
1573
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1574
            return -1;
1575

    
1576
        s->current_picture_ptr= (Picture*)pic;
1577
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1578
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1579
    }
1580

    
1581
    s->current_picture_ptr->pict_type= s->pict_type;
1582
//    if(s->flags && CODEC_FLAG_QSCALE)
1583
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1584
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1585

    
1586
    copy_picture(&s->current_picture, s->current_picture_ptr);
1587

    
1588
  if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1589
    if (s->pict_type != B_TYPE) {
1590
        s->last_picture_ptr= s->next_picture_ptr;
1591
        if(!s->dropable)
1592
            s->next_picture_ptr= s->current_picture_ptr;
1593
    }
1594
/*    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,
1595
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
1596
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
1597
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1598
        s->pict_type, s->dropable);*/
1599

    
1600
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1601
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1602

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

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

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

    
1624
    s->hurry_up= s->avctx->hurry_up;
1625
    s->error_resilience= avctx->error_resilience;
1626

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

    
1640
    if(s->dct_error_sum){
1641
        assert(s->avctx->noise_reduction && s->encoding);
1642

    
1643
        update_noise_reduction(s);
1644
    }
1645

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

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

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

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

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

    
1714
    sx= clip(sx, 0, w-1);
1715
    sy= clip(sy, 0, h-1);
1716
    ex= clip(ex, 0, w-1);
1717
    ey= clip(ey, 0, h-1);
1718

    
1719
    buf[sy*stride + sx]+= color;
1720

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

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

    
1763
    sx= clip(sx, -100, w+100);
1764
    sy= clip(sy, -100, h+100);
1765
    ex= clip(ex, -100, w+100);
1766
    ey= clip(ey, -100, h+100);
1767

    
1768
    dx= ex - sx;
1769
    dy= ey - sy;
1770

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

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

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

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

    
1791
    if(!pict || !pict->mb_type) return;
1792

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

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

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

    
1857

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

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

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

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

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

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

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

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

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

    
1978

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

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

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

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

    
2047
#ifdef CONFIG_ENCODERS
2048

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

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

    
2059
    return acc;
2060
}
2061

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

    
2066
    w= s->width &~15;
2067
    h= s->height&~15;
2068

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

    
2076
            acc+= sae + 500 < sad;
2077
        }
2078
    }
2079
    return acc;
2080
}
2081

    
2082

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

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

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

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

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

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

    
2124
    if(direct){
2125
        i= ff_find_unused_picture(s, 1);
2126

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

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

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

    
2141
        alloc_picture(s, (Picture*)pic, 0);
2142

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

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

    
2161
                if(!s->avctx->rc_buffer_size)
2162
                    dst +=INPLACE_OFFSET;
2163

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

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

    
2184
    s->input_picture[encoding_delay]= (Picture*)pic;
2185

    
2186
    return 0;
2187
}
2188

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

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

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

    
2213
    if(score) score64= score;
2214

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

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

    
2233
    assert(scale>=0 && scale <=3);
2234

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

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

    
2253
    if (avcodec_open(c, codec) < 0)
2254
        return -1;
2255

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

    
2261
        if(pre_input_ptr)
2262
            pre_input= *pre_input_ptr;
2263

    
2264
        if(pre_input.type != FF_BUFFER_TYPE_SHARED && i){
2265
            pre_input.data[0]+=INPLACE_OFFSET;
2266
            pre_input.data[1]+=INPLACE_OFFSET;
2267
            pre_input.data[2]+=INPLACE_OFFSET;
2268
        }
2269

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2329
    return best_b_count;
2330
}
2331

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

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

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

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

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

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

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

    
2367
                    goto no_output_pic;
2368
                }
2369
            }
2370

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2517
    s->picture_in_gop_number++;
2518

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

    
2522
    select_input_picture(s);
2523

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

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

    
2544
        MPV_frame_end(s);
2545

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2649
#endif //CONFIG_ENCODERS
2650

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

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

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

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

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

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

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

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

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

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

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

    
2734
    return;
2735
}
2736

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

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

    
2749
    ptr = ref_picture[0];
2750

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2928
    src += src_y * stride + src_x;
2929

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3473
    prefetch_motion(s, ref_picture, dir);
3474

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

    
3481
        assert(!s->mb_skipped);
3482

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

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

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

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

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

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

    
3533
        return;
3534
    }
3535

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3951
            assert(age);
3952

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4142
#ifdef CONFIG_ENCODERS
4143

    
4144
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
4145
{
4146
    static const char tab[64]=
4147
        {3,2,2,1,1,1,1,1,
4148
         1,1,1,1,1,1,1,1,
4149
         1,1,1,1,1,1,1,1,
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
         0,0,0,0,0,0,0,0};
4155
    int score=0;
4156
    int run=0;
4157
    int i;
4158
    DCTELEM *block= s->block[n];
4159
    const int last_index= s->block_last_index[n];
4160
    int skip_dc;
4161

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

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

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

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

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

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

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

    
4217
        block[j]= level;
4218
    }
4219

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

    
4224
#endif //CONFIG_ENCODERS
4225

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

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

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

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

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

    
4262
        emms_c();
4263

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

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

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

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

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

    
4294
#ifdef CONFIG_ENCODERS
4295

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

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

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

    
4331
    for(i=0; i<mb_block_count; i++) skip_dct[i]=0;
4332

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

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

    
4340
        if(!(s->flags&CODEC_FLAG_QP_RD)){
4341
            s->dquant= s->qscale - last_qp;
4342

    
4343
            if(s->out_format==FMT_H263){
4344
                s->dquant= clip(s->dquant, -2, 2); //FIXME RD
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)
4350
                                s->dquant= (s->dquant/2)*2;
4351
                            if(s->mv_dir&MV_DIRECT)
4352
                                s->dquant= 0;
4353
                        }
4354
                        if(s->mv_type==MV_TYPE_8X8)
4355
                            s->dquant=0;
4356
                    }
4357
                }
4358
            }
4359
        }
4360
        ff_set_qscale(s, last_qp + s->dquant);
4361
    }else if(s->flags&CODEC_FLAG_QP_RD)
4362
        ff_set_qscale(s, s->qscale + s->dquant);
4363

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4607
#endif //CONFIG_ENCODERS
4608

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

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

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

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

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

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

    
4642
    if(length==0) return;
4643

    
4644
    if(words < 16){
4645
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4646
    }else if(put_b