Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 137c8468

History | View | Annotate | Download (213 KB)

1
/*
2
 * The simplest mpeg encoder (well, it was the simplest!)
3
 * Copyright (c) 2000,2001 Fabrice Bellard.
4
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5
 *
6
 * This library is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2 of the License, or (at your option) any later version.
10
 *
11
 * This library is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with this library; if not, write to the Free Software
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
 *
20
 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
21
 */
22
 
23
/**
24
 * @file mpegvideo.c
25
 * The simplest mpeg encoder (well, it was the simplest!).
26
 */ 
27
 
28
#include <limits.h>
29
#include <math.h> //for PI
30
#include "avcodec.h"
31
#include "dsputil.h"
32
#include "mpegvideo.h"
33
#include "faandct.h"
34

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

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

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

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

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

    
74

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

    
78
//#define DEBUG
79

    
80

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

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

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

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

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

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

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

    
117
    for(qscale=qmin; qscale<=qmax; qscale++){
118
        int i;
119
        if (dsp->fdct == ff_jpeg_fdct_islow 
120
#ifdef FAAN_POSTSCALE
121
            || dsp->fdct == ff_faandct
122
#endif
123
            ) {
124
            for(i=0;i<64;i++) {
125
                const int j= dsp->idct_permutation[i];
126
                /* 16 <= qscale * quant_matrix[i] <= 7905 */
127
                /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
128
                /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
129
                /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
130
                
131
                qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / 
132
                                (qscale * quant_matrix[j]));
133
            }
134
        } else if (dsp->fdct == fdct_ifast
135
#ifndef FAAN_POSTSCALE
136
                   || dsp->fdct == ff_faandct
137
#endif
138
                   ) {
139
            for(i=0;i<64;i++) {
140
                const int j= dsp->idct_permutation[i];
141
                /* 16 <= qscale * quant_matrix[i] <= 7905 */
142
                /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
143
                /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
144
                /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
145
                
146
                qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) / 
147
                                (aanscales[i] * qscale * quant_matrix[j]));
148
            }
149
        } else {
150
            for(i=0;i<64;i++) {
151
                const int j= dsp->idct_permutation[i];
152
                /* We can safely suppose that 16 <= quant_matrix[i] <= 255
153
                   So 16           <= qscale * quant_matrix[i]             <= 7905
154
                   so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
155
                   so 32768        >= (1<<19) / (qscale * quant_matrix[i]) >= 67
156
                */
157
                qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
158
//                qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
159
                qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
160

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

    
168
static inline void update_qscale(MpegEncContext *s){
169
    s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
170
    s->qscale= clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
171
    
172
    s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
173
}
174
#endif //CONFIG_ENCODERS
175

    
176
void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
177
    int i;
178
    int end;
179
    
180
    st->scantable= src_scantable;
181

    
182
    for(i=0; i<64; i++){
183
        int j;
184
        j = src_scantable[i];
185
        st->permutated[i] = permutation[j];
186
#ifdef ARCH_POWERPC
187
        st->inverse[j] = i;
188
#endif
189
    }
190
    
191
    end=-1;
192
    for(i=0; i<64; i++){
193
        int j;
194
        j = st->permutated[i];
195
        if(j>end) end=j;
196
        st->raster_end[i]= end;
197
    }
198
}
199

    
200
#ifdef CONFIG_ENCODERS
201
void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
202
    int i;
203

    
204
    if(matrix){
205
        put_bits(pb, 1, 1);
206
        for(i=0;i<64;i++) {
207
            put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
208
        }
209
    }else
210
        put_bits(pb, 1, 0);
211
}
212
#endif //CONFIG_ENCODERS
213

    
214
/* init common dct for both encoder and decoder */
215
int DCT_common_init(MpegEncContext *s)
216
{
217
    s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
218
    s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
219
    s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
220
    s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
221
    s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
222
    s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
223

    
224
#ifdef CONFIG_ENCODERS
225
    s->dct_quantize= dct_quantize_c;
226
    s->denoise_dct= denoise_dct_c;
227
#endif
228
        
229
#ifdef HAVE_MMX
230
    MPV_common_init_mmx(s);
231
#endif
232
#ifdef ARCH_ALPHA
233
    MPV_common_init_axp(s);
234
#endif
235
#ifdef HAVE_MLIB
236
    MPV_common_init_mlib(s);
237
#endif
238
#ifdef HAVE_MMI
239
    MPV_common_init_mmi(s);
240
#endif
241
#ifdef ARCH_ARMV4L
242
    MPV_common_init_armv4l(s);
243
#endif
244
#ifdef ARCH_POWERPC
245
    MPV_common_init_ppc(s);
246
#endif
247

    
248
#ifdef CONFIG_ENCODERS
249
    s->fast_dct_quantize= s->dct_quantize;
250

    
251
    if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
252
        s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
253
    }
254

    
255
#endif //CONFIG_ENCODERS
256

    
257
    /* load & permutate scantables
258
       note: only wmv uses differnt ones 
259
    */
260
    if(s->alternate_scan){
261
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
262
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
263
    }else{
264
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
265
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
266
    }
267
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
268
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
269

    
270
    return 0;
271
}
272

    
273
static void copy_picture(Picture *dst, Picture *src){
274
    *dst = *src;
275
    dst->type= FF_BUFFER_TYPE_COPY;
276
}
277

    
278
static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
279
    int i;
280

    
281
    dst->pict_type              = src->pict_type;
282
    dst->quality                = src->quality;
283
    dst->coded_picture_number   = src->coded_picture_number;
284
    dst->display_picture_number = src->display_picture_number;
285
//    dst->reference              = src->reference;
286
    dst->pts                    = src->pts;
287
    dst->interlaced_frame       = src->interlaced_frame;
288
    dst->top_field_first        = src->top_field_first;
289

    
290
    if(src->motion_val[0] && src->motion_val[0] != dst->motion_val[0]){
291
        if(src->motion_subsample_log2 != dst->motion_subsample_log2)
292
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesnt match!\n");
293
        else{
294
            int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
295
            int height= ((16*s->mb_height)>>src->motion_subsample_log2);
296

    
297
            for(i=0; i<2; i++)
298
                memcpy(dst->motion_val[i], src->motion_val[i], stride*height*sizeof(int16_t));
299
        }
300
    }
301
}
302

    
303
/**
304
 * allocates a Picture
305
 * The pixels are allocated/set by calling get_buffer() if shared=0
306
 */
307
static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
308
    const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
309
    const int mb_array_size= s->mb_stride*s->mb_height;
310
    const int b8_array_size= s->b8_stride*s->mb_height*2;
311
    const int b4_array_size= s->b4_stride*s->mb_height*4;
312
    int i;
313
    
314
    if(shared){
315
        assert(pic->data[0]);
316
        assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
317
        pic->type= FF_BUFFER_TYPE_SHARED;
318
    }else{
319
        int r;
320
        
321
        assert(!pic->data[0]);
322
        
323
        r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
324
        
325
        if(r<0 || !pic->age || !pic->type || !pic->data[0]){
326
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
327
            return -1;
328
        }
329

    
330
        if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
331
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
332
            return -1;
333
        }
334

    
335
        if(pic->linesize[1] != pic->linesize[2]){
336
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride missmatch)\n");
337
            return -1;
338
        }
339

    
340
        s->linesize  = pic->linesize[0];
341
        s->uvlinesize= pic->linesize[1];
342
    }
343
    
344
    if(pic->qscale_table==NULL){
345
        if (s->encoding) {        
346
            CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
347
            CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
348
            CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
349
        }
350

    
351
        CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
352
        CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
353
        CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num    * sizeof(uint32_t))
354
        pic->mb_type= pic->mb_type_base + s->mb_stride+1;
355
        if(s->out_format == FMT_H264){
356
            for(i=0; i<2; i++){
357
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+2)  * sizeof(int16_t))
358
                pic->motion_val[i]= pic->motion_val_base[i]+2;
359
                CHECKED_ALLOCZ(pic->ref_index[i] , b8_array_size * sizeof(uint8_t))
360
            }
361
            pic->motion_subsample_log2= 2;
362
        }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
363
            for(i=0; i<2; i++){
364
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+2) * sizeof(int16_t))
365
                pic->motion_val[i]= pic->motion_val_base[i]+2;
366
            }
367
            pic->motion_subsample_log2= 3;
368
        }
369
        if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
370
            CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
371
        }
372
        pic->qstride= s->mb_stride;
373
        CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
374
    }
375

    
376
    //it might be nicer if the application would keep track of these but it would require a API change
377
    memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
378
    s->prev_pict_types[0]= s->pict_type;
379
    if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
380
        pic->age= INT_MAX; // skiped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
381
    
382
    return 0;
383
fail: //for the CHECKED_ALLOCZ macro
384
    return -1;
385
}
386

    
387
/**
388
 * deallocates a picture
389
 */
390
static void free_picture(MpegEncContext *s, Picture *pic){
391
    int i;
392

    
393
    if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
394
        s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
395
    }
396

    
397
    av_freep(&pic->mb_var);
398
    av_freep(&pic->mc_mb_var);
399
    av_freep(&pic->mb_mean);
400
    av_freep(&pic->mbskip_table);
401
    av_freep(&pic->qscale_table);
402
    av_freep(&pic->mb_type_base);
403
    av_freep(&pic->dct_coeff);
404
    av_freep(&pic->pan_scan);
405
    pic->mb_type= NULL;
406
    for(i=0; i<2; i++){
407
        av_freep(&pic->motion_val_base[i]);
408
        av_freep(&pic->ref_index[i]);
409
    }
410
    
411
    if(pic->type == FF_BUFFER_TYPE_SHARED){
412
        for(i=0; i<4; i++){
413
            pic->base[i]=
414
            pic->data[i]= NULL;
415
        }
416
        pic->type= 0;        
417
    }
418
}
419

    
420
static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
421
    int i;
422

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

    
427
     //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
428
    CHECKED_ALLOCZ(s->me.scratchpad,  (s->width+64)*2*16*2*sizeof(uint8_t)) 
429
    s->rd_scratchpad=   s->me.scratchpad;
430
    s->b_scratchpad=    s->me.scratchpad;
431
    s->obmc_scratchpad= s->me.scratchpad + 16;
432
    if (s->encoding) {
433
        CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
434
        CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
435
        if(s->avctx->noise_reduction){
436
            CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
437
        }
438
    }   
439
    CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
440
    s->block= s->blocks[0];
441

    
442
    for(i=0;i<12;i++){
443
        s->pblocks[i] = (short *)(&s->block[i]);
444
    }
445
    return 0;
446
fail:
447
    return -1; //free() through MPV_common_end()
448
}
449

    
450
static void free_duplicate_context(MpegEncContext *s){
451
    if(s==NULL) return;
452

    
453
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
454
    av_freep(&s->me.scratchpad);
455
    s->rd_scratchpad=   
456
    s->b_scratchpad=    
457
    s->obmc_scratchpad= NULL;
458
    
459
    av_freep(&s->dct_error_sum);
460
    av_freep(&s->me.map);
461
    av_freep(&s->me.score_map);
462
    av_freep(&s->blocks);
463
    s->block= NULL;
464
}
465

    
466
static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
467
#define COPY(a) bak->a= src->a
468
    COPY(allocated_edge_emu_buffer);
469
    COPY(edge_emu_buffer);
470
    COPY(me.scratchpad);
471
    COPY(rd_scratchpad);
472
    COPY(b_scratchpad);
473
    COPY(obmc_scratchpad);
474
    COPY(me.map);
475
    COPY(me.score_map);
476
    COPY(blocks);
477
    COPY(block);
478
    COPY(start_mb_y);
479
    COPY(end_mb_y);
480
    COPY(me.map_generation);
481
    COPY(pb);
482
    COPY(dct_error_sum);
483
    COPY(dct_count[0]);
484
    COPY(dct_count[1]);
485
#undef COPY
486
}
487

    
488
void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
489
    MpegEncContext bak;
490
    int i;
491
    //FIXME copy only needed parts
492
//START_TIMER
493
    backup_duplicate_context(&bak, dst);
494
    memcpy(dst, src, sizeof(MpegEncContext));
495
    backup_duplicate_context(dst, &bak);
496
    for(i=0;i<12;i++){
497
        dst->pblocks[i] = (short *)(&dst->block[i]);
498
    }
499
//STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
500
}
501

    
502
static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
503
#define COPY(a) dst->a= src->a
504
    COPY(pict_type);
505
    COPY(current_picture);
506
    COPY(f_code);
507
    COPY(b_code);
508
    COPY(qscale);
509
    COPY(lambda);
510
    COPY(lambda2);
511
    COPY(picture_in_gop_number);
512
    COPY(gop_picture_number);
513
    COPY(frame_pred_frame_dct); //FIXME dont set in encode_header
514
    COPY(progressive_frame); //FIXME dont set in encode_header
515
    COPY(partitioned_frame); //FIXME dont set in encode_header
516
#undef COPY
517
}
518

    
519
/**
520
 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
521
 * the changed fields will not depend upon the prior state of the MpegEncContext.
522
 */
523
static void MPV_common_defaults(MpegEncContext *s){
524
    s->y_dc_scale_table=
525
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
526
    s->chroma_qscale_table= ff_default_chroma_qscale_table;
527
    s->progressive_frame= 1;
528
    s->progressive_sequence= 1;
529
    s->picture_structure= PICT_FRAME;
530

    
531
    s->coded_picture_number = 0;
532
    s->picture_number = 0;
533
    s->input_picture_number = 0;
534

    
535
    s->picture_in_gop_number = 0;
536

    
537
    s->f_code = 1;
538
    s->b_code = 1;
539
}
540

    
541
/**
542
 * sets the given MpegEncContext to defaults for decoding.
543
 * the changed fields will not depend upon the prior state of the MpegEncContext.
544
 */
545
void MPV_decode_defaults(MpegEncContext *s){
546
    MPV_common_defaults(s);
547
}
548

    
549
/**
550
 * sets the given MpegEncContext to defaults for encoding.
551
 * the changed fields will not depend upon the prior state of the MpegEncContext.
552
 */
553

    
554
#ifdef CONFIG_ENCODERS
555
void MPV_encode_defaults(MpegEncContext *s){
556
    static int done=0;
557
    
558
    MPV_common_defaults(s);
559
    
560
    if(!done){
561
        int i;
562
        done=1;
563

    
564
        default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
565
        memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
566
        memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
567

    
568
        for(i=-16; i<16; i++){
569
            default_fcode_tab[i + MAX_MV]= 1;
570
        }
571
    }
572
    s->me.mv_penalty= default_mv_penalty;
573
    s->fcode_tab= default_fcode_tab;
574
}
575
#endif //CONFIG_ENCODERS
576

    
577
/** 
578
 * init common structure for both encoder and decoder.
579
 * this assumes that some variables like width/height are already set
580
 */
581
int MPV_common_init(MpegEncContext *s)
582
{
583
    int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
584

    
585
    dsputil_init(&s->dsp, s->avctx);
586
    DCT_common_init(s);
587

    
588
    s->flags= s->avctx->flags;
589
    s->flags2= s->avctx->flags2;
590

    
591
    s->mb_width  = (s->width  + 15) / 16;
592
    s->mb_height = (s->height + 15) / 16;
593
    s->mb_stride = s->mb_width + 1;
594
    s->b8_stride = s->mb_width*2 + 1;
595
    s->b4_stride = s->mb_width*4 + 1;
596
    mb_array_size= s->mb_height * s->mb_stride;
597
    mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
598

    
599
    /* set default edge pos, will be overriden in decode_header if needed */
600
    s->h_edge_pos= s->mb_width*16;
601
    s->v_edge_pos= s->mb_height*16;
602

    
603
    s->mb_num = s->mb_width * s->mb_height;
604
    
605
    s->block_wrap[0]=
606
    s->block_wrap[1]=
607
    s->block_wrap[2]=
608
    s->block_wrap[3]= s->b8_stride;
609
    s->block_wrap[4]=
610
    s->block_wrap[5]= s->mb_stride;
611
 
612
    y_size = s->b8_stride * (2 * s->mb_height + 1);
613
    c_size = s->mb_stride * (s->mb_height + 1);
614
    yc_size = y_size + 2 * c_size;
615
    
616
    /* convert fourcc to upper case */
617
    s->avctx->codec_tag=   toupper( s->avctx->codec_tag     &0xFF)          
618
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
619
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16) 
620
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
621

    
622
    s->avctx->stream_codec_tag=   toupper( s->avctx->stream_codec_tag     &0xFF)          
623
                               + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
624
                               + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16) 
625
                               + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
626

    
627
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
628

    
629
    CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
630
    for(y=0; y<s->mb_height; y++){
631
        for(x=0; x<s->mb_width; x++){
632
            s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
633
        }
634
    }
635
    s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
636
    
637
    if (s->encoding) {
638
        /* Allocate MV tables */
639
        CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
640
        CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
641
        CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
642
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
643
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
644
        CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
645
        s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
646
        s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
647
        s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
648
        s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
649
        s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
650
        s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
651

    
652
        if(s->msmpeg4_version){
653
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
654
        }
655
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
656

    
657
        /* Allocate MB type table */
658
        CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint16_t)) //needed for encoding
659
        
660
        CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
661
        
662
        CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
663
        CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
664
        CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
665
        CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
666
        CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
667
        CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
668
        
669
        if(s->avctx->noise_reduction){
670
            CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
671
        }
672
    }
673
    CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
674

    
675
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
676
    
677
    if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
678
        /* interlaced direct mode decoding tables */
679
            for(i=0; i<2; i++){
680
                int j, k;
681
                for(j=0; j<2; j++){
682
                    for(k=0; k<2; k++){
683
                        CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k]     , mv_table_size * 2 * sizeof(int16_t))
684
                        s->b_field_mv_table[i][j][k]    = s->b_field_mv_table_base[i][j][k]     + s->mb_stride + 1;
685
                    }
686
                    CHECKED_ALLOCZ(s->b_field_select_table[i][j]     , mb_array_size * 2 * sizeof(uint8_t))
687
                    CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j]     , mv_table_size * 2 * sizeof(int16_t))
688
                    s->p_field_mv_table[i][j]    = s->p_field_mv_table_base[i][j]     + s->mb_stride + 1;
689
                }
690
                CHECKED_ALLOCZ(s->p_field_select_table[i]      , mb_array_size * 2 * sizeof(uint8_t))
691
            }
692
    }
693
    if (s->out_format == FMT_H263) {
694
        /* ac values */
695
        CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
696
        s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
697
        s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
698
        s->ac_val[2] = s->ac_val[1] + c_size;
699
        
700
        /* cbp values */
701
        CHECKED_ALLOCZ(s->coded_block_base, y_size);
702
        s->coded_block= s->coded_block_base + s->b8_stride + 1;
703
        
704
        /* divx501 bitstream reorder buffer */
705
        CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
706

    
707
        /* cbp, ac_pred, pred_dir */
708
        CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
709
        CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
710
    }
