Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 2d2020b8

History | View | Annotate | Download (251 KB)

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

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

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

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

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

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

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

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

    
77

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

    
81
//#define DEBUG
82

    
83

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
201
    st->scantable= src_scantable;
202

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

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

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

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

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

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

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

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

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

    
262
    return p+4;
263
}
264

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

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

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

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

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

    
308
#endif //CONFIG_ENCODERS
309

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

    
323
    return 0;
324
}
325

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
607
    s->picture_in_gop_number = 0;
608

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

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

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

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

    
630
    MPV_common_defaults(s);
631

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

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

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

    
653
    s->mb_height = (s->height + 15) / 16;
654

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

    
660
    if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
661
        return -1;
662

    
663
    dsputil_init(&s->dsp, s->avctx);
664
    DCT_common_init(s);
665

    
666
    s->flags= s->avctx->flags;
667
    s->flags2= s->avctx->flags2;
668

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

    
676
    /* set chroma shifts */
677
    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
678
                                                    &(s->chroma_y_shift) );
679

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

    
684
    s->mb_num = s->mb_width * s->mb_height;
685

    
686
    s->block_wrap[0]=
687
    s->block_wrap[1]=
688
    s->block_wrap[2]=
689
    s->block_wrap[3]= s->b8_stride;
690
    s->block_wrap[4]=
691
    s->block_wrap[5]= s->mb_stride;
692

    
693
    y_size = s->b8_stride * (2 * s->mb_height + 1);
694
    c_size = s->mb_stride * (s->mb_height + 1);
695
    yc_size = y_size + 2 * c_size;
696

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

    
703
    s->stream_codec_tag=          toupper( s->avctx->stream_codec_tag     &0xFF)
704
                               + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
705
                               + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
706
                               + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
707

    
708
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
709

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

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

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

    
738
        /* Allocate MB type table */
739
        CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint16_t)) //needed for encoding
740

    
741
        CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
742

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

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

    
756
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
757

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

    
781
        /* cbp values */
782
        CHECKED_ALLOCZ(s->coded_block_base, y_size);
783
        s->coded_block= s->coded_block_base + s->b8_stride + 1;
784

    
785
        /* cbp, ac_pred, pred_dir */
786
        CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
787
        CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
788
    }
789

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

    
801
    /* which mb is a intra block */
802
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
803
    memset(s->mbintra_table, 1, mb_array_size);
804

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

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

    
817
    s->context_initialized = 1;
818

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

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

    
832
    return 0;
833
 fail:
834
    MPV_common_end(s);
835
    return -1;
836
}
837

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

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

    
850
    av_freep(&s->parse_context.buffer);
851
    s->parse_context.buffer_size=0;
852

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

    
879
    av_freep(&s->dc_val_base);
880
    av_freep(&s->ac_val_base);
881
    av_freep(&s->coded_block_base);
882
    av_freep(&s->mbintra_table);
883
    av_freep(&s->cbp_table);
884
    av_freep(&s->pred_dir_table);
885

    
886
    av_freep(&s->mbskip_table);
887
    av_freep(&s->prev_pict_types);
888
    av_freep(&s->bitstream_buffer);
889
    s->allocated_bitstream_buffer_size=0;
890

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

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

    
916
    for(i=0; i<3; i++)
917
        av_freep(&s->visualization_buffer[i]);
918

    
919
    avcodec_default_free_buffers(s->avctx);
920
}
921

    
922
#ifdef CONFIG_ENCODERS
923

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

    
931
    MPV_encode_defaults(s);
932

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

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

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

    
990
    if (s->gop_size <= 1) {
991
        s->intra_only = 1;
992
        s->gop_size = 12;
993
    } else {
994
        s->intra_only = 0;
995
    }
996

    
997
    s->me_method = avctx->me_method;
998

    
999
    /* Fixed QSCALE */
1000
    s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
1001

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

    
1011
    s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
1012
    s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
1013
    s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
1014
    s->intra_vlc_format= !!(s->flags2 & CODEC_FLAG2_INTRA_VLC);
1015
    s->q_scale_type= !!(s->flags2 & CODEC_FLAG2_NON_LINEAR_QUANT);
1016

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

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

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

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

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

    
1040
        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");
1041
    }
1042

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1127
    if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1128
       && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1129
       && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1130
        av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1131
        return -1;
1132
    }
1133

    
1134
    if(s->avctx->thread_count > 1)
1135
        s->rtp_mode= 1;
1136

    
1137
    if(!avctx->time_base.den || !avctx->time_base.num){
1138
        av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1139
        return -1;
1140
    }
1141

    
1142
    i= (INT_MAX/2+128)>>8;
1143
    if(avctx->me_threshold >= i){
1144
        av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1145
        return -1;
1146
    }
