Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 5a6b9443

History | View | Annotate | Download (252 KB)

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

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

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

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

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

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

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

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

    
77

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

    
81
//#define DEBUG
82

    
83

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
201
    st->scantable= src_scantable;
202

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

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

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

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

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

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

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

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

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

    
262
    return p+4;
263
}
264

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

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

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

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

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

    
308
#endif //CONFIG_ENCODERS
309

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

    
323
    return 0;
324
}
325

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
607
    s->picture_in_gop_number = 0;
608

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

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

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

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

    
630
    MPV_common_defaults(s);
631

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
820
    s->context_initialized = 1;
821

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

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

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

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

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

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

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

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

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

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

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

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

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

    
925
#ifdef CONFIG_ENCODERS
926

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

    
934
    MPV_encode_defaults(s);
935

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1043
        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");
1044
    }
1045

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1137
    if(s->avctx->thread_count > 1)
1138
        s->rtp_mode= 1;
1139

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

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

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

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

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

    
1179
    if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1180
        s->intra_quant_bias= avctx->intra_quant_bias;
1181
    if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1182
        s->inter_quant_bias= avctx->inter_quant_bias;
1183

    
1184
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1185

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

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

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

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

    
1345
    s->encoding = 1;
1346

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

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

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

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

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

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

    
1400
    if(ff_rate_control_init(s) < 0)
1401
        return -1;
1402

    
1403
    return 0;
1404
}
1405

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

    
1410
    ff_rate_control_uninit(s);
1411

    
1412
    MPV_common_end(s);
1413
    if (s->out_format == FMT_MJPEG)
1414
        mjpeg_close(s);
1415

    
1416
    av_freep(&avctx->extradata);
1417

    
1418
    return 0;
1419
}
1420

    
1421
#endif //CONFIG_ENCODERS
1422

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

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

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

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

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

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

    
1503
int ff_find_unused_picture(MpegEncContext *s, int shared){
1504
    int i;
1505

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

    
1519
    assert(0);
1520
    return -1;
1521
}
1522

    
1523
static void update_noise_reduction(MpegEncContext *s){
1524
    int intra, i;
1525

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

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

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

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

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

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

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

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

    
1587
        pic->coded_picture_number= s->coded_picture_number++;
1588

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

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

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

    
1602
    copy_picture(&s->current_picture, s->current_picture_ptr);
1603

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

    
1615
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1616
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1617

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

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

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

    
1638
    s->hurry_up= s->avctx->hurry_up;
1639
    s->error_resilience= avctx->error_resilience;
1640

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

    
1654
    if(s->dct_error_sum){
1655
        assert(s->avctx->noise_reduction && s->encoding);
1656

    
1657
        update_noise_reduction(s);
1658
    }
1659

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

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

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

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

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

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

    
1733
    buf[sy*stride + sx]+= color;
1734

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

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

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

    
1782
    dx= ex - sx;
1783
    dy= ey - sy;
1784

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

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

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

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

    
1805
    if(!pict || !pict->mb_type) return;
1806

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

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

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

    
1871

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

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

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

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

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

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

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

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

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

    
1992

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

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

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

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

    
2061
#ifdef CONFIG_ENCODERS
2062

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

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

    
2073
    return acc;
2074
}
2075

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

    
2080
    w= s->width &~15;
2081
    h= s->height&~15;
2082

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

    
2090
            acc+= sae + 500 < sad;
2091
        }
2092
    }
2093
    return acc;
2094
}
2095

    
2096

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

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

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

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

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

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

    
2138
    if(direct){
2139
        i= ff_find_unused_picture(s, 1);
2140

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

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

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

    
2155
        alloc_picture(s, (Picture*)pic, 0);
2156

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

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

    
2175
                if(!s->avctx->rc_buffer_size)
2176
                    dst +=INPLACE_OFFSET;
2177

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

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

    
2198
    s->input_picture[encoding_delay]= (Picture*)pic;
2199

    
2200
    return 0;
2201
}
2202

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

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

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

    
2227
    if(score) score64= score;
2228

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

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

    
2247
    assert(scale>=0 && scale <=3);
2248

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

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

    
2267
    if (avcodec_open(c, codec) < 0)
2268
        return -1;
2269

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

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

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

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

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

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

    
2301
        if(!s->input_picture[j])
2302
            break;
2303

    
2304
        c->error[0]= c->error[1]= c->error[2]= 0;
2305

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

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

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

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

    
2326
        rd += c->error[0] + c->error[1] + c->error[2];
