Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 1a822d30

History | View | Annotate | Download (252 KB)

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

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

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

    
38
//#undef NDEBUG
39
//#include <assert.h>
40

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

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

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

    
75

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

    
79
//#define DEBUG
80

    
81

    
82
/* for jpeg fast DCT */
83
#define CONST_BITS 14
84

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

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

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

    
107
#ifdef CONFIG_ENCODERS
108
static uint8_t default_mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
109
static uint8_t default_fcode_tab[MAX_MV*2+1];
110

    
111
enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
112

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

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

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

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

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

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

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

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

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

    
199
    st->scantable= src_scantable;
200

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

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

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

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

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

    
236
    assert(p<=end);
237
    if(p>=end)
238
        return end;
239

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

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

    
257
    p= FFMIN(p, end)-4;
258
    *state=  be2me_32(unaligned32(p));
259

    
260
    return p+4;
261
}
262

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

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

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

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

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

    
309
#endif //CONFIG_ENCODERS
310

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

    
324
    return 0;
325
}
326

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
609
    s->picture_in_gop_number = 0;
610

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
813
    s->context_initialized = 1;
814

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

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

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

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

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

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

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

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

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

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

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

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

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

    
918
#ifdef CONFIG_ENCODERS
919

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

    
927
    MPV_encode_defaults(s);
928

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

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

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

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

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

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

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

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

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

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

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

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

    
1032
    if(avctx->rc_buffer_size && avctx->bit_rate*av_q2d(avctx->time_base) > avctx->rc_buffer_size){
1033
        av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
1034
        return -1;
1035
    }
1036

    
1037
    if(avctx->bit_rate*av_q2d(avctx->time_base) > avctx->bit_rate_tolerance){
1038
        av_log(avctx, AV_LOG_ERROR, "bitrate tolerance too small for bitrate\n");
1039
        return -1;
1040
    }
1041

    
1042
    if(   s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
1043
       && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
1044
       && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
1045

    
1046
        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");
1047
    }
1048

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

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

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

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

    
1070
    if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
1071
        av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
1072
        return -1;
1073
    }
1074

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

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

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

    
1091
    if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1092
        av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1093
        return -1;
1094
    }
1095

    
1096
    if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1097
        av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1098
        return -1;
1099
    }
1100

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

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

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

    
1122
    if(s->q_scale_type == 1){
1123
        if(s->codec_id != CODEC_ID_MPEG2VIDEO){
1124
            av_log(avctx, AV_LOG_ERROR, "non linear quant is only available for mpeg2\n");
1125
            return -1;
1126
        }
1127
        if(avctx->qmax > 12){
1128
            av_log(avctx, AV_LOG_ERROR, "non linear quant only supports qmax <= 12 currently\n");
1129
            return -1;
1130
        }
1131
    }
1132

    
1133
    if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1134
       && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1135
       && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1136
        av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1137
        return -1;
1138
    }
1139

    
1140
    if(s->avctx->thread_count > 1)
1141
        s->rtp_mode= 1;
1142

    
1143
    if(!avctx->time_base.den || !avctx->time_base.num){
1144
        av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1145
        return -1;
1146
    }
1147

    
1148
    i= (INT_MAX/2+128)>>8;
1149
    if(avctx->me_threshold >= i){
1150
        av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1151
        return -1;
1152
    }
1153
    if(avctx->mb_threshold >= i){
1154
        av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1155
        return -1;
1156
    }
1157

    
1158
    if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
1159
        av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n");
1160
        avctx->b_frame_strategy = 0;
1161
    }
1162

    
1163
    i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
1164
    if(i > 1){
1165
        av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1166
        avctx->time_base.den /= i;
1167
        avctx->time_base.num /= i;
1168
//        return -1;
1169
    }
1170

    
1171
    if(s->codec_id==CODEC_ID_MJPEG){
1172
        s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1173
        s->inter_quant_bias= 0;
1174
    }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1175
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1176
        s->inter_quant_bias= 0;
1177
    }else{
1178
        s->intra_quant_bias=0;
1179
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1180
    }
1181

    
1182
    if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1183
        s->intra_quant_bias= avctx->intra_quant_bias;
1184
    if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1185
        s->inter_quant_bias= avctx->inter_quant_bias;
1186

    
1187
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1188

    
1189
    if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
1190
        av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1191
        return -1;
1192
    }
1193
    s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1194

    
1195
    switch(avctx->codec->id) {
1196
    case CODEC_ID_MPEG1VIDEO:
1197
        s->out_format = FMT_MPEG1;
1198
        s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY);
1199
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1200
        break;
1201
    case CODEC_ID_MPEG2VIDEO:
1202
        s->out_format = FMT_MPEG1;
1203
        s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY);
1204
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1205
        s->rtp_mode= 1;
1206
        break;
1207
    case CODEC_ID_LJPEG:
1208
    case CODEC_ID_MJPEG:
1209
        s->out_format = FMT_MJPEG;
1210
        s->intra_only = 1; /* force intra only for jpeg */
1211
        s->mjpeg_vsample[0] = 2;
1212
        s->mjpeg_vsample[1] = 2>>chroma_v_shift;
1213
        s->mjpeg_vsample[2] = 2>>chroma_v_shift;
1214
        s->mjpeg_hsample[0] = 2;
1215
        s->mjpeg_hsample[1] = 2>>chroma_h_shift;
1216
        s->mjpeg_hsample[2] = 2>>chroma_h_shift;
1217
        if (!(ENABLE_MJPEG_ENCODER || ENABLE_LJPEG_ENCODER)
1218
            || ff_mjpeg_encode_init(s) < 0)
1219
            return -1;
1220
        avctx->delay=0;
1221
        s->low_delay=1;
1222
        break;
1223
    case CODEC_ID_H261:
1224
        if (!ENABLE_H261_ENCODER)  return -1;
1225
        if (ff_h261_get_picture_format(s->width, s->height) < 0) {
1226
            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);
1227
            return -1;
1228
        }
1229
        s->out_format = FMT_H261;
1230
        avctx->delay=0;
1231
        s->low_delay=1;
1232
        break;
1233
    case CODEC_ID_H263:
1234
        if (h263_get_picture_format(s->width, s->height) == 7) {
1235
            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);
1236
            return -1;
1237
        }
1238
        s->out_format = FMT_H263;
1239
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1240
        avctx->delay=0;
1241
        s->low_delay=1;
1242
        break;
1243
    case CODEC_ID_H263P:
1244
        s->out_format = FMT_H263;
1245
        s->h263_plus = 1;
1246
        /* Fx */
1247
        s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1248
        s->h263_aic= (avctx->flags & CODEC_FLAG_AC_PRED) ? 1:0;
1249
        s->modified_quant= s->h263_aic;
1250
        s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1251
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1252
        s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1253
        s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1254
        s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1255

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

    
1343
    avctx->has_b_frames= !s->low_delay;
1344

    
1345
    s->encoding = 1;
1346

    
1347
    /* init */
1348
    if (MPV_common_init(s) < 0)
1349
        return -1;
1350

    
1351
    if(s->modified_quant)
