Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 5509bffa

History | View | Annotate | Download (240 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 library is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2 of the License, or (at your option) any later version.
10
 *
11
 * This library is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with this library; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
 *
20
 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
21
 */
22

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

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

    
34
#ifdef USE_FASTMEMCPY
35
#include "fastmemcpy.h"
36
#endif
37

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

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

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

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

    
73

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

    
77
//#define DEBUG
78

    
79

    
80
/* for jpeg fast DCT */
81
#define CONST_BITS 14
82

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

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

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

    
105
#ifdef CONFIG_ENCODERS
106
static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
107
static uint8_t default_fcode_tab[MAX_MV*2+1];
108

    
109
enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
110

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

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

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

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

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

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

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

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

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

    
197
    st->scantable= src_scantable;
198

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

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

    
217
#ifdef CONFIG_ENCODERS
218
void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
219
    int i;
220

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

    
231
/* init common dct for both encoder and decoder */
232
int DCT_common_init(MpegEncContext *s)
233
{
234
    s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
235
    s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
236
    s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
237
    s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
238
    s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
239
    s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
240

    
241
#ifdef CONFIG_ENCODERS
242
    s->dct_quantize= dct_quantize_c;
243
    s->denoise_dct= denoise_dct_c;
244
#endif //CONFIG_ENCODERS
245

    
246
#ifdef HAVE_MMX
247
    MPV_common_init_mmx(s);
248
#endif
249
#ifdef ARCH_ALPHA
250
    MPV_common_init_axp(s);
251
#endif
252
#ifdef HAVE_MLIB
253
    MPV_common_init_mlib(s);
254
#endif
255
#ifdef HAVE_MMI
256
    MPV_common_init_mmi(s);
257
#endif
258
#ifdef ARCH_ARMV4L
259
    MPV_common_init_armv4l(s);
260
#endif
261
#ifdef ARCH_POWERPC
262
    MPV_common_init_ppc(s);
263
#endif
264

    
265
#ifdef CONFIG_ENCODERS
266
    s->fast_dct_quantize= s->dct_quantize;
267

    
268
    if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
269
        s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
270
    }
271

    
272
#endif //CONFIG_ENCODERS
273

    
274
    /* load & permutate scantables
275
       note: only wmv uses different ones
276
    */
277
    if(s->alternate_scan){
278
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
279
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
280
    }else{
281
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
282
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
283
    }
284
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
285
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
286

    
287
    return 0;
288
}
289

    
290
static void copy_picture(Picture *dst, Picture *src){
291
    *dst = *src;
292
    dst->type= FF_BUFFER_TYPE_COPY;
293
}
294

    
295
static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
296
    int i;
297

    
298
    dst->pict_type              = src->pict_type;
299
    dst->quality                = src->quality;
300
    dst->coded_picture_number   = src->coded_picture_number;
301
    dst->display_picture_number = src->display_picture_number;
302
//    dst->reference              = src->reference;
303
    dst->pts                    = src->pts;
304
    dst->interlaced_frame       = src->interlaced_frame;
305
    dst->top_field_first        = src->top_field_first;
306

    
307
    if(s->avctx->me_threshold){
308
        if(!src->motion_val[0])
309
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
310
        if(!src->mb_type)
311
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
312
        if(!src->ref_index[0])
313
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
314
        if(src->motion_subsample_log2 != dst->motion_subsample_log2)
315
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
316
            src->motion_subsample_log2, dst->motion_subsample_log2);
317

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

    
320
        for(i=0; i<2; i++){
321
            int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
322
            int height= ((16*s->mb_height)>>src->motion_subsample_log2);
323

    
324
            if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
325
                memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
326
            }
327
            if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
328
                memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
329
            }
330
        }
331
    }
332
}
333

    
334
/**
335
 * allocates a Picture
336
 * The pixels are allocated/set by calling get_buffer() if shared=0
337
 */
338
static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
339
    const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
340
    const int mb_array_size= s->mb_stride*s->mb_height;
341
    const int b8_array_size= s->b8_stride*s->mb_height*2;
342
    const int b4_array_size= s->b4_stride*s->mb_height*4;
343
    int i;
344

    
345
    if(shared){
346
        assert(pic->data[0]);
347
        assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
348
        pic->type= FF_BUFFER_TYPE_SHARED;
349
    }else{
350
        int r;
351

    
352
        assert(!pic->data[0]);
353

    
354
        r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
355

    
356
        if(r<0 || !pic->age || !pic->type || !pic->data[0]){
357
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
358
            return -1;
359
        }
360

    
361
        if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
362
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
363
            return -1;
364
        }
365

    
366
        if(pic->linesize[1] != pic->linesize[2]){
367
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
368
            return -1;
369
        }
370

    
371
        s->linesize  = pic->linesize[0];
372
        s->uvlinesize= pic->linesize[1];
373
    }
374

    
375
    if(pic->qscale_table==NULL){
376
        if (s->encoding) {
377
            CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
378
            CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
379
            CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
380
        }
381

    
382
        CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
383
        CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
384
        CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num    * sizeof(uint32_t))
385
        pic->mb_type= pic->mb_type_base + s->mb_stride+1;
386
        if(s->out_format == FMT_H264){
387
            for(i=0; i<2; i++){
388
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4)  * sizeof(int16_t))
389
                pic->motion_val[i]= pic->motion_val_base[i]+4;
390
                CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
391
            }
392
            pic->motion_subsample_log2= 2;
393
        }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
394
            for(i=0; i<2; i++){
395
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
396
                pic->motion_val[i]= pic->motion_val_base[i]+4;
397
                CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
398
            }
399
            pic->motion_subsample_log2= 3;
400
        }
401
        if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
402
            CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
403
        }
404
        pic->qstride= s->mb_stride;
405
        CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
406
    }
407

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

    
414
    return 0;
415
fail: //for the CHECKED_ALLOCZ macro
416
    return -1;
417
}
418

    
419
/**
420
 * deallocates a picture
421
 */
422
static void free_picture(MpegEncContext *s, Picture *pic){
423
    int i;
424

    
425
    if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
426
        s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
427
    }
428

    
429
    av_freep(&pic->mb_var);
430
    av_freep(&pic->mc_mb_var);
431
    av_freep(&pic->mb_mean);
432
    av_freep(&pic->mbskip_table);
433
    av_freep(&pic->qscale_table);
434
    av_freep(&pic->mb_type_base);
435
    av_freep(&pic->dct_coeff);
436
    av_freep(&pic->pan_scan);
437
    pic->mb_type= NULL;
438
    for(i=0; i<2; i++){
439
        av_freep(&pic->motion_val_base[i]);
440
        av_freep(&pic->ref_index[i]);
441
    }
442

    
443
    if(pic->type == FF_BUFFER_TYPE_SHARED){
444
        for(i=0; i<4; i++){
445
            pic->base[i]=
446
            pic->data[i]= NULL;
447
        }
448
        pic->type= 0;
449
    }
450
}
451

    
452
static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
453
    int i;
454

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

    
459
     //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
460
    CHECKED_ALLOCZ(s->me.scratchpad,  (s->width+64)*4*16*2*sizeof(uint8_t))
461
    s->rd_scratchpad=   s->me.scratchpad;
462
    s->b_scratchpad=    s->me.scratchpad;
463
    s->obmc_scratchpad= s->me.scratchpad + 16;
464
    if (s->encoding) {
465
        CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
466
        CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
467
        if(s->avctx->noise_reduction){
468
            CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
469
        }
470
    }
471
    CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
472
    s->block= s->blocks[0];
473

    
474
    for(i=0;i<12;i++){
475
        s->pblocks[i] = (short *)(&s->block[i]);
476
    }
477
    return 0;
478
fail:
479
    return -1; //free() through MPV_common_end()
480
}
481

    
482
static void free_duplicate_context(MpegEncContext *s){
483
    if(s==NULL) return;
484

    
485
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
486
    av_freep(&s->me.scratchpad);
487
    s->rd_scratchpad=
488
    s->b_scratchpad=
489
    s->obmc_scratchpad= NULL;
490

    
491
    av_freep(&s->dct_error_sum);
492
    av_freep(&s->me.map);
493
    av_freep(&s->me.score_map);
494
    av_freep(&s->blocks);
495
    s->block= NULL;
496
}
497

    
498
static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
499
#define COPY(a) bak->a= src->a
500
    COPY(allocated_edge_emu_buffer);
501
    COPY(edge_emu_buffer);
502
    COPY(me.scratchpad);
503
    COPY(rd_scratchpad);
504
    COPY(b_scratchpad);
505
    COPY(obmc_scratchpad);
506
    COPY(me.map);
507
    COPY(me.score_map);
508
    COPY(blocks);
509
    COPY(block);
510
    COPY(start_mb_y);
511
    COPY(end_mb_y);
512
    COPY(me.map_generation);
513
    COPY(pb);
514
    COPY(dct_error_sum);
515
    COPY(dct_count[0]);
516
    COPY(dct_count[1]);
517
#undef COPY
518
}
519

    
520
void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
521
    MpegEncContext bak;
522
    int i;
523
    //FIXME copy only needed parts
524
//START_TIMER
525
    backup_duplicate_context(&bak, dst);
526
    memcpy(dst, src, sizeof(MpegEncContext));
527
    backup_duplicate_context(dst, &bak);
528
    for(i=0;i<12;i++){
529
        dst->pblocks[i] = (short *)(&dst->block[i]);
530
    }
531
//STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
532
}
533

    
534
static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
535
#define COPY(a) dst->a= src->a
536
    COPY(pict_type);
537
    COPY(current_picture);
538
    COPY(f_code);
539
    COPY(b_code);
540
    COPY(qscale);
541
    COPY(lambda);
542
    COPY(lambda2);
543
    COPY(picture_in_gop_number);
544
    COPY(gop_picture_number);
545
    COPY(frame_pred_frame_dct); //FIXME don't set in encode_header
546
    COPY(progressive_frame); //FIXME don't set in encode_header
547
    COPY(partitioned_frame); //FIXME don't set in encode_header
548
#undef COPY
549
}
550

    
551
/**
552
 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
553
 * the changed fields will not depend upon the prior state of the MpegEncContext.
554
 */
555
static void MPV_common_defaults(MpegEncContext *s){
556
    s->y_dc_scale_table=
557
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
558
    s->chroma_qscale_table= ff_default_chroma_qscale_table;
559
    s->progressive_frame= 1;
560
    s->progressive_sequence= 1;
561
    s->picture_structure= PICT_FRAME;
562

    
563
    s->coded_picture_number = 0;
564
    s->picture_number = 0;
565
    s->input_picture_number = 0;
566

    
567
    s->picture_in_gop_number = 0;
568

    
569
    s->f_code = 1;
570
    s->b_code = 1;
571
}
572

    
573
/**
574
 * sets the given MpegEncContext to defaults for decoding.
575
 * the changed fields will not depend upon the prior state of the MpegEncContext.
576
 */
577
void MPV_decode_defaults(MpegEncContext *s){
578
    MPV_common_defaults(s);
579
}
580

    
581
/**
582
 * sets the given MpegEncContext to defaults for encoding.
583
 * the changed fields will not depend upon the prior state of the MpegEncContext.
584
 */
585

    
586
#ifdef CONFIG_ENCODERS
587
static void MPV_encode_defaults(MpegEncContext *s){
588
    static int done=0;
589

    
590
    MPV_common_defaults(s);
591

    
592
    if(!done){
593
        int i;
594
        done=1;
595

    
596
        default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
597
        memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
598

    
599
        for(i=-16; i<16; i++){
600
            default_fcode_tab[i + MAX_MV]= 1;
601
        }
602
    }
603
    s->me.mv_penalty= default_mv_penalty;
604
    s->fcode_tab= default_fcode_tab;
605
}
606
#endif //CONFIG_ENCODERS
607

    
608
/**
609
 * init common structure for both encoder and decoder.
610
 * this assumes that some variables like width/height are already set
611
 */
612
int MPV_common_init(MpegEncContext *s)
613
{
614
    int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
615

    
616
    if(s->avctx->thread_count > MAX_THREADS || (16*s->avctx->thread_count > s->height && s->height)){
617
        av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
618
        return -1;
619
    }
620

    
621
    if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
622
        return -1;
623

    
624
    dsputil_init(&s->dsp, s->avctx);
625
    DCT_common_init(s);
626

    
627
    s->flags= s->avctx->flags;
628
    s->flags2= s->avctx->flags2;
629

    
630
    s->mb_width  = (s->width  + 15) / 16;
631
    s->mb_height = (s->height + 15) / 16;
632
    s->mb_stride = s->mb_width + 1;
633
    s->b8_stride = s->mb_width*2 + 1;
634
    s->b4_stride = s->mb_width*4 + 1;
635
    mb_array_size= s->mb_height * s->mb_stride;
636
    mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
637

    
638
    /* set chroma shifts */
639
    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
640
                                                    &(s->chroma_y_shift) );
641

    
642
    /* set default edge pos, will be overriden in decode_header if needed */
643
    s->h_edge_pos= s->mb_width*16;
644
    s->v_edge_pos= s->mb_height*16;
645

    
646
    s->mb_num = s->mb_width * s->mb_height;
647

    
648
    s->block_wrap[0]=
649
    s->block_wrap[1]=
650
    s->block_wrap[2]=
651
    s->block_wrap[3]= s->b8_stride;
652
    s->block_wrap[4]=
653
    s->block_wrap[5]= s->mb_stride;
654

    
655
    y_size = s->b8_stride * (2 * s->mb_height + 1);
656
    c_size = s->mb_stride * (s->mb_height + 1);
657
    yc_size = y_size + 2 * c_size;
658

    
659
    /* convert fourcc to upper case */
660
    s->avctx->codec_tag=   toupper( s->avctx->codec_tag     &0xFF)
661
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
662
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
663
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
664

    
665
    s->avctx->stream_codec_tag=   toupper( s->avctx->stream_codec_tag     &0xFF)
666
                               + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
667
                               + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
668
                               + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
669

    
670
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
671

    
672
    CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
673
    for(y=0; y<s->mb_height; y++){
674
        for(x=0; x<s->mb_width; x++){
675
            s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
676
        }
677
    }
678
    s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
679

    
680
    if (s->encoding) {
681
        /* Allocate MV tables */
682
        CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
683
        CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
684
        CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
685
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
686
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
687
        CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
688
        s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
689
        s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
690
        s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
691
        s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
692
        s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
693
        s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
694

    
695
        if(s->msmpeg4_version){
696
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
697
        }
698
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
699

    
700
        /* Allocate MB type table */
701
        CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint16_t)) //needed for encoding
702

    
703
        CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
704

    
705
        CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
706
        CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
707
        CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
708
        CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
709
        CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
710
        CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
711

    
712
        if(s->avctx->noise_reduction){
713
            CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
714
        }
715
    }
716
    CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
717

    
718
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
719

    
720
    if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
721
        /* interlaced direct mode decoding tables */
722
            for(i=0; i<2; i++){
723
                int j, k;
724
                for(j=0; j<2; j++){
725
                    for(k=0; k<2; k++){
726
                        CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k]     , mv_table_size * 2 * sizeof(int16_t))
727
                        s->b_field_mv_table[i][j][k]    = s->b_field_mv_table_base[i][j][k]     + s->mb_stride + 1;
728
                    }
729
                    CHECKED_ALLOCZ(s->b_field_select_table[i][j]     , mb_array_size * 2 * sizeof(uint8_t))
730
                    CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j]     , mv_table_size * 2 * sizeof(int16_t))
731
                    s->p_field_mv_table[i][j]    = s->p_field_mv_table_base[i][j]     + s->mb_stride + 1;
732
                }
733
                CHECKED_ALLOCZ(s->p_field_select_table[i]      , mb_array_size * 2 * sizeof(uint8_t))
734
            }
735
    }
736
    if (s->out_format == FMT_H263) {
737
        /* ac values */
738
        CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
739
        s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
740
        s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
741
        s->ac_val[2] = s->ac_val[1] + c_size;
742

    
743
        /* cbp values */
744
        CHECKED_ALLOCZ(s->coded_block_base, y_size);
745
        s->coded_block= s->coded_block_base + s->b8_stride + 1;
746

    
747
        /* cbp, ac_pred, pred_dir */
748
        CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
749
        CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
750
    }
751

    
752
    if (s->h263_pred || s->h263_plus || !s->encoding) {
753
        /* dc values */
754
        //MN: we need these for error resilience of intra-frames
755
        CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
756
        s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
757
        s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
758
        s->dc_val[2] = s->dc_val[1] + c_size;
759
        for(i=0;i<yc_size;i++)
760
            s->dc_val_base[i] = 1024;
761
    }
762

    
763
    /* which mb is a intra block */
764
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
765
    memset(s->mbintra_table, 1, mb_array_size);
766

    
767
    /* init macroblock skip table */
768
    CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
769
    //Note the +1 is for a quicker mpeg4 slice_end detection
770
    CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
771

    
772
    s->parse_context.state= -1;
773
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
774
       s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
775
       s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
776
       s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
777
    }
778

    
779
    s->context_initialized = 1;
780

    
781
    s->thread_context[0]= s;
782
    for(i=1; i<s->avctx->thread_count; i++){
783
        s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
784
        memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
785
    }
786

    
787
    for(i=0; i<s->avctx->thread_count; i++){
788
        if(init_duplicate_context(s->thread_context[i], s) < 0)
789
           goto fail;
790
        s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
791
        s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
792
    }
793

    
794
    return 0;
795
 fail:
796
    MPV_common_end(s);
797
    return -1;