2327

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

    
2334
    av_freep(&outbuf);
2335
    avcodec_close(c);
2336
    av_freep(&c);
2337

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

    
2342
    return best_b_count;
2343
}
2344

    
2345
static void select_input_picture(MpegEncContext *s){
2346
    int i;
2347

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

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

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

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

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

    
2377
                    emms_c();
2378
                    ff_vbv_update(s, 0);
2379

    
2380
                    goto no_output_pic;
2381
                }
2382
            }
2383

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

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

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

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

    
2415
                b_frames= FFMAX(0, i-1);
2416

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

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

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

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

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

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

    
2472
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2473

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

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

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

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

    
2490
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2491

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

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

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

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

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

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

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

    
2530
    s->picture_in_gop_number++;
2531

    
2532
    if(load_input_picture(s, pic_arg) < 0)
2533
        return -1;
2534

    
2535
    select_input_picture(s);
2536

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

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

    
2557
        MPV_frame_end(s);
2558

    
2559
        if (s->out_format == FMT_MJPEG)
2560
            mjpeg_picture_trailer(s);
2561

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

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

    
2590
            assert(s->avctx->rc_max_rate);
2591
        }
2592

    
2593
        if(s->flags&CODEC_FLAG_PASS1)
2594
            ff_write_pass1_stats(s);
2595

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

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

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

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

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

    
2640
            assert(s->repeat_first_field==0);
2641

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

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

    
2659
    return s->frame_bits/8;
2660
}
2661

    
2662
#endif //CONFIG_ENCODERS
2663

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

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

    
2686
    linesize = s->linesize;
2687
    uvlinesize = s->uvlinesize;
2688

    
2689
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2690

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

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

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

    
2713
    if(s->flags&CODEC_FLAG_GRAY) return;
2714

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

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

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

    
2747
    return;
2748
}
2749

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

    
2759
    linesize = s->linesize;
2760
    uvlinesize = s->uvlinesize;
2761

    
2762
    ptr = ref_picture[0];
2763

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

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

    
2782
    if(s->flags&CODEC_FLAG_GRAY) return;
2783

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2941
    src += src_y * stride + src_x;
2942

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

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

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

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

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

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

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

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

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

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

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

    
3063
    pix_op[0][dxy](dest_y, ptr_y, linesize, h);
3064

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

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

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

    
3098
    if(field_based){
3099
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
3100
    }
3101

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

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

    
3128
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
3129
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3130
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3131

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

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

    
3154
    if(field_select){
3155
        ptr_y += s->linesize;
3156
        ptr_cb+= s->uvlinesize;
3157
        ptr_cr+= s->uvlinesize;
3158
    }
3159

    
3160
    sx <<= 2 - lowres;
3161
    sy <<= 2 - lowres;
3162
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
3163

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

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

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

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

    
3236
    assert(s->quarter_sample==0);
3237

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

    
3252
    put_obmc(dest, ptr, s->linesize);
3253
}
3254

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

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

    
3269
    v_edge_pos = s->v_edge_pos >> field_based;
3270
    linesize = s->linesize << field_based;
3271
    uvlinesize = s->uvlinesize << field_based;
3272

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

    
3290
    uvdxy= (mx&1) | ((my&1)<<1);
3291
    mx>>=1;
3292
    my>>=1;
3293

    
3294
    uvsrc_x = s->mb_x *  8                 + mx;
3295
    uvsrc_y = s->mb_y * (8 >> field_based) + my;
3296

    
3297
    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
3298
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3299
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3300

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

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

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

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

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

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

    
3367
    dxy = ((my & 1) << 1) | (mx & 1);
3368
    mx >>= 1;
3369
    my >>= 1;
3370

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

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

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

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

    
3413
    if(s->quarter_sample){
3414
        mx/=2;
3415
        my/=2;
3416
    }
3417

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

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

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

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

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

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

    
3483
    mb_x = s->mb_x;
3484
    mb_y = s->mb_y;
3485

    
3486
    prefetch_motion(s, ref_picture, dir);
3487

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

    
3494
        assert(!s->mb_skipped);
3495

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

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

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

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

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

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

    
3546
        return;
3547
    }
3548

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

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

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

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

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

    
3620
                mx += s->mv[dir][i][0];
3621
                my += s->mv[dir][i][1];
3622
            }
3623
        }
3624

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

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

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

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

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

    
3699
                // after put we make avg of the same block
3700
                pix_op=s->dsp.avg_pixels_tab;
3701

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

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

    
3734
    mb_x = s->mb_x;