1352
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1353
    s->progressive_frame=
1354
    s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN));
1355
    s->quant_precision=5;
1356

    
1357
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1358
    ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1359

    
1360
    if (ENABLE_H261_ENCODER && s->out_format == FMT_H261)
1361
        ff_h261_encode_init(s);
1362
    if (s->out_format == FMT_H263)
1363
        h263_encode_init(s);
1364
    if (ENABLE_MSMPEG4_ENCODER && s->msmpeg4_version)
1365
        ff_msmpeg4_encode_init(s);
1366
    if (s->out_format == FMT_MPEG1)
1367
        ff_mpeg1_encode_init(s);
1368

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

    
1389
    /* precompute matrix */
1390
    /* for mjpeg, we do include qscale in the matrix */
1391
    if (s->out_format != FMT_MJPEG) {
1392
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1393
                       s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1394
        convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1395
                       s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1396
    }
1397

    
1398
    if(ff_rate_control_init(s) < 0)
1399
        return -1;
1400

    
1401
    return 0;
1402
}
1403

    
1404
int MPV_encode_end(AVCodecContext *avctx)
1405
{
1406
    MpegEncContext *s = avctx->priv_data;
1407

    
1408
    ff_rate_control_uninit(s);
1409

    
1410
    MPV_common_end(s);
1411
    if ((ENABLE_MJPEG_ENCODER || ENABLE_LJPEG_ENCODER) && s->out_format == FMT_MJPEG)
1412
        ff_mjpeg_encode_close(s);
1413

    
1414
    av_freep(&avctx->extradata);
1415

    
1416
    return 0;
1417
}
1418

    
1419
#endif //CONFIG_ENCODERS
1420

    
1421
void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
1422
{
1423
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1424
    uint8_t index_run[MAX_RUN+1];
1425
    int last, run, level, start, end, i;
1426

    
1427
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
1428
    if(static_store && rl->max_level[0])
1429
        return;
1430

    
1431
    /* compute max_level[], max_run[] and index_run[] */
1432
    for(last=0;last<2;last++) {
1433
        if (last == 0) {
1434
            start = 0;
1435
            end = rl->last;
1436
        } else {
1437
            start = rl->last;
1438
            end = rl->n;
1439
        }
1440

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

    
1472
/* draw the edges of width 'w' of an image of size width, height */
1473
//FIXME check that this is ok for mpeg4 interlaced
1474
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1475
{
1476
    uint8_t *ptr, *last_line;
1477
    int i;
1478

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

    
1501
int ff_find_unused_picture(MpegEncContext *s, int shared){
1502
    int i;
1503

    
1504
    if(shared){
1505
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1506
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1507
        }
1508
    }else{
1509
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1510
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1511
        }
1512
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1513
            if(s->picture[i].data[0]==NULL) return i;
1514
        }
1515
    }
1516

    
1517
    assert(0);
1518
    return -1;
1519
}
1520

    
1521
static void update_noise_reduction(MpegEncContext *s){
1522
    int intra, i;
1523

    
1524
    for(intra=0; intra<2; intra++){
1525
        if(s->dct_count[intra] > (1<<16)){
1526
            for(i=0; i<64; i++){
1527
                s->dct_error_sum[intra][i] >>=1;
1528
            }
1529
            s->dct_count[intra] >>= 1;
1530
        }
1531

    
1532
        for(i=0; i<64; i++){
1533
            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);
1534
        }
1535
    }
1536
}
1537

    
1538
/**
1539
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1540
 */
1541
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1542
{
1543
    int i;
1544
    AVFrame *pic;
1545
    s->mb_skipped = 0;
1546

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

    
1549
    /* mark&release old frames */
1550
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1551
      if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1552
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1553

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

    
1575
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1576
            pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1577
        else{
1578
            i= ff_find_unused_picture(s, 0);
1579
            pic= (AVFrame*)&s->picture[i];
1580
        }
1581

    
1582
        pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1583
                        && !s->dropable ? 3 : 0;
1584

    
1585
        pic->coded_picture_number= s->coded_picture_number++;
1586

    
1587
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1588
            return -1;
1589

    
1590
        s->current_picture_ptr= (Picture*)pic;
1591
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1592
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1593
    }
1594

    
1595
    s->current_picture_ptr->pict_type= s->pict_type;
1596
//    if(s->flags && CODEC_FLAG_QSCALE)
1597
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1598
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1599

    
1600
    copy_picture(&s->current_picture, s->current_picture_ptr);
1601

    
1602
    if (s->pict_type != B_TYPE) {
1603
        s->last_picture_ptr= s->next_picture_ptr;
1604
        if(!s->dropable)
1605
            s->next_picture_ptr= s->current_picture_ptr;
1606
    }
1607
/*    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,
1608
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
1609
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
1610
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1611
        s->pict_type, s->dropable);*/
1612

    
1613
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1614
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1615

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

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

    
1624
    if(s->picture_structure!=PICT_FRAME){
1625
        int i;
1626
        for(i=0; i<4; i++){
1627
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1628
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1629
            }
1630
            s->current_picture.linesize[i] *= 2;
1631
            s->last_picture.linesize[i] *=2;
1632
            s->next_picture.linesize[i] *=2;
1633
        }
1634
    }
1635

    
1636
    s->hurry_up= s->avctx->hurry_up;
1637
    s->error_resilience= avctx->error_resilience;
1638

    
1639
    /* set dequantizer, we can't do it during init as it might change for mpeg4
1640
       and we can't do it in the header decode as init is not called for mpeg4 there yet */
1641
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1642
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1643
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1644
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1645
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1646
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1647
    }else{
1648
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1649
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1650
    }
1651

    
1652
    if(s->dct_error_sum){
1653
        assert(s->avctx->noise_reduction && s->encoding);
1654

    
1655
        update_noise_reduction(s);
1656
    }
1657

    
1658
#ifdef HAVE_XVMC
1659
    if(s->avctx->xvmc_acceleration)
1660
        return XVMC_field_start(s, avctx);
1661
#endif
1662
    return 0;
1663
}
1664

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

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

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

    
1716
/**
1717
 * draws an line from (ex, ey) -> (sx, sy).
1718
 * @param w width of the image
1719
 * @param h height of the image
1720
 * @param stride stride/linesize of the image
1721
 * @param color color of the arrow
1722
 */
1723
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1724
    int x, y, fr, f;
1725

    
1726
    sx= av_clip(sx, 0, w-1);
1727
    sy= av_clip(sy, 0, h-1);
1728
    ex= av_clip(ex, 0, w-1);
1729
    ey= av_clip(ey, 0, h-1);
1730

    
1731
    buf[sy*stride + sx]+= color;
1732

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

    
1765
/**
1766
 * draws an arrow from (ex, ey) -> (sx, sy).
1767
 * @param w width of the image
1768
 * @param h height of the image
1769
 * @param stride stride/linesize of the image
1770
 * @param color color of the arrow
1771
 */
1772
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1773
    int dx,dy;
1774

    
1775
    sx= av_clip(sx, -100, w+100);
1776
    sy= av_clip(sy, -100, h+100);
