Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 3e207bb1

History | View | Annotate | Download (251 KB)

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

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

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

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

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

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

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

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

    
77

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

    
81
//#define DEBUG
82

    
83

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
201
    st->scantable= src_scantable;
202

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

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

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

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

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

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

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

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

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

    
262
    return p+4;
263
}
264

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

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

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

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

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

    
308
#endif //CONFIG_ENCODERS
309

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

    
323
    return 0;
324
}
325

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
607
    s->picture_in_gop_number = 0;
608

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

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

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

    
626
#ifdef CONFIG_ENCODERS
627
static void MPV_encode_defaults(MpegEncContext *s){
628
    MPV_common_defaults(s);
629

    
630
    {
631
        int i;
632

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
814
    s->context_initialized = 1;
815

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

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

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

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

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

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

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

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

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

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

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

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

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

    
919
#ifdef CONFIG_ENCODERS
920

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

    
928
    MPV_encode_defaults(s);
929

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1037
        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");
1038
    }
1039

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1131
    if(s->avctx->thread_count > 1)
1132
        s->rtp_mode= 1;
1133

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

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

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

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

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

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

    
1178
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1179

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

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

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

    
1337
    avctx->has_b_frames= !s->low_delay;
1338

    
1339
    s->encoding = 1;
1340

    
1341
    /* init */
1342
    if (MPV_common_init(s) < 0)
1343
        return -1;
1344

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

    
1351
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1352
    ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1353

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

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

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

    
1394
    if(ff_rate_control_init(s) < 0)
1395
        return -1;
1396

    
1397
    return 0;
1398
}
1399

    
1400
int MPV_encode_end(AVCodecContext *avctx)
1401
{
1402
    MpegEncContext *s = avctx->priv_data;
1403

    
1404
    ff_rate_control_uninit(s);
1405

    
1406
    MPV_common_end(s);
1407
    if (s->out_format == FMT_MJPEG)
1408
        mjpeg_close(s);
1409

    
1410
    av_freep(&avctx->extradata);
1411

    
1412
    return 0;
1413
}
1414

    
1415
#endif //CONFIG_ENCODERS
1416

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

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

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

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

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

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

    
1497
int ff_find_unused_picture(MpegEncContext *s, int shared){
1498
    int i;
1499

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

    
1513
    assert(0);
1514
    return -1;
1515
}
1516

    
1517
static void update_noise_reduction(MpegEncContext *s){
1518
    int intra, i;
1519

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

    
1528
        for(i=0; i<64; i++){
1529
            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);
1530
        }
1531
    }
1532
}
1533

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

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

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

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

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

    
1578
        pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1579
                        && !s->dropable ? 3 : 0;
1580

    
1581
        pic->coded_picture_number= s->coded_picture_number++;
1582

    
1583
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1584
            return -1;
1585

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

    
1591
    s->current_picture_ptr->pict_type= s->pict_type;
1592
//    if(s->flags && CODEC_FLAG_QSCALE)
1593
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1594
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1595

    
1596
    copy_picture(&s->current_picture, s->current_picture_ptr);
1597

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

    
1609
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1610
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1611

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

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

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

    
1632
    s->hurry_up= s->avctx->hurry_up;
1633
    s->error_resilience= avctx->error_resilience;
1634

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

    
1648
    if(s->dct_error_sum){
1649
        assert(s->avctx->noise_reduction && s->encoding);
1650

    
1651
        update_noise_reduction(s);
1652
    }
1653

    
1654
#ifdef HAVE_XVMC
1655
    if(s->avctx->xvmc_acceleration)
1656
        return XVMC_field_start(s, avctx);
1657
#endif
1658
    return 0;
1659
}
1660

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

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

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

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

    
1722
    sx= av_clip(sx, 0, w-1);
1723
    sy= av_clip(sy, 0, h-1);
1724
    ex= av_clip(ex, 0, w-1);
1725
    ey= av_clip(ey, 0, h-1);
1726

    
1727
    buf[sy*stride + sx]+= color;
1728

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

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

    
1771
    sx= av_clip(sx, -100, w+100);
1772
    sy= av_clip(sy, -100, h+100);