711
    
712
    if (s->h263_pred || s->h263_plus || !s->encoding) {
713
        /* dc values */
714
        //MN: we need these for error resilience of intra-frames
715
        CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
716
        s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
717
        s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
718
        s->dc_val[2] = s->dc_val[1] + c_size;
719
        for(i=0;i<yc_size;i++)
720
            s->dc_val_base[i] = 1024;
721
    }
722

    
723
    /* which mb is a intra block */
724
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
725
    memset(s->mbintra_table, 1, mb_array_size);
726
    
727
    /* init macroblock skip table */
728
    CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
729
    //Note the +1 is for a quicker mpeg4 slice_end detection
730
    CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
731
    
732
    s->parse_context.state= -1;
733
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
734
       s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
735
       s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
736
       s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
737
    }
738

    
739
    s->context_initialized = 1;
740

    
741
    s->thread_context[0]= s;
742
    for(i=1; i<s->avctx->thread_count; i++){
743
        s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
744
        memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
745
    }
746

    
747
    for(i=0; i<s->avctx->thread_count; i++){
748
        if(init_duplicate_context(s->thread_context[i], s) < 0)
749
           goto fail;
750
        s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
751
        s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
752
    }
753

    
754
    return 0;
755
 fail:
756
    MPV_common_end(s);
757
    return -1;
758
}
759

    
760
/* init common structure for both encoder and decoder */
761
void MPV_common_end(MpegEncContext *s)
762
{
763
    int i, j, k;
764

    
765
    for(i=0; i<s->avctx->thread_count; i++){
766
        free_duplicate_context(s->thread_context[i]);
767
    }
768
    for(i=1; i<s->avctx->thread_count; i++){
769
        av_freep(&s->thread_context[i]);
770
    }
771

    
772
    av_freep(&s->parse_context.buffer);
773
    s->parse_context.buffer_size=0;
774

    
775
    av_freep(&s->mb_type);
776
    av_freep(&s->p_mv_table_base);
777
    av_freep(&s->b_forw_mv_table_base);
778
    av_freep(&s->b_back_mv_table_base);
779
    av_freep(&s->b_bidir_forw_mv_table_base);
780
    av_freep(&s->b_bidir_back_mv_table_base);
781
    av_freep(&s->b_direct_mv_table_base);
782
    s->p_mv_table= NULL;
783
    s->b_forw_mv_table= NULL;
784
    s->b_back_mv_table= NULL;
785
    s->b_bidir_forw_mv_table= NULL;
786
    s->b_bidir_back_mv_table= NULL;
787
    s->b_direct_mv_table= NULL;
788
    for(i=0; i<2; i++){
789
        for(j=0; j<2; j++){
790
            for(k=0; k<2; k++){
791
                av_freep(&s->b_field_mv_table_base[i][j][k]);
792
                s->b_field_mv_table[i][j][k]=NULL;
793
            }
794
            av_freep(&s->b_field_select_table[i][j]);
795
            av_freep(&s->p_field_mv_table_base[i][j]);
796
            s->p_field_mv_table[i][j]=NULL;
797
        }
798
        av_freep(&s->p_field_select_table[i]);
799
    }
800
    
801
    av_freep(&s->dc_val_base);
802
    av_freep(&s->ac_val_base);
803
    av_freep(&s->coded_block_base);
804
    av_freep(&s->mbintra_table);
805
    av_freep(&s->cbp_table);
806
    av_freep(&s->pred_dir_table);
807
    
808
    av_freep(&s->mbskip_table);
809
    av_freep(&s->prev_pict_types);
810
    av_freep(&s->bitstream_buffer);
811
    av_freep(&s->avctx->stats_out);
812
    av_freep(&s->ac_stats);
813
    av_freep(&s->error_status_table);
814
    av_freep(&s->mb_index2xy);
815
    av_freep(&s->lambda_table);
816
    av_freep(&s->q_intra_matrix);
817
    av_freep(&s->q_inter_matrix);
818
    av_freep(&s->q_intra_matrix16);
819
    av_freep(&s->q_inter_matrix16);
820
    av_freep(&s->input_picture);
821
    av_freep(&s->reordered_input_picture);
822
    av_freep(&s->dct_offset);
823

    
824
    if(s->picture){
825
        for(i=0; i<MAX_PICTURE_COUNT; i++){
826
            free_picture(s, &s->picture[i]);
827
        }
828
    }
829
    av_freep(&s->picture);
830
    avcodec_default_free_buffers(s->avctx);
831
    s->context_initialized = 0;
832
    s->last_picture_ptr=
833
    s->next_picture_ptr=
834
    s->current_picture_ptr= NULL;
835

    
836
    for(i=0; i<3; i++)
837
        av_freep(&s->visualization_buffer[i]);
838
}
839

    
840
#ifdef CONFIG_ENCODERS
841

    
842
/* init video encoder */
843
int MPV_encode_init(AVCodecContext *avctx)
844
{
845
    MpegEncContext *s = avctx->priv_data;
846
    int i, dummy;
847
    int chroma_h_shift, chroma_v_shift;
848
    
849
    MPV_encode_defaults(s);
850

    
851
    avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME
852

    
853
    s->bit_rate = avctx->bit_rate;
854
    s->width = avctx->width;
855
    s->height = avctx->height;
856
    if(avctx->gop_size > 600){
857
        av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
858
        avctx->gop_size=600;
859
    }
860
    s->gop_size = avctx->gop_size;
861
    s->avctx = avctx;
862
    s->flags= avctx->flags;
863
    s->flags2= avctx->flags2;
864
    s->max_b_frames= avctx->max_b_frames;
865
    s->codec_id= avctx->codec->id;
866
    s->luma_elim_threshold  = avctx->luma_elim_threshold;
867
    s->chroma_elim_threshold= avctx->chroma_elim_threshold;
868
    s->strict_std_compliance= avctx->strict_std_compliance;
869
    s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
870
    s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
871
    s->mpeg_quant= avctx->mpeg_quant;
872
    s->rtp_mode= !!avctx->rtp_payload_size;
873

    
874
    if (s->gop_size <= 1) {
875
        s->intra_only = 1;
876
        s->gop_size = 12;
877
    } else {
878
        s->intra_only = 0;
879
    }
880

    
881
    s->me_method = avctx->me_method;
882

    
883
    /* Fixed QSCALE */
884
    s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
885
    
886
    s->adaptive_quant= (   s->avctx->lumi_masking
887
                        || s->avctx->dark_masking
888
                        || s->avctx->temporal_cplx_masking 
889
                        || s->avctx->spatial_cplx_masking
890
                        || s->avctx->p_masking
891
                        || (s->flags&CODEC_FLAG_QP_RD))
892
                       && !s->fixed_qscale;
893
    
894
    s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
895
    s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
896
    s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
897

    
898
    if(avctx->rc_max_rate && !avctx->rc_buffer_size){
899
        av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
900
        return -1;
901
    }    
902

    
903
    if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
904
        av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isnt recommanded!\n");
905
    }
906
    
907
    if(   s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate 
908
       && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
909
       && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
910
        
911
        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");
912
    }
913
       
914
    if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 
915
       && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
916
        av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
917
        return -1;
918
    }
919
        
920
    if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
921
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decission\n");
922
        return -1;
923
    }
924
    
925
    if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
926
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
927
        return -1;
928
    }
929
    
930
    if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
931
        av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
932
        return -1;
933
    }
934

    
935
    if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
936
        av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
937
        return -1;
938
    }
939
    
940
    if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
941
        av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
942
        return -1;
943
    }
944
    
945
    if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
946
        av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n");
947
        return -1;
948
    }
949
        
950
    if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
951
        av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
952
        return -1;
953
    }
954

    
955
    if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
956
        av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
957
        return -1;
958
    }
959
    
960
    if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
961
        av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
962
        return -1;
963
    }
964
    
965
    if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4 
966
       && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO 
967
       && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
968
        av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
969
        return -1;
970
    }
971
    
972
    if(s->avctx->thread_count > MAX_THREADS || 16*s->avctx->thread_count > s->height){
973
        av_log(avctx, AV_LOG_ERROR, "too many threads\n");
974
        return -1;
975
    }
976
    
977
    if(s->avctx->thread_count > 1)
978
        s->rtp_mode= 1;
979

    
980
    i= ff_gcd(avctx->frame_rate, avctx->frame_rate_base);
981
    if(i > 1){
982
        av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
983
        avctx->frame_rate /= i;
984
        avctx->frame_rate_base /= i;
985
//        return -1;
986
    }
987
    
988
    if(s->codec_id==CODEC_ID_MJPEG){
989
        s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
990
        s->inter_quant_bias= 0;
991
    }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
992
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
993
        s->inter_quant_bias= 0;
994
    }else{
995
        s->intra_quant_bias=0;
996
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
997
    }
998
    
999
    if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1000
        s->intra_quant_bias= avctx->intra_quant_bias;
1001
    if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1002
        s->inter_quant_bias= avctx->inter_quant_bias;
1003
        
1004
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1005

    
1006
    av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1007
    s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1008

    
1009
    switch(avctx->codec->id) {
1010
    case CODEC_ID_MPEG1VIDEO:
1011
        s->out_format = FMT_MPEG1;
1012
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1013
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1014
        break;
1015
    case CODEC_ID_MPEG2VIDEO:
1016
        s->out_format = FMT_MPEG1;
1017
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1018
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1019
        s->rtp_mode= 1;
1020
        break;
1021
    case CODEC_ID_LJPEG:
1022
    case CODEC_ID_MJPEG:
1023
        s->out_format = FMT_MJPEG;
1024
        s->intra_only = 1; /* force intra only for jpeg */
1025
        s->mjpeg_write_tables = 1; /* write all tables */
1026
        s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1027
        s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1028
        s->mjpeg_vsample[1] = 1;
1029
        s->mjpeg_vsample[2] = 1; 
1030
        s->mjpeg_hsample[0] = 1<<chroma_h_shift;
1031
        s->mjpeg_hsample[1] = 1; 
1032
        s->mjpeg_hsample[2] = 1; 
1033
        if (mjpeg_init(s) < 0)
1034
            return -1;
1035
        avctx->delay=0;
1036
        s->low_delay=1;
1037
        break;
1038
#ifdef CONFIG_RISKY
1039
    case CODEC_ID_H263:
1040
        if (h263_get_picture_format(s->width, s->height) == 7) {
1041
            av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
1042
            return -1;
1043
        }
1044
        s->out_format = FMT_H263;
1045
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1046
        avctx->delay=0;
1047
        s->low_delay=1;
1048
        break;
1049
    case CODEC_ID_H263P:
1050
        s->out_format = FMT_H263;
1051
        s->h263_plus = 1;
1052
        /* Fx */
1053
        s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1054
        s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1055
        s->modified_quant= s->h263_aic;
1056
        s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1057
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1058
        s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1059
        s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1060
        s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1061

    
1062
        /* /Fx */
1063
        /* These are just to be sure */
1064
        avctx->delay=0;
1065
        s->low_delay=1;
1066
        break;
1067
    case CODEC_ID_FLV1:
1068
        s->out_format = FMT_H263;
1069
        s->h263_flv = 2; /* format = 1; 11-bit codes */
1070
        s->unrestricted_mv = 1;
1071
        s->rtp_mode=0; /* don't allow GOB */
1072
        avctx->delay=0;
1073
        s->low_delay=1;
1074
        break;
1075
    case CODEC_ID_RV10:
1076
        s->out_format = FMT_H263;
1077
        avctx->delay=0;
1078
        s->low_delay=1;
1079
        break;
1080
    case CODEC_ID_MPEG4:
1081
        s->out_format = FMT_H263;
1082
        s->h263_pred = 1;
1083
        s->unrestricted_mv = 1;
1084
        s->low_delay= s->max_b_frames ? 0 : 1;
1085
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1086
        break;
1087
    case CODEC_ID_MSMPEG4V1:
1088
        s->out_format = FMT_H263;
1089
        s->h263_msmpeg4 = 1;
1090
        s->h263_pred = 1;
1091
        s->unrestricted_mv = 1;
1092
        s->msmpeg4_version= 1;
1093
        avctx->delay=0;
1094
        s->low_delay=1;
1095
        break;
1096
    case CODEC_ID_MSMPEG4V2:
1097
        s->out_format = FMT_H263;
1098
        s->h263_msmpeg4 = 1;
1099
        s->h263_pred = 1;
1100
        s->unrestricted_mv = 1;
1101
        s->msmpeg4_version= 2;
1102
        avctx->delay=0;
1103
        s->low_delay=1;
1104
        break;
1105
    case CODEC_ID_MSMPEG4V3:
1106
        s->out_format = FMT_H263;
1107
        s->h263_msmpeg4 = 1;
1108
        s->h263_pred = 1;
1109
        s->unrestricted_mv = 1;
1110
        s->msmpeg4_version= 3;
1111
        s->flipflop_rounding=1;
1112
        avctx->delay=0;
1113
        s->low_delay=1;
1114
        break;
1115
    case CODEC_ID_WMV1:
1116
        s->out_format = FMT_H263;
1117
        s->h263_msmpeg4 = 1;
1118
        s->h263_pred = 1;
1119
        s->unrestricted_mv = 1;
1120
        s->msmpeg4_version= 4;
1121
        s->flipflop_rounding=1;
1122
        avctx->delay=0;
1123
        s->low_delay=1;
1124
        break;
1125
    case CODEC_ID_WMV2:
1126
        s->out_format = FMT_H263;
1127
        s->h263_msmpeg4 = 1;
1128
        s->h263_pred = 1;
1129
        s->unrestricted_mv = 1;
1130
        s->msmpeg4_version= 5;
1131
        s->flipflop_rounding=1;
1132
        avctx->delay=0;
1133
        s->low_delay=1;
1134
        break;
1135
#endif
1136
    default:
1137
        return -1;
1138
    }
1139

    
1140
    s->encoding = 1;
1141

    
1142
    /* init */
1143
    if (MPV_common_init(s) < 0)
1144
        return -1;
1145

    
1146
    if(s->modified_quant)
1147
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1148
    s->progressive_frame= 
1149
    s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1150
    s->quant_precision=5;
1151
    
1152
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1153
    
1154
    ff_init_me(s);
1155

    
1156
#ifdef CONFIG_ENCODERS
1157
#ifdef CONFIG_RISKY
1158
    if (s->out_format == FMT_H263)
1159
        h263_encode_init(s);
1160
    if(s->msmpeg4_version)
1161
        ff_msmpeg4_encode_init(s);
1162
#endif
1163
    if (s->out_format == FMT_MPEG1)
1164
        ff_mpeg1_encode_init(s);
1165
#endif
1166

    
1167
    /* init q matrix */
1168
    for(i=0;i<64;i++) {
1169
        int j= s->dsp.idct_permutation[i];
1170
#ifdef CONFIG_RISKY
1171
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1172
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1173
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1174
        }else if(s->out_format == FMT_H263){
1175
            s->intra_matrix[j] =
1176
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1177
        }else
1178
#endif
1179
        { /* mpeg1/2 */
1180
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1181
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1182
        }
1183
        if(s->avctx->intra_matrix)
1184
            s->intra_matrix[j] = s->avctx->intra_matrix[i];
1185
        if(s->avctx->inter_matrix)
1186
            s->inter_matrix[j] = s->avctx->inter_matrix[i];
1187
    }
1188

    
1189
    /* precompute matrix */
1190
    /* for mjpeg, we do include qscale in the matrix */
1191
    if (s->out_format != FMT_MJPEG) {
1192
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 
1193
                       s->intra_matrix, s->intra_quant_bias, 1, 31);
1194
        convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, 
1195
                       s->inter_matrix, s->inter_quant_bias, 1, 31);
1196
    }
1197

    
1198
    if(ff_rate_control_init(s) < 0)
1199
        return -1;
1200
    
1201
    return 0;
1202
}
1203

    
1204
int MPV_encode_end(AVCodecContext *avctx)
1205
{
1206
    MpegEncContext *s = avctx->priv_data;
1207

    
1208
#ifdef STATS
1209
    print_stats();
1210
#endif
1211

    
1212
    ff_rate_control_uninit(s);
1213

    
1214
    MPV_common_end(s);
1215
    if (s->out_format == FMT_MJPEG)
1216
        mjpeg_close(s);
1217

    
1218
    av_freep(&avctx->extradata);
1219
      
1220
    return 0;
1221
}
1222

    
1223
#endif //CONFIG_ENCODERS
1224

    
1225
void init_rl(RLTable *rl)
1226
{
1227
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1228
    uint8_t index_run[MAX_RUN+1];
1229
    int last, run, level, start, end, i;
1230

    
1231
    /* compute max_level[], max_run[] and index_run[] */
1232
    for(last=0;last<2;last++) {
1233
        if (last == 0) {
1234
            start = 0;
1235
            end = rl->last;
1236
        } else {
1237
            start = rl->last;
1238
            end = rl->n;
1239
        }
1240

    
1241
        memset(max_level, 0, MAX_RUN + 1);
1242
        memset(max_run, 0, MAX_LEVEL + 1);
1243
        memset(index_run, rl->n, MAX_RUN + 1);
1244
        for(i=start;i<end;i++) {
1245
            run = rl->table_run[i];
1246
            level = rl->table_level[i];
1247
            if (index_run[run] == rl->n)
1248
                index_run[run] = i;
1249
            if (level > max_level[run])
1250
                max_level[run] = level;
1251
            if (run > max_run[level])
1252
                max_run[level] = run;
1253
        }
1254
        rl->max_level[last] = av_malloc(MAX_RUN + 1);
1255
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1256
        rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1257
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1258
        rl->index_run[last] = av_malloc(MAX_RUN + 1);
1259
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1260
    }
1261
}
1262

    
1263
/* draw the edges of width 'w' of an image of size width, height */
1264
//FIXME check that this is ok for mpeg4 interlaced
1265
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1266
{
1267
    uint8_t *ptr, *last_line;
1268
    int i;
1269

    
1270
    last_line = buf + (height - 1) * wrap;
1271
    for(i=0;i<w;i++) {
1272
        /* top and bottom */
1273
        memcpy(buf - (i + 1) * wrap, buf, width);
1274
        memcpy(last_line + (i + 1) * wrap, last_line, width);
1275
    }
1276
    /* left and right */
1277
    ptr = buf;
1278
    for(i=0;i<height;i++) {
1279
        memset(ptr - w, ptr[0], w);
1280
        memset(ptr + width, ptr[width-1], w);
1281
        ptr += wrap;
1282
    }
1283
    /* corners */
1284
    for(i=0;i<w;i++) {
1285
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1286
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1287
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1288
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1289
    }
1290
}
1291

    
1292
int ff_find_unused_picture(MpegEncContext *s, int shared){
1293
    int i;
1294
    
1295
    if(shared){
1296
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1297
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1298
        }
1299
    }else{
1300
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1301
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1302
        }