1777
    ex= av_clip(ex, -100, w+100);
1778
    ey= av_clip(ey, -100, h+100);
1779

    
1780
    dx= ex - sx;
1781
    dy= ey - sy;
1782

    
1783
    if(dx*dx + dy*dy > 3*3){
1784
        int rx=  dx + dy;
1785
        int ry= -dx + dy;
1786
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1787

    
1788
        //FIXME subpixel accuracy
1789
        rx= ROUNDED_DIV(rx*3<<4, length);
1790
        ry= ROUNDED_DIV(ry*3<<4, length);
1791

    
1792
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1793
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1794
    }
1795
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1796
}
1797

    
1798
/**
1799
 * prints debuging info for the given picture.
1800
 */
1801
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1802

    
1803
    if(!pict || !pict->mb_type) return;
1804

    
1805
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1806
        int x,y;
1807

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

    
1857
                    //segmentation
1858
                    if(IS_8X8(mb_type))
1859
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1860
                    else if(IS_16X8(mb_type))
1861
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1862
                    else if(IS_8X16(mb_type))
1863
                        av_log(s->avctx, AV_LOG_DEBUG, "|");
1864
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1865
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1866
                    else
1867
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1868

    
1869

    
1870
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1871
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1872
                    else
1873
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1874
                }
1875
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1876
            }
1877
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1878
        }
1879
    }
1880

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

    
1893
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1894
        for(i=0; i<3; i++){
1895
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1896
            pict->data[i]= s->visualization_buffer[i];
1897
        }
1898
        pict->type= FF_BUFFER_TYPE_COPY;
1899
        ptr= pict->data[0];
1900

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

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

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

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

    
1959
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1960
                            my*=2;
1961

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

    
1990

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

    
2017
                    u*= 0x0101010101010101ULL;
2018
                    v*= 0x0101010101010101ULL;
2019
                    for(y=0; y<8; y++){
2020
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
2021
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
2022
                    }
2023

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

    
2049
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
2050
                        // hmm
2051
                    }
2052
                }
2053
                s->mbskip_table[mb_index]=0;
2054
            }
2055
        }
2056
    }
2057
}
2058

    
2059
#ifdef CONFIG_ENCODERS
2060

    
2061
static int get_sae(uint8_t *src, int ref, int stride){
2062
    int x,y;
2063
    int acc=0;
2064

    
2065
    for(y=0; y<16; y++){
2066
        for(x=0; x<16; x++){
2067
            acc+= FFABS(src[x+y*stride] - ref);
2068
        }
2069
    }
2070

    
2071
    return acc;
2072
}
2073

    
2074
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
2075
    int x, y, w, h;
2076
    int acc=0;
2077

    
2078
    w= s->width &~15;
2079
    h= s->height&~15;
2080

    
2081
    for(y=0; y<h; y+=16){
2082
        for(x=0; x<w; x+=16){
2083
            int offset= x + y*stride;
2084
            int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
2085
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
2086
            int sae = get_sae(src + offset, mean, stride);
2087

    
2088
            acc+= sae + 500 < sad;
2089
        }
2090
    }
2091
    return acc;
2092
}
2093

    
2094

    
2095
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2096
    AVFrame *pic=NULL;
2097
    int64_t pts;
2098
    int i;
2099
    const int encoding_delay= s->max_b_frames;
2100
    int direct=1;
2101

    
2102
    if(pic_arg){
2103
        pts= pic_arg->pts;
2104
        pic_arg->display_picture_number= s->input_picture_number++;
2105

    
2106
        if(pts != AV_NOPTS_VALUE){
2107
            if(s->user_specified_pts != AV_NOPTS_VALUE){
2108
                int64_t time= pts;
2109
                int64_t last= s->user_specified_pts;
2110

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

    
2128
  if(pic_arg){
2129
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2130
    if(pic_arg->linesize[0] != s->linesize) direct=0;
2131
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2132
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2133

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

    
2136
    if(direct){
2137
        i= ff_find_unused_picture(s, 1);
2138

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

    
2142
        for(i=0; i<4; i++){
2143
            pic->data[i]= pic_arg->data[i];
2144
            pic->linesize[i]= pic_arg->linesize[i];
2145
        }
2146
        alloc_picture(s, (Picture*)pic, 1);
2147
    }else{
2148
        i= ff_find_unused_picture(s, 0);
2149

    
2150
        pic= (AVFrame*)&s->picture[i];
2151
        pic->reference= 3;
2152

    
2153
        alloc_picture(s, (Picture*)pic, 0);
2154

    
2155
        if(   pic->data[0] + INPLACE_OFFSET == pic_arg->data[0]
2156
           && pic->data[1] + INPLACE_OFFSET == pic_arg->data[1]
2157
           && pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){
2158
       // empty
2159
        }else{
2160
            int h_chroma_shift, v_chroma_shift;
2161
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2162

    
2163
            for(i=0; i<3; i++){
2164
                int src_stride= pic_arg->linesize[i];
2165
                int dst_stride= i ? s->uvlinesize : s->linesize;
2166
                int h_shift= i ? h_chroma_shift : 0;
2167
                int v_shift= i ? v_chroma_shift : 0;
2168
                int w= s->width >>h_shift;
2169
                int h= s->height>>v_shift;
2170
                uint8_t *src= pic_arg->data[i];
2171
                uint8_t *dst= pic->data[i];
2172

    
2173
                if(!s->avctx->rc_buffer_size)
2174
                    dst +=INPLACE_OFFSET;
2175

    
2176
                if(src_stride==dst_stride)
2177
                    memcpy(dst, src, src_stride*h);
2178
                else{
2179
                    while(h--){
2180
                        memcpy(dst, src, w);
2181
                        dst += dst_stride;
2182
                        src += src_stride;
2183
                    }
2184
                }
2185
            }
2186
        }
2187
    }
2188
    copy_picture_attributes(s, pic, pic_arg);
2189
    pic->pts= pts; //we set this here to avoid modifiying pic_arg
2190
  }
2191

    
2192
    /* shift buffer entries */
2193
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2194
        s->input_picture[i-1]= s->input_picture[i];
2195

    
2196
    s->input_picture[encoding_delay]= (Picture*)pic;
2197

    
2198
    return 0;
2199
}
2200

    
2201
static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2202
    int x, y, plane;
2203
    int score=0;
2204
    int64_t score64=0;
2205

    
2206
    for(plane=0; plane<3; plane++){
2207
        const int stride= p->linesize[plane];
2208
        const int bw= plane ? 1 : 2;
2209
        for(y=0; y<s->mb_height*bw; y++){
2210
            for(x=0; x<s->mb_width*bw; x++){
2211
                int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16;
2212
                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);
2213

    
2214
                switch(s->avctx->frame_skip_exp){
2215
                    case 0: score= FFMAX(score, v); break;
2216
                    case 1: score+= FFABS(v);break;
2217
                    case 2: score+= v*v;break;
2218
                    case 3: score64+= FFABS(v*v*(int64_t)v);break;
2219
                    case 4: score64+= v*v*(int64_t)(v*v);break;
2220
                }
2221
            }
2222
        }
2223
    }
2224

    
2225
    if(score) score64= score;
2226

    
2227
    if(score64 < s->avctx->frame_skip_threshold)
2228
        return 1;
2229
    if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2230
        return 1;
2231
    return 0;
2232
}
2233

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

    
2245
    assert(scale>=0 && scale <=3);