1773
    ex= av_clip(ex, -100, w+100);
1774
    ey= av_clip(ey, -100, h+100);
1775

    
1776
    dx= ex - sx;
1777
    dy= ey - sy;
1778

    
1779
    if(dx*dx + dy*dy > 3*3){
1780
        int rx=  dx + dy;
1781
        int ry= -dx + dy;
1782
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1783

    
1784
        //FIXME subpixel accuracy
1785
        rx= ROUNDED_DIV(rx*3<<4, length);
1786
        ry= ROUNDED_DIV(ry*3<<4, length);
1787

    
1788
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1789
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1790
    }
1791
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1792
}
1793

    
1794
/**
1795
 * prints debuging info for the given picture.
1796
 */
1797
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1798

    
1799
    if(!pict || !pict->mb_type) return;
1800

    
1801
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1802
        int x,y;
1803

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

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

    
1865

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

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

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

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

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

    
1941
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1942
                            my*=2;
1943

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

    
1955
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1956
                            my*=2;
1957

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

    
1986

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

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

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

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

    
2055
#ifdef CONFIG_ENCODERS
2056

    
2057
static int get_sae(uint8_t *src, int ref, int stride){
2058
    int x,y;
2059
    int acc=0;
2060

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

    
2067
    return acc;
2068
}
2069

    
2070
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
2071
    int x, y, w, h;
2072
    int acc=0;
2073

    
2074
    w= s->width &~15;
2075
    h= s->height&~15;
2076

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

    
2084
            acc+= sae + 500 < sad;
2085
        }
2086
    }
2087
    return acc;
2088
}
2089

    
2090

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

    
2098
    if(pic_arg){
2099
        pts= pic_arg->pts;
2100
        pic_arg->display_picture_number= s->input_picture_number++;
2101

    
2102
        if(pts != AV_NOPTS_VALUE){
2103
            if(s->user_specified_pts != AV_NOPTS_VALUE){
2104
                int64_t time= pts;
2105
                int64_t last= s->user_specified_pts;
2106

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

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

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

    
2132
    if(direct){
2133
        i= ff_find_unused_picture(s, 1);
2134

    
2135
        pic= (AVFrame*)&s->picture[i];
2136
        pic->reference= 3;
2137

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

    
2146
        pic= (AVFrame*)&s->picture[i];
2147
        pic->reference= 3;
2148

    
2149
        alloc_picture(s, (Picture*)pic, 0);
2150

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

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

    
2169
                if(!s->avctx->rc_buffer_size)
2170
                    dst +=INPLACE_OFFSET;
2171

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

    
2188
    /* shift buffer entries */
2189
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2190
        s->input_picture[i-1]= s->input_picture[i];
2191

    
2192
    s->input_picture[encoding_delay]= (Picture*)pic;
2193

    
2194
    return 0;
2195
}
2196

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

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

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

    
2221
    if(score) score64= score;
2222

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

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

    
2241
    assert(scale>=0 && scale <=3);
2242

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

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

    
2261
    if (avcodec_open(c, codec) < 0)
2262
        return -1;
2263

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

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

    
2277
        if(pre_input_ptr && (!i || s->input_picture[i-1])) {
2278
            pre_input= *pre_input_ptr;
2279

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

    
2286
            s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height);
2287
            s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1], pre_input.data[1], pre_input.linesize[1], c->width>>1, c->height>>1);
2288
            s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2], pre_input.data[2], pre_input.linesize[2], c->width>>1, c->height>>1);
2289
        }
2290
    }
2291

    
2292
    for(j=0; j<s->max_b_frames+1; j++){
2293
        int64_t rd=0;
2294

    
2295
        if(!s->input_picture[j])
2296
            break;
2297

    
2298
        c->error[0]= c->error[1]= c->error[2]= 0;
2299

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

    
2305
        for(i=0; i<s->max_b_frames+1; i++){
2306
            int is_p= i % (j+1) == j || i==s->max_b_frames;
2307

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

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

    
2320
        rd += c->error[0] + c->error[1] + c->error[2];
2321

    
2322
        if(rd < best_rd){
2323
            best_rd= rd;
2324
            best_b_count= j;
2325
        }
2326
    }
2327

    
2328
    av_freep(&outbuf);
2329
    avcodec_close(c);
2330
    av_freep(&c);
2331

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

    
2336
    return best_b_count;
2337
}
2338

    
2339
static void select_input_picture(MpegEncContext *s){
2340
    int i;
2341

    
2342
    for(i=1; i<MAX_PICTURE_COUNT; i++)
2343
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2344
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2345

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

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

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

    
2368
                        s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2369
                    }