798
}
799

    
800
/* init common structure for both encoder and decoder */
801
void MPV_common_end(MpegEncContext *s)
802
{
803
    int i, j, k;
804

    
805
    for(i=0; i<s->avctx->thread_count; i++){
806
        free_duplicate_context(s->thread_context[i]);
807
    }
808
    for(i=1; i<s->avctx->thread_count; i++){
809
        av_freep(&s->thread_context[i]);
810
    }
811

    
812
    av_freep(&s->parse_context.buffer);
813
    s->parse_context.buffer_size=0;
814

    
815
    av_freep(&s->mb_type);
816
    av_freep(&s->p_mv_table_base);
817
    av_freep(&s->b_forw_mv_table_base);
818
    av_freep(&s->b_back_mv_table_base);
819
    av_freep(&s->b_bidir_forw_mv_table_base);
820
    av_freep(&s->b_bidir_back_mv_table_base);
821
    av_freep(&s->b_direct_mv_table_base);
822
    s->p_mv_table= NULL;
823
    s->b_forw_mv_table= NULL;
824
    s->b_back_mv_table= NULL;
825
    s->b_bidir_forw_mv_table= NULL;
826
    s->b_bidir_back_mv_table= NULL;
827
    s->b_direct_mv_table= NULL;
828
    for(i=0; i<2; i++){
829
        for(j=0; j<2; j++){
830
            for(k=0; k<2; k++){
831
                av_freep(&s->b_field_mv_table_base[i][j][k]);
832
                s->b_field_mv_table[i][j][k]=NULL;
833
            }
834
            av_freep(&s->b_field_select_table[i][j]);
835
            av_freep(&s->p_field_mv_table_base[i][j]);
836
            s->p_field_mv_table[i][j]=NULL;
837
        }
838
        av_freep(&s->p_field_select_table[i]);
839
    }
840

    
841
    av_freep(&s->dc_val_base);
842
    av_freep(&s->ac_val_base);
843
    av_freep(&s->coded_block_base);
844
    av_freep(&s->mbintra_table);
845
    av_freep(&s->cbp_table);
846
    av_freep(&s->pred_dir_table);
847

    
848
    av_freep(&s->mbskip_table);
849
    av_freep(&s->prev_pict_types);
850
    av_freep(&s->bitstream_buffer);
851
    s->allocated_bitstream_buffer_size=0;
852

    
853
    av_freep(&s->avctx->stats_out);
854
    av_freep(&s->ac_stats);
855
    av_freep(&s->error_status_table);
856
    av_freep(&s->mb_index2xy);
857
    av_freep(&s->lambda_table);
858
    av_freep(&s->q_intra_matrix);
859
    av_freep(&s->q_inter_matrix);
860
    av_freep(&s->q_intra_matrix16);
861
    av_freep(&s->q_inter_matrix16);
862
    av_freep(&s->input_picture);
863
    av_freep(&s->reordered_input_picture);
864
    av_freep(&s->dct_offset);
865

    
866
    if(s->picture){
867
        for(i=0; i<MAX_PICTURE_COUNT; i++){
868
            free_picture(s, &s->picture[i]);
869
        }
870
    }
871
    av_freep(&s->picture);
872
    s->context_initialized = 0;
873
    s->last_picture_ptr=
874
    s->next_picture_ptr=
875
    s->current_picture_ptr= NULL;
876
    s->linesize= s->uvlinesize= 0;
877

    
878
    for(i=0; i<3; i++)
879
        av_freep(&s->visualization_buffer[i]);
880

    
881
    avcodec_default_free_buffers(s->avctx);
882
}
883

    
884
#ifdef CONFIG_ENCODERS
885

    
886
/* init video encoder */
887
int MPV_encode_init(AVCodecContext *avctx)
888
{
889
    MpegEncContext *s = avctx->priv_data;
890
    int i;
891
    int chroma_h_shift, chroma_v_shift;
892

    
893
    MPV_encode_defaults(s);
894

    
895
    if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUV420P){
896
        av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
897
        return -1;
898
    }
899

    
900
    if(avctx->codec_id == CODEC_ID_MJPEG || avctx->codec_id == CODEC_ID_LJPEG){
901
        if(avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL && avctx->pix_fmt != PIX_FMT_YUVJ420P){
902
            av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
903
            return -1;
904
        }
905
    }else{
906
        if(avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL && avctx->pix_fmt != PIX_FMT_YUV420P){
907
            av_log(avctx, AV_LOG_ERROR, "colorspace not supported\n");
908
            return -1;
909
        }
910
    }
911

    
912
    s->bit_rate = avctx->bit_rate;
913
    s->width = avctx->width;
914
    s->height = avctx->height;
915
    if(avctx->gop_size > 600){
916
        av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
917
        avctx->gop_size=600;
918
    }
919
    s->gop_size = avctx->gop_size;
920
    s->avctx = avctx;
921
    s->flags= avctx->flags;
922
    s->flags2= avctx->flags2;
923
    s->max_b_frames= avctx->max_b_frames;
924
    s->codec_id= avctx->codec->id;
925
    s->luma_elim_threshold  = avctx->luma_elim_threshold;
926
    s->chroma_elim_threshold= avctx->chroma_elim_threshold;
927
    s->strict_std_compliance= avctx->strict_std_compliance;
928
    s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
929
    s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
930
    s->mpeg_quant= avctx->mpeg_quant;
931
    s->rtp_mode= !!avctx->rtp_payload_size;
932
    s->intra_dc_precision= avctx->intra_dc_precision;
933
    s->user_specified_pts = AV_NOPTS_VALUE;
934

    
935
    if (s->gop_size <= 1) {
936
        s->intra_only = 1;
937
        s->gop_size = 12;
938
    } else {
939
        s->intra_only = 0;
940
    }
941

    
942
    s->me_method = avctx->me_method;
943

    
944
    /* Fixed QSCALE */
945
    s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
946

    
947
    s->adaptive_quant= (   s->avctx->lumi_masking
948
                        || s->avctx->dark_masking
949
                        || s->avctx->temporal_cplx_masking
950
                        || s->avctx->spatial_cplx_masking
951
                        || s->avctx->p_masking
952
                        || s->avctx->border_masking
953
                        || (s->flags&CODEC_FLAG_QP_RD))
954
                       && !s->fixed_qscale;
955

    
956
    s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
957
    s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
958
    s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
959

    
960
    if(avctx->rc_max_rate && !avctx->rc_buffer_size){
961
        av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
962
        return -1;
963
    }
964

    
965
    if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
966
        av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
967
    }
968

    
969
    if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
970
        av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
971
        return -1;
972
    }
973

    
974
    if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
975
        av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
976
        return -1;
977
    }
978

    
979
    if(   s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
980
       && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
981
       && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
982

    
983
        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");
984
    }
985

    
986
    if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
987
       && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
988
        av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
989
        return -1;
990
    }
991

    
992
    if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
993
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n");
994
        return -1;
995
    }
996

    
997
    if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
998
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
999
        return -1;
1000
    }
1001

    
1002
    if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
1003
        av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
1004
        return -1;
1005
    }
1006

    
1007
    if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
1008
        av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
1009
        return -1;
1010
    }
1011

    
1012
    if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
1013
        av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
1014
        return -1;
1015
    }
1016

    
1017
    if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
1018
       && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1019
        av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1020
        return -1;
1021
    }
1022

    
1023
    if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1024
        av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n");
1025
        return -1;
1026
    }
1027

    
1028
    if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1029
        av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1030
        return -1;
1031
    }
1032

    
1033
    if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1034
        av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1035
        return -1;
1036
    }
1037

    
1038
    if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1039
        av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
1040
        return -1;
1041
    }
1042

    
1043
    if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1044
       && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1045
       && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1046
        av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1047
        return -1;
1048
    }
1049

    
1050
    if(s->avctx->thread_count > 1)
1051
        s->rtp_mode= 1;
1052

    
1053
    if(!avctx->time_base.den || !avctx->time_base.num){
1054
        av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1055
        return -1;
1056
    }
1057

    
1058
    i= (INT_MAX/2+128)>>8;
1059
    if(avctx->me_threshold >= i){
1060
        av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1061
        return -1;
1062
    }
1063
    if(avctx->mb_threshold >= i){
1064
        av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1065
        return -1;
1066
    }
1067

    
1068
    if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
1069
        av_log(avctx, AV_LOG_ERROR, "b_frame_strategy must be 0 on the second pass");
1070
        return -1;
1071
    }
1072

    
1073
    i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
1074
    if(i > 1){
1075
        av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1076
        avctx->time_base.den /= i;
1077
        avctx->time_base.num /= i;
1078
//        return -1;
1079
    }
1080

    
1081
    if(s->codec_id==CODEC_ID_MJPEG){
1082
        s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1083
        s->inter_quant_bias= 0;
1084
    }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1085
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1086
        s->inter_quant_bias= 0;
1087
    }else{
1088
        s->intra_quant_bias=0;
1089
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1090
    }
1091

    
1092
    if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1093
        s->intra_quant_bias= avctx->intra_quant_bias;
1094
    if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1095
        s->inter_quant_bias= avctx->inter_quant_bias;
1096

    
1097
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1098

    
1099
    if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
1100
        av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1101
        return -1;
1102
    }
1103
    s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1104

    
1105
    switch(avctx->codec->id) {
1106
    case CODEC_ID_MPEG1VIDEO:
1107
        s->out_format = FMT_MPEG1;
1108
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1109
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1110
        break;
1111
    case CODEC_ID_MPEG2VIDEO:
1112
        s->out_format = FMT_MPEG1;
1113
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1114
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1115
        s->rtp_mode= 1;
1116
        break;
1117
    case CODEC_ID_LJPEG:
1118
    case CODEC_ID_JPEGLS:
1119
    case CODEC_ID_MJPEG:
1120
        s->out_format = FMT_MJPEG;
1121
        s->intra_only = 1; /* force intra only for jpeg */
1122
        s->mjpeg_write_tables = avctx->codec->id != CODEC_ID_JPEGLS;
1123
        s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1124
        s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1125
        s->mjpeg_vsample[1] = 1;
1126
        s->mjpeg_vsample[2] = 1;
1127
        s->mjpeg_hsample[0] = 1<<chroma_h_shift;
1128
        s->mjpeg_hsample[1] = 1;
1129
        s->mjpeg_hsample[2] = 1;
1130
        if (mjpeg_init(s) < 0)
1131
            return -1;
1132
        avctx->delay=0;
1133
        s->low_delay=1;
1134
        break;
1135
    case CODEC_ID_H261:
1136
        s->out_format = FMT_H261;
1137
        avctx->delay=0;
1138
        s->low_delay=1;
1139
        break;
1140
    case CODEC_ID_H263:
1141
        if (h263_get_picture_format(s->width, s->height) == 7) {
1142
            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);
1143
            return -1;
1144
        }
1145
        s->out_format = FMT_H263;
1146
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1147
        avctx->delay=0;
1148
        s->low_delay=1;
1149
        break;
1150
    case CODEC_ID_H263P:
1151
        s->out_format = FMT_H263;
1152
        s->h263_plus = 1;
1153
        /* Fx */
1154
        s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1155
        s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1156
        s->modified_quant= s->h263_aic;
1157
        s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1158
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1159
        s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1160
        s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1161
        s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1162

    
1163
        /* /Fx */
1164
        /* These are just to be sure */
1165
        avctx->delay=0;
1166
        s->low_delay=1;
1167
        break;
1168
    case CODEC_ID_FLV1:
1169
        s->out_format = FMT_H263;
1170
        s->h263_flv = 2; /* format = 1; 11-bit codes */
1171
        s->unrestricted_mv = 1;
1172
        s->rtp_mode=0; /* don't allow GOB */
1173
        avctx->delay=0;
1174
        s->low_delay=1;
1175
        break;
1176
    case CODEC_ID_RV10:
1177
        s->out_format = FMT_H263;
1178
        avctx->delay=0;
1179
        s->low_delay=1;
1180
        break;
1181
    case CODEC_ID_RV20:
1182
        s->out_format = FMT_H263;
1183
        avctx->delay=0;
1184
        s->low_delay=1;
1185
        s->modified_quant=1;
1186
        s->h263_aic=1;
1187
        s->h263_plus=1;
1188
        s->loop_filter=1;
1189
        s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1190
        break;
1191
    case CODEC_ID_MPEG4:
1192
        s->out_format = FMT_H263;
1193
        s->h263_pred = 1;
1194
        s->unrestricted_mv = 1;
1195
        s->low_delay= s->max_b_frames ? 0 : 1;
1196
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1197
        break;
1198
    case CODEC_ID_MSMPEG4V1:
1199
        s->out_format = FMT_H263;
1200
        s->h263_msmpeg4 = 1;
1201
        s->h263_pred = 1;
1202
        s->unrestricted_mv = 1;
1203
        s->msmpeg4_version= 1;
1204
        avctx->delay=0;
1205
        s->low_delay=1;
1206
        break;
1207
    case CODEC_ID_MSMPEG4V2:
1208
        s->out_format = FMT_H263;
1209
        s->h263_msmpeg4 = 1;
1210
        s->h263_pred = 1;
1211
        s->unrestricted_mv = 1;
1212
        s->msmpeg4_version= 2;
1213
        avctx->delay=0;
1214
        s->low_delay=1;
1215
        break;
1216
    case CODEC_ID_MSMPEG4V3:
1217
        s->out_format = FMT_H263;
1218
        s->h263_msmpeg4 = 1;
1219
        s->h263_pred = 1;
1220
        s->unrestricted_mv = 1;
1221
        s->msmpeg4_version= 3;
1222
        s->flipflop_rounding=1;
1223
        avctx->delay=0;
1224
        s->low_delay=1;
1225
        break;
1226
    case CODEC_ID_WMV1:
1227
        s->out_format = FMT_H263;
1228
        s->h263_msmpeg4 = 1;
1229
        s->h263_pred = 1;
1230
        s->unrestricted_mv = 1;
1231
        s->msmpeg4_version= 4;
1232
        s->flipflop_rounding=1;
1233
        avctx->delay=0;
1234
        s->low_delay=1;
1235
        break;
1236
    case CODEC_ID_WMV2:
1237
        s->out_format = FMT_H263;
1238
        s->h263_msmpeg4 = 1;
1239
        s->h263_pred = 1;
1240
        s->unrestricted_mv = 1;
1241
        s->msmpeg4_version= 5;
1242
        s->flipflop_rounding=1;
1243
        avctx->delay=0;
1244
        s->low_delay=1;
1245
        break;
1246
    default:
1247
        return -1;
1248
    }
1249

    
1250
    avctx->has_b_frames= !s->low_delay;
1251

    
1252
    s->encoding = 1;
1253

    
1254
    /* init */
1255
    if (MPV_common_init(s) < 0)
1256
        return -1;
1257

    
1258
    if(s->modified_quant)
1259
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1260
    s->progressive_frame=
1261
    s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1262
    s->quant_precision=5;
1263

    
1264
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1265
    ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1266

    
1267
#ifdef CONFIG_H261_ENCODER
1268
    if (s->out_format == FMT_H261)
1269
        ff_h261_encode_init(s);
1270
#endif
1271
    if (s->out_format == FMT_H263)
1272
        h263_encode_init(s);
1273
    if(s->msmpeg4_version)
1274
        ff_msmpeg4_encode_init(s);
1275
    if (s->out_format == FMT_MPEG1)
1276
        ff_mpeg1_encode_init(s);
1277

    
1278
    /* init q matrix */
1279
    for(i=0;i<64;i++) {
1280
        int j= s->dsp.idct_permutation[i];
1281
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1282
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1283
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1284
        }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1285
            s->intra_matrix[j] =
1286
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1287
        }else
1288
        { /* mpeg1/2 */
1289
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1290
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1291
        }
1292
        if(s->avctx->intra_matrix)
1293
            s->intra_matrix[j] = s->avctx->intra_matrix[i];
1294
        if(s->avctx->inter_matrix)
1295
            s->inter_matrix[j] = s->avctx->inter_matrix[i];
1296
    }
1297

    
1298
    /* precompute matrix */
1299
    /* for mjpeg, we do include qscale in the matrix */
1300
    if (s->out_format != FMT_MJPEG) {
1301
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1302
                       s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1303
        convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1304
                       s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1305
    }
1306

    
1307
    if(ff_rate_control_init(s) < 0)
1308
        return -1;
1309

    
1310
    return 0;