1147
    if(avctx->mb_threshold >= i){
1148
        av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1149
        return -1;
1150
    }
1151

    
1152
    if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
1153
        av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n");
1154
        avctx->b_frame_strategy = 0;
1155
    }
1156

    
1157
    i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
1158
    if(i > 1){
1159
        av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1160
        avctx->time_base.den /= i;
1161
        avctx->time_base.num /= i;
1162
//        return -1;
1163
    }
1164

    
1165
    if(s->codec_id==CODEC_ID_MJPEG){
1166
        s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1167
        s->inter_quant_bias= 0;
1168
    }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1169
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1170
        s->inter_quant_bias= 0;
1171
    }else{
1172
        s->intra_quant_bias=0;
1173
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1174
    }
1175

    
1176
    if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1177
        s->intra_quant_bias= avctx->intra_quant_bias;
1178
    if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1179
        s->inter_quant_bias= avctx->inter_quant_bias;
1180

    
1181
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1182

    
1183
    if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
1184
        av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1185
        return -1;
1186
    }
1187
    s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1188

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

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

    
1340
    avctx->has_b_frames= !s->low_delay;
1341

    
1342
    s->encoding = 1;
1343

    
1344
    /* init */
1345
    if (MPV_common_init(s) < 0)
1346
        return -1;
1347

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

    
1354
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1355
    ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1356

    
1357
#ifdef CONFIG_H261_ENCODER
1358
    if (s->out_format == FMT_H261)
1359
        ff_h261_encode_init(s);
1360
#endif
1361
    if (s->out_format == FMT_H263)
1362
        h263_encode_init(s);
1363
    if(s->msmpeg4_version)
1364
        ff_msmpeg4_encode_init(s);
1365
    if (s->out_format == FMT_MPEG1)
1366
        ff_mpeg1_encode_init(s);
1367

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

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

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

    
1400
    return 0;
1401
}
1402

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

    
1407
    ff_rate_control_uninit(s);
1408

    
1409
    MPV_common_end(s);
1410
    if (s->out_format == FMT_MJPEG)
1411
        mjpeg_close(s);
1412

    
1413
    av_freep(&avctx->extradata);
1414

    
1415
    return 0;
1416
}
1417

    
1418
#endif //CONFIG_ENCODERS
1419

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1654
        update_noise_reduction(s);
1655
    }
1656

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1868

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

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

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

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

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

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

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

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

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

    
1989

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

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

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

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

    
2058
#ifdef CONFIG_ENCODERS
2059

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

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

    
2070
    return acc;
2071
}
2072

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

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

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

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

    
2093

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2197
    return 0;
2198
}
2199

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

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

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

    
2224
    if(score) score64= score;
2225

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2339
    return best_b_count;
2340
}
2341

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

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

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

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

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

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

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

    
2377
                    goto no_output_pic;
2378
                }
2379
            }
2380

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2527
    s->picture_in_gop_number++;
2528

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

    
2532
    select_input_picture(s);
2533

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

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

    
2554
        MPV_frame_end(s);
2555

    
2556
        if (s->out_format == FMT_MJPEG)
2557
            mjpeg_picture_trailer(s);
2558

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2659
#endif //CONFIG_ENCODERS
2660

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

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

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

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

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

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

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

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

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

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

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

    
2744
    return;
2745
}
2746

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

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

    
2759
    ptr = ref_picture[0];
2760

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2938
    src += src_y * stride + src_x;
2939

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3483
    prefetch_motion(s, ref_picture, dir);
3484

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

    
3491
        assert(!s->mb_skipped);
3492

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

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

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

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

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

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

    
3543
        return;
3544
    }
3545

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3961
            assert(age);
3962

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4152
#ifdef CONFIG_ENCODERS
4153

    
4154
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
4155
{
4156
    static const char tab[64]=
4157
        {3,2,2,1,1,1,1,1,
4158
         1,1,1,1,1,1,1,1,
4159
         1,1,1,1,1,1,1,1,
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
         0,0,0,0,0,0,0,0};
4165
    int score=0;
4166
    int run=0;
4167
    int i;
4168
    DCTELEM *block= s->block[n];
4169
    const int last_index= s->block_last_index[n];
4170
    int skip_dc;
4171

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

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

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

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

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

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

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

    
4227
        block[j]= level;
4228
    }
4229

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

    
4234
#endif //CONFIG_ENCODERS
4235

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

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

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

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

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

    
4272
        emms_c();
4273

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

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

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

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

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

    
4304
#ifdef CONFIG_ENCODERS
4305

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4616
#endif //CONFIG_ENCODERS
4617

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

    
4622
    if(s==NULL || s->picture==NULL)
4623
        return;
4624

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

    
4632
    s->mb_x= s->mb_y= 0;
4633

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

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