2370

    
2371
                    emms_c();
2372
                    ff_vbv_update(s, 0);
2373

    
2374
                    goto no_output_pic;
2375
                }
2376
            }
2377

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

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

    
2389
                    s->input_picture[i]->pict_type=
2390
                        s->rc_context.entry[pict_num].new_pict_type;
2391
                }
2392
            }
2393

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

    
2409
                b_frames= FFMAX(0, i-1);
2410

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

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

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

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

    
2446
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2447
               && b_frames
2448
               && s->input_picture[b_frames]->pict_type== I_TYPE)
2449
                b_frames--;
2450

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

    
2466
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2467

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

    
2471
            int i= ff_find_unused_picture(s, 0);
2472
            Picture *pic= &s->picture[i];
2473

    
2474
            pic->reference              = s->reordered_input_picture[0]->reference;
2475
            alloc_picture(s, pic, 0);
2476

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

    
2484
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2485

    
2486
            s->current_picture_ptr= pic;
2487
        }else{
2488
            // input is not a shared pix -> reuse buffer for current_pix
2489

    
2490
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2491
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2492

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

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

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

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

    
2521
        init_put_bits(&s->thread_context[i]->pb, start, end - start);
2522
    }
2523

    
2524
    s->picture_in_gop_number++;
2525

    
2526
    if(load_input_picture(s, pic_arg) < 0)
2527
        return -1;
2528

    
2529
    select_input_picture(s);
2530

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

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

    
2551
        MPV_frame_end(s);
2552

    
2553
        if (s->out_format == FMT_MJPEG)
2554
            mjpeg_picture_trailer(s);
2555

    
2556
        if(avctx->rc_buffer_size){
2557
            RateControlContext *rcc= &s->rc_context;
2558
            int max_size= rcc->buffer_index/3;
2559

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

    
2584
            assert(s->avctx->rc_max_rate);
2585
        }
2586

    
2587
        if(s->flags&CODEC_FLAG_PASS1)
2588
            ff_write_pass1_stats(s);
2589

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

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

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

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

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

    
2634
            assert(s->repeat_first_field==0);
2635

    
2636
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2637
            assert(vbv_delay < 0xFFFF);
2638

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

    
2653
    return s->frame_bits/8;
2654
}
2655

    
2656
#endif //CONFIG_ENCODERS
2657

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

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

    
2680
    linesize = s->linesize;
2681
    uvlinesize = s->uvlinesize;
2682

    
2683
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2684

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

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

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

    
2707
    if(s->flags&CODEC_FLAG_GRAY) return;
2708

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

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

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

    
2741
    return;
2742
}
2743

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

    
2753
    linesize = s->linesize;
2754
    uvlinesize = s->uvlinesize;
2755

    
2756
    ptr = ref_picture[0];
2757

    
2758
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2759
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2760

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

    
2776
    if(s->flags&CODEC_FLAG_GRAY) return;
2777

    
2778
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2779
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2780

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

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

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

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

    
2832
    start_y= FFMAX(0, -src_y);
2833
    start_x= FFMAX(0, -src_x);
2834
    end_y= FFMIN(block_h, h-src_y);
2835
    end_x= FFMIN(block_w, w-src_x);
2836

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

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

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

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

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

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

    
2883
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2884
    src_x += motion_x >> 1;
2885
    src_y += motion_y >> 1;
2886

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

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

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

    
2925
    if(s->quarter_sample){
2926
        motion_x/=2;
2927
        motion_y/=2;
2928
    }
2929

    
2930
    sx= motion_x & s_mask;
2931
    sy= motion_y & s_mask;
2932
    src_x += motion_x >> (lowres+1);
2933
    src_y += motion_y >> (lowres+1);