1303
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1304
            if(s->picture[i].data[0]==NULL) return i;
1305
        }
1306
    }
1307

    
1308
    assert(0);
1309
    return -1;
1310
}
1311

    
1312
static void update_noise_reduction(MpegEncContext *s){
1313
    int intra, i;
1314

    
1315
    for(intra=0; intra<2; intra++){
1316
        if(s->dct_count[intra] > (1<<16)){
1317
            for(i=0; i<64; i++){
1318
                s->dct_error_sum[intra][i] >>=1;
1319
            }
1320
            s->dct_count[intra] >>= 1;
1321
        }
1322
        
1323
        for(i=0; i<64; i++){
1324
            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);
1325
        }
1326
    }
1327
}
1328

    
1329
/**
1330
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1331
 */
1332
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1333
{
1334
    int i;
1335
    AVFrame *pic;
1336
    s->mb_skiped = 0;
1337

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

    
1340
    /* mark&release old frames */
1341
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr->data[0]) {
1342
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1343

    
1344
        /* release forgotten pictures */
1345
        /* if(mpeg124/h263) */
1346
        if(!s->encoding){
1347
            for(i=0; i<MAX_PICTURE_COUNT; i++){
1348
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1349
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1350
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
1351
                }
1352
            }
1353
        }
1354
    }
1355
alloc:
1356
    if(!s->encoding){
1357
        /* release non refernce frames */
1358
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1359
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1360
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1361
            }
1362
        }
1363

    
1364
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1365
            pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1366
        else{
1367
            i= ff_find_unused_picture(s, 0);
1368
            pic= (AVFrame*)&s->picture[i];
1369
        }
1370

    
1371
        pic->reference= s->pict_type != B_TYPE ? 3 : 0;
1372

    
1373
        pic->coded_picture_number= s->coded_picture_number++;
1374
        
1375
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1376
            return -1;
1377

    
1378
        s->current_picture_ptr= (Picture*)pic;
1379
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1380
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1381
    }
1382

    
1383
    s->current_picture_ptr->pict_type= s->pict_type;
1384
//    if(s->flags && CODEC_FLAG_QSCALE) 
1385
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1386
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1387

    
1388
    copy_picture(&s->current_picture, s->current_picture_ptr);
1389
  
1390
  if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1391
    if (s->pict_type != B_TYPE) {
1392
        s->last_picture_ptr= s->next_picture_ptr;
1393
        s->next_picture_ptr= s->current_picture_ptr;
1394
    }
1395
    
1396
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1397
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1398
    
1399
    if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1400
        av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1401
        assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1402
        goto alloc;
1403
    }
1404

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

    
1407
    if(s->picture_structure!=PICT_FRAME){
1408
        int i;
1409
        for(i=0; i<4; i++){
1410
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1411
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1412
            } 
1413
            s->current_picture.linesize[i] *= 2;
1414
            s->last_picture.linesize[i] *=2;
1415
            s->next_picture.linesize[i] *=2;
1416
        }
1417
    }
1418
  }
1419
   
1420
    s->hurry_up= s->avctx->hurry_up;
1421
    s->error_resilience= avctx->error_resilience;
1422

    
1423
    /* set dequantizer, we cant do it during init as it might change for mpeg4
1424
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1425
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1426
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1427
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1428
    }else if(s->out_format == FMT_H263){
1429
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1430
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1431
    }else{
1432
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1433
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1434
    }
1435

    
1436
    if(s->dct_error_sum){
1437
        assert(s->avctx->noise_reduction && s->encoding);
1438

    
1439
        update_noise_reduction(s);
1440
    }
1441
        
1442
#ifdef HAVE_XVMC
1443
    if(s->avctx->xvmc_acceleration)
1444
        return XVMC_field_start(s, avctx);
1445
#endif
1446
    return 0;
1447
}
1448

    
1449
/* generic function for encode/decode called after a frame has been coded/decoded */
1450
void MPV_frame_end(MpegEncContext *s)
1451
{
1452
    int i;
1453
    /* draw edge for correct motion prediction if outside */
1454
#ifdef HAVE_XVMC
1455
//just to make sure that all data is rendered.
1456
    if(s->avctx->xvmc_acceleration){
1457
        XVMC_field_end(s);
1458
    }else
1459
#endif
1460
    if(s->unrestricted_mv && s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1461
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1462
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1463
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1464
    }
1465
    emms_c();
1466
    
1467
    s->last_pict_type    = s->pict_type;
1468
    if(s->pict_type!=B_TYPE){
1469
        s->last_non_b_pict_type= s->pict_type;
1470
    }
1471
#if 0
1472
        /* copy back current_picture variables */
1473
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1474
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1475
            s->picture[i]= s->current_picture;
1476
            break;
1477
        }    
1478
    }
1479
    assert(i<MAX_PICTURE_COUNT);
1480
#endif    
1481

    
1482
    if(s->encoding){
1483
        /* release non refernce frames */
1484
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1485
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1486
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1487
            }
1488
        }
1489
    }
1490
    // clear copies, to avoid confusion
1491
#if 0
1492
    memset(&s->last_picture, 0, sizeof(Picture));
1493
    memset(&s->next_picture, 0, sizeof(Picture));
1494
    memset(&s->current_picture, 0, sizeof(Picture));
1495
#endif
1496
}
1497

    
1498
/**
1499
 * draws an line from (ex, ey) -> (sx, sy).
1500
 * @param w width of the image
1501
 * @param h height of the image
1502
 * @param stride stride/linesize of the image
1503
 * @param color color of the arrow
1504
 */
1505
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1506
    int t, x, y, fr, f;
1507
    
1508
    sx= clip(sx, 0, w-1);
1509
    sy= clip(sy, 0, h-1);
1510
    ex= clip(ex, 0, w-1);
1511
    ey= clip(ey, 0, h-1);
1512
    
1513
    buf[sy*stride + sx]+= color;
1514
    
1515
    if(ABS(ex - sx) > ABS(ey - sy)){
1516
        if(sx > ex){
1517
            t=sx; sx=ex; ex=t;
1518
            t=sy; sy=ey; ey=t;
1519
        }
1520
        buf+= sx + sy*stride;
1521
        ex-= sx;
1522
        f= ((ey-sy)<<16)/ex;
1523
        for(x= 0; x <= ex; x++){
1524
            y = (x*f)>>16;
1525
            fr= (x*f)&0xFFFF;
1526
            buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1527
            buf[(y+1)*stride + x]+= (color*         fr )>>16;
1528
        }
1529
    }else{
1530
        if(sy > ey){
1531
            t=sx; sx=ex; ex=t;
1532
            t=sy; sy=ey; ey=t;
1533
        }
1534
        buf+= sx + sy*stride;
1535
        ey-= sy;
1536
        if(ey) f= ((ex-sx)<<16)/ey;
1537
        else   f= 0;
1538
        for(y= 0; y <= ey; y++){
1539
            x = (y*f)>>16;
1540
            fr= (y*f)&0xFFFF;
1541
            buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;;
1542
            buf[y*stride + x+1]+= (color*         fr )>>16;;
1543
        }
1544
    }
1545
}
1546

    
1547
/**
1548
 * draws an arrow from (ex, ey) -> (sx, sy).
1549
 * @param w width of the image
1550
 * @param h height of the image
1551
 * @param stride stride/linesize of the image
1552
 * @param color color of the arrow
1553
 */
1554
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1555
    int dx,dy;
1556

    
1557
    sx= clip(sx, -100, w+100);
1558
    sy= clip(sy, -100, h+100);
1559
    ex= clip(ex, -100, w+100);
1560
    ey= clip(ey, -100, h+100);
1561
    
1562
    dx= ex - sx;
1563
    dy= ey - sy;
1564
    
1565
    if(dx*dx + dy*dy > 3*3){
1566
        int rx=  dx + dy;
1567
        int ry= -dx + dy;
1568
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1569
        
1570
        //FIXME subpixel accuracy
1571
        rx= ROUNDED_DIV(rx*3<<4, length);
1572
        ry= ROUNDED_DIV(ry*3<<4, length);
1573
        
1574
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1575
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1576
    }
1577
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1578
}
1579

    
1580
/**
1581
 * prints debuging info for the given picture.
1582
 */
1583
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1584

    
1585
    if(!pict || !pict->mb_type) return;
1586

    
1587
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1588
        int x,y;
1589
        
1590
        av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1591
        switch (pict->pict_type) {
1592
            case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1593
            case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1594
            case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1595
            case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1596
            case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1597
            case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;            
1598
        }
1599
        for(y=0; y<s->mb_height; y++){
1600
            for(x=0; x<s->mb_width; x++){
1601
                if(s->avctx->debug&FF_DEBUG_SKIP){
1602
                    int count= s->mbskip_table[x + y*s->mb_stride];
1603
                    if(count>9) count=9;
1604
                    av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1605
                }
1606
                if(s->avctx->debug&FF_DEBUG_QP){
1607
                    av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1608
                }
1609
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1610
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
1611
                    //Type & MV direction
1612
                    if(IS_PCM(mb_type))
1613
                        av_log(s->avctx, AV_LOG_DEBUG, "P");
1614
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1615
                        av_log(s->avctx, AV_LOG_DEBUG, "A");
1616
                    else if(IS_INTRA4x4(mb_type))
1617
                        av_log(s->avctx, AV_LOG_DEBUG, "i");
1618
                    else if(IS_INTRA16x16(mb_type))
1619
                        av_log(s->avctx, AV_LOG_DEBUG, "I");
1620
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1621
                        av_log(s->avctx, AV_LOG_DEBUG, "d");
1622
                    else if(IS_DIRECT(mb_type))
1623
                        av_log(s->avctx, AV_LOG_DEBUG, "D");
1624
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1625
                        av_log(s->avctx, AV_LOG_DEBUG, "g");
1626
                    else if(IS_GMC(mb_type))
1627
                        av_log(s->avctx, AV_LOG_DEBUG, "G");
1628
                    else if(IS_SKIP(mb_type))
1629
                        av_log(s->avctx, AV_LOG_DEBUG, "S");
1630
                    else if(!USES_LIST(mb_type, 1))
1631
                        av_log(s->avctx, AV_LOG_DEBUG, ">");
1632
                    else if(!USES_LIST(mb_type, 0))
1633
                        av_log(s->avctx, AV_LOG_DEBUG, "<");
1634
                    else{
1635
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1636
                        av_log(s->avctx, AV_LOG_DEBUG, "X");
1637
                    }
1638
                    
1639
                    //segmentation
1640
                    if(IS_8X8(mb_type))
1641
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1642
                    else if(IS_16X8(mb_type))
1643
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1644
                    else if(IS_8X16(mb_type))
1645
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1646
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1647
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1648
                    else
1649
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1650
                    
1651
                        
1652
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1653
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1654
                    else
1655
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1656
                }
1657
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1658
            }
1659
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1660
        }
1661
    }
1662

    
1663
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1664
        const int shift= 1 + s->quarter_sample;
1665
        int mb_y;
1666
        uint8_t *ptr;
1667
        int i;
1668
        int h_chroma_shift, v_chroma_shift;
1669
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1670

    
1671
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1672
        for(i=0; i<3; i++){
1673
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*s->height:pict->linesize[i]*s->height >> v_chroma_shift);
1674
            pict->data[i]= s->visualization_buffer[i];
1675
        }
1676
        pict->type= FF_BUFFER_TYPE_COPY;
1677
        ptr= pict->data[0];
1678

    
1679
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1680
            int mb_x;
1681
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1682
                const int mb_index= mb_x + mb_y*s->mb_stride;
1683
                if((s->avctx->debug_mv) && pict->motion_val){
1684
                  int type;
1685
                  for(type=0; type<3; type++){
1686
                    int direction;
1687
                    switch (type) {
1688
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1689
                                continue;
1690
                              direction = 0;
1691
                              break;
1692
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1693
                                continue;
1694
                              direction = 0;
1695
                              break;
1696
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1697
                                continue;
1698
                              direction = 1;
1699
                              break;
1700
                    }
1701
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1702
                        continue;
1703

    
1704
                    //FIXME for h264
1705
                    if(IS_8X8(pict->mb_type[mb_index])){
1706
                      int i;
1707
                      for(i=0; i<4; i++){
1708
                        int sx= mb_x*16 + 4 + 8*(i&1);
1709
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1710
                        int xy= mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*s->b8_stride;
1711
                        int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1712
                        int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1713
                        draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1714
                      }
1715
                    }else if(IS_16X8(pict->mb_type[mb_index])){
1716
                      int i;
1717
                      for(i=0; i<2; i++){
1718
                        int sx=mb_x*16 + 8;
1719
                        int sy=mb_y*16 + 4 + 8*i;
1720
                        int xy= mb_x*2 + (mb_y*2 + i)*s->b8_stride;
1721
                        int mx=(pict->motion_val[direction][xy][0]>>shift) + sx;
1722
                        int my=(pict->motion_val[direction][xy][1]>>shift) + sy;
1723
                        draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1724
                      }
1725
                    }else{
1726
                      int sx= mb_x*16 + 8;
1727
                      int sy= mb_y*16 + 8;
1728
                      int xy= mb_x*2 + mb_y*2*s->b8_stride;
1729
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1730
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1731
                      draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1732
                    }
1733
                  }                  
1734
                }
1735
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1736
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1737
                    int y;
1738
                    for(y=0; y<8; y++){
1739
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1740
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1741
                    }
1742
                }
1743
                if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1744
                    int mb_type= pict->mb_type[mb_index];
1745
                    uint64_t u,v;
1746
                    int y;
1747
#define COLOR(theta, r)\
1748
u= (int)(128 + r*cos(theta*3.141592/180));\
1749
v= (int)(128 + r*sin(theta*3.141592/180));
1750

    
1751
                    
1752
                    u=v=128;
1753
                    if(IS_PCM(mb_type)){
1754
                        COLOR(120,48)
1755
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1756
                        COLOR(30,48)
1757
                    }else if(IS_INTRA4x4(mb_type)){
1758
                        COLOR(90,48)
1759
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1760
//                        COLOR(120,48)
1761
                    }else if(IS_DIRECT(mb_type)){
1762
                        COLOR(150,48)
1763
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1764
                        COLOR(170,48)
1765
                    }else if(IS_GMC(mb_type)){
1766
                        COLOR(190,48)
1767
                    }else if(IS_SKIP(mb_type)){
1768
//                        COLOR(180,48)
1769
                    }else if(!USES_LIST(mb_type, 1)){
1770
                        COLOR(240,48)
1771
                    }else if(!USES_LIST(mb_type, 0)){
1772
                        COLOR(0,48)
1773
                    }else{
1774
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1775
                        COLOR(300,48)
1776
                    }
1777

    
1778
                    u*= 0x0101010101010101ULL;
1779
                    v*= 0x0101010101010101ULL;
1780
                    for(y=0; y<8; y++){
1781
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1782
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1783
                    }
1784

    
1785
                    //segmentation
1786
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1787
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1788
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1789
                    }
1790
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1791
                        for(y=0; y<16; y++)
1792
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1793
                    }
1794
                        
1795
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1796
                        // hmm
1797
                    }
1798
                }
1799
                s->mbskip_table[mb_index]=0;
1800
            }
1801
        }
1802
    }
1803
}
1804

    
1805
#ifdef CONFIG_ENCODERS
1806

    
1807
static int get_sae(uint8_t *src, int ref, int stride){
1808
    int x,y;
1809
    int acc=0;
1810
    
1811
    for(y=0; y<16; y++){
1812
        for(x=0; x<16; x++){
1813
            acc+= ABS(src[x+y*stride] - ref);
1814
        }
1815
    }
1816
    
1817
    return acc;
1818
}
1819

    
1820
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1821
    int x, y, w, h;
1822
    int acc=0;
1823
    
1824
    w= s->width &~15;
1825
    h= s->height&~15;
1826
    
1827
    for(y=0; y<h; y+=16){
1828
        for(x=0; x<w; x+=16){
1829
            int offset= x + y*stride;
1830
            int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1831
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1832
            int sae = get_sae(src + offset, mean, stride);
1833
            
1834
            acc+= sae + 500 < sad;
1835
        }
1836
    }
1837
    return acc;
1838
}
1839

    
1840

    
1841
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1842
    AVFrame *pic=NULL;
1843
    int i;
1844
    const int encoding_delay= s->max_b_frames;
1845
    int direct=1;
1846
    
1847
  if(pic_arg){
1848
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1849
    if(pic_arg->linesize[0] != s->linesize) direct=0;
1850
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1851
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1852
  
1853
//    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1854
    
1855
    if(direct){
1856
        i= ff_find_unused_picture(s, 1);
1857

    
1858
        pic= (AVFrame*)&s->picture[i];
1859
        pic->reference= 3;
1860
    
1861
        for(i=0; i<4; i++){
1862
            pic->data[i]= pic_arg->data[i];
1863
            pic->linesize[i]= pic_arg->linesize[i];
1864
        }
1865
        alloc_picture(s, (Picture*)pic, 1);
1866
    }else{
1867
        int offset= 16;
1868
        i= ff_find_unused_picture(s, 0);
1869

    
1870
        pic= (AVFrame*)&s->picture[i];
1871
        pic->reference= 3;
1872

    
1873
        alloc_picture(s, (Picture*)pic, 0);
1874

    
1875
        if(   pic->data[0] + offset == pic_arg->data[0] 
1876
           && pic->data[1] + offset == pic_arg->data[1]
1877
           && pic->data[2] + offset == pic_arg->data[2]){
1878
       // empty
1879
        }else{
1880
            int h_chroma_shift, v_chroma_shift;
1881
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1882
        
1883
            for(i=0; i<3; i++){
1884
                int src_stride= pic_arg->linesize[i];
1885
                int dst_stride= i ? s->uvlinesize : s->linesize;
1886
                int h_shift= i ? h_chroma_shift : 0;
1887
                int v_shift= i ? v_chroma_shift : 0;
1888
                int w= s->width >>h_shift;
1889
                int h= s->height>>v_shift;
1890
                uint8_t *src= pic_arg->data[i];
1891
                uint8_t *dst= pic->data[i] + offset;
1892
            
1893
                if(src_stride==dst_stride)
1894
                    memcpy(dst, src, src_stride*h);
1895
                else{
1896
                    while(h--){
1897
                        memcpy(dst, src, w);
1898
                        dst += dst_stride;
1899
                        src += src_stride;
1900
                    }
1901
                }
1902
            }
1903
        }
1904
    }
1905
    copy_picture_attributes(s, pic, pic_arg);
1906
    
1907
    pic->display_picture_number= s->input_picture_number++;
1908
    if(pic->pts != AV_NOPTS_VALUE){ 
1909
        s->user_specified_pts= pic->pts;
1910
    }else{
1911
        if(s->user_specified_pts){
1912
            pic->pts= s->user_specified_pts + AV_TIME_BASE*(int64_t)s->avctx->frame_rate_base / s->avctx->frame_rate;
1913
            av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%Ld)\n", pic->pts);
1914
        }else{
1915
            pic->pts= av_rescale(pic->display_picture_number*(int64_t)s->avctx->frame_rate_base, AV_TIME_BASE, s->avctx->frame_rate);
1916
        }
1917
    }