1311
}
1312

    
1313
int MPV_encode_end(AVCodecContext *avctx)
1314
{
1315
    MpegEncContext *s = avctx->priv_data;
1316

    
1317
#ifdef STATS
1318
    print_stats();
1319
#endif
1320

    
1321
    ff_rate_control_uninit(s);
1322

    
1323
    MPV_common_end(s);
1324
    if (s->out_format == FMT_MJPEG)
1325
        mjpeg_close(s);
1326

    
1327
    av_freep(&avctx->extradata);
1328

    
1329
    return 0;
1330
}
1331

    
1332
#endif //CONFIG_ENCODERS
1333

    
1334
void init_rl(RLTable *rl, int use_static)
1335
{
1336
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1337
    uint8_t index_run[MAX_RUN+1];
1338
    int last, run, level, start, end, i;
1339

    
1340
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
1341
    if(use_static && rl->max_level[0])
1342
        return;
1343

    
1344
    /* compute max_level[], max_run[] and index_run[] */
1345
    for(last=0;last<2;last++) {
1346
        if (last == 0) {
1347
            start = 0;
1348
            end = rl->last;
1349
        } else {
1350
            start = rl->last;
1351
            end = rl->n;
1352
        }
1353

    
1354
        memset(max_level, 0, MAX_RUN + 1);
1355
        memset(max_run, 0, MAX_LEVEL + 1);
1356
        memset(index_run, rl->n, MAX_RUN + 1);
1357
        for(i=start;i<end;i++) {
1358
            run = rl->table_run[i];
1359
            level = rl->table_level[i];
1360
            if (index_run[run] == rl->n)
1361
                index_run[run] = i;
1362
            if (level > max_level[run])
1363
                max_level[run] = level;
1364
            if (run > max_run[level])
1365
                max_run[level] = run;
1366
        }
1367
        if(use_static)
1368
            rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1369
        else
1370
            rl->max_level[last] = av_malloc(MAX_RUN + 1);
1371
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1372
        if(use_static)
1373
            rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1374
        else
1375
            rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1376
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1377
        if(use_static)
1378
            rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1379
        else
1380
            rl->index_run[last] = av_malloc(MAX_RUN + 1);
1381
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1382
    }
1383
}
1384

    
1385
/* draw the edges of width 'w' of an image of size width, height */
1386
//FIXME check that this is ok for mpeg4 interlaced
1387
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1388
{
1389
    uint8_t *ptr, *last_line;
1390
    int i;
1391

    
1392
    last_line = buf + (height - 1) * wrap;
1393
    for(i=0;i<w;i++) {
1394
        /* top and bottom */
1395
        memcpy(buf - (i + 1) * wrap, buf, width);
1396
        memcpy(last_line + (i + 1) * wrap, last_line, width);
1397
    }
1398
    /* left and right */
1399
    ptr = buf;
1400
    for(i=0;i<height;i++) {
1401
        memset(ptr - w, ptr[0], w);
1402
        memset(ptr + width, ptr[width-1], w);
1403
        ptr += wrap;
1404
    }
1405
    /* corners */
1406
    for(i=0;i<w;i++) {
1407
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1408
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1409
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1410
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1411
    }
1412
}
1413

    
1414
int ff_find_unused_picture(MpegEncContext *s, int shared){
1415
    int i;
1416

    
1417
    if(shared){
1418
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1419
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1420
        }
1421
    }else{
1422
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1423
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1424
        }
1425
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1426
            if(s->picture[i].data[0]==NULL) return i;
1427
        }
1428
    }
1429

    
1430
    assert(0);
1431
    return -1;
1432
}
1433

    
1434
static void update_noise_reduction(MpegEncContext *s){
1435
    int intra, i;
1436

    
1437
    for(intra=0; intra<2; intra++){
1438
        if(s->dct_count[intra] > (1<<16)){
1439
            for(i=0; i<64; i++){
1440
                s->dct_error_sum[intra][i] >>=1;
1441
            }
1442
            s->dct_count[intra] >>= 1;
1443
        }
1444

    
1445
        for(i=0; i<64; i++){
1446
            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);
1447
        }
1448
    }
1449
}
1450

    
1451
/**
1452
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1453
 */
1454
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1455
{
1456
    int i;
1457
    AVFrame *pic;
1458
    s->mb_skipped = 0;
1459

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

    
1462
    /* mark&release old frames */
1463
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1464
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1465

    
1466
        /* release forgotten pictures */
1467
        /* if(mpeg124/h263) */
1468
        if(!s->encoding){
1469
            for(i=0; i<MAX_PICTURE_COUNT; i++){
1470
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1471
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1472
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1473
                }
1474
            }
1475
        }
1476
    }
1477
alloc:
1478
    if(!s->encoding){
1479
        /* release non reference frames */
1480
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1481
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1482
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1483
            }
1484
        }
1485

    
1486
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1487
            pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1488
        else{
1489
            i= ff_find_unused_picture(s, 0);
1490
            pic= (AVFrame*)&s->picture[i];
1491
        }
1492

    
1493
        pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1494
                        && !s->dropable ? 3 : 0;
1495

    
1496
        pic->coded_picture_number= s->coded_picture_number++;
1497

    
1498
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1499
            return -1;
1500

    
1501
        s->current_picture_ptr= (Picture*)pic;
1502
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1503
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1504
    }
1505

    
1506
    s->current_picture_ptr->pict_type= s->pict_type;
1507
//    if(s->flags && CODEC_FLAG_QSCALE)
1508
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1509
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1510

    
1511
    copy_picture(&s->current_picture, s->current_picture_ptr);
1512

    
1513
  if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1514
    if (s->pict_type != B_TYPE) {
1515
        s->last_picture_ptr= s->next_picture_ptr;
1516
        if(!s->dropable)
1517
            s->next_picture_ptr= s->current_picture_ptr;
1518
    }
1519
/*    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,
1520
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
1521
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
1522
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1523
        s->pict_type, s->dropable);*/
1524

    
1525
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1526
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1527

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

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

    
1536
    if(s->picture_structure!=PICT_FRAME){
1537
        int i;
1538
        for(i=0; i<4; i++){
1539
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1540
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1541
            }
1542
            s->current_picture.linesize[i] *= 2;
1543
            s->last_picture.linesize[i] *=2;
1544
            s->next_picture.linesize[i] *=2;
1545
        }
1546
    }
1547
  }
1548

    
1549
    s->hurry_up= s->avctx->hurry_up;
1550
    s->error_resilience= avctx->error_resilience;
1551

    
1552
    /* set dequantizer, we can't do it during init as it might change for mpeg4
1553
       and we can't do it in the header decode as init isnt called for mpeg4 there yet */
1554
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1555
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1556
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1557
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1558
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1559
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1560
    }else{
1561
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1562
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1563
    }
1564

    
1565
    if(s->dct_error_sum){
1566
        assert(s->avctx->noise_reduction && s->encoding);
1567

    
1568
        update_noise_reduction(s);
1569
    }
1570

    
1571
#ifdef HAVE_XVMC
1572
    if(s->avctx->xvmc_acceleration)
1573
        return XVMC_field_start(s, avctx);
1574
#endif
1575
    return 0;
1576
}
1577

    
1578
/* generic function for encode/decode called after a frame has been coded/decoded */
1579
void MPV_frame_end(MpegEncContext *s)
1580
{
1581
    int i;
1582
    /* draw edge for correct motion prediction if outside */
1583
#ifdef HAVE_XVMC
1584
//just to make sure that all data is rendered.
1585
    if(s->avctx->xvmc_acceleration){
1586
        XVMC_field_end(s);
1587
    }else
1588
#endif
1589
    if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1590
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1591
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1592
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1593
    }
1594
    emms_c();
1595

    
1596
    s->last_pict_type    = s->pict_type;
1597
    s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1598
    if(s->pict_type!=B_TYPE){
1599
        s->last_non_b_pict_type= s->pict_type;
1600
    }
1601
#if 0
1602
        /* copy back current_picture variables */
1603
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1604
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1605
            s->picture[i]= s->current_picture;
1606
            break;
1607
        }
1608
    }
1609
    assert(i<MAX_PICTURE_COUNT);
1610
#endif
1611

    
1612
    if(s->encoding){
1613
        /* release non-reference frames */
1614
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1615
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1616
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1617
            }
1618
        }
1619
    }
1620
    // clear copies, to avoid confusion
1621
#if 0
1622
    memset(&s->last_picture, 0, sizeof(Picture));
1623
    memset(&s->next_picture, 0, sizeof(Picture));
1624
    memset(&s->current_picture, 0, sizeof(Picture));
1625
#endif
1626
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1627
}
1628

    
1629
/**
1630
 * draws an line from (ex, ey) -> (sx, sy).
1631
 * @param w width of the image
1632
 * @param h height of the image
1633
 * @param stride stride/linesize of the image
1634
 * @param color color of the arrow
1635
 */
1636
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1637
    int t, x, y, fr, f;
1638

    
1639
    sx= clip(sx, 0, w-1);
1640
    sy= clip(sy, 0, h-1);
1641
    ex= clip(ex, 0, w-1);
1642
    ey= clip(ey, 0, h-1);
1643

    
1644
    buf[sy*stride + sx]+= color;
1645

    
1646
    if(ABS(ex - sx) > ABS(ey - sy)){
1647
        if(sx > ex){
1648
            t=sx; sx=ex; ex=t;
1649
            t=sy; sy=ey; ey=t;
1650
        }
1651
        buf+= sx + sy*stride;
1652
        ex-= sx;
1653
        f= ((ey-sy)<<16)/ex;
1654
        for(x= 0; x <= ex; x++){
1655
            y = (x*f)>>16;
1656
            fr= (x*f)&0xFFFF;
1657
            buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1658
            buf[(y+1)*stride + x]+= (color*         fr )>>16;
1659
        }
1660
    }else{
1661
        if(sy > ey){
1662
            t=sx; sx=ex; ex=t;
1663
            t=sy; sy=ey; ey=t;
1664
        }
1665
        buf+= sx + sy*stride;
1666
        ey-= sy;
1667
        if(ey) f= ((ex-sx)<<16)/ey;
1668
        else   f= 0;
1669
        for(y= 0; y <= ey; y++){
1670
            x = (y*f)>>16;
1671
            fr= (y*f)&0xFFFF;
1672
            buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;;
1673
            buf[y*stride + x+1]+= (color*         fr )>>16;;
1674
        }
1675
    }
1676
}
1677

    
1678
/**
1679
 * draws an arrow from (ex, ey) -> (sx, sy).
1680
 * @param w width of the image
1681
 * @param h height of the image
1682
 * @param stride stride/linesize of the image
1683
 * @param color color of the arrow
1684
 */
1685
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1686
    int dx,dy;
1687

    
1688
    sx= clip(sx, -100, w+100);
1689
    sy= clip(sy, -100, h+100);
1690
    ex= clip(ex, -100, w+100);
1691
    ey= clip(ey, -100, h+100);
1692

    
1693
    dx= ex - sx;
1694
    dy= ey - sy;
1695

    
1696
    if(dx*dx + dy*dy > 3*3){
1697
        int rx=  dx + dy;
1698
        int ry= -dx + dy;
1699
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1700

    
1701
        //FIXME subpixel accuracy
1702
        rx= ROUNDED_DIV(rx*3<<4, length);
1703
        ry= ROUNDED_DIV(ry*3<<4, length);
1704

    
1705
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1706
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1707
    }
1708
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1709
}
1710

    
1711
/**
1712
 * prints debuging info for the given picture.
1713
 */
1714
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1715

    
1716
    if(!pict || !pict->mb_type) return;
1717

    
1718
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1719
        int x,y;
1720

    
1721
        av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1722
        switch (pict->pict_type) {
1723
            case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1724
            case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1725
            case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1726
            case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1727
            case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1728
            case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1729
        }
1730
        for(y=0; y<s->mb_height; y++){
1731
            for(x=0; x<s->mb_width; x++){
1732
                if(s->avctx->debug&FF_DEBUG_SKIP){
1733
                    int count= s->mbskip_table[x + y*s->mb_stride];
1734
                    if(count>9) count=9;
1735
                    av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1736
                }
1737
                if(s->avctx->debug&FF_DEBUG_QP){
1738
                    av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1739
                }
1740
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1741
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
1742
                    //Type & MV direction
1743
                    if(IS_PCM(mb_type))
1744
                        av_log(s->avctx, AV_LOG_DEBUG, "P");
1745
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1746
                        av_log(s->avctx, AV_LOG_DEBUG, "A");
1747
                    else if(IS_INTRA4x4(mb_type))
1748
                        av_log(s->avctx, AV_LOG_DEBUG, "i");
1749
                    else if(IS_INTRA16x16(mb_type))
1750
                        av_log(s->avctx, AV_LOG_DEBUG, "I");
1751
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1752
                        av_log(s->avctx, AV_LOG_DEBUG, "d");
1753
                    else if(IS_DIRECT(mb_type))
1754
                        av_log(s->avctx, AV_LOG_DEBUG, "D");
1755
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1756
                        av_log(s->avctx, AV_LOG_DEBUG, "g");
1757
                    else if(IS_GMC(mb_type))
1758
                        av_log(s->avctx, AV_LOG_DEBUG, "G");
1759
                    else if(IS_SKIP(mb_type))
1760
                        av_log(s->avctx, AV_LOG_DEBUG, "S");
1761
                    else if(!USES_LIST(mb_type, 1))
1762
                        av_log(s->avctx, AV_LOG_DEBUG, ">");
1763
                    else if(!USES_LIST(mb_type, 0))
1764
                        av_log(s->avctx, AV_LOG_DEBUG, "<");
1765
                    else{
1766
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1767
                        av_log(s->avctx, AV_LOG_DEBUG, "X");
1768
                    }
1769

    
1770
                    //segmentation
1771
                    if(IS_8X8(mb_type))
1772
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1773
                    else if(IS_16X8(mb_type))
1774
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1775
                    else if(IS_8X16(mb_type))
1776
                        av_log(s->avctx, AV_LOG_DEBUG, "|");
1777
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1778
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1779
                    else
1780
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1781

    
1782

    
1783
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1784
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1785
                    else
1786
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1787
                }
1788
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1789
            }
1790
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1791
        }
1792
    }
1793

    
1794
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1795
        const int shift= 1 + s->quarter_sample;
1796
        int mb_y;
1797
        uint8_t *ptr;
1798
        int i;
1799
        int h_chroma_shift, v_chroma_shift;
1800
        const int width = s->avctx->width;
1801
        const int height= s->avctx->height;
1802
        const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1803
        const int mv_stride= (s->mb_width << mv_sample_log2) + 1;
1804
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1805

    
1806
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1807
        for(i=0; i<3; i++){
1808
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1809
            pict->data[i]= s->visualization_buffer[i];
1810
        }
1811
        pict->type= FF_BUFFER_TYPE_COPY;
1812
        ptr= pict->data[0];
1813

    
1814
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1815
            int mb_x;
1816
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1817
                const int mb_index= mb_x + mb_y*s->mb_stride;
1818
                if((s->avctx->debug_mv) && pict->motion_val){
1819
                  int type;
1820
                  for(type=0; type<3; type++){
1821
                    int direction = 0;
1822
                    switch (type) {
1823
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1824
                                continue;
1825
                              direction = 0;
1826
                              break;
1827
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1828
                                continue;
1829
                              direction = 0;
1830
                              break;
1831
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1832
                                continue;
1833
                              direction = 1;
1834
                              break;
1835
                    }
1836
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1837
                        continue;
1838

    
1839
                    if(IS_8X8(pict->mb_type[mb_index])){
1840
                      int i;
1841
                      for(i=0; i<4; i++){
1842
                        int sx= mb_x*16 + 4 + 8*(i&1);
1843
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1844
                        int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1845
                        int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1846
                        int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1847
                        draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1848
                      }
1849
                    }else if(IS_16X8(pict->mb_type[mb_index])){
1850
                      int i;
1851
                      for(i=0; i<2; i++){
1852
                        int sx=mb_x*16 + 8;
1853
                        int sy=mb_y*16 + 4 + 8*i;
1854
                        int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1855
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1856
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1857

    
1858
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1859
                            my*=2;
1860

    
1861
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1862
                      }
1863
                    }else if(IS_8X16(pict->mb_type[mb_index])){
1864
                      int i;
1865
                      for(i=0; i<2; i++){
1866
                        int sx=mb_x*16 + 4 + 8*i;
1867
                        int sy=mb_y*16 + 8;
1868
                        int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1869
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1870
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1871

    
1872
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1873
                            my*=2;
1874

    
1875
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1876
                      }
1877
                    }else{
1878
                      int sx= mb_x*16 + 8;
1879
                      int sy= mb_y*16 + 8;
1880
                      int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1881
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1882
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1883
                      draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1884
                    }
1885
                  }
1886
                }
1887
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1888
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1889
                    int y;
1890
                    for(y=0; y<8; y++){
1891
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1892
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1893
                    }
1894
                }
1895
                if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1896
                    int mb_type= pict->mb_type[mb_index];
1897
                    uint64_t u,v;
1898
                    int y;
1899
#define COLOR(theta, r)\
1900
u= (int)(128 + r*cos(theta*3.141592/180));\
1901
v= (int)(128 + r*sin(theta*3.141592/180));
1902

    
1903

    
1904
                    u=v=128;
1905
                    if(IS_PCM(mb_type)){
1906
                        COLOR(120,48)
1907
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1908
                        COLOR(30,48)
1909
                    }else if(IS_INTRA4x4(mb_type)){
1910
                        COLOR(90,48)
1911
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1912
//                        COLOR(120,48)
1913
                    }else if(IS_DIRECT(mb_type)){
1914
                        COLOR(150,48)
1915
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1916
                        COLOR(170,48)
1917
                    }else if(IS_GMC(mb_type)){
1918
                        COLOR(190,48)
1919
                    }else if(IS_SKIP(mb_type)){
1920
//                        COLOR(180,48)
1921
                    }else if(!USES_LIST(mb_type, 1)){
1922
                        COLOR(240,48)
1923
                    }else if(!USES_LIST(mb_type, 0)){
1924
                        COLOR(0,48)
1925
                    }else{
1926
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1927
                        COLOR(300,48)
1928
                    }
1929

    
1930
                    u*= 0x0101010101010101ULL;
1931
                    v*= 0x0101010101010101ULL;
1932
                    for(y=0; y<8; y++){
1933
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1934
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1935
                    }
1936

    
1937
                    //segmentation
1938
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1939
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1940
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1941
                    }
1942
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1943
                        for(y=0; y<16; y++)
1944
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1945
                    }
1946
                    if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1947
                        int dm= 1 << (mv_sample_log2-2);