2246

    
2247
//    emms_c();
2248
    p_lambda= s->last_lambda_for[P_TYPE]; //s->next_picture_ptr->quality;
2249
    b_lambda= s->last_lambda_for[B_TYPE]; //p_lambda *FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
2250
    if(!b_lambda) b_lambda= p_lambda; //FIXME we should do this somewhere else
2251
    lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT;
2252

    
2253
    c->width = s->width >> scale;
2254
    c->height= s->height>> scale;
2255
    c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
2256
    c->flags|= s->avctx->flags & CODEC_FLAG_QPEL;
2257
    c->mb_decision= s->avctx->mb_decision;
2258
    c->me_cmp= s->avctx->me_cmp;
2259
    c->mb_cmp= s->avctx->mb_cmp;
2260
    c->me_sub_cmp= s->avctx->me_sub_cmp;
2261
    c->pix_fmt = PIX_FMT_YUV420P;
2262
    c->time_base= s->avctx->time_base;
2263
    c->max_b_frames= s->max_b_frames;
2264

    
2265
    if (avcodec_open(c, codec) < 0)
2266
        return -1;
2267

    
2268
    for(i=0; i<s->max_b_frames+2; i++){
2269
        int ysize= c->width*c->height;
2270
        int csize= (c->width/2)*(c->height/2);
2271
        Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr;
2272

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

    
2281
        if(pre_input_ptr && (!i || s->input_picture[i-1])) {
2282
            pre_input= *pre_input_ptr;
2283

    
2284
            if(pre_input.type != FF_BUFFER_TYPE_SHARED && i) {
2285
                pre_input.data[0]+=INPLACE_OFFSET;
2286
                pre_input.data[1]+=INPLACE_OFFSET;
2287
                pre_input.data[2]+=INPLACE_OFFSET;
2288
            }
2289

    
2290
            s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height);
2291
            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);
2292
            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);
2293
        }
2294
    }
2295

    
2296
    for(j=0; j<s->max_b_frames+1; j++){
2297
        int64_t rd=0;
2298

    
2299
        if(!s->input_picture[j])
2300
            break;
2301

    
2302
        c->error[0]= c->error[1]= c->error[2]= 0;
2303

    
2304
        input[0].pict_type= I_TYPE;
2305
        input[0].quality= 1 * FF_QP2LAMBDA;
2306
        out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
2307
//        rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2308

    
2309
        for(i=0; i<s->max_b_frames+1; i++){
2310
            int is_p= i % (j+1) == j || i==s->max_b_frames;
2311

    
2312
            input[i+1].pict_type= is_p ? P_TYPE : B_TYPE;
2313
            input[i+1].quality= is_p ? p_lambda : b_lambda;
2314
            out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]);
2315
            rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2316
        }
2317

    
2318
        /* get the delayed frames */
2319
        while(out_size){
2320
            out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
2321
            rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2322
        }
2323

    
2324
        rd += c->error[0] + c->error[1] + c->error[2];
2325

    
2326
        if(rd < best_rd){
2327
            best_rd= rd;
2328
            best_b_count= j;
2329
        }
2330
    }
2331

    
2332
    av_freep(&outbuf);
2333
    avcodec_close(c);
2334
    av_freep(&c);
2335

    
2336
    for(i=0; i<s->max_b_frames+2; i++){
2337
        av_freep(&input[i].data[0]);
2338
    }
2339

    
2340
    return best_b_count;
2341
}
2342

    
2343
static void select_input_picture(MpegEncContext *s){
2344
    int i;
2345

    
2346
    for(i=1; i<MAX_PICTURE_COUNT; i++)
2347
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2348
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2349

    
2350
    /* set next picture type & ordering */
2351
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2352
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2353
            s->reordered_input_picture[0]= s->input_picture[0];
2354
            s->reordered_input_picture[0]->pict_type= I_TYPE;
2355
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2356
        }else{
2357
            int b_frames;
2358

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

    
2364
                    if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2365
                        for(i=0; i<4; i++)
2366
                            s->input_picture[0]->data[i]= NULL;
2367
                        s->input_picture[0]->type= 0;
2368
                    }else{
2369
                        assert(   s->input_picture[0]->type==FF_BUFFER_TYPE_USER
2370
                               || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2371

    
2372
                        s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2373
                    }
2374

    
2375
                    emms_c();
2376
                    ff_vbv_update(s, 0);
2377

    
2378
                    goto no_output_pic;
2379
                }
2380
            }
2381

    
2382
            if(s->flags&CODEC_FLAG_PASS2){
2383
                for(i=0; i<s->max_b_frames+1; i++){
2384
                    int pict_num= s->input_picture[0]->display_picture_number + i;
2385

    
2386
                    if(pict_num >= s->rc_context.num_entries)
2387
                        break;
2388
                    if(!s->input_picture[i]){
2389
                        s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2390
                        break;
2391
                    }
2392

    
2393
                    s->input_picture[i]->pict_type=
2394
                        s->rc_context.entry[pict_num].new_pict_type;
2395
                }
2396
            }
2397

    
2398
            if(s->avctx->b_frame_strategy==0){
2399
                b_frames= s->max_b_frames;
2400
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
2401
            }else if(s->avctx->b_frame_strategy==1){
2402
                for(i=1; i<s->max_b_frames+1; i++){
2403
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2404
                        s->input_picture[i]->b_frame_score=
2405
                            get_intra_count(s, s->input_picture[i  ]->data[0],
2406
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
2407
                    }
2408
                }
2409
                for(i=0; i<s->max_b_frames+1; i++){
2410
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/s->avctx->b_sensitivity) break;
2411
                }
2412

    
2413
                b_frames= FFMAX(0, i-1);
2414

    
2415
                /* reset scores */
2416
                for(i=0; i<b_frames+1; i++){
2417
                    s->input_picture[i]->b_frame_score=0;
2418
                }
2419
            }else if(s->avctx->b_frame_strategy==2){
2420
                b_frames= estimate_best_b_count(s);
2421
            }else{
2422
                av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2423
                b_frames=0;
2424
            }
2425

    
2426
            emms_c();
2427
//static int b_count=0;
2428
//b_count+= b_frames;
2429
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2430

    
2431
            for(i= b_frames - 1; i>=0; i--){
2432
                int type= s->input_picture[i]->pict_type;
2433
                if(type && type != B_TYPE)
2434
                    b_frames= i;
2435
            }
2436
            if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2437
                av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
2438
            }
2439

    
2440
            if(s->picture_in_gop_number + b_frames >= s->gop_size){
2441
              if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2442
                    b_frames= s->gop_size - s->picture_in_gop_number - 1;
2443
              }else{
2444
                if(s->flags & CODEC_FLAG_CLOSED_GOP)
2445
                    b_frames=0;
2446
                s->input_picture[b_frames]->pict_type= I_TYPE;
2447
              }