1918
  }
1919
  
1920
    /* shift buffer entries */
1921
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1922
        s->input_picture[i-1]= s->input_picture[i];
1923
        
1924
    s->input_picture[encoding_delay]= (Picture*)pic;
1925

    
1926
    return 0;
1927
}
1928

    
1929
static void select_input_picture(MpegEncContext *s){
1930
    int i;
1931

    
1932
    for(i=1; i<MAX_PICTURE_COUNT; i++)
1933
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1934
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1935

    
1936
    /* set next picture types & ordering */
1937
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1938
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
1939
            s->reordered_input_picture[0]= s->input_picture[0];
1940
            s->reordered_input_picture[0]->pict_type= I_TYPE;
1941
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
1942
        }else{
1943
            int b_frames;
1944
            
1945
            if(s->flags&CODEC_FLAG_PASS2){
1946
                for(i=0; i<s->max_b_frames+1; i++){
1947
                    int pict_num= s->input_picture[0]->display_picture_number + i;
1948
                    int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1949
                    s->input_picture[i]->pict_type= pict_type;
1950
                    
1951
                    if(i + 1 >= s->rc_context.num_entries) break;
1952
                }
1953
            }
1954

    
1955
            if(s->input_picture[0]->pict_type){
1956
                /* user selected pict_type */
1957
                for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
1958
                    if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
1959
                }
1960
            
1961
                if(b_frames > s->max_b_frames){
1962
                    av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
1963
                    b_frames = s->max_b_frames;
1964
                }
1965
            }else if(s->avctx->b_frame_strategy==0){
1966
                b_frames= s->max_b_frames;
1967
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
1968
            }else if(s->avctx->b_frame_strategy==1){
1969
                for(i=1; i<s->max_b_frames+1; i++){
1970
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
1971
                        s->input_picture[i]->b_frame_score= 
1972
                            get_intra_count(s, s->input_picture[i  ]->data[0], 
1973
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
1974
                    }
1975
                }
1976
                for(i=0; i<s->max_b_frames; i++){
1977
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
1978
                }
1979
                                
1980
                b_frames= FFMAX(0, i-1);
1981
                
1982
                /* reset scores */
1983
                for(i=0; i<b_frames+1; i++){
1984
                    s->input_picture[i]->b_frame_score=0;
1985
                }
1986
            }else{
1987
                av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1988
                b_frames=0;
1989
            }
1990

    
1991
            emms_c();
1992
//static int b_count=0;
1993
//b_count+= b_frames;
1994
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
1995
            if(s->picture_in_gop_number + b_frames >= s->gop_size){
1996
                if(s->flags & CODEC_FLAG_CLOSED_GOP)
1997
                    b_frames=0;
1998
                s->input_picture[b_frames]->pict_type= I_TYPE;
1999
            }
2000
            
2001
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2002
               && b_frames
2003
               && s->input_picture[b_frames]->pict_type== I_TYPE)
2004
                b_frames--;
2005

    
2006
            s->reordered_input_picture[0]= s->input_picture[b_frames];
2007
            if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2008
                s->reordered_input_picture[0]->pict_type= P_TYPE;
2009
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2010
            for(i=0; i<b_frames; i++){
2011
                s->reordered_input_picture[i+1]= s->input_picture[i];
2012
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2013
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2014
            }
2015
        }
2016
    }
2017
    
2018
    if(s->reordered_input_picture[0]){
2019
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2020

    
2021
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2022

    
2023
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2024
            // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2025
        
2026
            int i= ff_find_unused_picture(s, 0);
2027
            Picture *pic= &s->picture[i];
2028

    
2029
            /* mark us unused / free shared pic */
2030
            for(i=0; i<4; i++)
2031
                s->reordered_input_picture[0]->data[i]= NULL;
2032
            s->reordered_input_picture[0]->type= 0;
2033
            
2034
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2035
            pic->reference              = s->reordered_input_picture[0]->reference;
2036
            
2037
            alloc_picture(s, pic, 0);
2038

    
2039
            s->current_picture_ptr= pic;
2040
        }else{
2041
            // input is not a shared pix -> reuse buffer for current_pix
2042

    
2043
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
2044
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2045
            
2046
            s->current_picture_ptr= s->reordered_input_picture[0];
2047
            for(i=0; i<4; i++){
2048
                s->new_picture.data[i]+=16;
2049
            }
2050
        }
2051
        copy_picture(&s->current_picture, s->current_picture_ptr);
2052
    
2053
        s->picture_number= s->new_picture.display_picture_number;
2054
//printf("dpn:%d\n", s->picture_number);
2055
    }else{
2056
       memset(&s->new_picture, 0, sizeof(Picture));
2057
    }
2058
}
2059

    
2060
int MPV_encode_picture(AVCodecContext *avctx,
2061
                       unsigned char *buf, int buf_size, void *data)
2062
{
2063
    MpegEncContext *s = avctx->priv_data;
2064
    AVFrame *pic_arg = data;
2065
    int i, stuffing_count;
2066

    
2067
    if(avctx->pix_fmt != PIX_FMT_YUV420P){
2068
        av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2069
        return -1;
2070
    }
2071
    
2072
    for(i=0; i<avctx->thread_count; i++){
2073
        int start_y= s->thread_context[i]->start_mb_y;
2074
        int   end_y= s->thread_context[i]->  end_mb_y;
2075
        int h= s->mb_height;
2076
        uint8_t *start= buf + buf_size*start_y/h;
2077
        uint8_t *end  = buf + buf_size*  end_y/h;
2078

    
2079
        init_put_bits(&s->thread_context[i]->pb, start, end - start);
2080
    }
2081

    
2082
    s->picture_in_gop_number++;
2083

    
2084
    load_input_picture(s, pic_arg);
2085
    
2086
    select_input_picture(s);
2087
    
2088
    /* output? */
2089
    if(s->new_picture.data[0]){
2090
        s->pict_type= s->new_picture.pict_type;
2091
//emms_c();
2092
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2093
        MPV_frame_start(s, avctx);
2094

    
2095
        encode_picture(s, s->picture_number);
2096
        
2097
        avctx->real_pict_num  = s->picture_number;
2098
        avctx->header_bits = s->header_bits;
2099
        avctx->mv_bits     = s->mv_bits;
2100
        avctx->misc_bits   = s->misc_bits;
2101
        avctx->i_tex_bits  = s->i_tex_bits;
2102
        avctx->p_tex_bits  = s->p_tex_bits;
2103
        avctx->i_count     = s->i_count;
2104
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2105
        avctx->skip_count  = s->skip_count;
2106

    
2107
        MPV_frame_end(s);
2108

    
2109
        if (s->out_format == FMT_MJPEG)
2110
            mjpeg_picture_trailer(s);
2111
        
2112
        if(s->flags&CODEC_FLAG_PASS1)
2113
            ff_write_pass1_stats(s);
2114

    
2115
        for(i=0; i<4; i++){
2116
            avctx->error[i] += s->current_picture_ptr->error[i];
2117
        }
2118

    
2119
        flush_put_bits(&s->pb);
2120
        s->frame_bits  = put_bits_count(&s->pb);
2121

    
2122
        stuffing_count= ff_vbv_update(s, s->frame_bits);
2123
        if(stuffing_count){
2124
            switch(s->codec_id){
2125
            case CODEC_ID_MPEG1VIDEO:
2126
            case CODEC_ID_MPEG2VIDEO:
2127
                while(stuffing_count--){
2128
                    put_bits(&s->pb, 8, 0);
2129
                }
2130
            break;
2131
            case CODEC_ID_MPEG4:
2132
                put_bits(&s->pb, 16, 0);
2133
                put_bits(&s->pb, 16, 0x1C3);
2134
                stuffing_count -= 4;
2135
                while(stuffing_count--){
2136
                    put_bits(&s->pb, 8, 0xFF);
2137
                }
2138
            break;
2139
            default:
2140
                av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2141
            }
2142
            flush_put_bits(&s->pb);
2143
            s->frame_bits  = put_bits_count(&s->pb);
2144
        }
2145

    
2146
        /* update mpeg1/2 vbv_delay for CBR */    
2147
        if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2148
           && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2149
            int vbv_delay;
2150

    
2151
            assert(s->repeat_first_field==0);
2152
            
2153
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2154
            assert(vbv_delay < 0xFFFF);
2155

    
2156
            s->vbv_delay_ptr[0] &= 0xF8;
2157
            s->vbv_delay_ptr[0] |= vbv_delay>>13;
2158
            s->vbv_delay_ptr[1]  = vbv_delay>>5;
2159
            s->vbv_delay_ptr[2] &= 0x07;
2160
            s->vbv_delay_ptr[2] |= vbv_delay<<3;
2161
        }
2162
        s->total_bits += s->frame_bits;
2163
        avctx->frame_bits  = s->frame_bits;
2164
    }else{
2165
        assert((pbBufPtr(&s->pb) == s->pb.buf));
2166
        s->frame_bits=0;
2167
    }
2168
    assert((s->frame_bits&7)==0);
2169
    
2170
    return s->frame_bits/8;
2171
}
2172

    
2173
#endif //CONFIG_ENCODERS
2174

    
2175
static inline void gmc1_motion(MpegEncContext *s,
2176
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2177
                               uint8_t **ref_picture)
2178
{
2179
    uint8_t *ptr;
2180
    int offset, src_x, src_y, linesize, uvlinesize;
2181
    int motion_x, motion_y;
2182
    int emu=0;
2183

    
2184
    motion_x= s->sprite_offset[0][0];
2185
    motion_y= s->sprite_offset[0][1];
2186
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2187
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2188
    motion_x<<=(3-s->sprite_warping_accuracy);
2189
    motion_y<<=(3-s->sprite_warping_accuracy);
2190
    src_x = clip(src_x, -16, s->width);
2191
    if (src_x == s->width)
2192
        motion_x =0;
2193
    src_y = clip(src_y, -16, s->height);
2194
    if (src_y == s->height)
2195
        motion_y =0;
2196

    
2197
    linesize = s->linesize;
2198
    uvlinesize = s->uvlinesize;
2199
    
2200
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2201

    
2202
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2203
        if(   (unsigned)src_x >= s->h_edge_pos - 17
2204
           || (unsigned)src_y >= s->v_edge_pos - 17){
2205
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2206
            ptr= s->edge_emu_buffer;
2207
        }
2208
    }
2209
    
2210
    if((motion_x|motion_y)&7){
2211
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2212
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2213
    }else{
2214
        int dxy;
2215
        
2216
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2217
        if (s->no_rounding){
2218
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2219
        }else{
2220
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2221
        }
2222
    }
2223
    
2224
    if(s->flags&CODEC_FLAG_GRAY) return;
2225

    
2226
    motion_x= s->sprite_offset[1][0];
2227
    motion_y= s->sprite_offset[1][1];
2228
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2229
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2230
    motion_x<<=(3-s->sprite_warping_accuracy);
2231
    motion_y<<=(3-s->sprite_warping_accuracy);
2232
    src_x = clip(src_x, -8, s->width>>1);
2233
    if (src_x == s->width>>1)
2234
        motion_x =0;
2235
    src_y = clip(src_y, -8, s->height>>1);
2236
    if (src_y == s->height>>1)
2237
        motion_y =0;
2238

    
2239
    offset = (src_y * uvlinesize) + src_x;
2240
    ptr = ref_picture[1] + offset;
2241
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2242
        if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2243
           || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2244
            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);
2245
            ptr= s->edge_emu_buffer;
2246
            emu=1;
2247
        }
2248
    }
2249
    s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2250
    
2251
    ptr = ref_picture[2] + offset;
2252
    if(emu){
2253
        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);
2254
        ptr= s->edge_emu_buffer;
2255
    }
2256
    s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2257
    
2258
    return;
2259
}
2260

    
2261
static inline void gmc_motion(MpegEncContext *s,
2262
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2263
                               uint8_t **ref_picture)
2264
{
2265
    uint8_t *ptr;
2266
    int linesize, uvlinesize;
2267
    const int a= s->sprite_warping_accuracy;
2268
    int ox, oy;
2269

    
2270
    linesize = s->linesize;
2271
    uvlinesize = s->uvlinesize;
2272

    
2273
    ptr = ref_picture[0];
2274

    
2275
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2276
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2277

    
2278
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2279
           ox, 
2280
           oy, 
2281
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2282
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2283
           a+1, (1<<(2*a+1)) - s->no_rounding,
2284
           s->h_edge_pos, s->v_edge_pos);
2285
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2286
           ox + s->sprite_delta[0][0]*8, 
2287
           oy + s->sprite_delta[1][0]*8, 
2288
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2289
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2290
           a+1, (1<<(2*a+1)) - s->no_rounding,
2291
           s->h_edge_pos, s->v_edge_pos);
2292

    
2293
    if(s->flags&CODEC_FLAG_GRAY) return;
2294

    
2295
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2296
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2297

    
2298
    ptr = ref_picture[1];
2299
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2300
           ox, 
2301
           oy, 
2302
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2303
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2304
           a+1, (1<<(2*a+1)) - s->no_rounding,
2305
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2306
    
2307
    ptr = ref_picture[2];
2308
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2309
           ox, 
2310
           oy, 
2311
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2312
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2313
           a+1, (1<<(2*a+1)) - s->no_rounding,
2314
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2315
}
2316

    
2317
/**
2318
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2319
 * @param buf destination buffer
2320
 * @param src source buffer
2321
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2322
 * @param block_w width of block
2323
 * @param block_h height of block
2324
 * @param src_x x coordinate of the top left sample of the block in the source buffer
2325
 * @param src_y y coordinate of the top left sample of the block in the source buffer
2326
 * @param w width of the source buffer
2327
 * @param h height of the source buffer
2328
 */
2329
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
2330
                                    int src_x, int src_y, int w, int h){
2331
    int x, y;
2332
    int start_y, start_x, end_y, end_x;
2333

    
2334
    if(src_y>= h){
2335
        src+= (h-1-src_y)*linesize;
2336
        src_y=h-1;
2337
    }else if(src_y<=-block_h){
2338
        src+= (1-block_h-src_y)*linesize;
2339
        src_y=1-block_h;
2340
    }
2341
    if(src_x>= w){
2342
        src+= (w-1-src_x);
2343
        src_x=w-1;
2344
    }else if(src_x<=-block_w){
2345
        src+= (1-block_w-src_x);
2346
        src_x=1-block_w;
2347
    }
2348

    
2349
    start_y= FFMAX(0, -src_y);
2350
    start_x= FFMAX(0, -src_x);
2351
    end_y= FFMIN(block_h, h-src_y);
2352
    end_x= FFMIN(block_w, w-src_x);
2353

    
2354
    // copy existing part
2355
    for(y=start_y; y<end_y; y++){
2356
        for(x=start_x; x<end_x; x++){
2357
            buf[x + y*linesize]= src[x + y*linesize];
2358
        }
2359
    }
2360

    
2361
    //top
2362
    for(y=0; y<start_y; y++){
2363
        for(x=start_x; x<end_x; x++){
2364
            buf[x + y*linesize]= buf[x + start_y*linesize];
2365
        }
2366
    }
2367

    
2368
    //bottom
2369
    for(y=end_y; y<block_h; y++){
2370
        for(x=start_x; x<end_x; x++){
2371
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2372
        }
2373
    }
2374
                                    
2375
    for(y=0; y<block_h; y++){
2376
       //left
2377
        for(x=0; x<start_x; x++){
2378
            buf[x + y*linesize]= buf[start_x + y*linesize];
2379
        }
2380
       
2381
       //right
2382
        for(x=end_x; x<block_w; x++){
2383
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2384
        }
2385
    }
2386
}
2387

    
2388
static inline int hpel_motion(MpegEncContext *s, 
2389
                                  uint8_t *dest, uint8_t *src,
2390
                                  int field_based, int field_select,
2391
                                  int src_x, int src_y,
2392
                                  int width, int height, int stride,
2393
                                  int h_edge_pos, int v_edge_pos,
2394
                                  int w, int h, op_pixels_func *pix_op,
2395
                                  int motion_x, int motion_y)
2396
{
2397
    int dxy;
2398
    int emu=0;
2399

    
2400
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2401
    src_x += motion_x >> 1;
2402
    src_y += motion_y >> 1;
2403
                
2404
    /* WARNING: do no forget half pels */
2405
    src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2406
    if (src_x == width)
2407
        dxy &= ~1;
2408
    src_y = clip(src_y, -16, height);
2409
    if (src_y == height)
2410
        dxy &= ~2;
2411
    src += src_y * stride + src_x;
2412

    
2413
    if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2414
        if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2415
           || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2416
            ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2417
                             src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2418
            src= s->edge_emu_buffer;
2419
            emu=1;
2420
        }
2421
    }
2422
    if(field_select)
2423
        src += s->linesize;
2424
    pix_op[dxy](dest, src, stride, h);
2425
    return emu;
2426
}
2427

    
2428
/* apply one mpeg motion vector to the three components */
2429
static inline void mpeg_motion(MpegEncContext *s,
2430
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2431
                               int field_based, int bottom_field, int field_select,
2432
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2433
                               int motion_x, int motion_y, int h)
2434
{
2435
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2436
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2437
    
2438
#if 0    
2439
if(s->quarter_sample)
2440
{
2441
    motion_x>>=1;
2442
    motion_y>>=1;
2443
}
2444
#endif
2445

    
2446
    v_edge_pos = s->v_edge_pos >> field_based;
2447
    linesize   = s->current_picture.linesize[0] << field_based;
2448
    uvlinesize = s->current_picture.linesize[1] << field_based;
2449

    
2450
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2451
    src_x = s->mb_x* 16               + (motion_x >> 1);
2452
    src_y = s->mb_y*(16>>field_based) + (motion_y >> 1);
2453

    
2454
    if (s->out_format == FMT_H263) {
2455
        if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2456
            mx = (motion_x>>1)|(motion_x&1);
2457
            my = motion_y >>1;
2458
            uvdxy = ((my & 1) << 1) | (mx & 1);
2459
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2460
            uvsrc_y = s->mb_y*(8>>field_based) + (my >> 1);
2461
        }else{
2462
            uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2463
            uvsrc_x = src_x>>1;
2464
            uvsrc_y = src_y>>1;
2465
        }
2466
    } else {
2467
        mx = motion_x / 2;
2468
        my = motion_y / 2;
2469
        uvdxy = ((my & 1) << 1) | (mx & 1);
2470
        uvsrc_x = s->mb_x* 8               + (mx >> 1);
2471
        uvsrc_y = s->mb_y*(8>>field_based) + (my >> 1);
2472
    }