1948
                        for(i=0; i<4; i++){
1949
                            int sx= mb_x*16 + 8*(i&1);
1950
                            int sy= mb_y*16 + 8*(i>>1);
1951
                            int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1952
                            //FIXME bidir
1953
                            int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1954
                            if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1955
                                for(y=0; y<8; y++)
1956
                                    pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1957
                            if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1958
                                *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1959
                        }
1960
                    }
1961

    
1962
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1963
                        // hmm
1964
                    }
1965
                }
1966
                s->mbskip_table[mb_index]=0;
1967
            }
1968
        }
1969
    }
1970
}
1971

    
1972
#ifdef CONFIG_ENCODERS
1973

    
1974
static int get_sae(uint8_t *src, int ref, int stride){
1975
    int x,y;
1976
    int acc=0;
1977

    
1978
    for(y=0; y<16; y++){
1979
        for(x=0; x<16; x++){
1980
            acc+= ABS(src[x+y*stride] - ref);
1981
        }
1982
    }
1983

    
1984
    return acc;
1985
}
1986

    
1987
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1988
    int x, y, w, h;
1989
    int acc=0;
1990

    
1991
    w= s->width &~15;
1992
    h= s->height&~15;
1993

    
1994
    for(y=0; y<h; y+=16){
1995
        for(x=0; x<w; x+=16){
1996
            int offset= x + y*stride;
1997
            int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1998
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1999
            int sae = get_sae(src + offset, mean, stride);
2000

    
2001
            acc+= sae + 500 < sad;
2002
        }
2003
    }
2004
    return acc;
2005
}
2006

    
2007

    
2008
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2009
    AVFrame *pic=NULL;
2010
    int64_t pts;
2011
    int i;
2012
    const int encoding_delay= s->max_b_frames;
2013
    int direct=1;
2014

    
2015
    if(pic_arg){
2016
        pts= pic_arg->pts;
2017
        pic_arg->display_picture_number= s->input_picture_number++;
2018

    
2019
        if(pts != AV_NOPTS_VALUE){
2020
            if(s->user_specified_pts != AV_NOPTS_VALUE){
2021
                int64_t time= pts;
2022
                int64_t last= s->user_specified_pts;
2023

    
2024
                if(time <= last){
2025
                    av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts);
2026
                    return -1;
2027
                }
2028
            }
2029
            s->user_specified_pts= pts;
2030
        }else{
2031
            if(s->user_specified_pts != AV_NOPTS_VALUE){
2032
                s->user_specified_pts=
2033
                pts= s->user_specified_pts + 1;
2034
                av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts);
2035
            }else{
2036
                pts= pic_arg->display_picture_number;
2037
            }
2038
        }
2039
    }
2040

    
2041
  if(pic_arg){
2042
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2043
    if(pic_arg->linesize[0] != s->linesize) direct=0;
2044
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2045
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2046

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

    
2049
    if(direct){
2050
        i= ff_find_unused_picture(s, 1);
2051

    
2052
        pic= (AVFrame*)&s->picture[i];
2053
        pic->reference= 3;
2054

    
2055
        for(i=0; i<4; i++){
2056
            pic->data[i]= pic_arg->data[i];
2057
            pic->linesize[i]= pic_arg->linesize[i];
2058
        }
2059
        alloc_picture(s, (Picture*)pic, 1);
2060
    }else{
2061
        int offset= 16;
2062
        i= ff_find_unused_picture(s, 0);
2063

    
2064
        pic= (AVFrame*)&s->picture[i];
2065
        pic->reference= 3;
2066

    
2067
        alloc_picture(s, (Picture*)pic, 0);
2068

    
2069
        if(   pic->data[0] + offset == pic_arg->data[0]
2070
           && pic->data[1] + offset == pic_arg->data[1]
2071
           && pic->data[2] + offset == pic_arg->data[2]){
2072
       // empty
2073
        }else{
2074
            int h_chroma_shift, v_chroma_shift;
2075
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2076

    
2077
            for(i=0; i<3; i++){
2078
                int src_stride= pic_arg->linesize[i];
2079
                int dst_stride= i ? s->uvlinesize : s->linesize;
2080
                int h_shift= i ? h_chroma_shift : 0;
2081
                int v_shift= i ? v_chroma_shift : 0;
2082
                int w= s->width >>h_shift;
2083
                int h= s->height>>v_shift;
2084
                uint8_t *src= pic_arg->data[i];
2085
                uint8_t *dst= pic->data[i] + offset;
2086

    
2087
                if(src_stride==dst_stride)
2088
                    memcpy(dst, src, src_stride*h);
2089
                else{
2090
                    while(h--){
2091
                        memcpy(dst, src, w);
2092
                        dst += dst_stride;
2093
                        src += src_stride;
2094
                    }
2095
                }
2096
            }
2097
        }
2098
    }
2099
    copy_picture_attributes(s, pic, pic_arg);
2100
    pic->pts= pts; //we set this here to avoid modifiying pic_arg
2101
  }
2102

    
2103
    /* shift buffer entries */
2104
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2105
        s->input_picture[i-1]= s->input_picture[i];
2106

    
2107
    s->input_picture[encoding_delay]= (Picture*)pic;
2108

    
2109
    return 0;
2110
}
2111

    
2112
static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2113
    int x, y, plane;
2114
    int score=0;
2115
    int64_t score64=0;
2116

    
2117
    for(plane=0; plane<3; plane++){
2118
        const int stride= p->linesize[plane];
2119
        const int bw= plane ? 1 : 2;
2120
        for(y=0; y<s->mb_height*bw; y++){
2121
            for(x=0; x<s->mb_width*bw; x++){
2122
                int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16;
2123
                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);
2124

    
2125
                switch(s->avctx->frame_skip_exp){
2126
                    case 0: score= FFMAX(score, v); break;
2127
                    case 1: score+= ABS(v);break;
2128
                    case 2: score+= v*v;break;
2129
                    case 3: score64+= ABS(v*v*(int64_t)v);break;
2130
                    case 4: score64+= v*v*(int64_t)(v*v);break;
2131
                }
2132
            }
2133
        }
2134
    }
2135

    
2136
    if(score) score64= score;
2137

    
2138
    if(score64 < s->avctx->frame_skip_threshold)
2139
        return 1;
2140
    if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2141
        return 1;
2142
    return 0;
2143
}
2144

    
2145
static int estimate_best_b_count(MpegEncContext *s){
2146
    AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id);
2147
    AVCodecContext *c= avcodec_alloc_context();
2148
    AVFrame input[FF_MAX_B_FRAMES+2];
2149
    const int scale= s->avctx->brd_scale;
2150
    int i, j, out_size;
2151
    int outbuf_size= s->width * s->height; //FIXME
2152
    uint8_t *outbuf= av_malloc(outbuf_size);
2153
    ImgReSampleContext *resample;
2154
    int64_t best_rd= INT64_MAX;
2155
    int best_b_count= -1;
2156
    const int lambda2= s->lambda2;
2157

    
2158
    c->width = s->width >> scale;
2159
    c->height= s->height>> scale;
2160
    c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
2161
    c->flags|= s->avctx->flags & CODEC_FLAG_QPEL;
2162
    c->mb_decision= s->avctx->mb_decision;
2163
    c->me_cmp= s->avctx->me_cmp;
2164
    c->mb_cmp= s->avctx->mb_cmp;
2165
    c->me_sub_cmp= s->avctx->me_sub_cmp;
2166
    c->pix_fmt = PIX_FMT_YUV420P;
2167
    c->time_base= s->avctx->time_base;
2168
    c->max_b_frames= s->max_b_frames;
2169

    
2170
    if (avcodec_open(c, codec) < 0)
2171
        return -1;
2172

    
2173
    resample= img_resample_init(c->width, c->height, s->width, s->height); //FIXME use sws
2174

    
2175
    for(i=0; i<s->max_b_frames+2; i++){
2176
        int ysize= c->width*c->height;
2177
        int csize= (c->width/2)*(c->height/2);
2178

    
2179
        avcodec_get_frame_defaults(&input[i]);
2180
        input[i].data[0]= av_malloc(ysize + 2*csize);
2181
        input[i].data[1]= input[i].data[0] + ysize;
2182
        input[i].data[2]= input[i].data[1] + csize;
2183
        input[i].linesize[0]= c->width;
2184
        input[i].linesize[1]=
2185
        input[i].linesize[2]= c->width/2;
2186

    
2187
        if(!i || s->input_picture[i-1])
2188
            img_resample(resample, &input[i], i ? s->input_picture[i-1] : s->next_picture_ptr);
2189
    }
2190

    
2191
    for(j=0; j<s->max_b_frames+1; j++){
2192
        int64_t rd=0;
2193

    
2194
        if(!s->input_picture[j])
2195
            break;
2196

    
2197
        c->error[0]= c->error[1]= c->error[2]= 0;
2198

    
2199
        input[0].pict_type= I_TYPE;
2200
        input[0].quality= 2 * FF_QP2LAMBDA;
2201
        out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
2202
        rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2203

    
2204
        for(i=0; i<s->max_b_frames+1; i++){
2205
            int is_p= i % (j+1) == j || i==s->max_b_frames;
2206

    
2207
            input[i+1].pict_type= is_p ? P_TYPE : B_TYPE;
2208
            input[i+1].quality= s->last_lambda_for[input[i+1].pict_type];
2209
            out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]);
2210
            rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2211
        }
2212

    
2213
        /* get the delayed frames */
2214
        while(out_size){
2215
            out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
2216
            rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2217
        }
2218

    
2219
        rd += c->error[0] + c->error[1] + c->error[2];
2220

    
2221
        if(rd < best_rd){
2222
            best_rd= rd;
2223
            best_b_count= j;
2224
        }
2225
    }
2226

    
2227
    av_freep(&outbuf);
2228
    avcodec_close(c);
2229
    av_freep(&c);
2230
    img_resample_close(resample);
2231

    
2232
    for(i=0; i<s->max_b_frames+2; i++){
2233
        av_freep(&input[i].data[0]);
2234
    }
2235

    
2236
    return best_b_count;
2237
}
2238

    
2239
static void select_input_picture(MpegEncContext *s){
2240
    int i;
2241

    
2242
    for(i=1; i<MAX_PICTURE_COUNT; i++)
2243
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2244
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2245

    
2246
    /* set next picture type & ordering */
2247
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2248
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2249
            s->reordered_input_picture[0]= s->input_picture[0];
2250
            s->reordered_input_picture[0]->pict_type= I_TYPE;
2251
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2252
        }else{
2253
            int b_frames;
2254

    
2255
            if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2256
                if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2257
                //FIXME check that te gop check above is +-1 correct
2258
//av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2259

    
2260
                    if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2261
                        for(i=0; i<4; i++)
2262
                            s->input_picture[0]->data[i]= NULL;
2263
                        s->input_picture[0]->type= 0;
2264
                    }else{
2265
                        assert(   s->input_picture[0]->type==FF_BUFFER_TYPE_USER
2266
                               || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2267

    
2268
                        s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2269
                    }
2270

    
2271
                    emms_c();
2272
                    ff_vbv_update(s, 0);
2273

    
2274
                    goto no_output_pic;
2275
                }
2276
            }
2277

    
2278
            if(s->flags&CODEC_FLAG_PASS2){
2279
                for(i=0; i<s->max_b_frames+1; i++){
2280
                    int pict_num= s->input_picture[0]->display_picture_number + i;
2281

    
2282
                    if(pict_num >= s->rc_context.num_entries)
2283
                        break;
2284
                    if(!s->input_picture[i]){
2285
                        s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2286
                        break;
2287
                    }
2288

    
2289
                    s->input_picture[i]->pict_type=
2290
                        s->rc_context.entry[pict_num].new_pict_type;
2291
                }
2292
            }
2293

    
2294
            if(s->avctx->b_frame_strategy==0){
2295
                b_frames= s->max_b_frames;
2296
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
2297
            }else if(s->avctx->b_frame_strategy==1){
2298
                for(i=1; i<s->max_b_frames+1; i++){
2299
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2300
                        s->input_picture[i]->b_frame_score=
2301
                            get_intra_count(s, s->input_picture[i  ]->data[0],
2302
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
2303
                    }
2304
                }
2305
                for(i=0; i<s->max_b_frames+1; i++){
2306
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2307
                }
2308

    
2309
                b_frames= FFMAX(0, i-1);
2310

    
2311
                /* reset scores */
2312
                for(i=0; i<b_frames+1; i++){
2313
                    s->input_picture[i]->b_frame_score=0;
2314
                }
2315
            }else if(s->avctx->b_frame_strategy==2){
2316
                b_frames= estimate_best_b_count(s);
2317
            }else{
2318
                av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2319
                b_frames=0;
2320
            }
2321

    
2322
            emms_c();
2323
//static int b_count=0;
2324
//b_count+= b_frames;
2325
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2326

    
2327
            for(i= b_frames - 1; i>=0; i--){
2328
                int type= s->input_picture[i]->pict_type;
2329
                if(type && type != B_TYPE)
2330
                    b_frames= i;
2331
            }
2332
            if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2333
                av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
2334
            }
2335

    
2336
            if(s->picture_in_gop_number + b_frames >= s->gop_size){
2337
              if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2338
                    b_frames= s->gop_size - s->picture_in_gop_number - 1;
2339
              }else{
2340
                if(s->flags & CODEC_FLAG_CLOSED_GOP)
2341
                    b_frames=0;
2342
                s->input_picture[b_frames]->pict_type= I_TYPE;
2343
              }
2344
            }
2345

    
2346
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2347
               && b_frames
2348
               && s->input_picture[b_frames]->pict_type== I_TYPE)
2349
                b_frames--;
2350

    
2351
            s->reordered_input_picture[0]= s->input_picture[b_frames];
2352
            if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2353
                s->reordered_input_picture[0]->pict_type= P_TYPE;
2354
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2355
            for(i=0; i<b_frames; i++){
2356
                s->reordered_input_picture[i+1]= s->input_picture[i];
2357
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2358
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2359
            }
2360
        }
2361
    }
2362
no_output_pic:
2363
    if(s->reordered_input_picture[0]){
2364
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2365

    
2366
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2367

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

    
2371
            int i= ff_find_unused_picture(s, 0);
2372
            Picture *pic= &s->picture[i];
2373

    
2374
            /* mark us unused / free shared pic */
2375
            for(i=0; i<4; i++)
2376
                s->reordered_input_picture[0]->data[i]= NULL;
2377
            s->reordered_input_picture[0]->type= 0;
2378

    
2379
            pic->reference              = s->reordered_input_picture[0]->reference;
2380

    
2381
            alloc_picture(s, pic, 0);
2382

    
2383
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2384

    
2385
            s->current_picture_ptr= pic;
2386
        }else{
2387
            // input is not a shared pix -> reuse buffer for current_pix
2388

    
2389
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2390
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2391

    
2392
            s->current_picture_ptr= s->reordered_input_picture[0];
2393
            for(i=0; i<4; i++){
2394
                s->new_picture.data[i]+=16;
2395
            }
2396
        }
2397
        copy_picture(&s->current_picture, s->current_picture_ptr);
2398

    
2399
        s->picture_number= s->new_picture.display_picture_number;
2400
//printf("dpn:%d\n", s->picture_number);
2401
    }else{
2402
       memset(&s->new_picture, 0, sizeof(Picture));
2403
    }
2404
}
2405

    
2406
int MPV_encode_picture(AVCodecContext *avctx,
2407
                       unsigned char *buf, int buf_size, void *data)
2408
{
2409
    MpegEncContext *s = avctx->priv_data;
2410
    AVFrame *pic_arg = data;
2411
    int i, stuffing_count;
2412

    
2413
    if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUVJ420P){
2414
        av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2415
        return -1;
2416
    }
2417

    
2418
    for(i=0; i<avctx->thread_count; i++){
2419
        int start_y= s->thread_context[i]->start_mb_y;
2420
        int   end_y= s->thread_context[i]->  end_mb_y;
2421
        int h= s->mb_height;
2422
        uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h);
2423
        uint8_t *end  = buf + (size_t)(((int64_t) buf_size)*  end_y/h);
2424

    
2425
        init_put_bits(&s->thread_context[i]->pb, start, end - start);
2426
    }
2427

    
2428
    s->picture_in_gop_number++;
2429

    
2430
    if(load_input_picture(s, pic_arg) < 0)
2431
        return -1;
2432

    
2433
    select_input_picture(s);
2434

    
2435
    /* output? */