2448
            }
2449

    
2450
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2451
               && b_frames
2452
               && s->input_picture[b_frames]->pict_type== I_TYPE)
2453
                b_frames--;
2454

    
2455
            s->reordered_input_picture[0]= s->input_picture[b_frames];
2456
            if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2457
                s->reordered_input_picture[0]->pict_type= P_TYPE;
2458
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2459
            for(i=0; i<b_frames; i++){
2460
                s->reordered_input_picture[i+1]= s->input_picture[i];
2461
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2462
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2463
            }
2464
        }
2465
    }
2466
no_output_pic:
2467
    if(s->reordered_input_picture[0]){
2468
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2469

    
2470
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2471

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

    
2475
            int i= ff_find_unused_picture(s, 0);
2476
            Picture *pic= &s->picture[i];
2477

    
2478
            pic->reference              = s->reordered_input_picture[0]->reference;
2479
            alloc_picture(s, pic, 0);
2480

    
2481
            /* mark us unused / free shared pic */
2482
            if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_INTERNAL)
2483
                s->avctx->release_buffer(s->avctx, (AVFrame*)s->reordered_input_picture[0]);
2484
            for(i=0; i<4; i++)
2485
                s->reordered_input_picture[0]->data[i]= NULL;
2486
            s->reordered_input_picture[0]->type= 0;
2487

    
2488
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2489

    
2490
            s->current_picture_ptr= pic;
2491
        }else{
2492
            // input is not a shared pix -> reuse buffer for current_pix
2493

    
2494
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2495
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2496

    
2497
            s->current_picture_ptr= s->reordered_input_picture[0];
2498
            for(i=0; i<4; i++){
2499
                s->new_picture.data[i]+= INPLACE_OFFSET;
2500
            }
2501
        }
2502
        copy_picture(&s->current_picture, s->current_picture_ptr);
2503

    
2504
        s->picture_number= s->new_picture.display_picture_number;
2505
//printf("dpn:%d\n", s->picture_number);
2506
    }else{
2507
       memset(&s->new_picture, 0, sizeof(Picture));
2508
    }
2509
}
2510

    
2511
int MPV_encode_picture(AVCodecContext *avctx,
2512
                       unsigned char *buf, int buf_size, void *data)
2513
{
2514
    MpegEncContext *s = avctx->priv_data;
2515
    AVFrame *pic_arg = data;
2516
    int i, stuffing_count;
2517

    
2518
    for(i=0; i<avctx->thread_count; i++){
2519
        int start_y= s->thread_context[i]->start_mb_y;
2520
        int   end_y= s->thread_context[i]->  end_mb_y;
2521
        int h= s->mb_height;
2522
        uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h);
2523
        uint8_t *end  = buf + (size_t)(((int64_t) buf_size)*  end_y/h);
2524

    
2525
        init_put_bits(&s->thread_context[i]->pb, start, end - start);
2526
    }
2527

    
2528
    s->picture_in_gop_number++;
2529

    
2530
    if(load_input_picture(s, pic_arg) < 0)
2531
        return -1;
2532

    
2533
    select_input_picture(s);
2534

    
2535
    /* output? */
2536
    if(s->new_picture.data[0]){
2537
        s->pict_type= s->new_picture.pict_type;
2538
//emms_c();
2539
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2540
        MPV_frame_start(s, avctx);
2541
vbv_retry:
2542
        if (encode_picture(s, s->picture_number) < 0)
2543
            return -1;
2544

    
2545
        avctx->real_pict_num  = s->picture_number;
2546
        avctx->header_bits = s->header_bits;
2547
        avctx->mv_bits     = s->mv_bits;
2548
        avctx->misc_bits   = s->misc_bits;
2549
        avctx->i_tex_bits  = s->i_tex_bits;
2550
        avctx->p_tex_bits  = s->p_tex_bits;
2551
        avctx->i_count     = s->i_count;
2552
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2553
        avctx->skip_count  = s->skip_count;
2554

    
2555
        MPV_frame_end(s);
2556

    
2557
        if (ENABLE_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
2558
            ff_mjpeg_encode_picture_trailer(s);
2559

    
2560
        if(avctx->rc_buffer_size){
2561
            RateControlContext *rcc= &s->rc_context;
2562
            int max_size= rcc->buffer_index/3;
2563

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

    
2588
            assert(s->avctx->rc_max_rate);
2589
        }
2590

    
2591
        if(s->flags&CODEC_FLAG_PASS1)
2592
            ff_write_pass1_stats(s);
2593

    
2594
        for(i=0; i<4; i++){
2595
            s->current_picture_ptr->error[i]= s->current_picture.error[i];
2596
            avctx->error[i] += s->current_picture_ptr->error[i];
2597
        }
2598

    
2599
        if(s->flags&CODEC_FLAG_PASS1)
2600
            assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2601
        flush_put_bits(&s->pb);
2602
        s->frame_bits  = put_bits_count(&s->pb);
2603

    
2604
        stuffing_count= ff_vbv_update(s, s->frame_bits);
2605
        if(stuffing_count){
2606
            if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2607
                av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2608
                return -1;
2609
            }
2610

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

    
2633
        /* update mpeg1/2 vbv_delay for CBR */
2634
        if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2635
           && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2636
            int vbv_delay;
2637

    
2638
            assert(s->repeat_first_field==0);
2639

    
2640
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2641
            assert(vbv_delay < 0xFFFF);
2642

    
2643
            s->vbv_delay_ptr[0] &= 0xF8;
2644
            s->vbv_delay_ptr[0] |= vbv_delay>>13;
2645
            s->vbv_delay_ptr[1]  = vbv_delay>>5;
2646
            s->vbv_delay_ptr[2] &= 0x07;
2647
            s->vbv_delay_ptr[2] |= vbv_delay<<3;
2648
        }
2649
        s->total_bits += s->frame_bits;
2650
        avctx->frame_bits  = s->frame_bits;
2651
    }else{
2652
        assert((pbBufPtr(&s->pb) == s->pb.buf));
2653
        s->frame_bits=0;
2654
    }
2655
    assert((s->frame_bits&7)==0);
2656

    
2657
    return s->frame_bits/8;
2658
}
2659

    
2660
#endif //CONFIG_ENCODERS
2661

    
2662
static inline void gmc1_motion(MpegEncContext *s,
2663
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2664
                               uint8_t **ref_picture)
2665
{
2666
    uint8_t *ptr;
2667
    int offset, src_x, src_y, linesize, uvlinesize;
2668
    int motion_x, motion_y;
2669
    int emu=0;
2670

    
2671
    motion_x= s->sprite_offset[0][0];
2672
    motion_y= s->sprite_offset[0][1];
2673
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2674
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2675
    motion_x<<=(3-s->sprite_warping_accuracy);
2676
    motion_y<<=(3-s->sprite_warping_accuracy);
2677
    src_x = av_clip(src_x, -16, s->width);
2678
    if (src_x == s->width)
2679
        motion_x =0;
2680
    src_y = av_clip(src_y, -16, s->height);
2681
    if (src_y == s->height)
2682
        motion_y =0;
2683

    
2684
    linesize = s->linesize;
2685
    uvlinesize = s->uvlinesize;
2686

    
2687
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2688

    
2689
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2690
        if(   (unsigned)src_x >= s->h_edge_pos - 17
2691
           || (unsigned)src_y >= s->v_edge_pos - 17){
2692
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2693
            ptr= s->edge_emu_buffer;
2694
        }
2695
    }