2473

    
2474
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2475
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2476
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2477

    
2478
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2479
       || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
2480
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2481
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2482
            ptr_y = s->edge_emu_buffer;
2483
            if(!(s->flags&CODEC_FLAG_GRAY)){
2484
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2485
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2486
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2487
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2488
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2489
                ptr_cb= uvbuf;
2490
                ptr_cr= uvbuf+16;
2491
            }
2492
    }
2493

    
2494
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2495
        dest_y += s->linesize;
2496
        dest_cb+= s->uvlinesize;
2497
        dest_cr+= s->uvlinesize;
2498
    }
2499

    
2500
    if(field_select){
2501
        ptr_y += s->linesize;
2502
        ptr_cb+= s->uvlinesize;
2503
        ptr_cr+= s->uvlinesize;
2504
    }
2505

    
2506
    pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2507
    
2508
    if(!(s->flags&CODEC_FLAG_GRAY)){
2509
        pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
2510
        pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
2511
    }
2512
}
2513
//FIXME move to dsputil, avg variant, 16x16 version
2514
static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2515
    int x;
2516
    uint8_t * const top   = src[1];
2517
    uint8_t * const left  = src[2];
2518
    uint8_t * const mid   = src[0];
2519
    uint8_t * const right = src[3];
2520
    uint8_t * const bottom= src[4];
2521
#define OBMC_FILTER(x, t, l, m, r, b)\
2522
    dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2523
#define OBMC_FILTER4(x, t, l, m, r, b)\
2524
    OBMC_FILTER(x         , t, l, m, r, b);\
2525
    OBMC_FILTER(x+1       , t, l, m, r, b);\
2526
    OBMC_FILTER(x  +stride, t, l, m, r, b);\
2527
    OBMC_FILTER(x+1+stride, t, l, m, r, b);
2528
    
2529
    x=0;
2530
    OBMC_FILTER (x  , 2, 2, 4, 0, 0);
2531
    OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2532
    OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2533
    OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2534
    OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2535
    OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2536
    x+= stride;
2537
    OBMC_FILTER (x  , 1, 2, 5, 0, 0);
2538
    OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2539
    OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2540
    OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2541
    x+= stride;
2542
    OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
2543
    OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2544
    OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2545
    OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2546
    x+= 2*stride;
2547
    OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
2548
    OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2549
    OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2550
    OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2551
    x+= 2*stride;
2552
    OBMC_FILTER (x  , 0, 2, 5, 0, 1);
2553
    OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2554
    OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2555
    OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2556
    OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2557
    OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2558
    x+= stride;
2559
    OBMC_FILTER (x  , 0, 2, 4, 0, 2);
2560
    OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2561
    OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2562
    OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2563
}
2564

    
2565
/* obmc for 1 8x8 luma block */
2566
static inline void obmc_motion(MpegEncContext *s,
2567
                               uint8_t *dest, uint8_t *src,
2568
                               int src_x, int src_y,
2569
                               op_pixels_func *pix_op,
2570
                               int16_t mv[5][2]/* mid top left right bottom*/)
2571
#define MID    0
2572
{
2573
    int i;
2574
    uint8_t *ptr[5];
2575
    
2576
    assert(s->quarter_sample==0);
2577
    
2578
    for(i=0; i<5; i++){
2579
        if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2580
            ptr[i]= ptr[MID];
2581
        }else{
2582
            ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
2583
            hpel_motion(s, ptr[i], src, 0, 0,
2584
                        src_x, src_y,
2585
                        s->width, s->height, s->linesize,
2586
                        s->h_edge_pos, s->v_edge_pos,
2587
                        8, 8, pix_op,
2588
                        mv[i][0], mv[i][1]);
2589
        }
2590
    }
2591

    
2592
    put_obmc(dest, ptr, s->linesize);                
2593
}
2594

    
2595
static inline void qpel_motion(MpegEncContext *s,
2596
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2597
                               int field_based, int bottom_field, int field_select,
2598
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2599
                               qpel_mc_func (*qpix_op)[16],
2600
                               int motion_x, int motion_y, int h)
2601
{
2602
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2603
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
2604

    
2605
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2606
    src_x = s->mb_x *  16                 + (motion_x >> 2);
2607
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2608

    
2609
    v_edge_pos = s->v_edge_pos >> field_based;
2610
    linesize = s->linesize << field_based;
2611
    uvlinesize = s->uvlinesize << field_based;
2612
    
2613
    if(field_based){
2614
        mx= motion_x/2;
2615
        my= motion_y>>1;
2616
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2617
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
2618
        mx= (motion_x>>1) + rtab[motion_x&7];
2619
        my= (motion_y>>1) + rtab[motion_y&7];
2620
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2621
        mx= (motion_x>>1)|(motion_x&1);
2622
        my= (motion_y>>1)|(motion_y&1);
2623
    }else{
2624
        mx= motion_x/2;
2625
        my= motion_y/2;
2626
    }
2627
    mx= (mx>>1)|(mx&1);
2628
    my= (my>>1)|(my&1);
2629

    
2630
    uvdxy= (mx&1) | ((my&1)<<1);
2631
    mx>>=1;
2632
    my>>=1;
2633

    
2634
    uvsrc_x = s->mb_x *  8                 + mx;
2635
    uvsrc_y = s->mb_y * (8 >> field_based) + my;
2636

    
2637
    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
2638
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2639
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2640

    
2641
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 
2642
       || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
2643
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, 
2644
                         src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2645
        ptr_y= s->edge_emu_buffer;
2646
        if(!(s->flags&CODEC_FLAG_GRAY)){
2647
            uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
2648
            ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based, 
2649
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2650
            ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based, 
2651
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2652
            ptr_cb= uvbuf;
2653
            ptr_cr= uvbuf + 16;
2654
        }
2655
    }
2656

    
2657
    if(!field_based)
2658
        qpix_op[0][dxy](dest_y, ptr_y, linesize);
2659
    else{
2660
        if(bottom_field){
2661
            dest_y += s->linesize;
2662
            dest_cb+= s->uvlinesize;
2663
            dest_cr+= s->uvlinesize;
2664
        }
2665

    
2666
        if(field_select){
2667
            ptr_y  += s->linesize;
2668
            ptr_cb += s->uvlinesize;
2669
            ptr_cr += s->uvlinesize;
2670
        }
2671
        //damn interlaced mode
2672
        //FIXME boundary mirroring is not exactly correct here
2673
        qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
2674
        qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
2675
    }
2676
    if(!(s->flags&CODEC_FLAG_GRAY)){
2677
        pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
2678
        pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
2679
    }
2680
}
2681

    
2682
inline int ff_h263_round_chroma(int x){
2683
    if (x >= 0)
2684
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2685
    else {
2686
        x = -x;
2687
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2688
    }
2689
}
2690

    
2691
/**
2692
 * h263 chorma 4mv motion compensation.
2693
 */
2694
static inline void chroma_4mv_motion(MpegEncContext *s,
2695
                                     uint8_t *dest_cb, uint8_t *dest_cr,
2696
                                     uint8_t **ref_picture,
2697
                                     op_pixels_func *pix_op,
2698
                                     int mx, int my){
2699
    int dxy, emu=0, src_x, src_y, offset;
2700
    uint8_t *ptr;
2701
    
2702
    /* In case of 8X8, we construct a single chroma motion vector
2703
       with a special rounding */
2704
    mx= ff_h263_round_chroma(mx);
2705
    my= ff_h263_round_chroma(my);
2706
    
2707
    dxy = ((my & 1) << 1) | (mx & 1);
2708
    mx >>= 1;
2709
    my >>= 1;
2710

    
2711
    src_x = s->mb_x * 8 + mx;
2712
    src_y = s->mb_y * 8 + my;
2713
    src_x = clip(src_x, -8, s->width/2);
2714
    if (src_x == s->width/2)
2715
        dxy &= ~1;
2716
    src_y = clip(src_y, -8, s->height/2);
2717
    if (src_y == s->height/2)
2718
        dxy &= ~2;
2719
    
2720
    offset = (src_y * (s->uvlinesize)) + src_x;
2721
    ptr = ref_picture[1] + offset;
2722
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2723
        if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
2724
           || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
2725
            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);
2726
            ptr= s->edge_emu_buffer;
2727
            emu=1;
2728
        }
2729
    }
2730
    pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
2731

    
2732
    ptr = ref_picture[2] + offset;
2733
    if(emu){
2734
        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);
2735
        ptr= s->edge_emu_buffer;
2736
    }
2737
    pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
2738
}
2739

    
2740
/**
2741
 * motion compesation of a single macroblock
2742
 * @param s context
2743
 * @param dest_y luma destination pointer
2744
 * @param dest_cb chroma cb/u destination pointer
2745
 * @param dest_cr chroma cr/v destination pointer
2746
 * @param dir direction (0->forward, 1->backward)
2747
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2748
 * @param pic_op halfpel motion compensation function (average or put normally)
2749
 * @param pic_op qpel motion compensation function (average or put normally)
2750
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2751
 */
2752
static inline void MPV_motion(MpegEncContext *s, 
2753
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2754
                              int dir, uint8_t **ref_picture, 
2755
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
2756
{
2757
    int dxy, mx, my, src_x, src_y, motion_x, motion_y;
2758
    int mb_x, mb_y, i;
2759
    uint8_t *ptr, *dest;
2760

    
2761
    mb_x = s->mb_x;
2762
    mb_y = s->mb_y;
2763

    
2764
    if(s->obmc && s->pict_type != B_TYPE){
2765
        int16_t mv_cache[4][4][2];
2766
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
2767
        const int mot_stride= s->b8_stride;
2768
        const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
2769

    
2770
        assert(!s->mb_skiped);
2771
                
2772
        memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
2773
        memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2774
        memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2775

    
2776
        if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
2777
            memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
2778
        }else{
2779
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
2780
        }
2781

    
2782
        if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
2783
            *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
2784
            *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
2785
        }else{
2786
            *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
2787
            *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
2788
        }
2789

    
2790
        if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
2791
            *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
2792
            *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
2793
        }else{
2794
            *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
2795
            *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
2796
        }
2797
        
2798
        mx = 0;
2799
        my = 0;
2800
        for(i=0;i<4;i++) {
2801
            const int x= (i&1)+1;
2802
            const int y= (i>>1)+1;
2803
            int16_t mv[5][2]= {
2804
                {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
2805
                {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
2806
                {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
2807
                {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
2808
                {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
2809
            //FIXME cleanup
2810
            obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2811
                        ref_picture[0],
2812
                        mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2813
                        pix_op[1],
2814
                        mv);
2815

    
2816
            mx += mv[0][0];
2817
            my += mv[0][1];
2818
        }
2819
        if(!(s->flags&CODEC_FLAG_GRAY))
2820
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2821

    
2822
        return;
2823
    }
2824
   
2825
    switch(s->mv_type) {
2826
    case MV_TYPE_16X16:
2827
#ifdef CONFIG_RISKY
2828
        if(s->mcsel){
2829
            if(s->real_sprite_warping_points==1){
2830
                gmc1_motion(s, dest_y, dest_cb, dest_cr,
2831
                            ref_picture);
2832
            }else{
2833
                gmc_motion(s, dest_y, dest_cb, dest_cr,
2834
                            ref_picture);
2835
            }
2836
        }else if(s->quarter_sample){
2837
            qpel_motion(s, dest_y, dest_cb, dest_cr, 
2838
                        0, 0, 0,
2839
                        ref_picture, pix_op, qpix_op,
2840
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2841
        }else if(s->mspel){
2842
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
2843
                        ref_picture, pix_op,
2844
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2845
        }else
2846
#endif
2847
        {
2848
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 
2849
                        0, 0, 0,
2850
                        ref_picture, pix_op,
2851
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2852
        }           
2853
        break;
2854
    case MV_TYPE_8X8:
2855
        mx = 0;
2856
        my = 0;
2857
        if(s->quarter_sample){
2858
            for(i=0;i<4;i++) {
2859
                motion_x = s->mv[dir][i][0];
2860
                motion_y = s->mv[dir][i][1];
2861

    
2862
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2863
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
2864
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
2865
                    
2866
                /* WARNING: do no forget half pels */
2867
                src_x = clip(src_x, -16, s->width);
2868
                if (src_x == s->width)
2869
                    dxy &= ~3;
2870
                src_y = clip(src_y, -16, s->height);
2871
                if (src_y == s->height)
2872
                    dxy &= ~12;
2873
                    
2874
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2875
                if(s->flags&CODEC_FLAG_EMU_EDGE){
2876
                    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8 
2877
                       || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
2878
                        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);
2879
                        ptr= s->edge_emu_buffer;
2880
                    }
2881
                }
2882
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2883
                qpix_op[1][dxy](dest, ptr, s->linesize);
2884

    
2885
                mx += s->mv[dir][i][0]/2;
2886
                my += s->mv[dir][i][1]/2;
2887
            }
2888
        }else{
2889
            for(i=0;i<4;i++) {
2890
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2891
                            ref_picture[0], 0, 0,
2892
                            mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2893
                            s->width, s->height, s->linesize,
2894
                            s->h_edge_pos, s->v_edge_pos,
2895
                            8, 8, pix_op[1],
2896
                            s->mv[dir][i][0], s->mv[dir][i][1]);
2897

    
2898
                mx += s->mv[dir][i][0];
2899
                my += s->mv[dir][i][1];
2900
            }
2901
        }
2902

    
2903
        if(!(s->flags&CODEC_FLAG_GRAY))
2904
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2905
        break;
2906
    case MV_TYPE_FIELD:
2907
        if (s->picture_structure == PICT_FRAME) {
2908
            if(s->quarter_sample){
2909
                for(i=0; i<2; i++){
2910
                    qpel_motion(s, dest_y, dest_cb, dest_cr,
2911
                                1, i, s->field_select[dir][i],
2912
                                ref_picture, pix_op, qpix_op,
2913
                                s->mv[dir][i][0], s->mv[dir][i][1], 8);
2914
                }
2915
            }else{
2916
                /* top field */       
2917
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
2918
                            1, 0, s->field_select[dir][0],
2919
                            ref_picture, pix_op,
2920
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
2921
                /* bottom field */
2922
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
2923
                            1, 1, s->field_select[dir][1],
2924
                            ref_picture, pix_op,
2925
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
2926
            }
2927
        } else {
2928
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
2929
                ref_picture= s->current_picture_ptr->data;
2930
            } 
2931

    
2932
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
2933
                        0, 0, s->field_select[dir][0],
2934
                        ref_picture, pix_op,
2935
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2936
        }
2937
        break;
2938
    case MV_TYPE_16X8:
2939
        for(i=0; i<2; i++){
2940
            uint8_t ** ref2picture;
2941

    
2942
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
2943
                ref2picture= ref_picture;
2944
            }else{
2945
                ref2picture= s->current_picture_ptr->data;
2946
            } 
2947

    
2948
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 
2949
                        0, 0, s->field_select[dir][i],
2950
                        ref2picture, pix_op,
2951
                        s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
2952
                
2953
            dest_y += 16*s->linesize;
2954
            dest_cb+=  8*s->uvlinesize;
2955
            dest_cr+=  8*s->uvlinesize;
2956
        }        
2957
        break;
2958
    case MV_TYPE_DMV:
2959
        if(s->picture_structure == PICT_FRAME){
2960
            for(i=0; i<2; i++){
2961
                int j;
2962
                for(j=0; j<2; j++){
2963
                    mpeg_motion(s, dest_y, dest_cb, dest_cr,
2964
                                1, j, j^i,
2965
                                ref_picture, pix_op,
2966
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
2967
                }
2968
                pix_op = s->dsp.avg_pixels_tab; 
2969
            }
2970
        }else{
2971
            for(i=0; i<2; i++){
2972
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 
2973
                            0, 0, s->picture_structure != i+1,
2974
                            ref_picture, pix_op,
2975
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
2976

    
2977
                // after put we make avg of the same block
2978
                pix_op=s->dsp.avg_pixels_tab; 
2979

    
2980
                //opposite parity is always in the same frame if this is second field
2981
                if(!s->first_field){
2982
                    ref_picture = s->current_picture_ptr->data;    
2983
                }
2984
            }
2985
        }
2986
    break;
2987
    default: assert(0);
2988
    }
2989
}
2990

    
2991

    
2992
/* put block[] to dest[] */
2993
static inline void put_dct(MpegEncContext *s, 
2994
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2995
{
2996
    s->dct_unquantize_intra(s, block, i, qscale);
2997
    s->dsp.idct_put (dest, line_size, block);
2998
}
2999

    
3000
/* add block[] to dest[] */
3001
static inline void add_dct(MpegEncContext *s, 
3002
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
3003
{
3004
    if (s->block_last_index[i] >= 0) {
3005
        s->dsp.idct_add (dest, line_size, block);
3006
    }
3007
}
3008

    
3009
static inline void add_dequant_dct(MpegEncContext *s, 
3010
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3011
{
3012
    if (s->block_last_index[i] >= 0) {
3013
        s->dct_unquantize_inter(s, block, i, qscale);
3014

    
3015
        s->dsp.idct_add (dest, line_size, block);
3016
    }
3017
}
3018

    
3019
/**
3020
 * cleans dc, ac, coded_block for the current non intra MB
3021
 */
3022
void ff_clean_intra_table_entries(MpegEncContext *s)
3023
{
3024
    int wrap = s->b8_stride;
3025
    int xy = s->block_index[0];
3026
    
3027
    s->dc_val[0][xy           ] = 
3028
    s->dc_val[0][xy + 1       ] = 
3029
    s->dc_val[0][xy     + wrap] =
3030
    s->dc_val[0][xy + 1 + wrap] = 1024;
3031
    /* ac pred */
3032
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
3033
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3034
    if (s->msmpeg4_version>=3) {
3035
        s->coded_block[xy           ] =
3036
        s->coded_block[xy + 1       ] =
3037
        s->coded_block[xy     + wrap] =
3038
        s->coded_block[xy + 1 + wrap] = 0;
3039
    }
3040
    /* chroma */
3041
    wrap = s->mb_stride;
3042
    xy = s->mb_x + s->mb_y * wrap;
3043
    s->dc_val[1][xy] =
3044
    s->dc_val[2][xy] = 1024;
3045
    /* ac pred */
3046
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3047
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3048
    
3049
    s->mbintra_table[xy]= 0;
3050
}
3051

    
3052
/* generic function called after a macroblock has been parsed by the
3053
   decoder or after it has been encoded by the encoder.
3054

3055
   Important variables used:
3056
   s->mb_intra : true if intra macroblock
3057
   s->mv_dir   : motion vector direction
3058
   s->mv_type  : motion vector type
3059
   s->mv       : motion vector
3060
   s->interlaced_dct : true if interlaced dct used (mpeg2)
3061
 */
3062
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
3063
{
3064
    int mb_x, mb_y;
3065
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3066
#ifdef HAVE_XVMC
3067
    if(s->avctx->xvmc_acceleration){
3068
        XVMC_decode_mb(s);//xvmc uses pblocks
3069
        return;
3070
    }
3071
#endif
3072

    
3073
    mb_x = s->mb_x;
3074
    mb_y = s->mb_y;
3075

    
3076
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3077
       /* save DCT coefficients */
3078
       int i,j;
3079
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3080
       for(i=0; i<6; i++)
3081
           for(j=0; j<64; j++)
3082
               *dct++ = block[i][s->dsp.idct_permutation[j]];
3083
    }
3084

    
3085
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3086

    
3087
    /* update DC predictors for P macroblocks */
3088
    if (!s->mb_intra) {
3089
        if (s->h263_pred || s->h263_aic) {
3090
            if(s->mbintra_table[mb_xy])
3091
                ff_clean_intra_table_entries(s);
3092
        } else {
3093
            s->last_dc[0] =
3094
            s->last_dc[1] =
3095
            s->last_dc[2] = 128 << s->intra_dc_precision;
3096
        }
3097
    }
3098
    else if (s->h263_pred || s->h263_aic)
3099
        s->mbintra_table[mb_xy]=1;
3100

    
3101
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3102
        uint8_t *dest_y, *dest_cb, *dest_cr;
3103
        int dct_linesize, dct_offset;
3104
        op_pixels_func (*op_pix)[4];
3105
        qpel_mc_func (*op_qpix)[16];
3106
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3107
        const int uvlinesize= s->current_picture.linesize[1];
3108
        const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band;
3109

    
3110
        /* avoid copy if macroblock skipped in last frame too */
3111
        /* skip only during decoding as we might trash the buffers during encoding a bit */
3112
        if(!s->encoding){
3113
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3114
            const int age= s->current_picture.age;
3115

    
3116
            assert(age);
3117

    
3118
            if (s->mb_skiped) {
3119
                s->mb_skiped= 0;
3120
                assert(s->pict_type!=I_TYPE);
3121
 
3122
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
3123
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3124

    
3125
                /* if previous was skipped too, then nothing to do !  */
3126
                if (*mbskip_ptr >= age && s->current_picture.reference){
3127
                    return;
3128
                }
3129
            } else if(!s->current_picture.reference){
3130
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3131
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3132
            } else{
3133
                *mbskip_ptr = 0; /* not skipped */
3134
            }
3135
        }
3136

    
3137
        if (s->interlaced_dct) {
3138
            dct_linesize = linesize * 2;
3139
            dct_offset = linesize;
3140
        } else {
3141
            dct_linesize = linesize;
3142
            dct_offset = linesize * 8;
3143
        }
3144
        if(readable){
3145
            dest_y=  s->dest[0];
3146
            dest_cb= s->dest[1];
3147
            dest_cr= s->dest[2];
3148
        }else{
3149
            dest_y = s->b_scratchpad;
3150
            dest_cb= s->b_scratchpad+16*linesize;
3151
            dest_cr= s->b_scratchpad+16*linesize+8;
3152
        }
3153
        if (!s->mb_intra) {
3154
            /* motion handling */
3155
            /* decoding or more than one mb_type (MC was allready done otherwise) */
3156
            if(!s->encoding){
3157
                if ((!s->no_rounding) || s->pict_type==B_TYPE){                
3158
                    op_pix = s->dsp.put_pixels_tab;
3159
                    op_qpix= s->dsp.put_qpel_pixels_tab;
3160
                }else{
3161
                    op_pix = s->dsp.put_no_rnd_pixels_tab;
3162
                    op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3163
                }
3164

    
3165
                if (s->mv_dir & MV_DIR_FORWARD) {
3166
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3167
                    op_pix = s->dsp.avg_pixels_tab;
3168
                    op_qpix= s->dsp.avg_qpel_pixels_tab;
3169
                }
3170
                if (s->mv_dir & MV_DIR_BACKWARD) {
3171
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3172
                }
3173
            }
3174

    
3175
            /* skip dequant / idct if we are really late ;) */
3176
            if(s->hurry_up>1) return;
3177

    
3178
            /* add dct residue */
3179
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3180
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3181
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
3182
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
3183
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
3184
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
3185

    
3186
                if(!(s->flags&CODEC_FLAG_GRAY)){
3187
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3188
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3189
                }
3190
            } else if(s->codec_id != CODEC_ID_WMV2){
3191
                add_dct(s, block[0], 0, dest_y, dct_linesize);
3192
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
3193
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
3194
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
3195

    
3196
                if(!(s->flags&CODEC_FLAG_GRAY)){
3197
                    add_dct(s, block[4], 4, dest_cb, uvlinesize);
3198
                    add_dct(s, block[5], 5, dest_cr, uvlinesize);
3199
                }
3200
            } 
3201
#ifdef CONFIG_RISKY
3202
            else{
3203
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3204
            }
3205
#endif
3206
        } else {
3207
            /* dct only in intra block */
3208
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3209
                put_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
3210
                put_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
3211
                put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
3212
                put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
3213

    
3214
                if(!(s->flags&CODEC_FLAG_GRAY)){
3215
                    put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3216
                    put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3217
                }
3218
            }else{
3219
                s->dsp.idct_put(dest_y                 , dct_linesize, block[0]);
3220
                s->dsp.idct_put(dest_y              + 8, dct_linesize, block[1]);
3221
                s->dsp.idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
3222
                s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
3223

    
3224
                if(!(s->flags&CODEC_FLAG_GRAY)){
3225
                    s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3226
                    s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3227
                }
3228
            }
3229
        }
3230
        if(!readable){
3231
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3232
            s->dsp.put_pixels_tab[1][0](s->dest[1], dest_cb, uvlinesize, 8);
3233
            s->dsp.put_pixels_tab[1][0](s->dest[2], dest_cr, uvlinesize, 8);
3234
        }
3235
    }