2436
    if(s->new_picture.data[0]){
2437
        s->pict_type= s->new_picture.pict_type;
2438
//emms_c();
2439
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2440
        MPV_frame_start(s, avctx);
2441

    
2442
        encode_picture(s, s->picture_number);
2443

    
2444
        avctx->real_pict_num  = s->picture_number;
2445
        avctx->header_bits = s->header_bits;
2446
        avctx->mv_bits     = s->mv_bits;
2447
        avctx->misc_bits   = s->misc_bits;
2448
        avctx->i_tex_bits  = s->i_tex_bits;
2449
        avctx->p_tex_bits  = s->p_tex_bits;
2450
        avctx->i_count     = s->i_count;
2451
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2452
        avctx->skip_count  = s->skip_count;
2453

    
2454
        MPV_frame_end(s);
2455

    
2456
        if (s->out_format == FMT_MJPEG)
2457
            mjpeg_picture_trailer(s);
2458

    
2459
        if(s->flags&CODEC_FLAG_PASS1)
2460
            ff_write_pass1_stats(s);
2461

    
2462
        for(i=0; i<4; i++){
2463
            s->current_picture_ptr->error[i]= s->current_picture.error[i];
2464
            avctx->error[i] += s->current_picture_ptr->error[i];
2465
        }
2466

    
2467
        if(s->flags&CODEC_FLAG_PASS1)
2468
            assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2469
        flush_put_bits(&s->pb);
2470
        s->frame_bits  = put_bits_count(&s->pb);
2471

    
2472
        stuffing_count= ff_vbv_update(s, s->frame_bits);
2473
        if(stuffing_count){
2474
            if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2475
                av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2476
                return -1;
2477
            }
2478

    
2479
            switch(s->codec_id){
2480
            case CODEC_ID_MPEG1VIDEO:
2481
            case CODEC_ID_MPEG2VIDEO:
2482
                while(stuffing_count--){
2483
                    put_bits(&s->pb, 8, 0);
2484
                }
2485
            break;
2486
            case CODEC_ID_MPEG4:
2487
                put_bits(&s->pb, 16, 0);
2488
                put_bits(&s->pb, 16, 0x1C3);
2489
                stuffing_count -= 4;
2490
                while(stuffing_count--){
2491
                    put_bits(&s->pb, 8, 0xFF);
2492
                }
2493
            break;
2494
            default:
2495
                av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2496
            }
2497
            flush_put_bits(&s->pb);
2498
            s->frame_bits  = put_bits_count(&s->pb);
2499
        }
2500

    
2501
        /* update mpeg1/2 vbv_delay for CBR */
2502
        if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2503
           && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2504
            int vbv_delay;
2505

    
2506
            assert(s->repeat_first_field==0);
2507

    
2508
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2509
            assert(vbv_delay < 0xFFFF);
2510

    
2511
            s->vbv_delay_ptr[0] &= 0xF8;
2512
            s->vbv_delay_ptr[0] |= vbv_delay>>13;
2513
            s->vbv_delay_ptr[1]  = vbv_delay>>5;
2514
            s->vbv_delay_ptr[2] &= 0x07;
2515
            s->vbv_delay_ptr[2] |= vbv_delay<<3;
2516
        }
2517
        s->total_bits += s->frame_bits;
2518
        avctx->frame_bits  = s->frame_bits;
2519
    }else{
2520
        assert((pbBufPtr(&s->pb) == s->pb.buf));
2521
        s->frame_bits=0;
2522
    }
2523
    assert((s->frame_bits&7)==0);
2524

    
2525
    return s->frame_bits/8;
2526
}
2527

    
2528
#endif //CONFIG_ENCODERS
2529

    
2530
static inline void gmc1_motion(MpegEncContext *s,
2531
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2532
                               uint8_t **ref_picture)
2533
{
2534
    uint8_t *ptr;
2535
    int offset, src_x, src_y, linesize, uvlinesize;
2536
    int motion_x, motion_y;
2537
    int emu=0;
2538

    
2539
    motion_x= s->sprite_offset[0][0];
2540
    motion_y= s->sprite_offset[0][1];
2541
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2542
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2543
    motion_x<<=(3-s->sprite_warping_accuracy);
2544
    motion_y<<=(3-s->sprite_warping_accuracy);
2545
    src_x = clip(src_x, -16, s->width);
2546
    if (src_x == s->width)
2547
        motion_x =0;
2548
    src_y = clip(src_y, -16, s->height);
2549
    if (src_y == s->height)
2550
        motion_y =0;
2551

    
2552
    linesize = s->linesize;
2553
    uvlinesize = s->uvlinesize;
2554

    
2555
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2556

    
2557
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2558
        if(   (unsigned)src_x >= s->h_edge_pos - 17
2559
           || (unsigned)src_y >= s->v_edge_pos - 17){
2560
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2561
            ptr= s->edge_emu_buffer;
2562
        }
2563
    }
2564

    
2565
    if((motion_x|motion_y)&7){
2566
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2567
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2568
    }else{
2569
        int dxy;
2570

    
2571
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2572
        if (s->no_rounding){
2573
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2574
        }else{
2575
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2576
        }
2577
    }
2578

    
2579
    if(s->flags&CODEC_FLAG_GRAY) return;
2580

    
2581
    motion_x= s->sprite_offset[1][0];
2582
    motion_y= s->sprite_offset[1][1];
2583
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2584
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2585
    motion_x<<=(3-s->sprite_warping_accuracy);
2586
    motion_y<<=(3-s->sprite_warping_accuracy);
2587
    src_x = clip(src_x, -8, s->width>>1);
2588
    if (src_x == s->width>>1)
2589
        motion_x =0;
2590
    src_y = clip(src_y, -8, s->height>>1);
2591
    if (src_y == s->height>>1)
2592
        motion_y =0;
2593

    
2594
    offset = (src_y * uvlinesize) + src_x;
2595
    ptr = ref_picture[1] + offset;
2596
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2597
        if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2598
           || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2599
            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);
2600
            ptr= s->edge_emu_buffer;
2601
            emu=1;
2602
        }
2603
    }
2604
    s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2605

    
2606
    ptr = ref_picture[2] + offset;
2607
    if(emu){
2608
        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);
2609
        ptr= s->edge_emu_buffer;
2610
    }
2611
    s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2612

    
2613
    return;
2614
}
2615

    
2616
static inline void gmc_motion(MpegEncContext *s,
2617
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2618
                               uint8_t **ref_picture)
2619
{
2620
    uint8_t *ptr;
2621
    int linesize, uvlinesize;
2622
    const int a= s->sprite_warping_accuracy;
2623
    int ox, oy;
2624

    
2625
    linesize = s->linesize;
2626
    uvlinesize = s->uvlinesize;
2627

    
2628
    ptr = ref_picture[0];
2629

    
2630
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2631
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2632

    
2633
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2634
           ox,
2635
           oy,
2636
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2637
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2638
           a+1, (1<<(2*a+1)) - s->no_rounding,
2639
           s->h_edge_pos, s->v_edge_pos);
2640
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2641
           ox + s->sprite_delta[0][0]*8,
2642
           oy + s->sprite_delta[1][0]*8,
2643
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2644
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2645
           a+1, (1<<(2*a+1)) - s->no_rounding,
2646
           s->h_edge_pos, s->v_edge_pos);
2647

    
2648
    if(s->flags&CODEC_FLAG_GRAY) return;
2649

    
2650
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2651
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2652

    
2653
    ptr = ref_picture[1];
2654
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2655
           ox,
2656
           oy,
2657
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2658
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2659
           a+1, (1<<(2*a+1)) - s->no_rounding,
2660
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2661

    
2662
    ptr = ref_picture[2];
2663
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2664
           ox,
2665
           oy,
2666
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2667
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2668
           a+1, (1<<(2*a+1)) - s->no_rounding,
2669
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2670
}
2671

    
2672
/**
2673
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2674
 * @param buf destination buffer
2675
 * @param src source buffer
2676
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2677
 * @param block_w width of block
2678
 * @param block_h height of block
2679
 * @param src_x x coordinate of the top left sample of the block in the source buffer
2680
 * @param src_y y coordinate of the top left sample of the block in the source buffer
2681
 * @param w width of the source buffer
2682
 * @param h height of the source buffer
2683
 */
2684
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2685
                                    int src_x, int src_y, int w, int h){
2686
    int x, y;
2687
    int start_y, start_x, end_y, end_x;
2688

    
2689
    if(src_y>= h){
2690
        src+= (h-1-src_y)*linesize;
2691
        src_y=h-1;
2692
    }else if(src_y<=-block_h){
2693
        src+= (1-block_h-src_y)*linesize;
2694
        src_y=1-block_h;
2695
    }
2696
    if(src_x>= w){
2697
        src+= (w-1-src_x);
2698
        src_x=w-1;
2699
    }else if(src_x<=-block_w){
2700
        src+= (1-block_w-src_x);
2701
        src_x=1-block_w;
2702
    }
2703

    
2704
    start_y= FFMAX(0, -src_y);
2705
    start_x= FFMAX(0, -src_x);
2706
    end_y= FFMIN(block_h, h-src_y);
2707
    end_x= FFMIN(block_w, w-src_x);
2708

    
2709
    // copy existing part
2710
    for(y=start_y; y<end_y; y++){
2711
        for(x=start_x; x<end_x; x++){
2712
            buf[x + y*linesize]= src[x + y*linesize];
2713
        }
2714
    }
2715

    
2716
    //top
2717
    for(y=0; y<start_y; y++){
2718
        for(x=start_x; x<end_x; x++){
2719
            buf[x + y*linesize]= buf[x + start_y*linesize];
2720
        }
2721
    }
2722

    
2723
    //bottom
2724
    for(y=end_y; y<block_h; y++){
2725
        for(x=start_x; x<end_x; x++){
2726
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2727
        }
2728
    }
2729

    
2730
    for(y=0; y<block_h; y++){
2731
       //left
2732
        for(x=0; x<start_x; x++){
2733
            buf[x + y*linesize]= buf[start_x + y*linesize];
2734
        }
2735

    
2736
       //right
2737
        for(x=end_x; x<block_w; x++){
2738
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2739
        }
2740
    }
2741
}
2742

    
2743
static inline int hpel_motion(MpegEncContext *s,
2744
                                  uint8_t *dest, uint8_t *src,
2745
                                  int field_based, int field_select,
2746
                                  int src_x, int src_y,
2747
                                  int width, int height, int stride,
2748
                                  int h_edge_pos, int v_edge_pos,
2749
                                  int w, int h, op_pixels_func *pix_op,
2750
                                  int motion_x, int motion_y)
2751
{
2752
    int dxy;
2753
    int emu=0;
2754

    
2755
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2756
    src_x += motion_x >> 1;
2757
    src_y += motion_y >> 1;
2758

    
2759
    /* WARNING: do no forget half pels */
2760
    src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2761
    if (src_x == width)
2762
        dxy &= ~1;
2763
    src_y = clip(src_y, -16, height);
2764
    if (src_y == height)
2765
        dxy &= ~2;
2766
    src += src_y * stride + src_x;
2767

    
2768
    if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2769
        if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2770
           || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2771
            ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2772
                             src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2773
            src= s->edge_emu_buffer;
2774
            emu=1;
2775
        }
2776
    }
2777
    if(field_select)
2778
        src += s->linesize;
2779
    pix_op[dxy](dest, src, stride, h);
2780
    return emu;
2781
}
2782

    
2783
static inline int hpel_motion_lowres(MpegEncContext *s,
2784
                                  uint8_t *dest, uint8_t *src,
2785
                                  int field_based, int field_select,
2786
                                  int src_x, int src_y,
2787
                                  int width, int height, int stride,
2788
                                  int h_edge_pos, int v_edge_pos,
2789
                                  int w, int h, h264_chroma_mc_func *pix_op,
2790
                                  int motion_x, int motion_y)
2791
{
2792
    const int lowres= s->avctx->lowres;
2793
    const int s_mask= (2<<lowres)-1;
2794
    int emu=0;
2795
    int sx, sy;
2796

    
2797
    if(s->quarter_sample){
2798
        motion_x/=2;
2799
        motion_y/=2;
2800
    }
2801

    
2802
    sx= motion_x & s_mask;
2803
    sy= motion_y & s_mask;
2804
    src_x += motion_x >> (lowres+1);
2805
    src_y += motion_y >> (lowres+1);
2806

    
2807
    src += src_y * stride + src_x;
2808

    
2809
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
2810
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2811
        ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2812
                            src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2813
        src= s->edge_emu_buffer;
2814
        emu=1;
2815
    }
2816

    
2817
    sx <<= 2 - lowres;
2818
    sy <<= 2 - lowres;
2819
    if(field_select)
2820
        src += s->linesize;
2821
    pix_op[lowres](dest, src, stride, h, sx, sy);
2822
    return emu;
2823
}
2824

    
2825
/* apply one mpeg motion vector to the three components */
2826
static always_inline void mpeg_motion(MpegEncContext *s,
2827
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2828
                               int field_based, int bottom_field, int field_select,
2829
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2830
                               int motion_x, int motion_y, int h)
2831
{
2832
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2833
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2834

    
2835
#if 0
2836
if(s->quarter_sample)
2837
{
2838
    motion_x>>=1;
2839
    motion_y>>=1;
2840
}
2841
#endif
2842

    
2843
    v_edge_pos = s->v_edge_pos >> field_based;
2844
    linesize   = s->current_picture.linesize[0] << field_based;
2845
    uvlinesize = s->current_picture.linesize[1] << field_based;
2846

    
2847
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2848
    src_x = s->mb_x* 16               + (motion_x >> 1);
2849
    src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2850

    
2851
    if (s->out_format == FMT_H263) {
2852
        if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2853
            mx = (motion_x>>1)|(motion_x&1);
2854
            my = motion_y >>1;
2855
            uvdxy = ((my & 1) << 1) | (mx & 1);
2856
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2857
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2858
        }else{
2859
            uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2860
            uvsrc_x = src_x>>1;
2861
            uvsrc_y = src_y>>1;
2862
        }
2863
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2864
        mx = motion_x / 4;
2865
        my = motion_y / 4;
2866
        uvdxy = 0;
2867
        uvsrc_x = s->mb_x*8 + mx;
2868
        uvsrc_y = s->mb_y*8 + my;
2869
    } else {
2870
        if(s->chroma_y_shift){
2871
            mx = motion_x / 2;
2872
            my = motion_y / 2;
2873
            uvdxy = ((my & 1) << 1) | (mx & 1);
2874
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2875
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2876
        } else {
2877
            if(s->chroma_x_shift){
2878
            //Chroma422
2879
                mx = motion_x / 2;
2880
                uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2881
                uvsrc_x = s->mb_x* 8           + (mx >> 1);
2882
                uvsrc_y = src_y;
2883
            } else {
2884
            //Chroma444
2885
                uvdxy = dxy;
2886
                uvsrc_x = src_x;
2887
                uvsrc_y = src_y;
2888
            }
2889
        }
2890
    }
2891

    
2892
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2893
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2894
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2895

    
2896
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2897
       || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
2898
            if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2899
               s->codec_id == CODEC_ID_MPEG1VIDEO){
2900
                av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2901
                return ;
2902
            }
2903
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2904
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2905
            ptr_y = s->edge_emu_buffer;
2906
            if(!(s->flags&CODEC_FLAG_GRAY)){
2907
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2908
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
2909
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2910
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
2911
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2912
                ptr_cb= uvbuf;
2913
                ptr_cr= uvbuf+16;
2914
            }
2915
    }
2916

    
2917
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2918
        dest_y += s->linesize;
2919
        dest_cb+= s->uvlinesize;
2920
        dest_cr+= s->uvlinesize;
2921
    }
2922

    
2923
    if(field_select){
2924
        ptr_y += s->linesize;
2925
        ptr_cb+= s->uvlinesize;
2926
        ptr_cr+= s->uvlinesize;
2927
    }
2928

    
2929
    pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2930

    
2931
    if(!(s->flags&CODEC_FLAG_GRAY)){
2932
        pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2933
        pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2934
    }
2935
#if defined(CONFIG_H261_ENCODER) || defined(CONFIG_H261_DECODER)
2936
    if(s->out_format == FMT_H261){
2937
        ff_h261_loop_filter(s);
2938
    }
2939
#endif
2940
}
2941

    
2942
/* apply one mpeg motion vector to the three components */
2943
static always_inline void mpeg_motion_lowres(MpegEncContext *s,
2944
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2945
                               int field_based, int bottom_field, int field_select,
2946
                               uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
2947
                               int motion_x, int motion_y, int h)
2948
{
2949
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2950
    int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
2951
    const int lowres= s->avctx->lowres;
2952
    const int block_s= 8>>lowres;
2953
    const int s_mask= (2<<lowres)-1;
2954
    const int h_edge_pos = s->h_edge_pos >> lowres;
2955
    const int v_edge_pos = s->v_edge_pos >> lowres;
2956
    linesize   = s->current_picture.linesize[0] << field_based;
2957
    uvlinesize = s->current_picture.linesize[1] << field_based;
2958

    
2959
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
2960
        motion_x/=2;
2961
        motion_y/=2;
2962
    }
2963

    
2964
    if(field_based){
2965
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
2966
    }
2967

    
2968
    sx= motion_x & s_mask;
2969
    sy= motion_y & s_mask;
2970
    src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
2971
    src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
2972

    
2973
    if (s->out_format == FMT_H263) {
2974
        uvsx = ((motion_x>>1) & s_mask) | (sx&1);
2975
        uvsy = ((motion_y>>1) & s_mask) | (sy&1);
2976
        uvsrc_x = src_x>>1;
2977
        uvsrc_y = src_y>>1;
2978
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2979
        mx = motion_x / 4;
2980
        my = motion_y / 4;
2981
        uvsx = (2*mx) & s_mask;
2982
        uvsy = (2*my) & s_mask;
2983
        uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
2984
        uvsrc_y = s->mb_y*block_s               + (my >> lowres);
2985
    } else {
2986
        mx = motion_x / 2;
2987
        my = motion_y / 2;
2988
        uvsx = mx & s_mask;
2989
        uvsy = my & s_mask;
2990
        uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2991
        uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
2992
    }
2993

    
2994
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2995
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2996
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2997

    
2998
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
2999
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
3000
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3001
                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
3002
            ptr_y = s->edge_emu_buffer;
3003
            if(!(s->flags&CODEC_FLAG_GRAY)){
3004
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3005
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
3006
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3007
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3008
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3009
                ptr_cb= uvbuf;
3010
                ptr_cr= uvbuf+16;
3011
            }
3012
    }
3013

    
3014
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3015
        dest_y += s->linesize;
3016
        dest_cb+= s->uvlinesize;
3017
        dest_cr+= s->uvlinesize;
3018
    }