2934

    
2935
    src += src_y * stride + src_x;
2936

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

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

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

    
2963
#if 0
2964
if(s->quarter_sample)
2965
{
2966
    motion_x>>=1;
2967
    motion_y>>=1;
2968
}
2969
#endif
2970

    
2971
    v_edge_pos = s->v_edge_pos >> field_based;
2972
    linesize   = s->current_picture.linesize[0] << field_based;
2973
    uvlinesize = s->current_picture.linesize[1] << field_based;
2974

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

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

    
3020
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
3021
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3022
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3023

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

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

    
3051
    if(field_select){
3052
        ptr_y += s->linesize;
3053
        ptr_cb+= s->uvlinesize;
3054
        ptr_cr+= s->uvlinesize;
3055
    }
3056

    
3057
    pix_op[0][dxy](dest_y, ptr_y, linesize, h);
3058

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3230
    assert(s->quarter_sample==0);
3231

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

    
3246
    put_obmc(dest, ptr, s->linesize);
3247
}
3248

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

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

    
3263
    v_edge_pos = s->v_edge_pos >> field_based;
3264
    linesize = s->linesize << field_based;
3265
    uvlinesize = s->uvlinesize << field_based;
3266

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

    
3284
    uvdxy= (mx&1) | ((my&1)<<1);
3285
    mx>>=1;
3286
    my>>=1;
3287

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

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

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

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

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

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

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

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

    
3361
    dxy = ((my & 1) << 1) | (mx & 1);
3362
    mx >>= 1;
3363
    my >>= 1;
3364

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

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

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

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

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

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

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

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

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

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

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

    
3477
    mb_x = s->mb_x;
3478
    mb_y = s->mb_y;
3479

    
3480
    prefetch_motion(s, ref_picture, dir);
3481

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

    
3488
        assert(!s->mb_skipped);
3489

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

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

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

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

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

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

    
3540
        return;
3541
    }
3542

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3728
    mb_x = s->mb_x;
3729
    mb_y = s->mb_y;
3730

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3890
    s->mbintra_table[xy]= 0;
3891
}
3892

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

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

    
3914
    mb_x = s->mb_x;
3915
    mb_y = s->mb_y;
3916

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

    
3926
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3927

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

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

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

    
3958
            assert(age);
3959

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4149
#ifdef CONFIG_ENCODERS
4150

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

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

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

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

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

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

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

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

    
4224
        block[j]= level;
4225
    }
4226

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

    
4231
#endif //CONFIG_ENCODERS
4232

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

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

    
4248
        h= FFMIN(h, s->avctx->height - y);
4249

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

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

    
4269
        emms_c();
4270

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

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

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

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

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

    
4301
#ifdef CONFIG_ENCODERS
4302

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

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

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

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

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

    
4344
        s->lambda= s->lambda_table[mb_xy];
4345
        update_qscale(s);
4346

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

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

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

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

    
4376
    if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
4377
        uint8_t *ebuf= s->edge_emu_buffer + 32;
4378
        ff_emulated_edge_mc(ebuf            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
4379
        ptr_y= ebuf;
4380
        ff_emulated_edge_mc(ebuf+18*wrap_y  , ptr_cb, wrap_c, 8, mb_block_height, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
4381
        ptr_cb= ebuf+18*wrap_y;
4382
        ff_emulated_edge_mc(ebuf+18*wrap_y+8, ptr_cr, wrap_c, 8, mb_block_height, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
4383
        ptr_cr= ebuf+18*wrap_y+8;
4384
    }
4385

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

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

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

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

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

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

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

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

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

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

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

    
4457
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
4458

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

    
4463
                if(progressive_score > interlaced_score){
4464
                    s->interlaced_dct=1;
4465

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

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

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

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

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

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

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

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

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

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

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

    
4613
#endif //CONFIG_ENCODERS
4614

    
4615
void ff_mpeg_flush(AVCodecContext *avctx){
4616
    int i;
4617
    MpegEncContext *s = avctx->priv_data;
4618

    
4619
    if(s==NULL || s->picture==NULL)
4620
        return;
4621

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

    
4629
    s->mb_x= s->mb_y= 0;
4630

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

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