3236
}
3237

    
3238
#ifdef CONFIG_ENCODERS
3239

    
3240
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3241
{
3242
    static const char tab[64]=
3243
        {3,2,2,1,1,1,1,1,
3244
         1,1,1,1,1,1,1,1,
3245
         1,1,1,1,1,1,1,1,
3246
         0,0,0,0,0,0,0,0,
3247
         0,0,0,0,0,0,0,0,
3248
         0,0,0,0,0,0,0,0,
3249
         0,0,0,0,0,0,0,0,
3250
         0,0,0,0,0,0,0,0};
3251
    int score=0;
3252
    int run=0;
3253
    int i;
3254
    DCTELEM *block= s->block[n];
3255
    const int last_index= s->block_last_index[n];
3256
    int skip_dc;
3257

    
3258
    if(threshold<0){
3259
        skip_dc=0;
3260
        threshold= -threshold;
3261
    }else
3262
        skip_dc=1;
3263

    
3264
    /* are all which we could set to zero are allready zero? */
3265
    if(last_index<=skip_dc - 1) return;
3266

    
3267
    for(i=0; i<=last_index; i++){
3268
        const int j = s->intra_scantable.permutated[i];
3269
        const int level = ABS(block[j]);
3270
        if(level==1){
3271
            if(skip_dc && i==0) continue;
3272
            score+= tab[run];
3273
            run=0;
3274
        }else if(level>1){
3275
            return;
3276
        }else{
3277
            run++;
3278
        }
3279
    }
3280
    if(score >= threshold) return;
3281
    for(i=skip_dc; i<=last_index; i++){
3282
        const int j = s->intra_scantable.permutated[i];
3283
        block[j]=0;
3284
    }
3285
    if(block[0]) s->block_last_index[n]= 0;
3286
    else         s->block_last_index[n]= -1;
3287
}
3288

    
3289
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
3290
{
3291
    int i;
3292
    const int maxlevel= s->max_qcoeff;
3293
    const int minlevel= s->min_qcoeff;
3294
    int overflow=0;
3295
    
3296
    if(s->mb_intra){
3297
        i=1; //skip clipping of intra dc
3298
    }else
3299
        i=0;
3300
    
3301
    for(;i<=last_index; i++){
3302
        const int j= s->intra_scantable.permutated[i];
3303
        int level = block[j];
3304
       
3305
        if     (level>maxlevel){
3306
            level=maxlevel;
3307
            overflow++;
3308
        }else if(level<minlevel){
3309
            level=minlevel;
3310
            overflow++;
3311
        }
3312
        
3313
        block[j]= level;
3314
    }
3315
    
3316
    if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
3317
        av_log(s->avctx, AV_LOG_INFO, "warning, cliping %d dct coefficents to %d..%d\n", overflow, minlevel, maxlevel);
3318
}
3319

    
3320
#endif //CONFIG_ENCODERS
3321

    
3322
/**
3323
 *
3324
 * @param h is the normal height, this will be reduced automatically if needed for the last row
3325
 */
3326
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3327
    if (s->avctx->draw_horiz_band) {
3328
        AVFrame *src;
3329
        int offset[4];
3330
        
3331
        if(s->picture_structure != PICT_FRAME){
3332
            h <<= 1;
3333
            y <<= 1;
3334
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3335
        }
3336

    
3337
        h= FFMIN(h, s->height - y);
3338

    
3339
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) 
3340
            src= (AVFrame*)s->current_picture_ptr;
3341
        else if(s->last_picture_ptr)
3342
            src= (AVFrame*)s->last_picture_ptr;
3343
        else
3344
            return;
3345
            
3346
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3347
            offset[0]=
3348
            offset[1]=
3349
            offset[2]=
3350
            offset[3]= 0;
3351
        }else{
3352
            offset[0]= y * s->linesize;;
3353
            offset[1]= 
3354
            offset[2]= (y>>1) * s->uvlinesize;;
3355
            offset[3]= 0;
3356
        }
3357

    
3358
        emms_c();
3359

    
3360
        s->avctx->draw_horiz_band(s->avctx, src, offset,
3361
                                  y, s->picture_structure, h);
3362
    }
3363
}
3364

    
3365
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3366
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3367
    const int uvlinesize= s->current_picture.linesize[1];
3368
        
3369
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
3370
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
3371
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
3372
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3373
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3374
    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;
3375
    
3376
    if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){
3377
        s->dest[0] = s->current_picture.data[0] + s->mb_x * 16 - 16;
3378
        s->dest[1] = s->current_picture.data[1] + s->mb_x * 8 - 8;
3379
        s->dest[2] = s->current_picture.data[2] + s->mb_x * 8 - 8;
3380
    }else{
3381
        s->dest[0] = s->current_picture.data[0] + (s->mb_y * 16* linesize  ) + s->mb_x * 16 - 16;
3382
        s->dest[1] = s->current_picture.data[1] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
3383
        s->dest[2] = s->current_picture.data[2] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
3384
    }    
3385
}
3386

    
3387
#ifdef CONFIG_ENCODERS
3388

    
3389
static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
3390
    int x, y;
3391
//FIXME optimize
3392
    for(y=0; y<8; y++){
3393
        for(x=0; x<8; x++){
3394
            int x2, y2;
3395
            int sum=0;
3396
            int sqr=0;
3397
            int count=0;
3398

    
3399
            for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
3400
                for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
3401
                    int v= ptr[x2 + y2*stride];
3402
                    sum += v;
3403
                    sqr += v*v;
3404
                    count++;
3405
                }
3406
            }
3407
            weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
3408
        }
3409
    }
3410
}
3411

    
3412
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
3413
{
3414
    int16_t weight[6][64];
3415
    DCTELEM orig[6][64];
3416
    const int mb_x= s->mb_x;
3417
    const int mb_y= s->mb_y;
3418
    int i;
3419
    int skip_dct[6];
3420
    int dct_offset   = s->linesize*8; //default for progressive frames
3421
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3422
    int wrap_y, wrap_c;
3423
    
3424
    for(i=0; i<6; i++) skip_dct[i]=0;
3425
    
3426
    if(s->adaptive_quant){
3427
        const int last_qp= s->qscale;
3428
        const int mb_xy= mb_x + mb_y*s->mb_stride;
3429

    
3430
        s->lambda= s->lambda_table[mb_xy];
3431
        update_qscale(s);
3432
    
3433
        if(!(s->flags&CODEC_FLAG_QP_RD)){
3434
            s->dquant= s->qscale - last_qp;
3435

    
3436
            if(s->out_format==FMT_H263){
3437
                s->dquant= clip(s->dquant, -2, 2); //FIXME RD
3438
            
3439
                if(s->codec_id==CODEC_ID_MPEG4){        
3440
                    if(!s->mb_intra){
3441
                        if(s->pict_type == B_TYPE){
3442
                            if(s->dquant&1) 
3443
                                s->dquant= (s->dquant/2)*2;
3444
                            if(s->mv_dir&MV_DIRECT)
3445
                                s->dquant= 0;
3446
                        }
3447
                        if(s->mv_type==MV_TYPE_8X8)
3448
                            s->dquant=0;
3449
                    }
3450
                }
3451
            }
3452
        }
3453
        ff_set_qscale(s, last_qp + s->dquant);
3454
    }
3455

    
3456
    wrap_y = s->linesize;
3457
    wrap_c = s->uvlinesize;
3458
    ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
3459
    ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
3460
    ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3461

    
3462
    if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
3463
        ff_emulated_edge_mc(s->edge_emu_buffer            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
3464
        ptr_y= s->edge_emu_buffer;
3465
        ff_emulated_edge_mc(s->edge_emu_buffer+18*wrap_y  , ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3466
        ptr_cb= s->edge_emu_buffer+18*wrap_y;
3467
        ff_emulated_edge_mc(s->edge_emu_buffer+18*wrap_y+9, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3468
        ptr_cr= s->edge_emu_buffer+18*wrap_y+9;
3469
    }
3470

    
3471
    if (s->mb_intra) {
3472
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3473
            int progressive_score, interlaced_score;
3474

    
3475
            s->interlaced_dct=0;
3476
            progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8) 
3477
                              +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
3478

    
3479
            if(progressive_score > 0){
3480
                interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8) 
3481
                                  +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
3482
                if(progressive_score > interlaced_score){
3483
                    s->interlaced_dct=1;
3484
            
3485
                    dct_offset= wrap_y;
3486
                    wrap_y<<=1;
3487
                }
3488
            }
3489
        }
3490
        
3491
        s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
3492
        s->dsp.get_pixels(s->block[1], ptr_y              + 8, wrap_y);
3493
        s->dsp.get_pixels(s->block[2], ptr_y + dct_offset    , wrap_y);
3494
        s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
3495

    
3496
        if(s->flags&CODEC_FLAG_GRAY){
3497
            skip_dct[4]= 1;
3498
            skip_dct[5]= 1;
3499
        }else{
3500
            s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
3501
            s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
3502
        }
3503
    }else{
3504
        op_pixels_func (*op_pix)[4];
3505
        qpel_mc_func (*op_qpix)[16];
3506
        uint8_t *dest_y, *dest_cb, *dest_cr;
3507

    
3508
        dest_y  = s->dest[0];
3509
        dest_cb = s->dest[1];
3510
        dest_cr = s->dest[2];
3511

    
3512
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
3513
            op_pix = s->dsp.put_pixels_tab;
3514
            op_qpix= s->dsp.put_qpel_pixels_tab;
3515
        }else{
3516
            op_pix = s->dsp.put_no_rnd_pixels_tab;
3517
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3518
        }
3519

    
3520
        if (s->mv_dir & MV_DIR_FORWARD) {
3521
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3522
            op_pix = s->dsp.avg_pixels_tab;
3523
            op_qpix= s->dsp.avg_qpel_pixels_tab;
3524
        }
3525
        if (s->mv_dir & MV_DIR_BACKWARD) {
3526
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3527
        }
3528

    
3529
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3530
            int progressive_score, interlaced_score;
3531

    
3532
            s->interlaced_dct=0;
3533
            progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8) 
3534
                              +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
3535
            
3536
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
3537

    
3538
            if(progressive_score>0){
3539
                interlaced_score = s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y*2, 8) 
3540
                                  +s->dsp.ildct_cmp[0](s, dest_y + wrap_y  , ptr_y + wrap_y  , wrap_y*2, 8);
3541
            
3542
                if(progressive_score > interlaced_score){
3543
                    s->interlaced_dct=1;
3544
            
3545
                    dct_offset= wrap_y;
3546
                    wrap_y<<=1;
3547
                }
3548
            }
3549
        }
3550
        
3551
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
3552
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
3553
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
3554
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
3555
        
3556
        if(s->flags&CODEC_FLAG_GRAY){
3557
            skip_dct[4]= 1;
3558
            skip_dct[5]= 1;
3559
        }else{
3560
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
3561
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
3562
        }
3563
        /* pre quantization */         
3564
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
3565
            //FIXME optimize
3566
            if(s->dsp.sad[1](NULL, ptr_y               , dest_y               , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
3567
            if(s->dsp.sad[1](NULL, ptr_y            + 8, dest_y            + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
3568
            if(s->dsp.sad[1](NULL, ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
3569
            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;
3570
            if(s->dsp.sad[1](NULL, ptr_cb              , dest_cb              , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
3571
            if(s->dsp.sad[1](NULL, ptr_cr              , dest_cr              , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
3572
        }
3573
    }
3574

    
3575
    if(s->avctx->quantizer_noise_shaping){
3576
        if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y                 , wrap_y);
3577
        if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y              + 8, wrap_y);
3578
        if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset    , wrap_y);
3579
        if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
3580
        if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb                , wrap_c);
3581
        if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr                , wrap_c);
3582
        memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*6);
3583
    }
3584
            
3585
    /* DCT & quantize */
3586
    assert(s->out_format!=FMT_MJPEG || s->qscale==8);
3587
    {
3588
        for(i=0;i<6;i++) {
3589
            if(!skip_dct[i]){
3590
                int overflow;
3591
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
3592
            // FIXME we could decide to change to quantizer instead of clipping
3593
            // JS: I don't think that would be a good idea it could lower quality instead
3594
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
3595
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
3596
            }else
3597
                s->block_last_index[i]= -1;
3598
        }
3599
        if(s->avctx->quantizer_noise_shaping){
3600
            for(i=0;i<6;i++) {
3601
                if(!skip_dct[i]){
3602
                    s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
3603
                }
3604
            }
3605
        }
3606
        
3607
        if(s->luma_elim_threshold && !s->mb_intra)
3608
            for(i=0; i<4; i++)
3609
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
3610
        if(s->chroma_elim_threshold && !s->mb_intra)
3611
            for(i=4; i<6; i++)
3612
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
3613

    
3614
        if(s->flags & CODEC_FLAG_CBP_RD){
3615
            for(i=0;i<6;i++) {
3616
                if(s->block_last_index[i] == -1)
3617
                    s->coded_score[i]= INT_MAX/256;
3618
            }
3619
        }
3620
    }
3621

    
3622
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
3623
        s->block_last_index[4]=
3624
        s->block_last_index[5]= 0;
3625
        s->block[4][0]=
3626
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
3627
    }
3628

    
3629
    //non c quantize code returns incorrect block_last_index FIXME
3630
    if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
3631
        for(i=0; i<6; i++){
3632
            int j;
3633
            if(s->block_last_index[i]>0){
3634
                for(j=63; j>0; j--){
3635
                    if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
3636
                }
3637
                s->block_last_index[i]= j;
3638
            }
3639
        }
3640
    }