3019

    
3020
    if(field_select){
3021
        ptr_y += s->linesize;
3022
        ptr_cb+= s->uvlinesize;
3023
        ptr_cr+= s->uvlinesize;
3024
    }
3025

    
3026
    sx <<= 2 - lowres;
3027
    sy <<= 2 - lowres;
3028
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
3029

    
3030
    if(!(s->flags&CODEC_FLAG_GRAY)){
3031
        uvsx <<= 2 - lowres;
3032
        uvsy <<= 2 - lowres;
3033
        pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3034
        pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3035
    }
3036
    //FIXME h261 lowres loop filter
3037
}
3038

    
3039
//FIXME move to dsputil, avg variant, 16x16 version
3040
static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
3041
    int x;
3042
    uint8_t * const top   = src[1];
3043
    uint8_t * const left  = src[2];
3044
    uint8_t * const mid   = src[0];
3045
    uint8_t * const right = src[3];
3046
    uint8_t * const bottom= src[4];
3047
#define OBMC_FILTER(x, t, l, m, r, b)\
3048
    dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
3049
#define OBMC_FILTER4(x, t, l, m, r, b)\
3050
    OBMC_FILTER(x         , t, l, m, r, b);\
3051
    OBMC_FILTER(x+1       , t, l, m, r, b);\
3052
    OBMC_FILTER(x  +stride, t, l, m, r, b);\
3053
    OBMC_FILTER(x+1+stride, t, l, m, r, b);
3054

    
3055
    x=0;
3056
    OBMC_FILTER (x  , 2, 2, 4, 0, 0);
3057
    OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
3058
    OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
3059
    OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
3060
    OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
3061
    OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
3062
    x+= stride;
3063
    OBMC_FILTER (x  , 1, 2, 5, 0, 0);
3064
    OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
3065
    OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
3066
    OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
3067
    x+= stride;
3068
    OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
3069
    OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
3070
    OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
3071
    OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
3072
    x+= 2*stride;
3073
    OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
3074
    OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
3075
    OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
3076
    OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
3077
    x+= 2*stride;
3078
    OBMC_FILTER (x  , 0, 2, 5, 0, 1);
3079
    OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
3080
    OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
3081
    OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
3082
    OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
3083
    OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
3084
    x+= stride;
3085
    OBMC_FILTER (x  , 0, 2, 4, 0, 2);
3086
    OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
3087
    OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
3088
    OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
3089
}
3090

    
3091
/* obmc for 1 8x8 luma block */
3092
static inline void obmc_motion(MpegEncContext *s,
3093
                               uint8_t *dest, uint8_t *src,
3094
                               int src_x, int src_y,
3095
                               op_pixels_func *pix_op,
3096
                               int16_t mv[5][2]/* mid top left right bottom*/)
3097
#define MID    0
3098
{
3099
    int i;
3100
    uint8_t *ptr[5];
3101

    
3102
    assert(s->quarter_sample==0);
3103

    
3104
    for(i=0; i<5; i++){
3105
        if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
3106
            ptr[i]= ptr[MID];
3107
        }else{
3108
            ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
3109
            hpel_motion(s, ptr[i], src, 0, 0,
3110
                        src_x, src_y,
3111
                        s->width, s->height, s->linesize,
3112
                        s->h_edge_pos, s->v_edge_pos,
3113
                        8, 8, pix_op,
3114
                        mv[i][0], mv[i][1]);
3115
        }
3116
    }
3117

    
3118
    put_obmc(dest, ptr, s->linesize);
3119
}
3120

    
3121
static inline void qpel_motion(MpegEncContext *s,
3122
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3123
                               int field_based, int bottom_field, int field_select,
3124
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3125
                               qpel_mc_func (*qpix_op)[16],
3126
                               int motion_x, int motion_y, int h)
3127
{
3128
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3129
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3130

    
3131
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3132
    src_x = s->mb_x *  16                 + (motion_x >> 2);
3133
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3134

    
3135
    v_edge_pos = s->v_edge_pos >> field_based;
3136
    linesize = s->linesize << field_based;
3137
    uvlinesize = s->uvlinesize << field_based;
3138

    
3139
    if(field_based){
3140
        mx= motion_x/2;
3141
        my= motion_y>>1;
3142
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3143
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
3144
        mx= (motion_x>>1) + rtab[motion_x&7];
3145
        my= (motion_y>>1) + rtab[motion_y&7];
3146
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3147
        mx= (motion_x>>1)|(motion_x&1);
3148
        my= (motion_y>>1)|(motion_y&1);
3149
    }else{
3150
        mx= motion_x/2;
3151
        my= motion_y/2;
3152
    }
3153
    mx= (mx>>1)|(mx&1);
3154
    my= (my>>1)|(my&1);
3155

    
3156
    uvdxy= (mx&1) | ((my&1)<<1);
3157
    mx>>=1;
3158
    my>>=1;
3159

    
3160
    uvsrc_x = s->mb_x *  8                 + mx;
3161
    uvsrc_y = s->mb_y * (8 >> field_based) + my;
3162

    
3163
    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
3164
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3165
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3166

    
3167
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
3168
       || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
3169
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3170
                         src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3171
        ptr_y= s->edge_emu_buffer;
3172
        if(!(s->flags&CODEC_FLAG_GRAY)){
3173
            uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3174
            ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
3175
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3176
            ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
3177
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3178
            ptr_cb= uvbuf;
3179
            ptr_cr= uvbuf + 16;
3180
        }
3181
    }
3182

    
3183
    if(!field_based)
3184
        qpix_op[0][dxy](dest_y, ptr_y, linesize);
3185
    else{
3186
        if(bottom_field){
3187
            dest_y += s->linesize;
3188
            dest_cb+= s->uvlinesize;
3189
            dest_cr+= s->uvlinesize;
3190
        }
3191

    
3192
        if(field_select){
3193
            ptr_y  += s->linesize;
3194
            ptr_cb += s->uvlinesize;
3195
            ptr_cr += s->uvlinesize;
3196
        }
3197
        //damn interlaced mode
3198
        //FIXME boundary mirroring is not exactly correct here
3199
        qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
3200
        qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3201
    }
3202
    if(!(s->flags&CODEC_FLAG_GRAY)){
3203
        pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3204
        pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3205
    }
3206
}
3207

    
3208
inline int ff_h263_round_chroma(int x){
3209
    if (x >= 0)
3210
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3211
    else {
3212
        x = -x;
3213
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3214
    }
3215
}
3216

    
3217
/**
3218
 * h263 chorma 4mv motion compensation.
3219
 */
3220
static inline void chroma_4mv_motion(MpegEncContext *s,
3221
                                     uint8_t *dest_cb, uint8_t *dest_cr,
3222
                                     uint8_t **ref_picture,
3223
                                     op_pixels_func *pix_op,
3224
                                     int mx, int my){
3225
    int dxy, emu=0, src_x, src_y, offset;
3226
    uint8_t *ptr;
3227

    
3228
    /* In case of 8X8, we construct a single chroma motion vector
3229
       with a special rounding */
3230
    mx= ff_h263_round_chroma(mx);
3231
    my= ff_h263_round_chroma(my);
3232

    
3233
    dxy = ((my & 1) << 1) | (mx & 1);
3234
    mx >>= 1;
3235
    my >>= 1;
3236

    
3237
    src_x = s->mb_x * 8 + mx;
3238
    src_y = s->mb_y * 8 + my;
3239
    src_x = clip(src_x, -8, s->width/2);
3240
    if (src_x == s->width/2)
3241
        dxy &= ~1;
3242
    src_y = clip(src_y, -8, s->height/2);
3243
    if (src_y == s->height/2)
3244
        dxy &= ~2;
3245

    
3246
    offset = (src_y * (s->uvlinesize)) + src_x;
3247
    ptr = ref_picture[1] + offset;
3248
    if(s->flags&CODEC_FLAG_EMU_EDGE){
3249
        if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3250
           || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3251
            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);
3252
            ptr= s->edge_emu_buffer;
3253
            emu=1;
3254
        }
3255
    }
3256
    pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3257

    
3258
    ptr = ref_picture[2] + offset;
3259
    if(emu){
3260
        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);
3261
        ptr= s->edge_emu_buffer;
3262
    }
3263
    pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3264
}
3265

    
3266
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3267
                                     uint8_t *dest_cb, uint8_t *dest_cr,
3268
                                     uint8_t **ref_picture,
3269
                                     h264_chroma_mc_func *pix_op,
3270
                                     int mx, int my){
3271
    const int lowres= s->avctx->lowres;
3272
    const int block_s= 8>>lowres;
3273
    const int s_mask= (2<<lowres)-1;
3274
    const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3275
    const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3276
    int emu=0, src_x, src_y, offset, sx, sy;
3277
    uint8_t *ptr;
3278

    
3279
    if(s->quarter_sample){
3280
        mx/=2;
3281
        my/=2;
3282
    }
3283

    
3284
    /* In case of 8X8, we construct a single chroma motion vector
3285
       with a special rounding */
3286
    mx= ff_h263_round_chroma(mx);
3287
    my= ff_h263_round_chroma(my);
3288

    
3289
    sx= mx & s_mask;
3290
    sy= my & s_mask;
3291
    src_x = s->mb_x*block_s + (mx >> (lowres+1));
3292
    src_y = s->mb_y*block_s + (my >> (lowres+1));
3293

    
3294
    offset = src_y * s->uvlinesize + src_x;
3295
    ptr = ref_picture[1] + offset;
3296
    if(s->flags&CODEC_FLAG_EMU_EDGE){
3297
        if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3298
           || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3299
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3300
            ptr= s->edge_emu_buffer;
3301
            emu=1;
3302
        }
3303
    }
3304
    sx <<= 2 - lowres;
3305
    sy <<= 2 - lowres;
3306
    pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3307

    
3308
    ptr = ref_picture[2] + offset;
3309
    if(emu){
3310
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3311
        ptr= s->edge_emu_buffer;
3312
    }
3313
    pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3314
}
3315

    
3316
/**
3317
 * motion compensation of a single macroblock
3318
 * @param s context
3319
 * @param dest_y luma destination pointer
3320
 * @param dest_cb chroma cb/u destination pointer
3321
 * @param dest_cr chroma cr/v destination pointer
3322
 * @param dir direction (0->forward, 1->backward)
3323
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3324
 * @param pic_op halfpel motion compensation function (average or put normally)
3325
 * @param pic_op qpel motion compensation function (average or put normally)
3326
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3327
 */
3328
static inline void MPV_motion(MpegEncContext *s,
3329
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3330
                              int dir, uint8_t **ref_picture,
3331
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3332
{
3333
    int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3334
    int mb_x, mb_y, i;
3335
    uint8_t *ptr, *dest;
3336

    
3337
    mb_x = s->mb_x;
3338
    mb_y = s->mb_y;
3339

    
3340
    if(s->obmc && s->pict_type != B_TYPE){
3341
        int16_t mv_cache[4][4][2];
3342
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
3343
        const int mot_stride= s->b8_stride;
3344
        const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3345

    
3346
        assert(!s->mb_skipped);
3347

    
3348
        memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
3349
        memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3350
        memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3351

    
3352
        if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3353
            memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3354
        }else{
3355
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3356
        }
3357

    
3358
        if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3359
            *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3360
            *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3361
        }else{
3362
            *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3363
            *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3364
        }
3365

    
3366
        if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3367
            *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3368
            *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3369
        }else{
3370
            *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3371
            *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3372
        }
3373

    
3374
        mx = 0;
3375
        my = 0;
3376
        for(i=0;i<4;i++) {
3377
            const int x= (i&1)+1;
3378
            const int y= (i>>1)+1;
3379
            int16_t mv[5][2]= {
3380
                {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
3381
                {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3382
                {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3383
                {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3384
                {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3385
            //FIXME cleanup
3386
            obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3387
                        ref_picture[0],
3388
                        mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3389
                        pix_op[1],
3390
                        mv);
3391

    
3392
            mx += mv[0][0];
3393
            my += mv[0][1];
3394
        }
3395
        if(!(s->flags&CODEC_FLAG_GRAY))
3396
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3397

    
3398
        return;
3399
    }
3400

    
3401
    switch(s->mv_type) {
3402
    case MV_TYPE_16X16:
3403
        if(s->mcsel){
3404
            if(s->real_sprite_warping_points==1){
3405
                gmc1_motion(s, dest_y, dest_cb, dest_cr,
3406
                            ref_picture);
3407
            }else{
3408
                gmc_motion(s, dest_y, dest_cb, dest_cr,
3409
                            ref_picture);
3410
            }
3411
        }else if(s->quarter_sample){
3412
            qpel_motion(s, dest_y, dest_cb, dest_cr,
3413
                        0, 0, 0,
3414
                        ref_picture, pix_op, qpix_op,
3415
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3416
        }else if(s->mspel){
3417
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3418
                        ref_picture, pix_op,
3419
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3420
        }else
3421
        {
3422
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3423
                        0, 0, 0,
3424
                        ref_picture, pix_op,
3425
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3426
        }
3427
        break;
3428
    case MV_TYPE_8X8:
3429
        mx = 0;
3430
        my = 0;
3431
        if(s->quarter_sample){
3432
            for(i=0;i<4;i++) {
3433
                motion_x = s->mv[dir][i][0];
3434
                motion_y = s->mv[dir][i][1];
3435

    
3436
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3437
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3438
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3439

    
3440
                /* WARNING: do no forget half pels */
3441
                src_x = clip(src_x, -16, s->width);
3442
                if (src_x == s->width)
3443
                    dxy &= ~3;
3444
                src_y = clip(src_y, -16, s->height);
3445
                if (src_y == s->height)
3446
                    dxy &= ~12;
3447

    
3448
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3449
                if(s->flags&CODEC_FLAG_EMU_EDGE){
3450
                    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8
3451
                       || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3452
                        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);
3453
                        ptr= s->edge_emu_buffer;
3454
                    }
3455
                }
3456
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3457
                qpix_op[1][dxy](dest, ptr, s->linesize);
3458

    
3459
                mx += s->mv[dir][i][0]/2;
3460
                my += s->mv[dir][i][1]/2;
3461
            }
3462
        }else{
3463
            for(i=0;i<4;i++) {
3464
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3465
                            ref_picture[0], 0, 0,
3466
                            mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3467
                            s->width, s->height, s->linesize,
3468
                            s->h_edge_pos, s->v_edge_pos,
3469
                            8, 8, pix_op[1],
3470
                            s->mv[dir][i][0], s->mv[dir][i][1]);
3471

    
3472
                mx += s->mv[dir][i][0];
3473
                my += s->mv[dir][i][1];
3474
            }
3475
        }
3476

    
3477
        if(!(s->flags&CODEC_FLAG_GRAY))
3478
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3479
        break;
3480
    case MV_TYPE_FIELD:
3481
        if (s->picture_structure == PICT_FRAME) {
3482
            if(s->quarter_sample){
3483
                for(i=0; i<2; i++){
3484
                    qpel_motion(s, dest_y, dest_cb, dest_cr,
3485
                                1, i, s->field_select[dir][i],
3486
                                ref_picture, pix_op, qpix_op,
3487
                                s->mv[dir][i][0], s->mv[dir][i][1], 8);
3488
                }
3489
            }else{
3490
                /* top field */
3491
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3492
                            1, 0, s->field_select[dir][0],
3493
                            ref_picture, pix_op,
3494
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
3495
                /* bottom field */
3496
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3497
                            1, 1, s->field_select[dir][1],
3498
                            ref_picture, pix_op,
3499
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
3500
            }
3501
        } else {
3502
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3503
                ref_picture= s->current_picture_ptr->data;
3504
            }
3505

    
3506
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3507
                        0, 0, s->field_select[dir][0],
3508
                        ref_picture, pix_op,
3509
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3510
        }
3511
        break;
3512
    case MV_TYPE_16X8:
3513
        for(i=0; i<2; i++){
3514
            uint8_t ** ref2picture;
3515

    
3516
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3517
                ref2picture= ref_picture;
3518
            }else{
3519
                ref2picture= s->current_picture_ptr->data;
3520
            }
3521

    
3522
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3523
                        0, 0, s->field_select[dir][i],
3524
                        ref2picture, pix_op,
3525
                        s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3526

    
3527
            dest_y += 16*s->linesize;
3528
            dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3529
            dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3530
        }
3531
        break;
3532
    case MV_TYPE_DMV:
3533
        if(s->picture_structure == PICT_FRAME){
3534
            for(i=0; i<2; i++){
3535
                int j;
3536
                for(j=0; j<2; j++){
3537
                    mpeg_motion(s, dest_y, dest_cb, dest_cr,
3538
                                1, j, j^i,
3539
                                ref_picture, pix_op,
3540
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3541
                }
3542
                pix_op = s->dsp.avg_pixels_tab;
3543
            }
3544
        }else{
3545
            for(i=0; i<2; i++){
3546
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3547
                            0, 0, s->picture_structure != i+1,
3548
                            ref_picture, pix_op,
3549
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3550

    
3551
                // after put we make avg of the same block
3552
                pix_op=s->dsp.avg_pixels_tab;
3553

    
3554
                //opposite parity is always in the same frame if this is second field
3555
                if(!s->first_field){
3556
                    ref_picture = s->current_picture_ptr->data;
3557
                }
3558
            }
3559
        }
3560
    break;
3561
    default: assert(0);
3562
    }
3563
}
3564

    
3565
/**
3566
 * motion compensation of a single macroblock
3567
 * @param s context
3568
 * @param dest_y luma destination pointer
3569
 * @param dest_cb chroma cb/u destination pointer
3570
 * @param dest_cr chroma cr/v destination pointer
3571
 * @param dir direction (0->forward, 1->backward)
3572
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3573
 * @param pic_op halfpel motion compensation function (average or put normally)
3574
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3575
 */