2696

    
2697
    if((motion_x|motion_y)&7){
2698
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2699
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2700
    }else{
2701
        int dxy;
2702

    
2703
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2704
        if (s->no_rounding){
2705
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2706
        }else{
2707
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2708
        }
2709
    }
2710

    
2711
    if(s->flags&CODEC_FLAG_GRAY) return;
2712

    
2713
    motion_x= s->sprite_offset[1][0];
2714
    motion_y= s->sprite_offset[1][1];
2715
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2716
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2717
    motion_x<<=(3-s->sprite_warping_accuracy);
2718
    motion_y<<=(3-s->sprite_warping_accuracy);
2719
    src_x = av_clip(src_x, -8, s->width>>1);
2720
    if (src_x == s->width>>1)
2721
        motion_x =0;
2722
    src_y = av_clip(src_y, -8, s->height>>1);
2723
    if (src_y == s->height>>1)
2724
        motion_y =0;
2725

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

    
2738
    ptr = ref_picture[2] + offset;
2739
    if(emu){
2740
        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);
2741
        ptr= s->edge_emu_buffer;
2742
    }
2743
    s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2744

    
2745
    return;
2746
}
2747

    
2748
static inline void gmc_motion(MpegEncContext *s,
2749
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2750
                               uint8_t **ref_picture)
2751
{
2752
    uint8_t *ptr;
2753
    int linesize, uvlinesize;
2754
    const int a= s->sprite_warping_accuracy;
2755
    int ox, oy;
2756

    
2757
    linesize = s->linesize;
2758
    uvlinesize = s->uvlinesize;
2759

    
2760
    ptr = ref_picture[0];
2761

    
2762
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2763
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2764

    
2765
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2766
           ox,
2767
           oy,
2768
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2769
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2770
           a+1, (1<<(2*a+1)) - s->no_rounding,
2771
           s->h_edge_pos, s->v_edge_pos);
2772
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2773
           ox + s->sprite_delta[0][0]*8,
2774
           oy + s->sprite_delta[1][0]*8,
2775
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2776
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2777
           a+1, (1<<(2*a+1)) - s->no_rounding,
2778
           s->h_edge_pos, s->v_edge_pos);
2779

    
2780
    if(s->flags&CODEC_FLAG_GRAY) return;
2781

    
2782
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2783
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2784

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

    
2794
    ptr = ref_picture[2];
2795
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2796
           ox,
2797
           oy,
2798
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2799
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2800
           a+1, (1<<(2*a+1)) - s->no_rounding,
2801
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2802
}
2803

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

    
2821
    if(src_y>= h){
2822
        src+= (h-1-src_y)*linesize;
2823
        src_y=h-1;
2824
    }else if(src_y<=-block_h){
2825
        src+= (1-block_h-src_y)*linesize;
2826
        src_y=1-block_h;
2827
    }
2828
    if(src_x>= w){
2829
        src+= (w-1-src_x);
2830
        src_x=w-1;
2831
    }else if(src_x<=-block_w){
2832
        src+= (1-block_w-src_x);
2833
        src_x=1-block_w;
2834
    }
2835

    
2836
    start_y= FFMAX(0, -src_y);
2837
    start_x= FFMAX(0, -src_x);
2838
    end_y= FFMIN(block_h, h-src_y);
2839
    end_x= FFMIN(block_w, w-src_x);
2840

    
2841
    // copy existing part
2842
    for(y=start_y; y<end_y; y++){
2843
        for(x=start_x; x<end_x; x++){
2844
            buf[x + y*linesize]= src[x + y*linesize];
2845
        }
2846
    }
2847

    
2848
    //top
2849
    for(y=0; y<start_y; y++){
2850
        for(x=start_x; x<end_x; x++){
2851
            buf[x + y*linesize]= buf[x + start_y*linesize];
2852
        }
2853
    }
2854

    
2855
    //bottom
2856
    for(y=end_y; y<block_h; y++){
2857
        for(x=start_x; x<end_x; x++){
2858
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2859
        }
2860
    }
2861

    
2862
    for(y=0; y<block_h; y++){
2863
       //left
2864
        for(x=0; x<start_x; x++){
2865
            buf[x + y*linesize]= buf[start_x + y*linesize];
2866
        }
2867

    
2868
       //right
2869
        for(x=end_x; x<block_w; x++){
2870
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2871
        }
2872
    }
2873
}
2874

    
2875
static inline int hpel_motion(MpegEncContext *s,
2876
                                  uint8_t *dest, uint8_t *src,
2877
                                  int field_based, int field_select,
2878
                                  int src_x, int src_y,
2879
                                  int width, int height, int stride,
2880
                                  int h_edge_pos, int v_edge_pos,
2881
                                  int w, int h, op_pixels_func *pix_op,
2882
                                  int motion_x, int motion_y)
2883
{
2884
    int dxy;
2885
    int emu=0;
2886

    
2887
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2888
    src_x += motion_x >> 1;
2889
    src_y += motion_y >> 1;
2890

    
2891
    /* WARNING: do no forget half pels */
2892
    src_x = av_clip(src_x, -16, width); //FIXME unneeded for emu?
2893
    if (src_x == width)
2894
        dxy &= ~1;
2895
    src_y = av_clip(src_y, -16, height);
2896
    if (src_y == height)
2897
        dxy &= ~2;
2898
    src += src_y * stride + src_x;
2899

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

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

    
2929
    if(s->quarter_sample){
2930
        motion_x/=2;
2931
        motion_y/=2;
2932
    }
2933

    
2934
    sx= motion_x & s_mask;
2935
    sy= motion_y & s_mask;
2936
    src_x += motion_x >> (lowres+1);
2937
    src_y += motion_y >> (lowres+1);
2938

    
2939
    src += src_y * stride + src_x;
2940

    
2941
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
2942
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2943
        ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2944
                            src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2945
        src= s->edge_emu_buffer;
2946
        emu=1;
2947
    }
2948

    
2949
    sx <<= 2 - lowres;
2950
    sy <<= 2 - lowres;
2951
    if(field_select)
2952
        src += s->linesize;
2953
    pix_op[lowres](dest, src, stride, h, sx, sy);
2954
    return emu;
2955
}
2956

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

    
2967
#if 0
2968
if(s->quarter_sample)
2969
{
2970
    motion_x>>=1;
2971
    motion_y>>=1;
2972
}
2973
#endif
2974

    
2975
    v_edge_pos = s->v_edge_pos >> field_based;
2976
    linesize   = s->current_picture.linesize[0] << field_based;
2977
    uvlinesize = s->current_picture.linesize[1] << field_based;
2978

    
2979
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2980
    src_x = s->mb_x* 16               + (motion_x >> 1);