3641

    
3642
    /* huffman encode */
3643
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
3644
    case CODEC_ID_MPEG1VIDEO:
3645
    case CODEC_ID_MPEG2VIDEO:
3646
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
3647
#ifdef CONFIG_RISKY
3648
    case CODEC_ID_MPEG4:
3649
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3650
    case CODEC_ID_MSMPEG4V2:
3651
    case CODEC_ID_MSMPEG4V3:
3652
    case CODEC_ID_WMV1:
3653
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3654
    case CODEC_ID_WMV2:
3655
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
3656
    case CODEC_ID_H263:
3657
    case CODEC_ID_H263P:
3658
    case CODEC_ID_FLV1:
3659
    case CODEC_ID_RV10:
3660
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
3661
#endif
3662
    case CODEC_ID_MJPEG:
3663
        mjpeg_encode_mb(s, s->block); break;
3664
    default:
3665
        assert(0);
3666
    }
3667
}
3668

    
3669
#endif //CONFIG_ENCODERS
3670

    
3671
/**
3672
 * combines the (truncated) bitstream to a complete frame
3673
 * @returns -1 if no complete frame could be created
3674
 */
3675
int ff_combine_frame( MpegEncContext *s, int next, uint8_t **buf, int *buf_size){
3676
    ParseContext *pc= &s->parse_context;
3677

    
3678
#if 0
3679
    if(pc->overread){
3680
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
3681
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
3682
    }
3683
#endif
3684

    
3685
    /* copy overreaded byes from last frame into buffer */
3686
    for(; pc->overread>0; pc->overread--){
3687
        pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
3688
    }
3689
    
3690
    pc->last_index= pc->index;
3691

    
3692
    /* copy into buffer end return */
3693
    if(next == END_NOT_FOUND){
3694
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
3695

    
3696
        memcpy(&pc->buffer[pc->index], *buf, *buf_size);
3697
        pc->index += *buf_size;
3698
        return -1;
3699
    }
3700

    
3701
    *buf_size=
3702
    pc->overread_index= pc->index + next;
3703
    
3704
    /* append to buffer */
3705
    if(pc->index){
3706
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
3707

    
3708
        memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
3709
        pc->index = 0;
3710
        *buf= pc->buffer;
3711
    }
3712

    
3713
    /* store overread bytes */
3714
    for(;next < 0; next++){
3715
        pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
3716
        pc->overread++;
3717
    }
3718

    
3719
#if 0
3720
    if(pc->overread){
3721
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
3722
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
3723
    }
3724
#endif
3725

    
3726
    return 0;
3727
}
3728

    
3729
void ff_mpeg_flush(AVCodecContext *avctx){
3730
    int i;
3731
    MpegEncContext *s = avctx->priv_data;
3732
    
3733
    if(s==NULL || s->picture==NULL) 
3734
        return;
3735
    
3736
    for(i=0; i<MAX_PICTURE_COUNT; i++){
3737
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
3738
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
3739
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
3740
    }
3741
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
3742
    
3743
    s->parse_context.state= -1;
3744
    s->parse_context.frame_start_found= 0;
3745
    s->parse_context.overread= 0;
3746
    s->parse_context.overread_index= 0;
3747
    s->parse_context.index= 0;
3748
    s->parse_context.last_index= 0;
3749
    s->bitstream_buffer_size=0;
3750
}
3751

    
3752
#ifdef CONFIG_ENCODERS
3753
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
3754
{
3755
    const uint16_t *srcw= (uint16_t*)src;
3756
    int words= length>>4;
3757
    int bits= length&15;
3758
    int i;
3759

    
3760
    if(length==0) return;
3761
    
3762
    if(words < 16){
3763
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
3764
    }else if(put_bits_count(pb)&7){
3765
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
3766
    }else{
3767
        for(i=0; put_bits_count(pb)&31; i++)
3768
            put_bits(pb, 8, src[i]);
3769
        flush_put_bits(pb);
3770
        memcpy(pbBufPtr(pb), src+i, 2*words-i);
3771
        skip_put_bytes(pb, 2*words-i);
3772
    }
3773
        
3774
    put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
3775
}
3776

    
3777
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
3778
    int i;
3779

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

    
3782
    /* mpeg1 */
3783
    d->mb_skip_run= s->mb_skip_run;
3784
    for(i=0; i<3; i++)
3785
        d->last_dc[i]= s->last_dc[i];
3786
    
3787
    /* statistics */
3788
    d->mv_bits= s->mv_bits;
3789
    d->i_tex_bits= s->i_tex_bits;
3790
    d->p_tex_bits= s->p_tex_bits;
3791
    d->i_count= s->i_count;
3792
    d->f_count= s->f_count;
3793
    d->b_count= s->b_count;
3794
    d->skip_count= s->skip_count;
3795
    d->misc_bits= s->misc_bits;
3796
    d->last_bits= 0;
3797

    
3798
    d->mb_skiped= 0;
3799
    d->qscale= s->qscale;
3800
    d->dquant= s->dquant;
3801
}
3802

    
3803
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
3804
    int i;
3805

    
3806
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
3807
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
3808
    
3809
    /* mpeg1 */
3810
    d->mb_skip_run= s->mb_skip_run;
3811
    for(i=0; i<3; i++)
3812
        d->last_dc[i]= s->last_dc[i];
3813
    
3814
    /* statistics */
3815
    d->mv_bits= s->mv_bits;
3816
    d->i_tex_bits= s->i_tex_bits;
3817
    d->p_tex_bits= s->p_tex_bits;
3818
    d->i_count= s->i_count;
3819
    d->f_count= s->f_count;
3820
    d->b_count= s->b_count;
3821
    d->skip_count= s->skip_count;
3822
    d->misc_bits= s->misc_bits;
3823

    
3824
    d->mb_intra= s->mb_intra;
3825
    d->mb_skiped= s->mb_skiped;
3826
    d->mv_type= s->mv_type;
3827
    d->mv_dir= s->mv_dir;
3828
    d->pb= s->pb;
3829
    if(s->data_partitioning){
3830
        d->pb2= s->pb2;
3831
        d->tex_pb= s->tex_pb;
3832
    }
3833
    d->block= s->block;
3834
    for(i=0; i<6; i++)
3835
        d->block_last_index[i]= s->block_last_index[i];
3836
    d->interlaced_dct= s->interlaced_dct;
3837
    d->qscale= s->qscale;
3838
}
3839

    
3840
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
3841
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
3842
                           int *dmin, int *next_block, int motion_x, int motion_y)
3843
{
3844
    int score;
3845
    uint8_t *dest_backup[3];
3846
    
3847
    copy_context_before_encode(s, backup, type);
3848

    
3849
    s->block= s->blocks[*next_block];
3850
    s->pb= pb[*next_block];
3851
    if(s->data_partitioning){
3852
        s->pb2   = pb2   [*next_block];
3853
        s->tex_pb= tex_pb[*next_block];
3854
    }
3855
    
3856
    if(*next_block){
3857
        memcpy(dest_backup, s->dest, sizeof(s->dest));
3858
        s->dest[0] = s->rd_scratchpad;
3859
        s->dest[1] = s->rd_scratchpad + 16*s->linesize;
3860
        s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
3861
        assert(s->linesize >= 32); //FIXME
3862
    }
3863

    
3864
    encode_mb(s, motion_x, motion_y);
3865
    
3866
    score= put_bits_count(&s->pb);
3867
    if(s->data_partitioning){
3868
        score+= put_bits_count(&s->pb2);
3869
        score+= put_bits_count(&s->tex_pb);
3870
    }
3871
   
3872
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
3873
        MPV_decode_mb(s, s->block);
3874

    
3875
        score *= s->lambda2;
3876
        score += sse_mb(s) << FF_LAMBDA_SHIFT;
3877
    }
3878
    
3879
    if(*next_block){
3880
        memcpy(s->dest, dest_backup, sizeof(s->dest));
3881
    }
3882

    
3883
    if(score<*dmin){
3884
        *dmin= score;
3885
        *next_block^=1;
3886

    
3887
        copy_context_after_encode(best, s, type);
3888
    }
3889
}
3890
                
3891
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
3892
    uint32_t *sq = squareTbl + 256;
3893
    int acc=0;
3894
    int x,y;
3895
    
3896
    if(w==16 && h==16) 
3897
        return s->dsp.sse[0](NULL, src1, src2, stride, 16);
3898
    else if(w==8 && h==8)
3899
        return s->dsp.sse[1](NULL, src1, src2, stride, 8);
3900
    
3901
    for(y=0; y<h; y++){
3902
        for(x=0; x<w; x++){
3903
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
3904
        } 
3905
    }
3906
    
3907
    assert(acc>=0);
3908
    
3909
    return acc;
3910
}
3911

    
3912
static int sse_mb(MpegEncContext *s){
3913
    int w= 16;
3914
    int h= 16;
3915

    
3916
    if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3917
    if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3918

    
3919
    if(w==16 && h==16)
3920
        return  s->dsp.sse[0](NULL, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16)
3921
               +s->dsp.sse[1](NULL, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8)
3922
               +s->dsp.sse[1](NULL, s->new_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
3923
    else
3924
        return  sse(s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], w, h, s->linesize)
3925
               +sse(s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[1], w>>1, h>>1, s->uvlinesize)
3926
               +sse(s, s->new_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[2], w>>1, h>>1, s->uvlinesize);
3927
}
3928

    
3929
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
3930
    MpegEncContext *s= arg;
3931

    
3932
    
3933
    s->me.pre_pass=1;
3934
    s->me.dia_size= s->avctx->pre_dia_size;
3935
    s->first_slice_line=1;
3936
    for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
3937
        for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
3938
            ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
3939
        }
3940
        s->first_slice_line=0;
3941
    }
3942
    
3943
    s->me.pre_pass=0;
3944
    
3945
    return 0;
3946
}
3947

    
3948
static int estimate_motion_thread(AVCodecContext *c, void *arg){
3949
    MpegEncContext *s= arg;
3950

    
3951
    s->me.dia_size= s->avctx->dia_size;
3952
    s->first_slice_line=1;
3953
    for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
3954
        s->mb_x=0; //for block init below
3955
        ff_init_block_index(s);
3956
        for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
3957
            s->block_index[0]+=2;
3958
            s->block_index[1]+=2;
3959
            s->block_index[2]+=2;
3960
            s->block_index[3]+=2;
3961
            
3962
            /* compute motion vector & mb_type and store in context */
3963
            if(s->pict_type==B_TYPE)
3964
                ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
3965
            else
3966
                ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
3967
        }
3968
        s->first_slice_line=0;
3969
    }
3970
    return 0;
3971
}
3972

    
3973
static int mb_var_thread(AVCodecContext *c, void *arg){
3974
    MpegEncContext *s= arg;
3975
    int mb_x, mb_y;
3976

    
3977
    for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
3978
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3979
            int xx = mb_x * 16;
3980
            int yy = mb_y * 16;
3981
            uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
3982
            int varc;
3983
            int sum = s->dsp.pix_sum(pix, s->linesize);
3984
    
3985
            varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
3986

    
3987
            s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
3988
            s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
3989
            s->mb_var_sum_temp    += varc;
3990
        }
3991
    }
3992
    return 0;
3993
}
3994

    
3995
static void write_slice_end(MpegEncContext *s){
3996
    if(s->codec_id==CODEC_ID_MPEG4){
3997
        if(s->partitioned_frame){
3998
            ff_mpeg4_merge_partitions(s);
3999
        }
4000
    
4001
        ff_mpeg4_stuffing(&s->pb);
4002
    }else if(s->out_format == FMT_MJPEG){
4003
        ff_mjpeg_stuffing(&s->pb);
4004
    }
4005

    
4006
    align_put_bits(&s->pb);
4007
    flush_put_bits(&s->pb);
4008
}
4009

    
4010
static int encode_thread(AVCodecContext *c, void *arg){
4011
    MpegEncContext *s= arg;
4012
    int mb_x, mb_y, pdif = 0;
4013
    int i, j;
4014
    MpegEncContext best_s, backup_s;
4015
    uint8_t bit_buf[2][3000];
4016
    uint8_t bit_buf2[2][3000];
4017
    uint8_t bit_buf_tex[2][3000];
4018
    PutBitContext pb[2], pb2[2], tex_pb[2];
4019
//printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4020

    
4021
    for(i=0; i<2; i++){
4022
        init_put_bits(&pb    [i], bit_buf    [i], 3000);
4023
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000);
4024
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000);
4025
    }
4026

    
4027
    s->last_bits= put_bits_count(&s->pb);
4028
    s->mv_bits=0;
4029
    s->misc_bits=0;
4030
    s->i_tex_bits=0;
4031
    s->p_tex_bits=0;
4032
    s->i_count=0;
4033
    s->f_count=0;
4034
    s->b_count=0;
4035
    s->skip_count=0;
4036

    
4037
    for(i=0; i<3; i++){
4038
        /* init last dc values */
4039
        /* note: quant matrix value (8) is implied here */
4040
        s->last_dc[i] = 128;
4041
        
4042
        s->current_picture_ptr->error[i] = 0;
4043
    }
4044
    s->mb_skip_run = 0;
4045
    memset(s->last_mv, 0, sizeof(s->last_mv));
4046
     
4047
    s->last_mv_dir = 0;
4048

    
4049
#ifdef CONFIG_RISKY
4050
    switch(s->codec_id){
4051
    case CODEC_ID_H263:
4052
    case CODEC_ID_H263P:
4053
    case CODEC_ID_FLV1:
4054
        s->gob_index = ff_h263_get_gob_height(s);
4055
        break;
4056
    case CODEC_ID_MPEG4:
4057
        if(s->partitioned_frame)
4058
            ff_mpeg4_init_partitions(s);
4059
        break;
4060
    }
4061
#endif
4062

    
4063
    s->resync_mb_x=0;
4064
    s->resync_mb_y=0; 
4065
    s->first_slice_line = 1;
4066
    s->ptr_lastgob = s->pb.buf;
4067
    for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4068
//    printf("row %d at %X\n", s->mb_y, (int)s);
4069
        s->mb_x=0;
4070
        s->mb_y= mb_y;
4071

    
4072
        ff_set_qscale(s, s->qscale);
4073
        ff_init_block_index(s);
4074
        
4075
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4076
            const int xy= mb_y*s->mb_stride + mb_x;
4077
            int mb_type= s->mb_type[xy];
4078
//            int d;
4079
            int dmin= INT_MAX;
4080
            int dir;
4081

    
4082
            s->mb_x = mb_x;
4083
            ff_update_block_index(s);
4084

    
4085
            /* write gob / video packet header  */
4086
#ifdef CONFIG_RISKY
4087
            if(s->rtp_mode){
4088
                int current_packet_size, is_gob_start;
4089
                
4090
                current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
4091
                
4092
                is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0; 
4093
                
4094
                if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
4095
                
4096
                switch(s->codec_id){
4097
                case CODEC_ID_H263:
4098
                case CODEC_ID_H263P:
4099
                    if(!s->h263_slice_structured)
4100
                        if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
4101
                    break;
4102
                case CODEC_ID_MPEG2VIDEO:
4103
                    if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
4104
                case CODEC_ID_MPEG1VIDEO:
4105
                    if(s->mb_skip_run) is_gob_start=0;
4106
                    break;
4107
                }
4108

    
4109
                if(is_gob_start){
4110
                    if(s->start_mb_y != mb_y || mb_x!=0){
4111
                        write_slice_end(s);
4112

    
4113
                        if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
4114
                            ff_mpeg4_init_partitions(s);
4115
                        }
4116
                    }
4117
                
4118
                    assert((put_bits_count(&s->pb)&7) == 0);
4119
                    current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4120
                    
4121
                    if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
4122
                        int r= put_bits_count(&s->pb)/8 + s->picture_number + s->codec_id + s->mb_x + s->mb_y;
4123
                        int d= 100 / s->avctx->error_rate;
4124
                        if(r % d == 0){
4125
                            current_packet_size=0;
4126
#ifndef ALT_BITSTREAM_WRITER
4127
                            s->pb.buf_ptr= s->ptr_lastgob;
4128
#endif
4129
                            assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
4130
                        }
4131
                    }
4132
        
4133
                    if (s->avctx->rtp_callback)
4134
                        s->avctx->rtp_callback(s->ptr_lastgob, current_packet_size, 0);
4135
                    
4136
                    switch(s->codec_id){
4137
                    case CODEC_ID_MPEG4:
4138
                        ff_mpeg4_encode_video_packet_header(s);
4139
                        ff_mpeg4_clean_buffers(s);
4140
                    break;
4141
                    case CODEC_ID_MPEG1VIDEO:
4142
                    case CODEC_ID_MPEG2VIDEO:
4143
                        ff_mpeg1_encode_slice_header(s);
4144
                        ff_mpeg1_clean_buffers(s);
4145
                    break;
4146
                    case CODEC_ID_H263:
4147
                    case CODEC_ID_H263P:
4148
                        h263_encode_gob_header(s, mb_y);                       
4149
                    break;
4150
                    }
4151

    
4152
                    if(s->flags&CODEC_FLAG_PASS1){
4153
                        int bits= put_bits_count(&s->pb);
4154
                        s->misc_bits+= bits - s->last_bits;
4155
                        s->last_bits= bits;
4156
                    }
4157
    
4158
                    s->ptr_lastgob += current_packet_size;
4159
                    s->first_slice_line=1;
4160
                    s->resync_mb_x=mb_x;
4161
                    s->resync_mb_y=mb_y;
4162
                }
4163
            }
4164
#endif
4165

    
4166
            if(  (s->resync_mb_x   == s->mb_x)
4167
               && s->resync_mb_y+1 == s->mb_y){
4168
                s->first_slice_line=0; 
4169
            }