3576
static inline void MPV_motion_lowres(MpegEncContext *s,
3577
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3578
                              int dir, uint8_t **ref_picture,
3579
                              h264_chroma_mc_func *pix_op)
3580
{
3581
    int mx, my;
3582
    int mb_x, mb_y, i;
3583
    const int lowres= s->avctx->lowres;
3584
    const int block_s= 8>>lowres;
3585

    
3586
    mb_x = s->mb_x;
3587
    mb_y = s->mb_y;
3588

    
3589
    switch(s->mv_type) {
3590
    case MV_TYPE_16X16:
3591
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3592
                    0, 0, 0,
3593
                    ref_picture, pix_op,
3594
                    s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3595
        break;
3596
    case MV_TYPE_8X8:
3597
        mx = 0;
3598
        my = 0;
3599
            for(i=0;i<4;i++) {
3600
                hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
3601
                            ref_picture[0], 0, 0,
3602
                            (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
3603
                            s->width, s->height, s->linesize,
3604
                            s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
3605
                            block_s, block_s, pix_op,
3606
                            s->mv[dir][i][0], s->mv[dir][i][1]);
3607

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

    
3612
        if(!(s->flags&CODEC_FLAG_GRAY))
3613
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
3614
        break;
3615
    case MV_TYPE_FIELD:
3616
        if (s->picture_structure == PICT_FRAME) {
3617
            /* top field */
3618
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3619
                        1, 0, s->field_select[dir][0],
3620
                        ref_picture, pix_op,
3621
                        s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3622
            /* bottom field */
3623
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3624
                        1, 1, s->field_select[dir][1],
3625
                        ref_picture, pix_op,
3626
                        s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3627
        } else {
3628
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3629
                ref_picture= s->current_picture_ptr->data;
3630
            }
3631

    
3632
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3633
                        0, 0, s->field_select[dir][0],
3634
                        ref_picture, pix_op,
3635
                        s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3636
        }
3637
        break;
3638
    case MV_TYPE_16X8:
3639
        for(i=0; i<2; i++){
3640
            uint8_t ** ref2picture;
3641

    
3642
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3643
                ref2picture= ref_picture;
3644
            }else{
3645
                ref2picture= s->current_picture_ptr->data;
3646
            }
3647

    
3648
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3649
                        0, 0, s->field_select[dir][i],
3650
                        ref2picture, pix_op,
3651
                        s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
3652

    
3653
            dest_y += 2*block_s*s->linesize;
3654
            dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3655
            dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3656
        }
3657
        break;
3658
    case MV_TYPE_DMV:
3659
        if(s->picture_structure == PICT_FRAME){
3660
            for(i=0; i<2; i++){
3661
                int j;
3662
                for(j=0; j<2; j++){
3663
                    mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3664
                                1, j, j^i,
3665
                                ref_picture, pix_op,
3666
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
3667
                }
3668
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3669
            }
3670
        }else{
3671
            for(i=0; i<2; i++){
3672
                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3673
                            0, 0, s->picture_structure != i+1,
3674
                            ref_picture, pix_op,
3675
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
3676

    
3677
                // after put we make avg of the same block
3678
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3679

    
3680
                //opposite parity is always in the same frame if this is second field
3681
                if(!s->first_field){
3682
                    ref_picture = s->current_picture_ptr->data;
3683
                }
3684
            }
3685
        }
3686
    break;
3687
    default: assert(0);
3688
    }
3689
}
3690

    
3691
/* put block[] to dest[] */
3692
static inline void put_dct(MpegEncContext *s,
3693
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3694
{
3695
    s->dct_unquantize_intra(s, block, i, qscale);
3696
    s->dsp.idct_put (dest, line_size, block);
3697
}
3698

    
3699
/* add block[] to dest[] */
3700
static inline void add_dct(MpegEncContext *s,
3701
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
3702
{
3703
    if (s->block_last_index[i] >= 0) {
3704
        s->dsp.idct_add (dest, line_size, block);
3705
    }
3706
}
3707

    
3708
static inline void add_dequant_dct(MpegEncContext *s,
3709
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3710
{
3711
    if (s->block_last_index[i] >= 0) {
3712
        s->dct_unquantize_inter(s, block, i, qscale);
3713

    
3714
        s->dsp.idct_add (dest, line_size, block);
3715
    }
3716
}
3717

    
3718
/**
3719
 * cleans dc, ac, coded_block for the current non intra MB
3720
 */
3721
void ff_clean_intra_table_entries(MpegEncContext *s)
3722
{
3723
    int wrap = s->b8_stride;
3724
    int xy = s->block_index[0];
3725

    
3726
    s->dc_val[0][xy           ] =
3727
    s->dc_val[0][xy + 1       ] =
3728
    s->dc_val[0][xy     + wrap] =
3729
    s->dc_val[0][xy + 1 + wrap] = 1024;
3730
    /* ac pred */
3731
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
3732
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3733
    if (s->msmpeg4_version>=3) {
3734
        s->coded_block[xy           ] =
3735
        s->coded_block[xy + 1       ] =
3736
        s->coded_block[xy     + wrap] =
3737
        s->coded_block[xy + 1 + wrap] = 0;
3738
    }
3739
    /* chroma */
3740
    wrap = s->mb_stride;
3741
    xy = s->mb_x + s->mb_y * wrap;
3742
    s->dc_val[1][xy] =
3743
    s->dc_val[2][xy] = 1024;
3744
    /* ac pred */
3745
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3746
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3747

    
3748
    s->mbintra_table[xy]= 0;
3749
}
3750

    
3751
/* generic function called after a macroblock has been parsed by the
3752
   decoder or after it has been encoded by the encoder.
3753

3754
   Important variables used:
3755
   s->mb_intra : true if intra macroblock
3756
   s->mv_dir   : motion vector direction
3757
   s->mv_type  : motion vector type
3758
   s->mv       : motion vector
3759
   s->interlaced_dct : true if interlaced dct used (mpeg2)
3760
 */
3761
static always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
3762
{
3763
    int mb_x, mb_y;
3764
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3765
#ifdef HAVE_XVMC
3766
    if(s->avctx->xvmc_acceleration){
3767
        XVMC_decode_mb(s);//xvmc uses pblocks
3768
        return;
3769
    }
3770
#endif
3771

    
3772
    mb_x = s->mb_x;
3773
    mb_y = s->mb_y;
3774

    
3775
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3776
       /* save DCT coefficients */
3777
       int i,j;
3778
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3779
       for(i=0; i<6; i++)
3780
           for(j=0; j<64; j++)
3781
               *dct++ = block[i][s->dsp.idct_permutation[j]];
3782
    }
3783

    
3784
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3785

    
3786
    /* update DC predictors for P macroblocks */
3787
    if (!s->mb_intra) {
3788
        if (s->h263_pred || s->h263_aic) {
3789
            if(s->mbintra_table[mb_xy])
3790
                ff_clean_intra_table_entries(s);
3791
        } else {
3792
            s->last_dc[0] =
3793
            s->last_dc[1] =
3794
            s->last_dc[2] = 128 << s->intra_dc_precision;
3795
        }
3796
    }
3797
    else if (s->h263_pred || s->h263_aic)
3798
        s->mbintra_table[mb_xy]=1;
3799

    
3800
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3801
        uint8_t *dest_y, *dest_cb, *dest_cr;
3802
        int dct_linesize, dct_offset;
3803
        op_pixels_func (*op_pix)[4];
3804
        qpel_mc_func (*op_qpix)[16];
3805
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
3806
        const int uvlinesize= s->current_picture.linesize[1];
3807
        const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3808
        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3809

    
3810
        /* avoid copy if macroblock skipped in last frame too */
3811
        /* skip only during decoding as we might trash the buffers during encoding a bit */
3812
        if(!s->encoding){
3813
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3814
            const int age= s->current_picture.age;
3815

    
3816
            assert(age);
3817

    
3818
            if (s->mb_skipped) {
3819
                s->mb_skipped= 0;
3820
                assert(s->pict_type!=I_TYPE);
3821

    
3822
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
3823
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3824

    
3825
                /* if previous was skipped too, then nothing to do !  */
3826
                if (*mbskip_ptr >= age && s->current_picture.reference){
3827
                    return;
3828
                }
3829
            } else if(!s->current_picture.reference){
3830
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3831
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3832
            } else{
3833
                *mbskip_ptr = 0; /* not skipped */
3834
            }
3835
        }
3836

    
3837
        dct_linesize = linesize << s->interlaced_dct;
3838
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3839

    
3840
        if(readable){
3841
            dest_y=  s->dest[0];
3842
            dest_cb= s->dest[1];
3843
            dest_cr= s->dest[2];
3844
        }else{
3845
            dest_y = s->b_scratchpad;
3846
            dest_cb= s->b_scratchpad+16*linesize;
3847
            dest_cr= s->b_scratchpad+32*linesize;
3848
        }
3849

    
3850
        if (!s->mb_intra) {
3851
            /* motion handling */
3852
            /* decoding or more than one mb_type (MC was already done otherwise) */
3853
            if(!s->encoding){
3854
                if(lowres_flag){
3855
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
3856

    
3857
                    if (s->mv_dir & MV_DIR_FORWARD) {
3858
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
3859
                        op_pix = s->dsp.avg_h264_chroma_pixels_tab;
3860
                    }
3861
                    if (s->mv_dir & MV_DIR_BACKWARD) {
3862
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
3863
                    }
3864
                }else{
3865
                    if ((!s->no_rounding) || s->pict_type==B_TYPE){
3866
                        op_pix = s->dsp.put_pixels_tab;
3867
                        op_qpix= s->dsp.put_qpel_pixels_tab;
3868
                    }else{
3869
                        op_pix = s->dsp.put_no_rnd_pixels_tab;
3870
                        op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3871
                    }
3872
                    if (s->mv_dir & MV_DIR_FORWARD) {
3873
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3874
                        op_pix = s->dsp.avg_pixels_tab;
3875
                        op_qpix= s->dsp.avg_qpel_pixels_tab;
3876
                    }
3877
                    if (s->mv_dir & MV_DIR_BACKWARD) {
3878
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3879
                    }
3880
                }
3881
            }
3882

    
3883
            /* skip dequant / idct if we are really late ;) */
3884
            if(s->hurry_up>1) goto skip_idct;
3885
            if(s->avctx->skip_idct){
3886
                if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == B_TYPE)
3887
                   ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != I_TYPE)
3888
                   || s->avctx->skip_idct >= AVDISCARD_ALL)
3889
                    goto skip_idct;
3890
            }
3891

    
3892
            /* add dct residue */
3893
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3894
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3895
                add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3896
                add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3897
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3898
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3899

    
3900
                if(!(s->flags&CODEC_FLAG_GRAY)){
3901
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3902
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3903
                }
3904
            } else if(s->codec_id != CODEC_ID_WMV2){
3905
                add_dct(s, block[0], 0, dest_y                          , dct_linesize);
3906
                add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
3907
                add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
3908
                add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3909

    
3910
                if(!(s->flags&CODEC_FLAG_GRAY)){
3911
                    if(s->chroma_y_shift){//Chroma420
3912
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
3913
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
3914
                    }else{
3915
                        //chroma422
3916
                        dct_linesize = uvlinesize << s->interlaced_dct;
3917
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3918

    
3919
                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
3920
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
3921
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
3922
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
3923
                        if(!s->chroma_x_shift){//Chroma444
3924
                            add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
3925
                            add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
3926
                            add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
3927
                            add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
3928
                        }
3929
                    }
3930
                }//fi gray
3931
            }
3932
            else{
3933
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3934
            }
3935
        } else {
3936
            /* dct only in intra block */
3937
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3938
                put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3939
                put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3940
                put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3941
                put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3942

    
3943
                if(!(s->flags&CODEC_FLAG_GRAY)){
3944
                    put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3945
                    put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3946
                }
3947
            }else{
3948
                s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
3949
                s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
3950
                s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
3951
                s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
3952

    
3953
                if(!(s->flags&CODEC_FLAG_GRAY)){
3954
                    if(s->chroma_y_shift){
3955
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3956
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3957
                    }else{
3958

    
3959
                        dct_linesize = uvlinesize << s->interlaced_dct;
3960
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3961

    
3962
                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
3963
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
3964
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
3965
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
3966
                        if(!s->chroma_x_shift){//Chroma444
3967
                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
3968
                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
3969
                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
3970
                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
3971
                        }
3972
                    }
3973
                }//gray
3974
            }
3975
        }
3976
skip_idct:
3977
        if(!readable){
3978
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3979
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
3980
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
3981
        }
3982
    }
3983
}
3984

    
3985
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
3986
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
3987
    else                  MPV_decode_mb_internal(s, block, 0);
3988
}
3989

    
3990
#ifdef CONFIG_ENCODERS
3991

    
3992
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3993
{
3994
    static const char tab[64]=
3995
        {3,2,2,1,1,1,1,1,
3996
         1,1,1,1,1,1,1,1,
3997
         1,1,1,1,1,1,1,1,
3998
         0,0,0,0,0,0,0,0,
3999
         0,0,0,0,0,0,0,0,
4000
         0,0,0,0,0,0,0,0,
4001
         0,0,0,0,0,0,0,0,
4002
         0,0,0,0,0,0,0,0};
4003
    int score=0;
4004
    int run=0;
4005
    int i;
4006
    DCTELEM *block= s->block[n];
4007
    const int last_index= s->block_last_index[n];
4008
    int skip_dc;
4009

    
4010
    if(threshold<0){
4011
        skip_dc=0;
4012
        threshold= -threshold;
4013
    }else
4014
        skip_dc=1;
4015

    
4016
    /* are all which we could set to zero are allready zero? */
4017
    if(last_index<=skip_dc - 1) return;
4018

    
4019
    for(i=0; i<=last_index; i++){
4020
        const int j = s->intra_scantable.permutated[i];
4021
        const int level = ABS(block[j]);
4022
        if(level==1){
4023
            if(skip_dc && i==0) continue;
4024
            score+= tab[run];
4025
            run=0;
4026
        }else if(level>1){
4027
            return;
4028
        }else{
4029
            run++;
4030
        }
4031
    }
4032
    if(score >= threshold) return;
4033
    for(i=skip_dc; i<=last_index; i++){
4034
        const int j = s->intra_scantable.permutated[i];
4035
        block[j]=0;
4036
    }
4037
    if(block[0]) s->block_last_index[n]= 0;
4038
    else         s->block_last_index[n]= -1;
4039
}
4040

    
4041
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
4042
{
4043
    int i;
4044
    const int maxlevel= s->max_qcoeff;
4045
    const int minlevel= s->min_qcoeff;
4046
    int overflow=0;
4047

    
4048
    if(s->mb_intra){
4049
        i=1; //skip clipping of intra dc
4050
    }else
4051
        i=0;
4052

    
4053
    for(;i<=last_index; i++){
4054
        const int j= s->intra_scantable.permutated[i];
4055
        int level = block[j];
4056

    
4057
        if     (level>maxlevel){
4058
            level=maxlevel;
4059
            overflow++;
4060
        }else if(level<minlevel){
4061
            level=minlevel;
4062
            overflow++;
4063
        }
4064

    
4065
        block[j]= level;
4066
    }
4067

    
4068
    if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
4069
        av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel);
4070
}
4071

    
4072
#endif //CONFIG_ENCODERS
4073

    
4074
/**
4075
 *
4076
 * @param h is the normal height, this will be reduced automatically if needed for the last row
4077
 */
4078
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
4079
    if (s->avctx->draw_horiz_band) {
4080
        AVFrame *src;
4081
        int offset[4];
4082

    
4083
        if(s->picture_structure != PICT_FRAME){
4084
            h <<= 1;
4085
            y <<= 1;
4086
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
4087
        }
4088

    
4089
        h= FFMIN(h, s->avctx->height - y);
4090

    
4091
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
4092
            src= (AVFrame*)s->current_picture_ptr;
4093
        else if(s->last_picture_ptr)
4094
            src= (AVFrame*)s->last_picture_ptr;
4095
        else
4096
            return;
4097

    
4098
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
4099
            offset[0]=
4100
            offset[1]=
4101
            offset[2]=
4102
            offset[3]= 0;
4103
        }else{
4104
            offset[0]= y * s->linesize;;
4105
            offset[1]=
4106
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
4107
            offset[3]= 0;
4108
        }
4109

    
4110
        emms_c();
4111

    
4112
        s->avctx->draw_horiz_band(s->avctx, src, offset,
4113
                                  y, s->picture_structure, h);
4114
    }
4115
}
4116

    
4117
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
4118
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
4119
    const int uvlinesize= s->current_picture.linesize[1];
4120
    const int mb_size= 4 - s->avctx->lowres;
4121

    
4122
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
4123
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
4124
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
4125
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
4126
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
4127
    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;
4128
    //block_index is not used by mpeg2, so it is not affected by chroma_format
4129

    
4130
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
4131
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4132
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4133

    
4134
    if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
4135
    {
4136
        s->dest[0] += s->mb_y *   linesize << mb_size;
4137
        s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4138
        s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4139
    }
4140
}
4141

    
4142
#ifdef CONFIG_ENCODERS
4143

    
4144
static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
4145
    int x, y;