2981
    src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2982

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

    
3024
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
3025
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3026
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3027

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

    
3049
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3050
        dest_y += s->linesize;
3051
        dest_cb+= s->uvlinesize;
3052
        dest_cr+= s->uvlinesize;
3053
    }
3054

    
3055
    if(field_select){
3056
        ptr_y += s->linesize;
3057
        ptr_cb+= s->uvlinesize;
3058
        ptr_cr+= s->uvlinesize;
3059
    }
3060

    
3061
    pix_op[0][dxy](dest_y, ptr_y, linesize, h);
3062

    
3063
    if(!(s->flags&CODEC_FLAG_GRAY)){
3064
        pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
3065
        pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
3066
    }
3067
    if((ENABLE_H261_ENCODER || ENABLE_H261_DECODER) && s->out_format == FMT_H261){
3068
        ff_h261_loop_filter(s);
3069
    }
3070
}
3071

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

    
3089
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
3090
        motion_x/=2;
3091
        motion_y/=2;
3092
    }
3093

    
3094
    if(field_based){
3095
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
3096
    }
3097

    
3098
    sx= motion_x & s_mask;
3099
    sy= motion_y & s_mask;
3100
    src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
3101
    src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
3102

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

    
3124
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
3125
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3126
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3127

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

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

    
3150
    if(field_select){
3151
        ptr_y += s->linesize;
3152
        ptr_cb+= s->uvlinesize;
3153
        ptr_cr+= s->uvlinesize;
3154
    }
3155

    
3156
    sx <<= 2 - lowres;
3157
    sy <<= 2 - lowres;
3158
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
3159

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

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

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

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

    
3232
    assert(s->quarter_sample==0);
3233

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

    
3248
    put_obmc(dest, ptr, s->linesize);
3249
}
3250

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

    
3261
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3262
    src_x = s->mb_x *  16                 + (motion_x >> 2);
3263
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3264

    
3265
    v_edge_pos = s->v_edge_pos >> field_based;
3266
    linesize = s->linesize << field_based;
3267
    uvlinesize = s->uvlinesize << field_based;
3268

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

    
3286
    uvdxy= (mx&1) | ((my&1)<<1);
3287
    mx>>=1;
3288
    my>>=1;
3289

    
3290
    uvsrc_x = s->mb_x *  8                 + mx;
3291
    uvsrc_y = s->mb_y * (8 >> field_based) + my;
3292

    
3293
    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
3294
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3295
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3296

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

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

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

    
3338
inline int ff_h263_round_chroma(int x){
3339
    if (x >= 0)
3340
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3341
    else {
3342
        x = -x;
3343
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3344
    }
3345
}
3346

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

    
3358
    /* In case of 8X8, we construct a single chroma motion vector
3359
       with a special rounding */
3360
    mx= ff_h263_round_chroma(mx);
3361
    my= ff_h263_round_chroma(my);
3362

    
3363
    dxy = ((my & 1) << 1) | (mx & 1);
3364
    mx >>= 1;
3365
    my >>= 1;
3366

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

    
3376
    offset = (src_y * (s->uvlinesize)) + src_x;
3377
    ptr = ref_picture[1] + offset;
3378
    if(s->flags&CODEC_FLAG_EMU_EDGE){
3379
        if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3380
           || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
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
            emu=1;
3384
        }
3385
    }
3386
    pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3387

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

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

    
3409
    if(s->quarter_sample){
3410
        mx/=2;
3411
        my/=2;
3412
    }
3413

    
3414
    /* In case of 8X8, we construct a single chroma motion vector
3415
       with a special rounding */
3416
    mx= ff_h263_round_chroma(mx);
3417
    my= ff_h263_round_chroma(my);
3418

    
3419
    sx= mx & s_mask;
3420
    sy= my & s_mask;
3421
    src_x = s->mb_x*block_s + (mx >> (lowres+1));
3422
    src_y = s->mb_y*block_s + (my >> (lowres+1));
3423

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

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

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

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

    
3479
    mb_x = s->mb_x;
3480
    mb_y = s->mb_y;
3481

    
3482
    prefetch_motion(s, ref_picture, dir);
3483

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

    
3490
        assert(!s->mb_skipped);
3491

    
3492
        memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
3493
        memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3494
        memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3495

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

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

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

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

    
3536
            mx += mv[0][0];
3537
            my += mv[0][1];
3538
        }
3539
        if(!(s->flags&CODEC_FLAG_GRAY))
3540
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3541

    
3542
        return;
3543
    }
3544

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

    
3580
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3581
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3582
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3583

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

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

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

    
3616
                mx += s->mv[dir][i][0];
3617
                my += s->mv[dir][i][1];
3618
            }
3619
        }
3620

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

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

    
3660
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3661
                ref2picture= ref_picture;
3662
            }else{
3663
                ref2picture= s->current_picture_ptr->data;
3664
            }
3665

    
3666
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3667
                        0, 0, s->field_select[dir][i],
3668
                        ref2picture, pix_op,
3669
                        s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3670

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

    
3695
                // after put we make avg of the same block
3696
                pix_op=s->dsp.avg_pixels_tab;
3697

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

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

    
3730
    mb_x = s->mb_x;
3731
    mb_y = s->mb_y;
3732

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

    
3752
                mx += s->mv[dir][i][0];
3753
                my += s->mv[dir][i][1];
3754
            }
3755

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

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

    
3786
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3787
                ref2picture= ref_picture;
3788
            }else{
3789
                ref2picture= s->current_picture_ptr->data;
3790
            }
3791

    
3792
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3793
                        0, 0, s->field_select[dir][i],
3794
                        ref2picture, pix_op,
3795
                        s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
3796

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

    
3821
                // after put we make avg of the same block
3822
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3823

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

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

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

    
3852
static inline void add_dequant_dct(MpegEncContext *s,
3853
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3854
{
3855
    if (s->block_last_index[i] >= 0) {
3856
        s->dct_unquantize_inter(s, block, i, qscale);
3857

    
3858
        s->dsp.idct_add (dest, line_size, block);
3859
    }
3860
}
3861

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

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

    
3892
    s->mbintra_table[xy]= 0;
3893
}
3894

    
3895
/* generic function called after a macroblock has been parsed by the
3896
   decoder or after it has been encoded by the encoder.
3897

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

    
3916
    mb_x = s->mb_x;
3917
    mb_y = s->mb_y;
3918

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

    
3928
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3929

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

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

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

    
3960
            assert(age);
3961

    
3962
            if (s->mb_skipped) {
3963
                s->mb_skipped= 0;
3964
                assert(s->pict_type!=I_TYPE);
3965

    
3966
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
3967
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3968

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

    
3981
        dct_linesize = linesize << s->interlaced_dct;
3982
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3983

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

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

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

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

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

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

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

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

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

    
4114
                if(!(s->flags&CODEC_FLAG_GRAY)){
4115
                    if(s->chroma_y_shift){
4116
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
4117
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
4118
                    }else{
4119

    
4120
                        dct_linesize = uvlinesize << s->interlaced_dct;
4121
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
4122

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

    
4146
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
4147
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
4148
    else                  MPV_decode_mb_internal(s, block, 0);
4149
}
4150

    
4151
#ifdef CONFIG_ENCODERS
4152

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

    
4171
    if(threshold<0){
4172
        skip_dc=0;
4173
        threshold= -threshold;
4174
    }else
4175
        skip_dc=1;
4176

    
4177
    /* are all which we could set to zero are allready zero? */