4170

    
4171
            s->mb_skiped=0;
4172
            s->dquant=0; //only for QP_RD
4173

    
4174
            if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible
4175
                int next_block=0;
4176
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
4177

    
4178
                copy_context_before_encode(&backup_s, s, -1);
4179
                backup_s.pb= s->pb;
4180
                best_s.data_partitioning= s->data_partitioning;
4181
                best_s.partitioned_frame= s->partitioned_frame;
4182
                if(s->data_partitioning){
4183
                    backup_s.pb2= s->pb2;
4184
                    backup_s.tex_pb= s->tex_pb;
4185
                }
4186

    
4187
                if(mb_type&CANDIDATE_MB_TYPE_INTER){
4188
                    s->mv_dir = MV_DIR_FORWARD;
4189
                    s->mv_type = MV_TYPE_16X16;
4190
                    s->mb_intra= 0;
4191
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
4192
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
4193
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb, 
4194
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4195
                }
4196
                if(mb_type&CANDIDATE_MB_TYPE_INTER_I){ 
4197
                    s->mv_dir = MV_DIR_FORWARD;
4198
                    s->mv_type = MV_TYPE_FIELD;
4199
                    s->mb_intra= 0;
4200
                    for(i=0; i<2; i++){
4201
                        j= s->field_select[0][i] = s->p_field_select_table[i][xy];
4202
                        s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
4203
                        s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
4204
                    }
4205
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb, 
4206
                                 &dmin, &next_block, 0, 0);
4207
                }
4208
                if(mb_type&CANDIDATE_MB_TYPE_SKIPED){
4209
                    s->mv_dir = MV_DIR_FORWARD;
4210
                    s->mv_type = MV_TYPE_16X16;
4211
                    s->mb_intra= 0;
4212
                    s->mv[0][0][0] = 0;
4213
                    s->mv[0][0][1] = 0;
4214
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPED, pb, pb2, tex_pb, 
4215
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4216
                }
4217
                if(mb_type&CANDIDATE_MB_TYPE_INTER4V){                 
4218
                    s->mv_dir = MV_DIR_FORWARD;
4219
                    s->mv_type = MV_TYPE_8X8;
4220
                    s->mb_intra= 0;
4221
                    for(i=0; i<4; i++){
4222
                        s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
4223
                        s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
4224
                    }
4225
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb, 
4226
                                 &dmin, &next_block, 0, 0);
4227
                }
4228
                if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
4229
                    s->mv_dir = MV_DIR_FORWARD;
4230
                    s->mv_type = MV_TYPE_16X16;
4231
                    s->mb_intra= 0;
4232
                    s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
4233
                    s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
4234
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb, 
4235
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4236
                }
4237
                if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
4238
                    s->mv_dir = MV_DIR_BACKWARD;
4239
                    s->mv_type = MV_TYPE_16X16;
4240
                    s->mb_intra= 0;
4241
                    s->mv[1][0][0] = s->b_back_mv_table[xy][0];
4242
                    s->mv[1][0][1] = s->b_back_mv_table[xy][1];
4243
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb, 
4244
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
4245
                }
4246
                if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
4247
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4248
                    s->mv_type = MV_TYPE_16X16;
4249
                    s->mb_intra= 0;
4250
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
4251
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
4252
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
4253
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
4254
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb, 
4255
                                 &dmin, &next_block, 0, 0);
4256
                }
4257
                if(mb_type&CANDIDATE_MB_TYPE_DIRECT){
4258
                    int mx= s->b_direct_mv_table[xy][0];
4259
                    int my= s->b_direct_mv_table[xy][1];
4260
                    
4261
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4262
                    s->mb_intra= 0;
4263
#ifdef CONFIG_RISKY
4264
                    ff_mpeg4_set_direct_mv(s, mx, my);
4265
#endif
4266
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb, 
4267
                                 &dmin, &next_block, mx, my);
4268
                }
4269
                if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){ 
4270
                    s->mv_dir = MV_DIR_FORWARD;
4271
                    s->mv_type = MV_TYPE_FIELD;
4272
                    s->mb_intra= 0;
4273
                    for(i=0; i<2; i++){
4274
                        j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
4275
                        s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
4276
                        s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
4277
                    }
4278
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb, 
4279
                                 &dmin, &next_block, 0, 0);
4280
                }
4281
                if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){ 
4282
                    s->mv_dir = MV_DIR_BACKWARD;
4283
                    s->mv_type = MV_TYPE_FIELD;
4284
                    s->mb_intra= 0;
4285
                    for(i=0; i<2; i++){
4286
                        j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
4287
                        s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
4288
                        s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
4289
                    }
4290
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb, 
4291
                                 &dmin, &next_block, 0, 0);
4292
                }
4293
                if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){ 
4294
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4295
                    s->mv_type = MV_TYPE_FIELD;
4296
                    s->mb_intra= 0;
4297
                    for(dir=0; dir<2; dir++){
4298
                        for(i=0; i<2; i++){
4299
                            j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
4300
                            s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
4301
                            s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
4302
                        }
4303
                    }
4304
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb, 
4305
                                 &dmin, &next_block, 0, 0);
4306
                }
4307
                if(mb_type&CANDIDATE_MB_TYPE_INTRA){
4308
                    s->mv_dir = 0;
4309
                    s->mv_type = MV_TYPE_16X16;
4310
                    s->mb_intra= 1;
4311
                    s->mv[0][0][0] = 0;
4312
                    s->mv[0][0][1] = 0;
4313
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb, 
4314
                                 &dmin, &next_block, 0, 0);
4315
                    if(s->h263_pred || s->h263_aic){
4316
                        if(best_s.mb_intra)
4317
                            s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
4318
                        else
4319
                            ff_clean_intra_table_entries(s); //old mode?
4320
                    }
4321
                }
4322

    
4323
                if(s->flags & CODEC_FLAG_QP_RD){
4324
                    if(best_s.mv_type==MV_TYPE_16X16 && !(best_s.mv_dir&MV_DIRECT)){
4325
                        const int last_qp= backup_s.qscale;
4326
                        int dquant, dir, qp, dc[6];
4327
                        DCTELEM ac[6][16];
4328
                        const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
4329
                        
4330
                        assert(backup_s.dquant == 0);
4331

    
4332
                        //FIXME intra
4333
                        s->mv_dir= best_s.mv_dir;
4334
                        s->mv_type = MV_TYPE_16X16;
4335
                        s->mb_intra= best_s.mb_intra;
4336
                        s->mv[0][0][0] = best_s.mv[0][0][0];
4337
                        s->mv[0][0][1] = best_s.mv[0][0][1];
4338
                        s->mv[1][0][0] = best_s.mv[1][0][0];
4339
                        s->mv[1][0][1] = best_s.mv[1][0][1];
4340
                        
4341
                        dir= s->pict_type == B_TYPE ? 2 : 1;
4342
                        if(last_qp + dir > s->avctx->qmax) dir= -dir;
4343
                        for(dquant= dir; dquant<=2 && dquant>=-2; dquant += dir){
4344
                            qp= last_qp + dquant;
4345
                            if(qp < s->avctx->qmin || qp > s->avctx->qmax)
4346
                                break;
4347
                            backup_s.dquant= dquant;
4348
                            if(s->mb_intra){
4349
                                for(i=0; i<6; i++){
4350
                                    dc[i]= s->dc_val[0][ s->block_index[i] ];
4351
                                    memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
4352
                                }
4353
                            }
4354

    
4355
                            encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb, 
4356
                                         &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
4357
                            if(best_s.qscale != qp){
4358
                                if(s->mb_intra){
4359
                                    for(i=0; i<6; i++){
4360
                                        s->dc_val[0][ s->block_index[i] ]= dc[i];
4361
                                        memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
4362
                                    }
4363
                                }
4364
                                if(dir > 0 && dquant==dir){
4365
                                    dquant= 0;
4366
                                    dir= -dir;
4367
                                }else
4368
                                    break;
4369
                            }
4370
                        }
4371
                        qp= best_s.qscale;
4372
                        s->current_picture.qscale_table[xy]= qp;
4373
                    }
4374
                }
4375

    
4376
                copy_context_after_encode(s, &best_s, -1);
4377
                
4378
                pb_bits_count= put_bits_count(&s->pb);
4379
                flush_put_bits(&s->pb);
4380
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
4381
                s->pb= backup_s.pb;
4382
                
4383
                if(s->data_partitioning){
4384
                    pb2_bits_count= put_bits_count(&s->pb2);
4385
                    flush_put_bits(&s->pb2);
4386
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
4387
                    s->pb2= backup_s.pb2;
4388
                    
4389
                    tex_pb_bits_count= put_bits_count(&s->tex_pb);
4390
                    flush_put_bits(&s->tex_pb);
4391
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
4392
                    s->tex_pb= backup_s.tex_pb;
4393
                }
4394
                s->last_bits= put_bits_count(&s->pb);
4395
               
4396
#ifdef CONFIG_RISKY
4397
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4398
                    ff_h263_update_motion_val(s);
4399
#endif
4400
        
4401
                if(next_block==0){ //FIXME 16 vs linesize16
4402
                    s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad                     , s->linesize  ,16);
4403
                    s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize    , s->uvlinesize, 8);
4404
                    s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
4405
                }
4406

    
4407
                if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
4408
                    MPV_decode_mb(s, s->block);
4409
            } else {
4410
                int motion_x, motion_y;
4411
                s->mv_type=MV_TYPE_16X16;
4412
                // only one MB-Type possible
4413
                
4414
                switch(mb_type){
4415
                case CANDIDATE_MB_TYPE_INTRA:
4416
                    s->mv_dir = 0;
4417
                    s->mb_intra= 1;
4418
                    motion_x= s->mv[0][0][0] = 0;
4419
                    motion_y= s->mv[0][0][1] = 0;
4420
                    break;
4421
                case CANDIDATE_MB_TYPE_INTER:
4422
                    s->mv_dir = MV_DIR_FORWARD;
4423
                    s->mb_intra= 0;
4424
                    motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
4425
                    motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
4426
                    break;
4427
                case CANDIDATE_MB_TYPE_INTER_I:
4428
                    s->mv_dir = MV_DIR_FORWARD;
4429
                    s->mv_type = MV_TYPE_FIELD;
4430
                    s->mb_intra= 0;
4431
                    for(i=0; i<2; i++){
4432
                        j= s->field_select[0][i] = s->p_field_select_table[i][xy];
4433
                        s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
4434
                        s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
4435
                    }
4436
                    motion_x = motion_y = 0;
4437
                    break;
4438
                case CANDIDATE_MB_TYPE_INTER4V:
4439
                    s->mv_dir = MV_DIR_FORWARD;
4440
                    s->mv_type = MV_TYPE_8X8;
4441
                    s->mb_intra= 0;
4442
                    for(i=0; i<4; i++){
4443
                        s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
4444
                        s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
4445
                    }
4446
                    motion_x= motion_y= 0;
4447
                    break;
4448
                case CANDIDATE_MB_TYPE_DIRECT:
4449
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4450
                    s->mb_intra= 0;
4451
                    motion_x=s->b_direct_mv_table[xy][0];
4452
                    motion_y=s->b_direct_mv_table[xy][1];
4453
#ifdef CONFIG_RISKY
4454
                    ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
4455
#endif
4456
                    break;
4457
                case CANDIDATE_MB_TYPE_BIDIR:
4458
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4459
                    s->mb_intra= 0;
4460
                    motion_x=0;
4461
                    motion_y=0;
4462
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
4463
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
4464
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
4465
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
4466
                    break;
4467
                case CANDIDATE_MB_TYPE_BACKWARD:
4468
                    s->mv_dir = MV_DIR_BACKWARD;
4469
                    s->mb_intra= 0;
4470
                    motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
4471
                    motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
4472
                    break;
4473
                case CANDIDATE_MB_TYPE_FORWARD:
4474
                    s->mv_dir = MV_DIR_FORWARD;
4475
                    s->mb_intra= 0;
4476
                    motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
4477
                    motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
4478
//                    printf(" %d %d ", motion_x, motion_y);
4479
                    break;
4480
                case CANDIDATE_MB_TYPE_FORWARD_I:
4481
                    s->mv_dir = MV_DIR_FORWARD;
4482
                    s->mv_type = MV_TYPE_FIELD;
4483
                    s->mb_intra= 0;
4484
                    for(i=0; i<2; i++){
4485
                        j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
4486
                        s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
4487
                        s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
4488
                    }
4489
                    motion_x=motion_y=0;
4490
                    break;
4491
                case CANDIDATE_MB_TYPE_BACKWARD_I:
4492
                    s->mv_dir = MV_DIR_BACKWARD;
4493
                    s->mv_type = MV_TYPE_FIELD;
4494
                    s->mb_intra= 0;
4495
                    for(i=0; i<2; i++){
4496
                        j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
4497
                        s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
4498
                        s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
4499
                    }
4500
                    motion_x=motion_y=0;
4501
                    break;
4502
                case CANDIDATE_MB_TYPE_BIDIR_I:
4503
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4504
                    s->mv_type = MV_TYPE_FIELD;
4505
                    s->mb_intra= 0;
4506
                    for(dir=0; dir<2; dir++){
4507
                        for(i=0; i<2; i++){
4508
                            j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
4509
                            s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
4510
                            s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
4511
                        }
4512
                    }
4513
                    motion_x=motion_y=0;
4514
                    break;
4515
                default:
4516
                    motion_x=motion_y=0; //gcc warning fix
4517
                    av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
4518
                }
4519

    
4520
                encode_mb(s, motion_x, motion_y);
4521

    
4522
                // RAL: Update last macrobloc type
4523
                s->last_mv_dir = s->mv_dir;
4524
            
4525
#ifdef CONFIG_RISKY
4526
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4527
                    ff_h263_update_motion_val(s);
4528
#endif
4529
                
4530
                MPV_decode_mb(s, s->block);
4531
            }
4532

    
4533
            /* clean the MV table in IPS frames for direct mode in B frames */
4534
            if(s->mb_intra /* && I,P,S_TYPE */){
4535
                s->p_mv_table[xy][0]=0;
4536
                s->p_mv_table[xy][1]=0;
4537
            }
4538
            
4539
            if(s->flags&CODEC_FLAG_PSNR){
4540
                int w= 16;
4541
                int h= 16;
4542

    
4543
                if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4544
                if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4545

    
4546
                s->current_picture_ptr->error[0] += sse(
4547
                    s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
4548
                    s->dest[0], w, h, s->linesize);
4549
                s->current_picture_ptr->error[1] += sse(
4550
                    s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
4551
                    s->dest[1], w>>1, h>>1, s->uvlinesize);
4552
                s->current_picture_ptr->error[2] += sse(
4553
                    s, s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
4554
                    s->dest[2], w>>1, h>>1, s->uvlinesize);
4555
            }
4556
            if(s->loop_filter)
4557
                ff_h263_loop_filter(s);
4558
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
4559
        }
4560
    }
4561

    
4562
#ifdef CONFIG_RISKY
4563
    //not beautifull here but we must write it before flushing so it has to be here
4564
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
4565
        msmpeg4_encode_ext_header(s);
4566
#endif
4567

    
4568
    write_slice_end(s);
4569

    
4570
    /* Send the last GOB if RTP */    
4571
    if (s->avctx->rtp_callback) {
4572
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
4573
        /* Call the RTP callback to send the last GOB */
4574
        emms_c();
4575
        s->avctx->rtp_callback(s->ptr_lastgob, pdif, 0);
4576
    }
4577

    
4578
    return 0;
4579
}
4580

    
4581
#define MERGE(field) dst->field += src->field; src->field=0
4582
static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
4583
    MERGE(scene_change_score);
4584
    MERGE(mc_mb_var_sum_temp);
4585
    MERGE(mb_var_sum_temp);
4586
}
4587

    
4588
static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
4589
    int i;
4590

    
4591
    MERGE(dct_count[0]); //note, the other dct vars are not part of the context
4592
    MERGE(dct_count[1]);
4593
    MERGE(mv_bits);
4594
    MERGE(header_bits);
4595
    MERGE(i_tex_bits);
4596
    MERGE(p_tex_bits);
4597
    MERGE(i_count);
4598
    MERGE(f_count);
4599
    MERGE(b_count);
4600
    MERGE(skip_count);
4601
    MERGE(misc_bits);
4602
    MERGE(error_count);
4603
    MERGE(padding_bug_score);
4604

    
4605
    if(dst->avctx->noise_reduction){
4606
        for(i=0; i<64; i++){
4607
            MERGE(dct_error_sum[0][i]);
4608
            MERGE(dct_error_sum[1][i]);
4609
        }
4610
    }
4611
    
4612
    assert(put_bits_count(&src->pb) % 8 ==0);
4613
    assert(put_bits_count(&dst->pb) % 8 ==0);
4614
    ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
4615
    flush_put_bits(&dst->pb);
4616
}
4617

    
4618
static void encode_picture(MpegEncContext *s, int picture_number)
4619
{
4620
    int i, j;
4621
    int bits;
4622

    
4623
    s->picture_number = picture_number;
4624
    
4625
    /* Reset the average MB variance */
4626
    s->mb_var_sum_temp    =
4627
    s->mc_mb_var_sum_temp = 0;
4628

    
4629
#ifdef CONFIG_RISKY
4630
    /* we need to initialize some time vars before we can encode b-frames */
4631
    // RAL: Condition added for MPEG1VIDEO
4632
    if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
4633
        ff_set_mpeg4_time(s, s->picture_number);  //FIXME rename and use has_b_frames or similar
4634
#endif
4635
        
4636
    s->scene_change_score=0;
4637
    
4638
    s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration
4639
    
4640
    if(s->pict_type==I_TYPE){
4641
        if(s->msmpeg4_version >= 3) s->no_rounding=1;
4642
        else                        s->no_rounding=0;
4643
    }else if(s->pict_type!=B_TYPE){
4644
        if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
4645
            s->no_rounding ^= 1;          
4646
    }
4647
    
4648
    s->mb_intra=0; //for the rate distoration & bit compare functions
4649
    for(i=1; i<s->avctx->thread_count; i++){
4650
        ff_update_duplicate_context(s->thread_context[i], s);
4651
    }
4652
    
4653
    /* Estimate motion for every MB */
4654
    if(s->pict_type != I_TYPE){
4655
        if(s->pict_type != B_TYPE){
4656
            if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
4657
                s->avctx->execute(s->avctx, pre_estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
4658
            }
4659
        }
4660

    
4661
        s->avctx->execute(s->avctx, estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
4662
    }else /* if(s->pict_type == I_TYPE) */{
4663
        /* I-Frame */
4664
        for(i=0; i<s->mb_stride*s->mb_height; i++)
4665
            s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
4666
        
4667
        if(!s->fixed_qscale){