3735
    mb_y = s->mb_y;
3736

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

    
3756
                mx += s->mv[dir][i][0];
3757
                my += s->mv[dir][i][1];
3758
            }
3759

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

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

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

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

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

    
3825
                // after put we make avg of the same block
3826
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3827

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

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

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

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

    
3862
        s->dsp.idct_add (dest, line_size, block);
3863
    }
3864
}
3865

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

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

    
3896
    s->mbintra_table[xy]= 0;
3897
}
3898

    
3899
/* generic function called after a macroblock has been parsed by the
3900
   decoder or after it has been encoded by the encoder.
3901

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

    
3920
    mb_x = s->mb_x;
3921
    mb_y = s->mb_y;
3922

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

    
3932
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3933

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

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

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

    
3964
            assert(age);
3965

    
3966
            if (s->mb_skipped) {
3967
                s->mb_skipped= 0;
3968
                assert(s->pict_type!=I_TYPE);
3969

    
3970
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
3971
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3972

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

    
3985
        dct_linesize = linesize << s->interlaced_dct;
3986
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3987

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

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

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

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

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

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

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

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

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

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

    
4124
                        dct_linesize = uvlinesize << s->interlaced_dct;
4125
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
4126

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

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

    
4155
#ifdef CONFIG_ENCODERS
4156

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

    
4175
    if(threshold<0){
4176
        skip_dc=0;
4177
        threshold= -threshold;
4178
    }else
4179
        skip_dc=1;
4180

    
4181
    /* are all which we could set to zero are allready zero? */
4182
    if(last_index<=skip_dc - 1) return;
4183

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

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

    
4213
    if(s->mb_intra){
4214
        i=1; //skip clipping of intra dc
4215
    }else
4216
        i=0;
4217

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

    
4222
        if     (level>maxlevel){
4223
            level=maxlevel;
4224
            overflow++;
4225
        }else if(level<minlevel){
4226
            level=minlevel;
4227
            overflow++;
4228
        }
4229

    
4230
        block[j]= level;
4231
    }
4232

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

    
4237
#endif //CONFIG_ENCODERS
4238

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

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

    
4254
        h= FFMIN(h, s->avctx->height - y);
4255

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

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

    
4275
        emms_c();
4276

    
4277
        s->avctx->draw_horiz_band(s->avctx, src, offset,
4278
                                  y, s->picture_structure, h);
4279
    }
4280
}
4281

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

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

    
4295
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
4296
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4297
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4298

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

    
4307
#ifdef CONFIG_ENCODERS
4308

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

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

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

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

    
4346
    if(s->adaptive_quant){
4347
        const int last_qp= s->qscale;
4348
        const int mb_xy= mb_x + mb_y*s->mb_stride;
4349

    
4350
        s->lambda= s->lambda_table[mb_xy];
4351
        update_qscale(s);
4352

    
4353
        if(!(s->flags&CODEC_FLAG_QP_RD)){
4354
            s->qscale= s->current_picture_ptr->qscale_table[mb_xy];
4355
            s->dquant= s->qscale - last_qp;
4356

    
4357
            if(s->out_format==FMT_H263){
4358
                s->dquant= av_clip(s->dquant, -2, 2);
4359

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

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

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

    
4392
    if (s->mb_intra) {
4393
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4394
            int progressive_score, interlaced_score;
4395

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

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

    
4406
                    dct_offset= wrap_y;
4407
                    wrap_y<<=1;
4408
                    if (s->chroma_format == CHROMA_422)
4409
                        wrap_c<<=1;
4410
                }
4411
            }
4412
        }
4413

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

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

    
4435
        dest_y  = s->dest[0];
4436
        dest_cb = s->dest[1];
4437
        dest_cr = s->dest[2];
4438

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

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

    
4456
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4457
            int progressive_score, interlaced_score;
4458

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

    
4463
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
4464

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

    
4469
                if(progressive_score > interlaced_score){
4470
                    s->interlaced_dct=1;
4471

    
4472
                    dct_offset= wrap_y;
4473
                    wrap_y<<=1;
4474
                    if (s->chroma_format == CHROMA_422)
4475
                        wrap_c<<=1;
4476
                }
4477
            }
4478
        }
4479

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

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

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

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

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

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

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

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

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

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

    
4619
#endif //CONFIG_ENCODERS
4620

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

    
4625
    if(s==NULL || s->picture==NULL)
4626
        return;
4627

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

    
4635
    s->mb_x= s->mb_y= 0;
4636

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