4178
    if(last_index<=skip_dc - 1) return;
4179

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

    
4202
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
4203
{
4204
    int i;
4205
    const int maxlevel= s->max_qcoeff;
4206
    const int minlevel= s->min_qcoeff;
4207
    int overflow=0;
4208

    
4209
    if(s->mb_intra){
4210
        i=1; //skip clipping of intra dc
4211
    }else
4212
        i=0;
4213

    
4214
    for(;i<=last_index; i++){
4215
        const int j= s->intra_scantable.permutated[i];
4216
        int level = block[j];
4217

    
4218
        if     (level>maxlevel){
4219
            level=maxlevel;
4220
            overflow++;
4221
        }else if(level<minlevel){
4222
            level=minlevel;
4223
            overflow++;
4224
        }
4225

    
4226
        block[j]= level;
4227
    }
4228

    
4229
    if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
4230
        av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel);
4231
}
4232

    
4233
#endif //CONFIG_ENCODERS
4234

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

    
4244
        if(s->picture_structure != PICT_FRAME){
4245
            h <<= 1;
4246
            y <<= 1;
4247
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
4248
        }
4249

    
4250
        h= FFMIN(h, s->avctx->height - y);
4251

    
4252
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
4253
            src= (AVFrame*)s->current_picture_ptr;
4254
        else if(s->last_picture_ptr)
4255
            src= (AVFrame*)s->last_picture_ptr;
4256
        else
4257
            return;
4258

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

    
4271
        emms_c();
4272

    
4273
        s->avctx->draw_horiz_band(s->avctx, src, offset,
4274
                                  y, s->picture_structure, h);
4275
    }
4276
}
4277

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

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

    
4291
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
4292
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4293
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4294

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

    
4303
#ifdef CONFIG_ENCODERS
4304

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

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

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

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

    
4342
    if(s->adaptive_quant){
4343
        const int last_qp= s->qscale;
4344
        const int mb_xy= mb_x + mb_y*s->mb_stride;
4345

    
4346
        s->lambda= s->lambda_table[mb_xy];
4347
        update_qscale(s);
4348

    
4349
        if(!(s->flags&CODEC_FLAG_QP_RD)){
4350
            s->qscale= s->current_picture_ptr->qscale_table[mb_xy];
4351
            s->dquant= s->qscale - last_qp;
4352

    
4353
            if(s->out_format==FMT_H263){
4354
                s->dquant= av_clip(s->dquant, -2, 2);
4355

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

    
4372
    wrap_y = s->linesize;
4373
    wrap_c = s->uvlinesize;
4374
    ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
4375
    ptr_cb = s->new_picture.data[1] + (mb_y * mb_block_height * wrap_c) + mb_x * 8;
4376
    ptr_cr = s->new_picture.data[2] + (mb_y * mb_block_height * wrap_c) + mb_x * 8;
4377

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

    
4388
    if (s->mb_intra) {
4389
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4390
            int progressive_score, interlaced_score;
4391

    
4392
            s->interlaced_dct=0;
4393
            progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8)
4394
                              +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
4395

    
4396
            if(progressive_score > 0){
4397
                interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8)
4398
                                  +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
4399
                if(progressive_score > interlaced_score){
4400
                    s->interlaced_dct=1;
4401

    
4402
                    dct_offset= wrap_y;
4403
                    wrap_y<<=1;
4404
                    if (s->chroma_format == CHROMA_422)
4405
                        wrap_c<<=1;
4406
                }
4407
            }
4408
        }
4409

    
4410
        s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
4411
        s->dsp.get_pixels(s->block[1], ptr_y              + 8, wrap_y);
4412
        s->dsp.get_pixels(s->block[2], ptr_y + dct_offset    , wrap_y);
4413
        s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
4414

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

    
4431
        dest_y  = s->dest[0];
4432
        dest_cb = s->dest[1];
4433
        dest_cr = s->dest[2];
4434

    
4435
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
4436
            op_pix = s->dsp.put_pixels_tab;
4437
            op_qpix= s->dsp.put_qpel_pixels_tab;
4438
        }else{
4439
            op_pix = s->dsp.put_no_rnd_pixels_tab;
4440
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
4441
        }
4442

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

    
4452
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4453
            int progressive_score, interlaced_score;
4454

    
4455
            s->interlaced_dct=0;
4456
            progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8)
4457
                              +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
4458

    
4459
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
4460

    
4461
            if(progressive_score>0){
4462
                interlaced_score = s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y*2, 8)
4463
                                  +s->dsp.ildct_cmp[0](s, dest_y + wrap_y  , ptr_y + wrap_y  , wrap_y*2, 8);
4464

    
4465
                if(progressive_score > interlaced_score){
4466
                    s->interlaced_dct=1;
4467

    
4468
                    dct_offset= wrap_y;
4469
                    wrap_y<<=1;
4470
                    if (s->chroma_format == CHROMA_422)
4471
                        wrap_c<<=1;
4472
                }
4473
            }
4474
        }
4475

    
4476
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
4477
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
4478
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
4479
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
4480

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

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

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

    
4544
        if(s->luma_elim_threshold && !s->mb_intra)
4545
            for(i=0; i<4; i++)
4546
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
4547
        if(s->chroma_elim_threshold && !s->mb_intra)
4548
            for(i=4; i<mb_block_count; i++)
4549
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
4550

    
4551
        if(s->flags & CODEC_FLAG_CBP_RD){
4552
            for(i=0;i<mb_block_count;i++) {
4553
                if(s->block_last_index[i] == -1)
4554
                    s->coded_score[i]= INT_MAX/256;
4555
            }
4556
        }
4557
    }
4558

    
4559
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
4560
        s->block_last_index[4]=
4561
        s->block_last_index[5]= 0;
4562
        s->block[4][0]=
4563
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
4564
    }
4565

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

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

    
4615
static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
4616
{
4617
    if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y,  8, 6);
4618
    else                                encode_mb_internal(s, motion_x, motion_y, 16, 8);
4619
}
4620

    
4621
#endif //CONFIG_ENCODERS
4622

    
4623
void ff_mpeg_flush(AVCodecContext *avctx){
4624
    int i;
4625
    MpegEncContext *s = avctx->priv_data;
4626

    
4627
    if(s==NULL || s->picture==NULL)
4628
        return;
4629

    
4630
    for(i=0; i<MAX_PICTURE_COUNT; i++){
4631
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
4632
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
4633
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
4634
    }
4635
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
4636

    
4637
    s->mb_x= s->mb_y= 0;
4638

    
4639
    s->parse_context.state= -1;
4640
    s->parse_context.frame_start_found= 0;
4641
    s->parse_context.overread= 0;
4642
    s->parse_context.overread_index=