4146
//FIXME optimize
4147
    for(y=0; y<8; y++){
4148
        for(x=0; x<8; x++){
4149
            int x2, y2;
4150
            int sum=0;
4151
            int sqr=0;
4152
            int count=0;
4153

    
4154
            for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
4155
                for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
4156
                    int v= ptr[x2 + y2*stride];
4157
                    sum += v;
4158
                    sqr += v*v;
4159
                    count++;
4160
                }
4161
            }
4162
            weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
4163
        }
4164
    }
4165
}
4166

    
4167
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
4168
{
4169
    int16_t weight[6][64];
4170
    DCTELEM orig[6][64];
4171
    const int mb_x= s->mb_x;
4172
    const int mb_y= s->mb_y;
4173
    int i;
4174
    int skip_dct[6];
4175
    int dct_offset   = s->linesize*8; //default for progressive frames
4176
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
4177
    int wrap_y, wrap_c;
4178

    
4179
    for(i=0; i<6; i++) skip_dct[i]=0;
4180

    
4181
    if(s->adaptive_quant){
4182
        const int last_qp= s->qscale;
4183
        const int mb_xy= mb_x + mb_y*s->mb_stride;
4184

    
4185
        s->lambda= s->lambda_table[mb_xy];
4186
        update_qscale(s);
4187

    
4188
        if(!(s->flags&CODEC_FLAG_QP_RD)){
4189
            s->dquant= s->qscale - last_qp;
4190

    
4191
            if(s->out_format==FMT_H263){
4192
                s->dquant= clip(s->dquant, -2, 2); //FIXME RD
4193

    
4194
                if(s->codec_id==CODEC_ID_MPEG4){
4195
                    if(!s->mb_intra){
4196
                        if(s->pict_type == B_TYPE){
4197
                            if(s->dquant&1)
4198
                                s->dquant= (s->dquant/2)*2;
4199
                            if(s->mv_dir&MV_DIRECT)
4200
                                s->dquant= 0;
4201
                        }
4202
                        if(s->mv_type==MV_TYPE_8X8)
4203
                            s->dquant=0;
4204
                    }
4205
                }
4206
            }
4207
        }
4208
        ff_set_qscale(s, last_qp + s->dquant);
4209
    }else if(s->flags&CODEC_FLAG_QP_RD)
4210
        ff_set_qscale(s, s->qscale + s->dquant);
4211

    
4212
    wrap_y = s->linesize;
4213
    wrap_c = s->uvlinesize;
4214
    ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
4215
    ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
4216
    ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
4217

    
4218
    if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
4219
        uint8_t *ebuf= s->edge_emu_buffer + 32;
4220
        ff_emulated_edge_mc(ebuf            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
4221
        ptr_y= ebuf;
4222
        ff_emulated_edge_mc(ebuf+18*wrap_y  , ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
4223
        ptr_cb= ebuf+18*wrap_y;
4224
        ff_emulated_edge_mc(ebuf+18*wrap_y+8, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
4225
        ptr_cr= ebuf+18*wrap_y+8;
4226
    }
4227

    
4228
    if (s->mb_intra) {
4229
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4230
            int progressive_score, interlaced_score;
4231

    
4232
            s->interlaced_dct=0;
4233
            progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8)
4234
                              +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
4235

    
4236
            if(progressive_score > 0){
4237
                interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8)
4238
                                  +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
4239
                if(progressive_score > interlaced_score){
4240
                    s->interlaced_dct=1;
4241

    
4242
                    dct_offset= wrap_y;
4243
                    wrap_y<<=1;
4244
                }
4245
            }
4246
        }
4247

    
4248
        s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
4249
        s->dsp.get_pixels(s->block[1], ptr_y              + 8, wrap_y);
4250
        s->dsp.get_pixels(s->block[2], ptr_y + dct_offset    , wrap_y);
4251
        s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
4252

    
4253
        if(s->flags&CODEC_FLAG_GRAY){
4254
            skip_dct[4]= 1;
4255
            skip_dct[5]= 1;
4256
        }else{
4257
            s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
4258
            s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
4259
        }
4260
    }else{
4261
        op_pixels_func (*op_pix)[4];
4262
        qpel_mc_func (*op_qpix)[16];
4263
        uint8_t *dest_y, *dest_cb, *dest_cr;
4264

    
4265
        dest_y  = s->dest[0];
4266
        dest_cb = s->dest[1];
4267
        dest_cr = s->dest[2];
4268

    
4269
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
4270
            op_pix = s->dsp.put_pixels_tab;
4271
            op_qpix= s->dsp.put_qpel_pixels_tab;
4272
        }else{
4273
            op_pix = s->dsp.put_no_rnd_pixels_tab;
4274
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
4275
        }
4276

    
4277
        if (s->mv_dir & MV_DIR_FORWARD) {
4278
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
4279
            op_pix = s->dsp.avg_pixels_tab;
4280
            op_qpix= s->dsp.avg_qpel_pixels_tab;
4281
        }
4282
        if (s->mv_dir & MV_DIR_BACKWARD) {
4283
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
4284
        }
4285

    
4286
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4287
            int progressive_score, interlaced_score;
4288

    
4289
            s->interlaced_dct=0;
4290
            progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8)
4291
                              +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
4292

    
4293
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
4294

    
4295
            if(progressive_score>0){
4296
                interlaced_score = s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y*2, 8)
4297
                                  +s->dsp.ildct_cmp[0](s, dest_y + wrap_y  , ptr_y + wrap_y  , wrap_y*2, 8);
4298

    
4299
                if(progressive_score > interlaced_score){
4300
                    s->interlaced_dct=1;
4301

    
4302
                    dct_offset= wrap_y;
4303
                    wrap_y<<=1;
4304
                }
4305
            }
4306
        }
4307

    
4308
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
4309
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
4310
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
4311
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
4312

    
4313
        if(s->flags&CODEC_FLAG_GRAY){
4314
            skip_dct[4]= 1;
4315
            skip_dct[5]= 1;
4316
        }else{
4317
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
4318
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
4319
        }
4320
        /* pre quantization */
4321
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
4322
            //FIXME optimize
4323
            if(s->dsp.sad[1](NULL, ptr_y               , dest_y               , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
4324
            if(s->dsp.sad[1](NULL, ptr_y            + 8, dest_y            + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
4325
            if(s->dsp.sad[1](NULL, ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
4326
            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;
4327
            if(s->dsp.sad[1](NULL, ptr_cb              , dest_cb              , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
4328
            if(s->dsp.sad[1](NULL, ptr_cr              , dest_cr              , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
4329
        }
4330
    }
4331

    
4332
    if(s->avctx->quantizer_noise_shaping){
4333
        if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y                 , wrap_y);
4334
        if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y              + 8, wrap_y);
4335
        if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset    , wrap_y);
4336
        if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
4337
        if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb                , wrap_c);
4338
        if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr                , wrap_c);
4339
        memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*6);
4340
    }
4341

    
4342
    /* DCT & quantize */
4343
    assert(s->out_format!=FMT_MJPEG || s->qscale==8);
4344
    {
4345
        for(i=0;i<6;i++) {
4346
            if(!skip_dct[i]){
4347
                int overflow;
4348
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
4349
            // FIXME we could decide to change to quantizer instead of clipping
4350
            // JS: I don't think that would be a good idea it could lower quality instead
4351
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
4352
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
4353
            }else
4354
                s->block_last_index[i]= -1;
4355
        }
4356
        if(s->avctx->quantizer_noise_shaping){
4357
            for(i=0;i<6;i++) {
4358
                if(!skip_dct[i]){
4359
                    s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
4360
                }
4361
            }
4362
        }
4363

    
4364
        if(s->luma_elim_threshold && !s->mb_intra)
4365
            for(i=0; i<4; i++)
4366
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
4367
        if(s->chroma_elim_threshold && !s->mb_intra)
4368
            for(i=4; i<6; i++)
4369
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
4370

    
4371
        if(s->flags & CODEC_FLAG_CBP_RD){
4372
            for(i=0;i<6;i++) {
4373
                if(s->block_last_index[i] == -1)
4374
                    s->coded_score[i]= INT_MAX/256;
4375
            }
4376
        }
4377
    }
4378

    
4379
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
4380
        s->block_last_index[4]=
4381
        s->block_last_index[5]= 0;
4382
        s->block[4][0]=
4383
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
4384
    }
4385

    
4386
    //non c quantize code returns incorrect block_last_index FIXME
4387
    if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
4388
        for(i=0; i<6; i++){
4389
            int j;
4390
            if(s->block_last_index[i]>0){
4391
                for(j=63; j>0; j--){
4392
                    if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
4393
                }
4394
                s->block_last_index[i]= j;
4395
            }
4396
        }
4397
    }
4398

    
4399
    /* huffman encode */
4400
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
4401
    case CODEC_ID_MPEG1VIDEO:
4402
    case CODEC_ID_MPEG2VIDEO:
4403
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
4404
    case CODEC_ID_MPEG4:
4405
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4406
    case CODEC_ID_MSMPEG4V2:
4407
    case CODEC_ID_MSMPEG4V3:
4408
    case CODEC_ID_WMV1:
4409
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4410
    case CODEC_ID_WMV2:
4411
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
4412
#ifdef CONFIG_H261_ENCODER
4413
    case CODEC_ID_H261:
4414
        ff_h261_encode_mb(s, s->block, motion_x, motion_y); break;
4415
#endif
4416
    case CODEC_ID_H263:
4417
    case CODEC_ID_H263P:
4418
    case CODEC_ID_FLV1:
4419
    case CODEC_ID_RV10:
4420
    case CODEC_ID_RV20:
4421
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
4422
    case CODEC_ID_MJPEG:
4423
        mjpeg_encode_mb(s, s->block); break;
4424
    default:
4425
        assert(0);
4426
    }
4427
}
4428

    
4429
#endif //CONFIG_ENCODERS
4430

    
4431
void ff_mpeg_flush(AVCodecContext *avctx){
4432
    int i;
4433
    MpegEncContext *s = avctx->priv_data;
4434

    
4435
    if(s==NULL || s->picture==NULL)
4436
        return;
4437

    
4438
    for(i=0; i<MAX_PICTURE_COUNT; i++){
4439
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
4440
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
4441
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
4442
    }
4443
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
4444

    
4445
    s->mb_x= s->mb_y= 0;
4446

    
4447
    s->parse_context.state= -1;
4448
    s->parse_context.frame_start_found= 0;
4449
    s->parse_context.overread= 0;
4450
    s->parse_context.overread_index= 0;
4451
    s->parse_context.index= 0;
4452
    s->parse_context.last_index= 0;
4453
    s->bitstream_buffer_size=0;
4454
}
4455

    
4456
#ifdef CONFIG_ENCODERS
4457
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4458
{
4459
    const uint16_t *srcw= (uint16_t*)src;
4460
    int words= length>>4;
4461
    int bits= length&15;
4462
    int i;
4463

    
4464
    if(length==0) return;
4465

    
4466
    if(words < 16){
4467
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4468
    }else if(put_bits_count(pb)&7){
4469
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4470
    }else{
4471
        for(i=0; put_bits_count(pb)&31; i++)
4472
            put_bits(pb, 8, src[i]);
4473
        flush_put_bits(pb);
4474
        memcpy(pbBufPtr(pb), src+i, 2*words-i);
4475
        skip_put_bytes(pb, 2*words-i);
4476
    }
4477

    
4478
    put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
4479
}
4480

    
4481
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
4482
    int i;
4483

    
4484
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4485

    
4486
    /* mpeg1 */
4487
    d->mb_skip_run= s->mb_skip_run;
4488
    for(i=0; i<3; i++)
4489
        d->last_dc[i]= s->last_dc[i];
4490

    
4491
    /* statistics */
4492
    d->mv_bits= s->mv_bits;
4493
    d->i_tex_bits= s->i_tex_bits;
4494
    d->p_tex_bits= s->p_tex_bits;
4495
    d->i_count= s->i_count;
4496
    d->f_count= s->f_count;
4497
    d->b_count= s->b_count;
4498
    d->skip_count= s->skip_count;
4499
    d->misc_bits= s->misc_bits;
4500
    d->last_bits= 0;
4501

    
4502
    d->mb_skipped= 0;
4503
    d->qscale= s->qscale;
4504
    d->dquant= s->dquant;
4505
}
4506

    
4507
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
4508
    int i;
4509

    
4510
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
4511
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4512

    
4513
    /* mpeg1 */
4514
    d->mb_skip_run= s->mb_skip_run;
4515
    for(i=0; i<3; i++)
4516
        d->last_dc[i]= s->last_dc[i];
4517

    
4518
    /* statistics */
4519
    d->mv_bits= s->mv_bits;
4520
    d->i_tex_bits= s->i_tex_bits;
4521
    d->p_tex_bits= s->p_tex_bits;
4522
    d->i_count= s->i_count;
4523
    d->f_count= s->f_count;
4524
    d->b_count= s->b_count;
4525
    d->skip_count= s->skip_count;
4526
    d->misc_bits= s->misc_bits;
4527

    
4528
    d->mb_intra= s->mb_intra;
4529
    d->mb_skipped= s->mb_skipped;
4530
    d->mv_type= s->mv_type;
4531
    d->mv_dir= s->mv_dir;
4532
    d->pb= s->pb;
4533
    if(s->data_partitioning){
4534
        d->pb2= s->pb2;
4535
        d->tex_pb= s->tex_pb;
4536
    }
4537
    d->block= s->block;
4538
    for(i=0; i<6; i++)
4539
        d->block_last_index[i]= s->block_last_index[i];
4540
    d->interlaced_dct= s->interlaced_dct;
4541
    d->qscale= s->qscale;
4542
}
4543

    
4544
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
4545
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
4546
                           int *dmin, int *next_block, int motion_x, int motion_y)
4547
{
4548
    int score;
4549
    uint8_t *dest_backup[3];
4550

    
4551
    copy_context_before_encode(s, backup, type);
4552

    
4553
    s->block= s->blocks[*next_block];
4554
    s->pb= pb[*next_block];
4555
    if(s->data_partitioning){
4556
        s->pb2   = pb2   [*next_block];
4557
        s->tex_pb= tex_pb[*next_block];
4558
    }
4559

    
4560
    if(*next_block){
4561
        memcpy(dest_backup, s->dest, sizeof(s->dest));
4562
        s->dest[0] = s->rd_scratchpad;
4563
        s->dest[1] = s->rd_scratchpad + 16*s->linesize;
4564
        s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
4565
        assert(s->linesize >= 32); //FIXME
4566
    }
4567

    
4568
    encode_mb(s, motion_x, motion_y);
4569

    
4570
    score= put_bits_count(&s->pb);
4571
    if(s->data_partitioning){
4572
        score+= put_bits_count(&s->pb2);
4573
        score+= put_bits_count(&s->tex_pb);
4574
    }
4575

    
4576
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
4577
        MPV_decode_mb(s, s->block);
4578

    
4579
        score *= s->lambda2;
4580
        score += sse_mb(s) << FF_LAMBDA_SHIFT;
4581
    }
4582

    
4583
    if(*next_block){
4584
        memcpy(s->dest, dest_backup, sizeof(s->dest));
4585
    }
4586

    
4587
    if(score<*dmin){
4588
        *dmin= score;
4589
        *next_block^=1;
4590

    
4591
        copy_context_after_encode(best, s, type);
4592
    }
4593
}
4594

    
4595
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
4596
    uint32_t *sq = squareTbl + 256;
4597
    int acc=0;
4598
    int x,y;
4599

    
4600
    if(w==16 && h==16)
4601
        return s->dsp.sse[0](NULL, src1, src2, stride, 16);
4602
    else if(w==8 && h==8)
4603
        return s->dsp.sse[1](NULL, src1, src2, stride, 8);
4604

    
4605
    for(y=0; y<h; y++){
4606
        for(x=0; x<w; x++){
4607
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
4608
        }
4609
    }
4610

    
4611
    assert(acc>=0);
4612

    
4613
    return acc;
4614
}
4615

    
4616
static int sse_mb(MpegEncContext *s){
4617
    int w= 16;
4618
    int h= 16;
4619

    
4620
    if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4621
    if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4622

    
4623
    if(w==16 && h==16)
4624
      if(s->avctx->mb_cmp == FF_CMP_NSSE){
4625
        return  s->dsp.nsse[0](s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16)
4626
               +s->dsp.nsse[1](s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8)
4627
               +s->dsp.nsse[1](s, s->new_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
4628
      }else{
4629
        return  s->dsp.sse[0](NULL, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16)
4630
               +s->dsp.sse[1](NULL, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8)
4631
               +s->dsp.sse[1](NULL, s->new_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
4632
      }
4633
    else
4634
        return  sse(s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], w, h, s->linesize)
4635
               +sse(s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[1], w>>1, h>>1, s->uvlinesize)
4636
               +sse(s, s->new_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[2], w>>1, h>>1, s->uvlinesize);
4637
}
4638

    
4639
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
4640
    MpegEncContext *s= arg;
4641

    
4642

    
4643
    s->me.pre_pass=1;
4644
    s->me.dia_size= s->avctx->pre_dia_size;
4645
    s->first_slice_line=1;
4646
    for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
4647
        for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
4648
            ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4649
        }
4650
        s->first_slice_line=0;
4651
    }
4652

    
4653
    s->me.pre_pass=0;
4654

    
4655
    return 0;
4656
}
4657

    
4658
static int estimate_motion_thread(AVCodecContext *c, void *arg){
4659
    MpegEncContext *s= arg;
4660

    
4661
    s->me.dia_size= s->avctx->dia_size;
4662
    s->first_slice_line=1;
4663
    for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4664
        s->mb_x=0; //for block init below
4665
        ff_init_block_index(s);
4666
        for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
4667
            s->block_index[