Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 5917d17c

History | View | Annotate | Download (113 KB)

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

    
28
#ifdef USE_FASTMEMCPY
29
#include "fastmemcpy.h"
30
#endif
31

    
32
//#undef NDEBUG
33
//#include <assert.h>
34

    
35
static void encode_picture(MpegEncContext *s, int picture_number);
36
static void dct_unquantize_mpeg1_c(MpegEncContext *s, 
37
                                   DCTELEM *block, int n, int qscale);
38
static void dct_unquantize_mpeg2_c(MpegEncContext *s,
39
                                   DCTELEM *block, int n, int qscale);
40
static void dct_unquantize_h263_c(MpegEncContext *s, 
41
                                  DCTELEM *block, int n, int qscale);
42
static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w);
43
static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
44

    
45
void (*draw_edges)(UINT8 *buf, int wrap, int width, int height, int w)= draw_edges_c;
46
static void emulated_edge_mc(MpegEncContext *s, UINT8 *src, int linesize, int block_w, int block_h, 
47
                                    int src_x, int src_y, int w, int h);
48

    
49
#define EDGE_WIDTH 16
50

    
51
/* enable all paranoid tests for rounding, overflows, etc... */
52
//#define PARANOID
53

    
54
//#define DEBUG
55

    
56

    
57
/* for jpeg fast DCT */
58
#define CONST_BITS 14
59

    
60
static const unsigned short aanscales[64] = {
61
    /* precomputed values scaled up by 14 bits */
62
    16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
63
    22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
64
    21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
65
    19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
66
    16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
67
    12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
68
    8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
69
    4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
70
};
71

    
72
static UINT8 h263_chroma_roundtab[16] = {
73
    0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
74
};
75

    
76
static UINT16 default_mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
77
static UINT8 default_fcode_tab[MAX_MV*2+1];
78

    
79
/* default motion estimation */
80
int motion_estimation_method = ME_EPZS;
81

    
82
static void convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[64], uint16_t (*qmat16_bias)[64],
83
                           const UINT16 *quant_matrix, int bias, int qmin, int qmax)
84
{
85
    int qscale;
86

    
87
    for(qscale=qmin; qscale<=qmax; qscale++){
88
        int i;
89
        if (s->fdct == ff_jpeg_fdct_islow) {
90
            for(i=0;i<64;i++) {
91
                const int j= s->idct_permutation[i];
92
                /* 16 <= qscale * quant_matrix[i] <= 7905 */
93
                /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
94
                /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
95
                /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
96
                
97
                qmat[qscale][j] = (int)((UINT64_C(1) << QMAT_SHIFT) / 
98
                                (qscale * quant_matrix[j]));
99
            }
100
        } else if (s->fdct == fdct_ifast) {
101
            for(i=0;i<64;i++) {
102
                const int j= s->idct_permutation[i];
103
                /* 16 <= qscale * quant_matrix[i] <= 7905 */
104
                /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
105
                /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
106
                /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
107
                
108
                qmat[qscale][j] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) / 
109
                                (aanscales[i] * qscale * quant_matrix[j]));
110
            }
111
        } else {
112
            for(i=0;i<64;i++) {
113
                const int j= s->idct_permutation[i];
114
                /* We can safely suppose that 16 <= quant_matrix[i] <= 255
115
                   So 16           <= qscale * quant_matrix[i]             <= 7905
116
                   so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
117
                   so 32768        >= (1<<19) / (qscale * quant_matrix[i]) >= 67
118
                */
119
                qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
120
                qmat16[qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
121

    
122
                if(qmat16[qscale][i]==0 || qmat16[qscale][i]==128*256) qmat16[qscale][i]=128*256-1;
123
                qmat16_bias[qscale][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][i]);
124
            }
125
        }
126
    }
127
}
128
// move into common.c perhaps 
129
#define CHECKED_ALLOCZ(p, size)\
130
{\
131
    p= av_mallocz(size);\
132
    if(p==NULL){\
133
        perror("malloc");\
134
        goto fail;\
135
    }\
136
}
137
/*
138
static void build_end(void)
139
{
140
    int lastIndex;
141
    int lastIndexAfterPerm=0;
142
    for(lastIndex=0; lastIndex<64; lastIndex++)
143
    {
144
        if(ff_zigzag_direct[lastIndex] > lastIndexAfterPerm) 
145
            lastIndexAfterPerm= ff_zigzag_direct[lastIndex];
146
        zigzag_end[lastIndex]= lastIndexAfterPerm + 1;
147
    }
148
}
149
*/
150
void ff_init_scantable(MpegEncContext *s, ScanTable *st, const UINT8 *src_scantable){
151
    int i;
152
    int end;
153

    
154
    for(i=0; i<64; i++){
155
        int j;
156
        j = src_scantable[i];
157
        st->permutated[i] = s->idct_permutation[j];
158
    }
159
    
160
    end=-1;
161
    for(i=0; i<64; i++){
162
        int j;
163
        j = st->permutated[i];
164
        if(j>end) end=j;
165
        st->raster_end[i]= end;
166
    }
167
}
168

    
169
/* XXX: those functions should be suppressed ASAP when all IDCTs are
170
   converted */
171
static void ff_jref_idct_put(UINT8 *dest, int line_size, DCTELEM *block)
172
{
173
    j_rev_dct (block);
174
    put_pixels_clamped(block, dest, line_size);
175
}
176
static void ff_jref_idct_add(UINT8 *dest, int line_size, DCTELEM *block)
177
{
178
    j_rev_dct (block);
179
    add_pixels_clamped(block, dest, line_size);
180
}
181

    
182
/* init common structure for both encoder and decoder */
183
int MPV_common_init(MpegEncContext *s)
184
{
185
    int c_size, i;
186
    UINT8 *pict;
187

    
188
    s->dct_unquantize_h263 = dct_unquantize_h263_c;
189
    s->dct_unquantize_mpeg1 = dct_unquantize_mpeg1_c;
190
    s->dct_unquantize_mpeg2 = dct_unquantize_mpeg2_c;
191
    s->dct_quantize= dct_quantize_c;
192

    
193
    if(s->avctx->dct_algo==FF_DCT_FASTINT)
194
        s->fdct = fdct_ifast;
195
    else
196
        s->fdct = ff_jpeg_fdct_islow; //slow/accurate/default
197

    
198
    if(s->avctx->idct_algo==FF_IDCT_INT){
199
        s->idct_put= ff_jref_idct_put;
200
        s->idct_add= ff_jref_idct_add;
201
        for(i=0; i<64; i++)
202
            s->idct_permutation[i]= (i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2);
203
    }else{ //accurate/default
204
        s->idct_put= simple_idct_put;
205
        s->idct_add= simple_idct_add;
206
        for(i=0; i<64; i++)
207
            s->idct_permutation[i]= i;
208
    }
209
        
210
#ifdef HAVE_MMX
211
    MPV_common_init_mmx(s);
212
#endif
213
#ifdef ARCH_ALPHA
214
    MPV_common_init_axp(s);
215
#endif
216
#ifdef HAVE_MLIB
217
    MPV_common_init_mlib(s);
218
#endif
219
#ifdef HAVE_MMI
220
    MPV_common_init_mmi(s);
221
#endif
222
    
223

    
224
    /* load & permutate scantables
225
       note: only wmv uses differnt ones 
226
    */
227
    ff_init_scantable(s, &s->inter_scantable  , ff_zigzag_direct);
228
    ff_init_scantable(s, &s->intra_scantable  , ff_zigzag_direct);
229
    ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);
230
    ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
231

    
232
    s->mb_width = (s->width + 15) / 16;
233
    s->mb_height = (s->height + 15) / 16;
234
    
235
    /* set default edge pos, will be overriden in decode_header if needed */
236
    s->h_edge_pos= s->mb_width*16;
237
    s->v_edge_pos= s->mb_height*16;
238
    
239
    /* convert fourcc to upper case */
240
    s->avctx->fourcc=   toupper( s->avctx->fourcc     &0xFF)          
241
                     + (toupper((s->avctx->fourcc>>8 )&0xFF)<<8 )
242
                     + (toupper((s->avctx->fourcc>>16)&0xFF)<<16) 
243
                     + (toupper((s->avctx->fourcc>>24)&0xFF)<<24);
244

    
245
    s->mb_num = s->mb_width * s->mb_height;
246
    if(!(s->flags&CODEC_FLAG_DR1)){
247
      s->linesize   = s->mb_width * 16 + 2 * EDGE_WIDTH;
248
      s->uvlinesize = s->mb_width * 8  +     EDGE_WIDTH;
249

    
250
      for(i=0;i<3;i++) {
251
        int w, h, shift, pict_start;
252

    
253
        w = s->linesize;
254
        h = s->mb_height * 16 + 2 * EDGE_WIDTH;
255
        shift = (i == 0) ? 0 : 1;
256
        c_size = (s->linesize>>shift) * (h >> shift);
257
        pict_start = (s->linesize>>shift) * (EDGE_WIDTH >> shift) + (EDGE_WIDTH >> shift);
258

    
259
        CHECKED_ALLOCZ(pict, c_size)
260
        s->last_picture_base[i] = pict;
261
        s->last_picture[i] = pict + pict_start;
262
        if(i>0) memset(s->last_picture_base[i], 128, c_size);
263
    
264
        CHECKED_ALLOCZ(pict, c_size)
265
        s->next_picture_base[i] = pict;
266
        s->next_picture[i] = pict + pict_start;
267
        if(i>0) memset(s->next_picture_base[i], 128, c_size);
268
        
269
        if (s->has_b_frames || s->codec_id==CODEC_ID_MPEG4) {
270
        /* Note the MPEG4 stuff is here cuz of buggy encoders which dont set the low_delay flag but 
271
           do low-delay encoding, so we cant allways distinguish b-frame containing streams from low_delay streams */
272
            CHECKED_ALLOCZ(pict, c_size)
273
            s->aux_picture_base[i] = pict;
274
            s->aux_picture[i] = pict + pict_start;
275
            if(i>0) memset(s->aux_picture_base[i], 128, c_size);
276
        }
277
      }
278
      s->ip_buffer_count= 2;
279
    }
280
    
281
    CHECKED_ALLOCZ(s->edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
282
    
283
    if (s->encoding) {
284
        int j;
285
        int mv_table_size= (s->mb_width+2)*(s->mb_height+2);
286
        
287
        CHECKED_ALLOCZ(s->mb_var   , s->mb_num * sizeof(INT16))
288
        CHECKED_ALLOCZ(s->mc_mb_var, s->mb_num * sizeof(INT16))
289
        CHECKED_ALLOCZ(s->mb_mean  , s->mb_num * sizeof(INT8))
290

    
291
        /* Allocate MV tables */
292
        CHECKED_ALLOCZ(s->p_mv_table            , mv_table_size * 2 * sizeof(INT16))
293
        CHECKED_ALLOCZ(s->b_forw_mv_table       , mv_table_size * 2 * sizeof(INT16))
294
        CHECKED_ALLOCZ(s->b_back_mv_table       , mv_table_size * 2 * sizeof(INT16))
295
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table , mv_table_size * 2 * sizeof(INT16))
296
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table , mv_table_size * 2 * sizeof(INT16))
297
        CHECKED_ALLOCZ(s->b_direct_forw_mv_table, mv_table_size * 2 * sizeof(INT16))
298
        CHECKED_ALLOCZ(s->b_direct_back_mv_table, mv_table_size * 2 * sizeof(INT16))
299
        CHECKED_ALLOCZ(s->b_direct_mv_table     , mv_table_size * 2 * sizeof(INT16))
300

    
301
        CHECKED_ALLOCZ(s->me_scratchpad,  s->linesize*16*3*sizeof(uint8_t))
302
        
303
        CHECKED_ALLOCZ(s->me_map      , ME_MAP_SIZE*sizeof(uint32_t))
304
        CHECKED_ALLOCZ(s->me_score_map, ME_MAP_SIZE*sizeof(uint16_t))
305

    
306
        if(s->max_b_frames){
307
            for(j=0; j<REORDER_BUFFER_SIZE; j++){
308
                int i;
309
                for(i=0;i<3;i++) {
310
                    int w, h, shift;
311

    
312
                    w = s->linesize;
313
                    h = s->mb_height * 16;
314
                    shift = (i == 0) ? 0 : 1;
315
                    c_size = (w >> shift) * (h >> shift);
316

    
317
                    CHECKED_ALLOCZ(pict, c_size);
318
                    s->picture_buffer[j][i] = pict;
319
                }
320
            }
321
        }
322

    
323
        if(s->codec_id==CODEC_ID_MPEG4){
324
            CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
325
            CHECKED_ALLOCZ(   s->pb2_buffer, PB_BUFFER_SIZE);
326
        }
327
        
328
        if(s->msmpeg4_version){
329
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
330
        }
331
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
332
    }
333
    
334
    if (s->out_format == FMT_H263 || s->encoding) {
335
        int size;
336
        /* Allocate MB type table */
337
        CHECKED_ALLOCZ(s->mb_type  , s->mb_num * sizeof(UINT8))
338

    
339
        /* MV prediction */
340
        size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
341
        CHECKED_ALLOCZ(s->motion_val, size * 2 * sizeof(INT16));
342
    }
343

    
344
    if(s->codec_id==CODEC_ID_MPEG4){
345
        /* 4mv and interlaced direct mode decoding tables */
346
        CHECKED_ALLOCZ(s->co_located_type_table, s->mb_num * sizeof(UINT8))
347
        CHECKED_ALLOCZ(s->field_mv_table, s->mb_num*2*2 * sizeof(INT16))
348
        CHECKED_ALLOCZ(s->field_select_table, s->mb_num*2* sizeof(INT8))
349
    }
350

    
351
    if (s->h263_pred || s->h263_plus) {
352
        int y_size, c_size, i, size;
353
        
354
        /* dc values */
355

    
356
        y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
357
        c_size = (s->mb_width + 2) * (s->mb_height + 2);
358
        size = y_size + 2 * c_size;
359
        CHECKED_ALLOCZ(s->dc_val[0], size * sizeof(INT16));
360
        s->dc_val[1] = s->dc_val[0] + y_size;
361
        s->dc_val[2] = s->dc_val[1] + c_size;
362
        for(i=0;i<size;i++)
363
            s->dc_val[0][i] = 1024;
364

    
365
        /* ac values */
366
        CHECKED_ALLOCZ(s->ac_val[0], size * sizeof(INT16) * 16);
367
        s->ac_val[1] = s->ac_val[0] + y_size;
368
        s->ac_val[2] = s->ac_val[1] + c_size;
369
        
370
        /* cbp values */
371
        CHECKED_ALLOCZ(s->coded_block, y_size);
372
        
373
        /* divx501 bitstream reorder buffer */
374
        CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
375
        
376
        /* cbp, ac_pred, pred_dir */
377
        CHECKED_ALLOCZ(s->cbp_table  , s->mb_num * sizeof(UINT8))
378
        CHECKED_ALLOCZ(s->pred_dir_table, s->mb_num * sizeof(UINT8))
379
    }
380
    CHECKED_ALLOCZ(s->qscale_table  , s->mb_num * sizeof(UINT8))
381
    
382
    /* which mb is a intra block */
383
    CHECKED_ALLOCZ(s->mbintra_table, s->mb_num);
384
    memset(s->mbintra_table, 1, s->mb_num);
385
    
386
    /* default structure is frame */
387
    s->picture_structure = PICT_FRAME;
388
    
389
    /* init macroblock skip table */
390
    CHECKED_ALLOCZ(s->mbskip_table, s->mb_num);
391
    
392
    s->block= s->blocks[0];
393

    
394
    s->context_initialized = 1;
395
    return 0;
396
 fail:
397
    MPV_common_end(s);
398
    return -1;
399
}
400

    
401

    
402
//extern int sads;
403

    
404
/* init common structure for both encoder and decoder */
405
void MPV_common_end(MpegEncContext *s)
406
{
407
    int i;
408

    
409
    av_freep(&s->mb_type);
410
    av_freep(&s->mb_var);
411
    av_freep(&s->mc_mb_var);
412
    av_freep(&s->mb_mean);
413
    av_freep(&s->p_mv_table);
414
    av_freep(&s->b_forw_mv_table);
415
    av_freep(&s->b_back_mv_table);
416
    av_freep(&s->b_bidir_forw_mv_table);
417
    av_freep(&s->b_bidir_back_mv_table);
418
    av_freep(&s->b_direct_forw_mv_table);
419
    av_freep(&s->b_direct_back_mv_table);
420
    av_freep(&s->b_direct_mv_table);
421
    av_freep(&s->motion_val);
422
    av_freep(&s->dc_val[0]);
423
    av_freep(&s->ac_val[0]);
424
    av_freep(&s->coded_block);
425
    av_freep(&s->mbintra_table);
426
    av_freep(&s->cbp_table);
427
    av_freep(&s->pred_dir_table);
428
    av_freep(&s->qscale_table);
429
    av_freep(&s->me_scratchpad);
430
    av_freep(&s->me_map);
431
    av_freep(&s->me_score_map);
432
    
433
    av_freep(&s->mbskip_table);
434
    av_freep(&s->bitstream_buffer);
435
    av_freep(&s->tex_pb_buffer);
436
    av_freep(&s->pb2_buffer);
437
    av_freep(&s->edge_emu_buffer);
438
    av_freep(&s->co_located_type_table);
439
    av_freep(&s->field_mv_table);
440
    av_freep(&s->field_select_table);
441
    av_freep(&s->avctx->stats_out);
442
    av_freep(&s->ac_stats);
443
    
444
    for(i=0;i<3;i++) {
445
        int j;
446
        if(!(s->flags&CODEC_FLAG_DR1)){
447
            av_freep(&s->last_picture_base[i]);
448
            av_freep(&s->next_picture_base[i]);
449
            av_freep(&s->aux_picture_base[i]);
450
        }
451
        s->last_picture_base[i]=
452
        s->next_picture_base[i]=
453
        s->aux_picture_base [i] = NULL;
454
        s->last_picture[i]=
455
        s->next_picture[i]=
456
        s->aux_picture [i] = NULL;
457

    
458
        for(j=0; j<REORDER_BUFFER_SIZE; j++){
459
            av_freep(&s->picture_buffer[j][i]);
460
        }
461
    }
462
    s->context_initialized = 0;
463
}
464

    
465
/* init video encoder */
466
int MPV_encode_init(AVCodecContext *avctx)
467
{
468
    MpegEncContext *s = avctx->priv_data;
469
    int i;
470

    
471
    avctx->pix_fmt = PIX_FMT_YUV420P;
472

    
473
    s->bit_rate = avctx->bit_rate;
474
    s->bit_rate_tolerance = avctx->bit_rate_tolerance;
475
    s->frame_rate = avctx->frame_rate;
476
    s->width = avctx->width;
477
    s->height = avctx->height;
478
    if(avctx->gop_size > 600){
479
        fprintf(stderr, "Warning keyframe interval too large! reducing it ...\n");
480
        avctx->gop_size=600;
481
    }
482
    s->gop_size = avctx->gop_size;
483
    s->rtp_mode = avctx->rtp_mode;
484
    s->rtp_payload_size = avctx->rtp_payload_size;
485
    if (avctx->rtp_callback)
486
        s->rtp_callback = avctx->rtp_callback;
487
    s->qmin= avctx->qmin;
488
    s->qmax= avctx->qmax;
489
    s->max_qdiff= avctx->max_qdiff;
490
    s->qcompress= avctx->qcompress;
491
    s->qblur= avctx->qblur;
492
    s->avctx = avctx;
493
    s->aspect_ratio_info= avctx->aspect_ratio_info;
494
    if (avctx->aspect_ratio_info == FF_ASPECT_EXTENDED)
495
    {
496
        s->aspected_width = avctx->aspected_width;
497
        s->aspected_height = avctx->aspected_height;
498
    }
499
    s->flags= avctx->flags;
500
    s->max_b_frames= avctx->max_b_frames;
501
    s->b_frame_strategy= avctx->b_frame_strategy;
502
    s->codec_id= avctx->codec->id;
503
    s->luma_elim_threshold  = avctx->luma_elim_threshold;
504
    s->chroma_elim_threshold= avctx->chroma_elim_threshold;
505
    s->strict_std_compliance= avctx->strict_std_compliance;
506
    s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
507
    s->mpeg_quant= avctx->mpeg_quant;
508

    
509
    if (s->gop_size <= 1) {
510
        s->intra_only = 1;
511
        s->gop_size = 12;
512
    } else {
513
        s->intra_only = 0;
514
    }
515

    
516
    /* ME algorithm */
517
    if (avctx->me_method == 0)
518
        /* For compatibility */
519
        s->me_method = motion_estimation_method;
520
    else
521
        s->me_method = avctx->me_method;
522

    
523
    /* Fixed QSCALE */
524
    s->fixed_qscale = (avctx->flags & CODEC_FLAG_QSCALE);
525
    
526
    s->adaptive_quant= (   s->avctx->lumi_masking
527
                        || s->avctx->dark_masking
528
                        || s->avctx->temporal_cplx_masking 
529
                        || s->avctx->spatial_cplx_masking
530
                        || s->avctx->p_masking)
531
                       && !s->fixed_qscale;
532
    
533
    s->progressive_sequence= !(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
534

    
535
    switch(avctx->codec->id) {
536
    case CODEC_ID_MPEG1VIDEO:
537
        s->out_format = FMT_MPEG1;
538
        avctx->delay=0; //FIXME not sure, should check the spec
539
        break;
540
    case CODEC_ID_MJPEG:
541
        s->out_format = FMT_MJPEG;
542
        s->intra_only = 1; /* force intra only for jpeg */
543
        s->mjpeg_write_tables = 1; /* write all tables */
544
        s->mjpeg_data_only_frames = 0; /* write all the needed headers */
545
        s->mjpeg_vsample[0] = 2; /* set up default sampling factors */
546
        s->mjpeg_vsample[1] = 1; /* the only currently supported values */
547
        s->mjpeg_vsample[2] = 1; 
548
        s->mjpeg_hsample[0] = 2;
549
        s->mjpeg_hsample[1] = 1; 
550
        s->mjpeg_hsample[2] = 1; 
551
        if (mjpeg_init(s) < 0)
552
            return -1;
553
        avctx->delay=0;
554
        break;
555
    case CODEC_ID_H263:
556
        if (h263_get_picture_format(s->width, s->height) == 7) {
557
            printf("Input picture size isn't suitable for h263 codec! try h263+\n");
558
            return -1;
559
        }
560
        s->out_format = FMT_H263;
561
        avctx->delay=0;
562
        break;
563
    case CODEC_ID_H263P:
564
        s->out_format = FMT_H263;
565
        s->rtp_mode = 1;
566
        s->rtp_payload_size = 1200; 
567
        s->h263_plus = 1;
568
        s->unrestricted_mv = 1;
569
        s->h263_aic = 1;
570
        
571
        /* These are just to be sure */
572
        s->umvplus = 0;
573
        s->umvplus_dec = 0;
574
        avctx->delay=0;
575
        break;
576
    case CODEC_ID_RV10:
577
        s->out_format = FMT_H263;
578
        s->h263_rv10 = 1;
579
        avctx->delay=0;
580
        break;
581
    case CODEC_ID_MPEG4:
582
        s->out_format = FMT_H263;
583
        s->h263_pred = 1;
584
        s->unrestricted_mv = 1;
585
        s->has_b_frames= s->max_b_frames ? 1 : 0;
586
        s->low_delay=0;
587
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); 
588
        break;
589
    case CODEC_ID_MSMPEG4V1:
590
        s->out_format = FMT_H263;
591
        s->h263_msmpeg4 = 1;
592
        s->h263_pred = 1;
593
        s->unrestricted_mv = 1;
594
        s->msmpeg4_version= 1;
595
        avctx->delay=0;
596
        break;
597
    case CODEC_ID_MSMPEG4V2:
598
        s->out_format = FMT_H263;
599
        s->h263_msmpeg4 = 1;
600
        s->h263_pred = 1;
601
        s->unrestricted_mv = 1;
602
        s->msmpeg4_version= 2;
603
        avctx->delay=0;
604
        break;
605
    case CODEC_ID_MSMPEG4V3:
606
        s->out_format = FMT_H263;
607
        s->h263_msmpeg4 = 1;
608
        s->h263_pred = 1;
609
        s->unrestricted_mv = 1;
610
        s->msmpeg4_version= 3;
611
        avctx->delay=0;
612
        break;
613
    case CODEC_ID_WMV1:
614
        s->out_format = FMT_H263;
615
        s->h263_msmpeg4 = 1;
616
        s->h263_pred = 1;
617
        s->unrestricted_mv = 1;
618
        s->msmpeg4_version= 4;
619
        avctx->delay=0;
620
        break;
621
    case CODEC_ID_WMV2:
622
        s->out_format = FMT_H263;
623
        s->h263_msmpeg4 = 1;
624
        s->h263_pred = 1;
625
        s->unrestricted_mv = 1;
626
        s->msmpeg4_version= 5;
627
        avctx->delay=0;
628
        break;
629
    default:
630
        return -1;
631
    }
632
    
633
    { /* set up some save defaults, some codecs might override them later */
634
        static int done=0;
635
        if(!done){
636
            int i;
637
            done=1;
638
            memset(default_mv_penalty, 0, sizeof(UINT16)*(MAX_FCODE+1)*(2*MAX_MV+1));
639
            memset(default_fcode_tab , 0, sizeof(UINT8)*(2*MAX_MV+1));
640

    
641
            for(i=-16; i<16; i++){
642
                default_fcode_tab[i + MAX_MV]= 1;
643
            }
644
        }
645
    }
646
    s->mv_penalty= default_mv_penalty;
647
    s->fcode_tab= default_fcode_tab;
648
    s->y_dc_scale_table=
649
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
650
 
651
    /* dont use mv_penalty table for crap MV as it would be confused */
652
    if (s->me_method < ME_EPZS) s->mv_penalty = default_mv_penalty;
653

    
654
    s->encoding = 1;
655

    
656
    /* init */
657
    if (MPV_common_init(s) < 0)
658
        return -1;
659
    
660
    if (s->out_format == FMT_H263)
661
        h263_encode_init(s);
662
    else if (s->out_format == FMT_MPEG1)
663
        ff_mpeg1_encode_init(s);
664
    if(s->msmpeg4_version)
665
        ff_msmpeg4_encode_init(s);
666

    
667
    /* init default q matrix */
668
    for(i=0;i<64;i++) {
669
        int j= s->idct_permutation[i];
670
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
671
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
672
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
673
        }else if(s->out_format == FMT_H263){
674
            s->intra_matrix[j] =
675
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
676
        }else{ /* mpeg1 */
677
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
678
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
679
        }
680
    }
681

    
682
    /* precompute matrix */
683
    /* for mjpeg, we do include qscale in the matrix */
684
    if (s->out_format != FMT_MJPEG) {
685
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, s->q_intra_matrix16_bias, 
686
                       s->intra_matrix, s->intra_quant_bias, 1, 31);
687
        convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16, s->q_inter_matrix16_bias, 
688
                       s->inter_matrix, s->inter_quant_bias, 1, 31);
689
    }
690

    
691
    if(ff_rate_control_init(s) < 0)
692
        return -1;
693

    
694
    s->picture_number = 0;
695
    s->picture_in_gop_number = 0;
696
    s->fake_picture_number = 0;
697
    /* motion detector init */
698
    s->f_code = 1;
699
    s->b_code = 1;
700

    
701
    return 0;
702
}
703

    
704
int MPV_encode_end(AVCodecContext *avctx)
705
{
706
    MpegEncContext *s = avctx->priv_data;
707

    
708
#ifdef STATS
709
    print_stats();
710
#endif
711

    
712
    ff_rate_control_uninit(s);
713

    
714
    MPV_common_end(s);
715
    if (s->out_format == FMT_MJPEG)
716
        mjpeg_close(s);
717
      
718
    return 0;
719
}
720

    
721
/* draw the edges of width 'w' of an image of size width, height */
722
//FIXME check that this is ok for mpeg4 interlaced
723
static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w)
724
{
725
    UINT8 *ptr, *last_line;
726
    int i;
727

    
728
    last_line = buf + (height - 1) * wrap;
729
    for(i=0;i<w;i++) {
730
        /* top and bottom */
731
        memcpy(buf - (i + 1) * wrap, buf, width);
732
        memcpy(last_line + (i + 1) * wrap, last_line, width);
733
    }
734
    /* left and right */
735
    ptr = buf;
736
    for(i=0;i<height;i++) {
737
        memset(ptr - w, ptr[0], w);
738
        memset(ptr + width, ptr[width-1], w);
739
        ptr += wrap;
740
    }
741
    /* corners */
742
    for(i=0;i<w;i++) {
743
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
744
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
745
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
746
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
747
    }
748
}
749

    
750
/* generic function for encode/decode called before a frame is coded/decoded */
751
void MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
752
{
753
    int i;
754
    UINT8 *tmp;
755

    
756
    s->mb_skiped = 0;
757
    s->decoding_error=0;
758
    avctx->mbskip_table= s->mbskip_table;
759

    
760
    if(avctx->flags&CODEC_FLAG_DR1){
761
        avctx->get_buffer_callback(avctx, s->width, s->height, s->pict_type);
762

    
763
        s->linesize  = avctx->dr_stride;
764
        s->uvlinesize= avctx->dr_uvstride;
765
        s->ip_buffer_count= avctx->dr_ip_buffer_count;
766
    }
767
    avctx->dr_ip_buffer_count= s->ip_buffer_count;
768
    
769
    if (s->pict_type == B_TYPE) {
770
        for(i=0;i<3;i++) {
771
            if(avctx->flags&CODEC_FLAG_DR1)
772
                s->aux_picture[i]= avctx->dr_buffer[i];
773
            
774
            //FIXME the following should never be needed, the decoder should drop b frames if no reference is available
775
            if(s->next_picture[i]==NULL)
776
                s->next_picture[i]= s->aux_picture[i];
777
            if(s->last_picture[i]==NULL)
778
                s->last_picture[i]= s->next_picture[i];
779

    
780
            s->current_picture[i] = s->aux_picture[i];
781
        }
782
    } else {
783
        for(i=0;i<3;i++) {
784
            /* swap next and last */
785
            if(avctx->flags&CODEC_FLAG_DR1)
786
                tmp= avctx->dr_buffer[i];
787
            else
788
                tmp = s->last_picture[i];
789

    
790
            s->last_picture[i] = s->next_picture[i];
791
            s->next_picture[i] = tmp;
792
            s->current_picture[i] = tmp;
793

    
794
            if(s->last_picture[i]==NULL)
795
                s->last_picture[i]= s->next_picture[i];
796

    
797
            s->last_dr_opaque= s->next_dr_opaque;
798
            s->next_dr_opaque= avctx->dr_opaque_frame;
799

    
800
            if(s->has_b_frames && s->last_dr_opaque && s->codec_id!=CODEC_ID_SVQ1)
801
                avctx->dr_opaque_frame= s->last_dr_opaque;
802
            else
803
                avctx->dr_opaque_frame= s->next_dr_opaque;
804
        }
805
    }
806
    /* set dequantizer, we cant do it during init as it might change for mpeg4
807
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
808
    if(s->out_format == FMT_H263){
809
        if(s->mpeg_quant)
810
            s->dct_unquantize = s->dct_unquantize_mpeg2;
811
        else
812
            s->dct_unquantize = s->dct_unquantize_h263;
813
    }else 
814
        s->dct_unquantize = s->dct_unquantize_mpeg1;
815
}
816

    
817
/* generic function for encode/decode called after a frame has been coded/decoded */
818
void MPV_frame_end(MpegEncContext *s)
819
{
820
    s->avctx->key_frame   = (s->pict_type == I_TYPE);
821
    s->avctx->pict_type   = s->pict_type;
822

    
823
    /* draw edge for correct motion prediction if outside */
824
    if (s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
825
        draw_edges(s->current_picture[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
826
        draw_edges(s->current_picture[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
827
        draw_edges(s->current_picture[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
828
    }
829
    emms_c();
830
    
831
    s->last_pict_type    = s->pict_type;
832
    if(s->pict_type!=B_TYPE){
833
        s->last_non_b_pict_type= s->pict_type;
834
        s->num_available_buffers++;
835
        if(s->num_available_buffers>2) s->num_available_buffers= 2;
836
    }
837
}
838

    
839
/* reorder input for encoding */
840
void reorder_input(MpegEncContext *s, AVPicture *pict)
841
{
842
    int i, j, index;
843
            
844
    if(s->max_b_frames > FF_MAX_B_FRAMES) s->max_b_frames= FF_MAX_B_FRAMES;
845

    
846
//        delay= s->max_b_frames+1; (or 0 if no b frames cuz decoder diff)
847

    
848
    for(j=0; j<REORDER_BUFFER_SIZE-1; j++){
849
        s->coded_order[j]= s->coded_order[j+1];
850
    }
851
    s->coded_order[j].picture[0]= s->coded_order[j].picture[1]= s->coded_order[j].picture[2]= NULL; //catch uninitalized buffers
852
    s->coded_order[j].pict_type=0;
853

    
854
    switch(s->input_pict_type){
855
    default: 
856
    case I_TYPE:
857
    case S_TYPE:
858
    case P_TYPE:
859
        index= s->max_b_frames - s->b_frames_since_non_b;
860
        s->b_frames_since_non_b=0;
861
        break;            
862
    case B_TYPE:
863
        index= s->max_b_frames + 1;
864
        s->b_frames_since_non_b++;
865
        break;          
866
    }
867
//printf("index:%d type:%d strides: %d %d\n", index, s->input_pict_type, pict->linesize[0], s->linesize);
868
    if(   (index==0 || (s->flags&CODEC_FLAG_INPUT_PRESERVED))
869
       && pict->linesize[0] == s->linesize
870
       && pict->linesize[1] == s->uvlinesize
871
       && pict->linesize[2] == s->uvlinesize){
872
//printf("ptr\n");
873
        for(i=0; i<3; i++){
874
            s->coded_order[index].picture[i]= pict->data[i];
875
        }
876
    }else{
877
//printf("copy\n");
878
        for(i=0; i<3; i++){
879
            uint8_t *src = pict->data[i];
880
            uint8_t *dest;
881
            int src_wrap = pict->linesize[i];
882
            int dest_wrap = s->linesize;
883
            int w = s->width;
884
            int h = s->height;
885

    
886
            if(index==0) dest= s->last_picture[i]+16; //is current_picture indeed but the switch hapens after reordering
887
            else         dest= s->picture_buffer[s->picture_buffer_index][i];
888

    
889
            if (i >= 1) {
890
                dest_wrap >>= 1;
891
                w >>= 1;
892
                h >>= 1;
893
            }
894

    
895
            s->coded_order[index].picture[i]= dest;
896
            for(j=0;j<h;j++) {
897
                memcpy(dest, src, w);
898
                dest += dest_wrap;
899
                src += src_wrap;
900
            }
901
        }
902
        if(index!=0){
903
            s->picture_buffer_index++;
904
            if(s->picture_buffer_index >= REORDER_BUFFER_SIZE) s->picture_buffer_index=0;
905
        }
906
    }
907
    s->coded_order[index].pict_type = s->input_pict_type;
908
    s->coded_order[index].qscale    = s->input_qscale;
909
    s->coded_order[index].force_type= s->force_input_type;
910
    s->coded_order[index].picture_in_gop_number= s->input_picture_in_gop_number;
911
    s->coded_order[index].picture_number= s->input_picture_number;
912

    
913
    for(i=0; i<3; i++){
914
        s->new_picture[i]= s->coded_order[0].picture[i];
915
    }
916
}
917

    
918
int MPV_encode_picture(AVCodecContext *avctx,
919
                       unsigned char *buf, int buf_size, void *data)
920
{
921
    MpegEncContext *s = avctx->priv_data;
922
    AVPicture *pict = data;
923

    
924
    s->input_qscale = avctx->quality;
925

    
926
    init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
927

    
928
    if(avctx->flags&CODEC_FLAG_TYPE){
929
        s->input_pict_type=
930
        s->force_input_type= avctx->key_frame ? I_TYPE : P_TYPE;
931
    }else if(s->flags&CODEC_FLAG_PASS2){
932
        s->input_pict_type=
933
        s->force_input_type= s->rc_context.entry[s->input_picture_number].new_pict_type;
934
    }else{
935
        s->force_input_type=0;
936
        if (!s->intra_only) {
937
            /* first picture of GOP is intra */
938
            if (s->input_picture_in_gop_number % s->gop_size==0){
939
                s->input_pict_type = I_TYPE;
940
            }else if(s->max_b_frames==0){
941
                s->input_pict_type = P_TYPE;
942
            }else{
943
                if(s->b_frames_since_non_b < s->max_b_frames) //FIXME more IQ
944
                    s->input_pict_type = B_TYPE;
945
                else
946
                    s->input_pict_type = P_TYPE;
947
            }
948
        } else {
949
            s->input_pict_type = I_TYPE;
950
        }
951
    }
952

    
953
    if(s->input_pict_type==I_TYPE)
954
        s->input_picture_in_gop_number=0;
955
    
956
    reorder_input(s, pict);
957
    
958
    /* output? */
959
    if(s->coded_order[0].picture[0]){
960

    
961
        s->pict_type= s->coded_order[0].pict_type;
962
        if (s->fixed_qscale) /* the ratecontrol needs the last qscale so we dont touch it for CBR */
963
            s->qscale= s->coded_order[0].qscale;
964
        s->force_type= s->coded_order[0].force_type;
965
        s->picture_in_gop_number= s->coded_order[0].picture_in_gop_number;
966
        s->picture_number= s->coded_order[0].picture_number;
967

    
968
        MPV_frame_start(s, avctx);
969

    
970
        encode_picture(s, s->picture_number);
971
        
972
        avctx->real_pict_num  = s->picture_number;
973
        avctx->header_bits = s->header_bits;
974
        avctx->mv_bits     = s->mv_bits;
975
        avctx->misc_bits   = s->misc_bits;
976
        avctx->i_tex_bits  = s->i_tex_bits;
977
        avctx->p_tex_bits  = s->p_tex_bits;
978
        avctx->i_count     = s->i_count;
979
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
980
        avctx->skip_count  = s->skip_count;
981

    
982
        MPV_frame_end(s);
983

    
984
        if (s->out_format == FMT_MJPEG)
985
            mjpeg_picture_trailer(s);
986

    
987
        if(!s->fixed_qscale)
988
            avctx->quality = s->qscale;
989
        
990
        if(s->flags&CODEC_FLAG_PASS1)
991
            ff_write_pass1_stats(s);
992
    
993
    }
994

    
995
    s->input_picture_number++;
996
    s->input_picture_in_gop_number++;
997

    
998
    flush_put_bits(&s->pb);
999
    s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1000
    
1001
    s->total_bits += s->frame_bits;
1002
    avctx->frame_bits  = s->frame_bits;
1003
//printf("fcode: %d, type: %d, head: %d, mv: %d, misc: %d, frame: %d, itex: %d, ptex: %d\n", 
1004
//s->f_code, avctx->key_frame, s->header_bits, s->mv_bits, s->misc_bits, s->frame_bits, s->i_tex_bits, s->p_tex_bits);
1005
#if 0 //dump some stats to stats.txt for testing/debuging
1006
if(s->max_b_frames==0)
1007
{
1008
    static FILE *f=NULL;
1009
    if(!f) f= fopen("stats.txt", "wb");
1010
    get_psnr(pict->data, s->current_picture,
1011
             pict->linesize, s->linesize, avctx);
1012
    fprintf(f, "%7d, %7d, %2.4f\n", pbBufPtr(&s->pb) - s->pb.buf, s->qscale, avctx->psnr_y);
1013
}
1014
#endif
1015

    
1016
    if (avctx->get_psnr) {
1017
        /* At this point pict->data should have the original frame   */
1018
        /* an s->current_picture should have the coded/decoded frame */
1019
        get_psnr(pict->data, s->current_picture,
1020
                 pict->linesize, s->linesize, avctx);
1021
//        printf("%f\n", avctx->psnr_y);
1022
    }
1023
    return pbBufPtr(&s->pb) - s->pb.buf;
1024
}
1025

    
1026
static inline void gmc1_motion(MpegEncContext *s,
1027
                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1028
                               int dest_offset,
1029
                               UINT8 **ref_picture, int src_offset,
1030
                               int h)
1031
{
1032
    UINT8 *ptr;
1033
    int offset, src_x, src_y, linesize, uvlinesize;
1034
    int motion_x, motion_y;
1035
    int emu=0;
1036

    
1037
    if(s->real_sprite_warping_points>1) printf("more than 1 warp point isnt supported\n");
1038
    motion_x= s->sprite_offset[0][0];
1039
    motion_y= s->sprite_offset[0][1];
1040
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1041
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1042
    motion_x<<=(3-s->sprite_warping_accuracy);
1043
    motion_y<<=(3-s->sprite_warping_accuracy);
1044
    src_x = clip(src_x, -16, s->width);
1045
    if (src_x == s->width)
1046
        motion_x =0;
1047
    src_y = clip(src_y, -16, s->height);
1048
    if (src_y == s->height)
1049
        motion_y =0;
1050
    
1051
    linesize = s->linesize;
1052
    uvlinesize = s->uvlinesize;
1053
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1054

    
1055
    dest_y+=dest_offset;
1056
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1057
        if(src_x<0 || src_y<0 || src_x + (motion_x&15) + 16 > s->h_edge_pos
1058
                              || src_y + (motion_y&15) + h  > s->v_edge_pos){
1059
            emulated_edge_mc(s, ptr, linesize, 17, h+1, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1060
            ptr= s->edge_emu_buffer;
1061
            emu=1;
1062
        }
1063
    }
1064
    gmc1(dest_y  , ptr  , linesize, h, motion_x&15, motion_y&15, s->no_rounding);
1065
    gmc1(dest_y+8, ptr+8, linesize, h, motion_x&15, motion_y&15, s->no_rounding);
1066

    
1067
    motion_x= s->sprite_offset[1][0];
1068
    motion_y= s->sprite_offset[1][1];
1069
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
1070
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
1071
    motion_x<<=(3-s->sprite_warping_accuracy);
1072
    motion_y<<=(3-s->sprite_warping_accuracy);
1073
    src_x = clip(src_x, -8, s->width>>1);
1074
    if (src_x == s->width>>1)
1075
        motion_x =0;
1076
    src_y = clip(src_y, -8, s->height>>1);
1077
    if (src_y == s->height>>1)
1078
        motion_y =0;
1079

    
1080
    offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
1081
    ptr = ref_picture[1] + offset;
1082
    if(emu){
1083
        emulated_edge_mc(s, ptr, uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1084
        ptr= s->edge_emu_buffer;
1085
    }
1086
    gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, h>>1, motion_x&15, motion_y&15, s->no_rounding);
1087
    
1088
    ptr = ref_picture[2] + offset;
1089
    if(emu){
1090
        emulated_edge_mc(s, ptr, uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1091
        ptr= s->edge_emu_buffer;
1092
    }
1093
    gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, h>>1, motion_x&15, motion_y&15, s->no_rounding);
1094
    
1095
    return;
1096
}
1097

    
1098
static void emulated_edge_mc(MpegEncContext *s, UINT8 *src, int linesize, int block_w, int block_h, 
1099
                                    int src_x, int src_y, int w, int h){
1100
    int x, y;
1101
    int start_y, start_x, end_y, end_x;
1102
    UINT8 *buf= s->edge_emu_buffer;
1103
    
1104
    if(src_y>= h){
1105
        src+= (h-1-src_y)*linesize;
1106
        src_y=h-1;
1107
    }else if(src_y<=-block_h){
1108
        src+= (1-block_h-src_y)*linesize;
1109
        src_y=1-block_h;
1110
    }
1111
    if(src_x>= w){
1112
        src+= (w-1-src_x);
1113
        src_x=w-1;
1114
    }else if(src_x<=-block_w){
1115
        src+= (1-block_w-src_x);
1116
        src_x=1-block_w;
1117
    }
1118

    
1119
    start_y= MAX(0, -src_y);
1120
    start_x= MAX(0, -src_x);
1121
    end_y= MIN(block_h, h-src_y);
1122
    end_x= MIN(block_w, w-src_x);
1123

    
1124
    // copy existing part
1125
    for(y=start_y; y<end_y; y++){
1126
        for(x=start_x; x<end_x; x++){
1127
            buf[x + y*linesize]= src[x + y*linesize];
1128
        }
1129
    }
1130

    
1131
    //top
1132
    for(y=0; y<start_y; y++){
1133
        for(x=start_x; x<end_x; x++){
1134
            buf[x + y*linesize]= buf[x + start_y*linesize];
1135
        }
1136
    }
1137

    
1138
    //bottom
1139
    for(y=end_y; y<block_h; y++){
1140
        for(x=start_x; x<end_x; x++){
1141
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1142
        }
1143
    }
1144
                                    
1145
    for(y=0; y<block_h; y++){
1146
       //left
1147
        for(x=0; x<start_x; x++){
1148
            buf[x + y*linesize]= buf[start_x + y*linesize];
1149
        }
1150
       
1151
       //right
1152
        for(x=end_x; x<block_w; x++){
1153
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1154
        }
1155
    }
1156
}
1157

    
1158

    
1159
/* apply one mpeg motion vector to the three components */
1160
static inline void mpeg_motion(MpegEncContext *s,
1161
                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1162
                               int dest_offset,
1163
                               UINT8 **ref_picture, int src_offset,
1164
                               int field_based, op_pixels_func (*pix_op)[4],
1165
                               int motion_x, int motion_y, int h)
1166
{
1167
    UINT8 *ptr;
1168
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1169
    int emu=0;
1170
#if 0    
1171
if(s->quarter_sample)
1172
{
1173
    motion_x>>=1;
1174
    motion_y>>=1;
1175
}
1176
#endif
1177
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1178
    src_x = s->mb_x * 16 + (motion_x >> 1);
1179
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 1);
1180
                
1181
    /* WARNING: do no forget half pels */
1182
    height = s->height >> field_based;
1183
    v_edge_pos = s->v_edge_pos >> field_based;
1184
    src_x = clip(src_x, -16, s->width);
1185
    if (src_x == s->width)
1186
        dxy &= ~1;
1187
    src_y = clip(src_y, -16, height);
1188
    if (src_y == height)
1189
        dxy &= ~2;
1190
    linesize   = s->linesize << field_based;
1191
    uvlinesize = s->uvlinesize << field_based;
1192
    ptr = ref_picture[0] + (src_y * linesize) + (src_x) + src_offset;
1193
    dest_y += dest_offset;
1194

    
1195
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1196
        if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 16 > s->h_edge_pos
1197
                              || src_y + (motion_y&1) + h  > v_edge_pos){
1198
            emulated_edge_mc(s, ptr, linesize, 17, h+1, src_x, src_y, s->h_edge_pos, v_edge_pos);
1199
            ptr= s->edge_emu_buffer;
1200
            emu=1;
1201
        }
1202
    }
1203
    pix_op[0][dxy](dest_y, ptr, linesize, h);
1204

    
1205
    if(s->flags&CODEC_FLAG_GRAY) return;
1206

    
1207
    if (s->out_format == FMT_H263) {
1208
        dxy = 0;
1209
        if ((motion_x & 3) != 0)
1210
            dxy |= 1;
1211
        if ((motion_y & 3) != 0)
1212
            dxy |= 2;
1213
        mx = motion_x >> 2;
1214
        my = motion_y >> 2;
1215
    } else {
1216
        mx = motion_x / 2;
1217
        my = motion_y / 2;
1218
        dxy = ((my & 1) << 1) | (mx & 1);
1219
        mx >>= 1;
1220
        my >>= 1;
1221
    }
1222
    
1223
    src_x = s->mb_x * 8 + mx;
1224
    src_y = s->mb_y * (8 >> field_based) + my;
1225
    src_x = clip(src_x, -8, s->width >> 1);
1226
    if (src_x == (s->width >> 1))
1227
        dxy &= ~1;
1228
    src_y = clip(src_y, -8, height >> 1);
1229
    if (src_y == (height >> 1))
1230
        dxy &= ~2;
1231
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1232
    ptr = ref_picture[1] + offset;
1233
    if(emu){
1234
        emulated_edge_mc(s, ptr, uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, v_edge_pos>>1);
1235
        ptr= s->edge_emu_buffer;
1236
    }
1237
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1238

    
1239
    ptr = ref_picture[2] + offset;
1240
    if(emu){
1241
        emulated_edge_mc(s, ptr, uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, v_edge_pos>>1);
1242
        ptr= s->edge_emu_buffer;
1243
    }
1244
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1245
}
1246

    
1247
static inline void qpel_motion(MpegEncContext *s,
1248
                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1249
                               int dest_offset,
1250
                               UINT8 **ref_picture, int src_offset,
1251
                               int field_based, op_pixels_func (*pix_op)[4],
1252
                               qpel_mc_func (*qpix_op)[16],
1253
                               int motion_x, int motion_y, int h)
1254
{
1255
    UINT8 *ptr;
1256
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1257
    int emu=0;
1258

    
1259
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1260
    src_x = s->mb_x * 16 + (motion_x >> 2);
1261
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
1262

    
1263
    height = s->height >> field_based;
1264
    v_edge_pos = s->v_edge_pos >> field_based;
1265
    src_x = clip(src_x, -16, s->width);
1266
    if (src_x == s->width)
1267
        dxy &= ~3;
1268
    src_y = clip(src_y, -16, height);
1269
    if (src_y == height)
1270
        dxy &= ~12;
1271
    linesize = s->linesize << field_based;
1272
    uvlinesize = s->uvlinesize << field_based;
1273
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1274
    dest_y += dest_offset;
1275
//printf("%d %d %d\n", src_x, src_y, dxy);
1276
    
1277
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1278
        if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 16 > s->h_edge_pos
1279
                              || src_y + (motion_y&3) + h  > v_edge_pos){
1280
            emulated_edge_mc(s, ptr, linesize, 17, h+1, src_x, src_y, s->h_edge_pos, v_edge_pos);
1281
            ptr= s->edge_emu_buffer;
1282
            emu=1;
1283
        }
1284
    }
1285
    if(!field_based)
1286
        qpix_op[0][dxy](dest_y, ptr, linesize);
1287
    else{
1288
        //damn interlaced mode
1289
        //FIXME boundary mirroring is not exactly correct here
1290
        qpix_op[1][dxy](dest_y  , ptr  , linesize);
1291
        qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
1292
    }
1293

    
1294
    if(s->flags&CODEC_FLAG_GRAY) return;
1295

    
1296
    if(field_based){
1297
        mx= motion_x/2;
1298
        my= motion_y>>1;
1299
    }else if(s->divx_version){
1300
        mx= (motion_x>>1)|(motion_x&1);
1301
        my= (motion_y>>1)|(motion_y&1);
1302
    }else{
1303
        mx= motion_x/2;
1304
        my= motion_y/2;
1305
    }
1306
    mx= (mx>>1)|(mx&1);
1307
    my= (my>>1)|(my&1);
1308
    dxy= (mx&1) | ((my&1)<<1);
1309
    mx>>=1;
1310
    my>>=1;
1311

    
1312
    src_x = s->mb_x * 8 + mx;
1313
    src_y = s->mb_y * (8 >> field_based) + my;
1314
    src_x = clip(src_x, -8, s->width >> 1);
1315
    if (src_x == (s->width >> 1))
1316
        dxy &= ~1;
1317
    src_y = clip(src_y, -8, height >> 1);
1318
    if (src_y == (height >> 1))
1319
        dxy &= ~2;
1320

    
1321
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1322
    ptr = ref_picture[1] + offset;
1323
    if(emu){
1324
        emulated_edge_mc(s, ptr,  uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, v_edge_pos>>1);
1325
        ptr= s->edge_emu_buffer;
1326
    }
1327
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1328
    
1329
    ptr = ref_picture[2] + offset;
1330
    if(emu){
1331
        emulated_edge_mc(s, ptr,  uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, v_edge_pos>>1);
1332
        ptr= s->edge_emu_buffer;
1333
    }
1334
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1335
}
1336

    
1337

    
1338
static inline void MPV_motion(MpegEncContext *s, 
1339
                              UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1340
                              int dir, UINT8 **ref_picture, 
1341
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
1342
{
1343
    int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
1344
    int mb_x, mb_y, i;
1345
    UINT8 *ptr, *dest;
1346
    int emu=0;
1347

    
1348
    mb_x = s->mb_x;
1349
    mb_y = s->mb_y;
1350

    
1351
    switch(s->mv_type) {
1352
    case MV_TYPE_16X16:
1353
        if(s->mcsel){
1354
            gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
1355
                        ref_picture, 0,
1356
                        16);
1357
        }else if(s->quarter_sample){
1358
            qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1359
                        ref_picture, 0,
1360
                        0, pix_op, qpix_op,
1361
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1362
        }else{
1363
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1364
                        ref_picture, 0,
1365
                        0, pix_op,
1366
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1367
        }           
1368
        break;
1369
    case MV_TYPE_8X8:
1370
        mx = 0;
1371
        my = 0;
1372
        if(s->quarter_sample){
1373
            for(i=0;i<4;i++) {
1374
                motion_x = s->mv[dir][i][0];
1375
                motion_y = s->mv[dir][i][1];
1376

    
1377
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1378
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
1379
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
1380
                    
1381
                /* WARNING: do no forget half pels */
1382
                src_x = clip(src_x, -16, s->width);
1383
                if (src_x == s->width)
1384
                    dxy &= ~3;
1385
                src_y = clip(src_y, -16, s->height);
1386
                if (src_y == s->height)
1387
                    dxy &= ~12;
1388
                    
1389
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1390
                if(s->flags&CODEC_FLAG_EMU_EDGE){
1391
                    if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 8 > s->h_edge_pos
1392
                                          || src_y + (motion_y&3) + 8 > s->v_edge_pos){
1393
                        emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1394
                        ptr= s->edge_emu_buffer;
1395
                    }
1396
                }
1397
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1398
                qpix_op[1][dxy](dest, ptr, s->linesize);
1399

    
1400
                mx += s->mv[dir][i][0]/2;
1401
                my += s->mv[dir][i][1]/2;
1402
            }
1403
        }else{
1404
            for(i=0;i<4;i++) {
1405
                motion_x = s->mv[dir][i][0];
1406
                motion_y = s->mv[dir][i][1];
1407

    
1408
                dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1409
                src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;
1410
                src_y = mb_y * 16 + (motion_y >> 1) + (i >>1) * 8;
1411
                    
1412
                /* WARNING: do no forget half pels */
1413
                src_x = clip(src_x, -16, s->width);
1414
                if (src_x == s->width)
1415
                    dxy &= ~1;
1416
                src_y = clip(src_y, -16, s->height);
1417
                if (src_y == s->height)
1418
                    dxy &= ~2;
1419
                    
1420
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1421
                if(s->flags&CODEC_FLAG_EMU_EDGE){
1422
                    if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 8 > s->h_edge_pos
1423
                                          || src_y + (motion_y&1) + 8 > s->v_edge_pos){
1424
                        emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1425
                        ptr= s->edge_emu_buffer;
1426
                    }
1427
                }
1428
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1429
                pix_op[1][dxy](dest, ptr, s->linesize, 8);
1430

    
1431
                mx += s->mv[dir][i][0];
1432
                my += s->mv[dir][i][1];
1433
            }
1434
        }
1435

    
1436
        if(s->flags&CODEC_FLAG_GRAY) break;
1437
        /* In case of 8X8, we construct a single chroma motion vector
1438
           with a special rounding */
1439
        for(i=0;i<4;i++) {
1440
        }
1441
        if (mx >= 0)
1442
            mx = (h263_chroma_roundtab[mx & 0xf] + ((mx >> 3) & ~1));
1443
        else {
1444
            mx = -mx;
1445
            mx = -(h263_chroma_roundtab[mx & 0xf] + ((mx >> 3) & ~1));
1446
        }
1447
        if (my >= 0)
1448
            my = (h263_chroma_roundtab[my & 0xf] + ((my >> 3) & ~1));
1449
        else {
1450
            my = -my;
1451
            my = -(h263_chroma_roundtab[my & 0xf] + ((my >> 3) & ~1));
1452
        }
1453
        dxy = ((my & 1) << 1) | (mx & 1);
1454
        mx >>= 1;
1455
        my >>= 1;
1456

    
1457
        src_x = mb_x * 8 + mx;
1458
        src_y = mb_y * 8 + my;
1459
        src_x = clip(src_x, -8, s->width/2);
1460
        if (src_x == s->width/2)
1461
            dxy &= ~1;
1462
        src_y = clip(src_y, -8, s->height/2);
1463
        if (src_y == s->height/2)
1464
            dxy &= ~2;
1465
        
1466
        offset = (src_y * (s->uvlinesize)) + src_x;
1467
        ptr = ref_picture[1] + offset;
1468
        if(s->flags&CODEC_FLAG_EMU_EDGE){
1469
                if(src_x<0 || src_y<0 || src_x + (dxy &1) + 8 > s->h_edge_pos>>1
1470
                                      || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
1471
                    emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1472
                    ptr= s->edge_emu_buffer;
1473
                    emu=1;
1474
                }
1475
            }
1476
        pix_op[1][dxy](dest_cb, ptr, s->uvlinesize, 8);
1477

    
1478
        ptr = ref_picture[2] + offset;
1479
        if(emu){
1480
            emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1481
            ptr= s->edge_emu_buffer;
1482
        }
1483
        pix_op[1][dxy](dest_cr, ptr, s->uvlinesize, 8);
1484
        break;
1485
    case MV_TYPE_FIELD:
1486
        if (s->picture_structure == PICT_FRAME) {
1487
            if(s->quarter_sample){
1488
                /* top field */
1489
                qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1490
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
1491
                            1, pix_op, qpix_op,
1492
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
1493
                /* bottom field */
1494
                qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
1495
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
1496
                            1, pix_op, qpix_op,
1497
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
1498
            }else{
1499
                /* top field */       
1500
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1501
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
1502
                            1, pix_op,
1503
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
1504
                /* bottom field */
1505
                mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
1506
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
1507
                            1, pix_op,
1508
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
1509
            }
1510
        } else {
1511
            
1512

    
1513
        }
1514
        break;
1515
    }
1516
}
1517

    
1518

    
1519
/* put block[] to dest[] */
1520
static inline void put_dct(MpegEncContext *s, 
1521
                           DCTELEM *block, int i, UINT8 *dest, int line_size)
1522
{
1523
    s->dct_unquantize(s, block, i, s->qscale);
1524
    s->idct_put (dest, line_size, block);
1525
}
1526

    
1527
/* add block[] to dest[] */
1528
static inline void add_dct(MpegEncContext *s, 
1529
                           DCTELEM *block, int i, UINT8 *dest, int line_size)
1530
{
1531
    if (s->block_last_index[i] >= 0) {
1532
        s->idct_add (dest, line_size, block);
1533
    }
1534
}
1535

    
1536
static inline void add_dequant_dct(MpegEncContext *s, 
1537
                           DCTELEM *block, int i, UINT8 *dest, int line_size)
1538
{
1539
    if (s->block_last_index[i] >= 0) {
1540
        s->dct_unquantize(s, block, i, s->qscale);
1541

    
1542
        s->idct_add (dest, line_size, block);
1543
    }
1544
}
1545

    
1546
/**
1547
 * cleans dc, ac, coded_block for the current non intra MB
1548
 */
1549
void ff_clean_intra_table_entries(MpegEncContext *s)
1550
{
1551
    int wrap = s->block_wrap[0];
1552
    int xy = s->block_index[0];
1553
    
1554
    s->dc_val[0][xy           ] = 
1555
    s->dc_val[0][xy + 1       ] = 
1556
    s->dc_val[0][xy     + wrap] =
1557
    s->dc_val[0][xy + 1 + wrap] = 1024;
1558
    /* ac pred */
1559
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(INT16));
1560
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(INT16));
1561
    if (s->msmpeg4_version>=3) {
1562
        s->coded_block[xy           ] =
1563
        s->coded_block[xy + 1       ] =
1564
        s->coded_block[xy     + wrap] =
1565
        s->coded_block[xy + 1 + wrap] = 0;
1566
    }
1567
    /* chroma */
1568
    wrap = s->block_wrap[4];
1569
    xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
1570
    s->dc_val[1][xy] =
1571
    s->dc_val[2][xy] = 1024;
1572
    /* ac pred */
1573
    memset(s->ac_val[1][xy], 0, 16 * sizeof(INT16));
1574
    memset(s->ac_val[2][xy], 0, 16 * sizeof(INT16));
1575
    
1576
    s->mbintra_table[s->mb_x + s->mb_y*s->mb_width]= 0;
1577
}
1578

    
1579
/* generic function called after a macroblock has been parsed by the
1580
   decoder or after it has been encoded by the encoder.
1581

1582
   Important variables used:
1583
   s->mb_intra : true if intra macroblock
1584
   s->mv_dir   : motion vector direction
1585
   s->mv_type  : motion vector type
1586
   s->mv       : motion vector
1587
   s->interlaced_dct : true if interlaced dct used (mpeg2)
1588
 */
1589
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1590
{
1591
    int mb_x, mb_y;
1592
    const int mb_xy = s->mb_y * s->mb_width + s->mb_x;
1593

    
1594
    mb_x = s->mb_x;
1595
    mb_y = s->mb_y;
1596

    
1597
#ifdef FF_POSTPROCESS
1598
    /* Obsolete. Exists for compatibility with mplayer only. */
1599
    quant_store[mb_y][mb_x]=s->qscale;
1600
    //printf("[%02d][%02d] %d\n",mb_x,mb_y,s->qscale);
1601
#else
1602
    /* even more obsolete, exists for mplayer xp only */
1603
    if(s->avctx->quant_store) s->avctx->quant_store[mb_y*s->avctx->qstride+mb_x] = s->qscale;
1604
#endif
1605
    s->qscale_table[mb_xy]= s->qscale;
1606

    
1607
    /* update DC predictors for P macroblocks */
1608
    if (!s->mb_intra) {
1609
        if (s->h263_pred || s->h263_aic) {
1610
            if(s->mbintra_table[mb_xy])
1611
                ff_clean_intra_table_entries(s);
1612
        } else {
1613
            s->last_dc[0] =
1614
            s->last_dc[1] =
1615
            s->last_dc[2] = 128 << s->intra_dc_precision;
1616
        }
1617
    }
1618
    else if (s->h263_pred || s->h263_aic)
1619
        s->mbintra_table[mb_xy]=1;
1620

    
1621
    /* update motion predictor, not for B-frames as they need the motion_val from the last P/S-Frame */
1622
    if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) { //FIXME move into h263.c if possible, format specific stuff shouldnt be here
1623
        
1624
        const int wrap = s->block_wrap[0];
1625
        const int xy = s->block_index[0];
1626
        const int mb_index= s->mb_x + s->mb_y*s->mb_width;
1627
        if(s->mv_type == MV_TYPE_8X8){
1628
            s->co_located_type_table[mb_index]= CO_LOCATED_TYPE_4MV;
1629
        } else {
1630
            int motion_x, motion_y;
1631
            if (s->mb_intra) {
1632
                motion_x = 0;
1633
                motion_y = 0;
1634
                if(s->co_located_type_table)
1635
                    s->co_located_type_table[mb_index]= 0;
1636
            } else if (s->mv_type == MV_TYPE_16X16) {
1637
                motion_x = s->mv[0][0][0];
1638
                motion_y = s->mv[0][0][1];
1639
                if(s->co_located_type_table)
1640
                    s->co_located_type_table[mb_index]= 0;
1641
            } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
1642
                int i;
1643
                motion_x = s->mv[0][0][0] + s->mv[0][1][0];
1644
                motion_y = s->mv[0][0][1] + s->mv[0][1][1];
1645
                motion_x = (motion_x>>1) | (motion_x&1);
1646
                for(i=0; i<2; i++){
1647
                    s->field_mv_table[mb_index][i][0]= s->mv[0][i][0];
1648
                    s->field_mv_table[mb_index][i][1]= s->mv[0][i][1];
1649
                    s->field_select_table[mb_index][i]= s->field_select[0][i];
1650
                }
1651
                s->co_located_type_table[mb_index]= CO_LOCATED_TYPE_FIELDMV;
1652
            }
1653
            /* no update if 8X8 because it has been done during parsing */
1654
            s->motion_val[xy][0] = motion_x;
1655
            s->motion_val[xy][1] = motion_y;
1656
            s->motion_val[xy + 1][0] = motion_x;
1657
            s->motion_val[xy + 1][1] = motion_y;
1658
            s->motion_val[xy + wrap][0] = motion_x;
1659
            s->motion_val[xy + wrap][1] = motion_y;
1660
            s->motion_val[xy + 1 + wrap][0] = motion_x;
1661
            s->motion_val[xy + 1 + wrap][1] = motion_y;
1662
        }
1663
    }
1664
    
1665
    if (!(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) {
1666
        UINT8 *dest_y, *dest_cb, *dest_cr;
1667
        int dct_linesize, dct_offset;
1668
        op_pixels_func (*op_pix)[4];
1669
        qpel_mc_func (*op_qpix)[16];
1670

    
1671
        /* avoid copy if macroblock skipped in last frame too 
1672
           dont touch it for B-frames as they need the skip info from the next p-frame */
1673
        if (s->pict_type != B_TYPE) {
1674
            UINT8 *mbskip_ptr = &s->mbskip_table[mb_xy];
1675
            if (s->mb_skiped) {
1676
                s->mb_skiped = 0;
1677

    
1678
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
1679
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
1680

    
1681
                /* if previous was skipped too, then nothing to do ! 
1682
                   skip only during decoding as we might trash the buffers during encoding a bit */
1683
                if (*mbskip_ptr >= s->ip_buffer_count  && !s->encoding) 
1684
                    goto the_end;
1685
            } else {
1686
                *mbskip_ptr = 0; /* not skipped */
1687
            }
1688
        }
1689

    
1690
        if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band){
1691
            dest_y = s->current_picture [0] + mb_x * 16;
1692
            dest_cb = s->current_picture[1] + mb_x * 8;
1693
            dest_cr = s->current_picture[2] + mb_x * 8;
1694
        }else{
1695
            dest_y = s->current_picture [0] + (mb_y * 16* s->linesize  ) + mb_x * 16;
1696
            dest_cb = s->current_picture[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
1697
            dest_cr = s->current_picture[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
1698
        }
1699

    
1700
        if (s->interlaced_dct) {
1701
            dct_linesize = s->linesize * 2;
1702
            dct_offset = s->linesize;
1703
        } else {
1704
            dct_linesize = s->linesize;
1705
            dct_offset = s->linesize * 8;
1706
        }
1707

    
1708
        if (!s->mb_intra) {
1709
            /* motion handling */
1710
            /* decoding or more than one mb_type (MC was allready done otherwise) */
1711
            if((!s->encoding) || (s->mb_type[mb_xy]&(s->mb_type[mb_xy]-1))){
1712
                if ((!s->no_rounding) || s->pict_type==B_TYPE){                
1713
                    op_pix = put_pixels_tab;
1714
                    op_qpix= put_qpel_pixels_tab;
1715
                }else{
1716
                    op_pix = put_no_rnd_pixels_tab;
1717
                    op_qpix= put_no_rnd_qpel_pixels_tab;
1718
                }
1719

    
1720
                if (s->mv_dir & MV_DIR_FORWARD) {
1721
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture, op_pix, op_qpix);
1722
                    op_pix = avg_pixels_tab;
1723
                    op_qpix= avg_qpel_pixels_tab;
1724
                }
1725
                if (s->mv_dir & MV_DIR_BACKWARD) {
1726
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture, op_pix, op_qpix);
1727
                }
1728
            }
1729

    
1730
            /* skip dequant / idct if we are really late ;) */
1731
            if(s->hurry_up>1) goto the_end;
1732

    
1733
            /* add dct residue */
1734
            if(s->encoding || !(   s->mpeg2 || s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO 
1735
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1736
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
1737
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
1738
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
1739
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
1740

    
1741
                if(!(s->flags&CODEC_FLAG_GRAY)){
1742
                    add_dequant_dct(s, block[4], 4, dest_cb, s->uvlinesize);
1743
                    add_dequant_dct(s, block[5], 5, dest_cr, s->uvlinesize);
1744
                }
1745
            } else {
1746
                add_dct(s, block[0], 0, dest_y, dct_linesize);
1747
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
1748
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
1749
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
1750

    
1751
                if(!(s->flags&CODEC_FLAG_GRAY)){
1752
                    add_dct(s, block[4], 4, dest_cb, s->uvlinesize);
1753
                    add_dct(s, block[5], 5, dest_cr, s->uvlinesize);
1754
                }
1755
            }
1756
        } else {
1757
            /* dct only in intra block */
1758
            if(s->encoding || !(s->mpeg2 || s->codec_id==CODEC_ID_MPEG1VIDEO)){
1759
                put_dct(s, block[0], 0, dest_y, dct_linesize);
1760
                put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
1761
                put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
1762
                put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
1763

    
1764
                if(!(s->flags&CODEC_FLAG_GRAY)){
1765
                    put_dct(s, block[4], 4, dest_cb, s->uvlinesize);
1766
                    put_dct(s, block[5], 5, dest_cr, s->uvlinesize);
1767
                }
1768
            }else{
1769
                s->idct_put(dest_y                 , dct_linesize, block[0]);
1770
                s->idct_put(dest_y              + 8, dct_linesize, block[1]);
1771
                s->idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
1772
                s->idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
1773

    
1774
                if(!(s->flags&CODEC_FLAG_GRAY)){
1775
                    s->idct_put(dest_cb, s->uvlinesize, block[4]);
1776
                    s->idct_put(dest_cr, s->uvlinesize, block[5]);
1777
                }
1778
            }
1779
        }
1780
    }
1781
 the_end:
1782
    emms_c(); //FIXME remove
1783
}
1784

    
1785
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
1786
{
1787
    static const char tab[64]=
1788
        {3,2,2,1,1,1,1,1,
1789
         1,1,1,1,1,1,1,1,
1790
         1,1,1,1,1,1,1,1,
1791
         0,0,0,0,0,0,0,0,
1792
         0,0,0,0,0,0,0,0,
1793
         0,0,0,0,0,0,0,0,
1794
         0,0,0,0,0,0,0,0,
1795
         0,0,0,0,0,0,0,0};
1796
    int score=0;
1797
    int run=0;
1798
    int i;
1799
    DCTELEM *block= s->block[n];
1800
    const int last_index= s->block_last_index[n];
1801
    int skip_dc;
1802

    
1803
    if(threshold<0){
1804
        skip_dc=0;
1805
        threshold= -threshold;
1806
    }else
1807
        skip_dc=1;
1808

    
1809
    /* are all which we could set to zero are allready zero? */
1810
    if(last_index<=skip_dc - 1) return;
1811

    
1812
    for(i=0; i<=last_index; i++){
1813
        const int j = s->intra_scantable.permutated[i];
1814
        const int level = ABS(block[j]);
1815
        if(level==1){
1816
            if(skip_dc && i==0) continue;
1817
            score+= tab[run];
1818
            run=0;
1819
        }else if(level>1){
1820
            return;
1821
        }else{
1822
            run++;
1823
        }
1824
    }
1825
    if(score >= threshold) return;
1826
    for(i=skip_dc; i<=last_index; i++){
1827
        const int j = s->intra_scantable.permutated[i];
1828
        block[j]=0;
1829
    }
1830
    if(block[0]) s->block_last_index[n]= 0;
1831
    else         s->block_last_index[n]= -1;
1832
}
1833

    
1834
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
1835
{
1836
    int i;
1837
    const int maxlevel= s->max_qcoeff;
1838
    const int minlevel= s->min_qcoeff;
1839
    
1840
    if(s->mb_intra){
1841
        i=1; //skip clipping of intra dc
1842
    }else
1843
        i=0;
1844
    
1845
    for(;i<=last_index; i++){
1846
        const int j= s->intra_scantable.permutated[i];
1847
        int level = block[j];
1848
       
1849
        if     (level>maxlevel) level=maxlevel;
1850
        else if(level<minlevel) level=minlevel;
1851
        block[j]= level;
1852
    }
1853
}
1854

    
1855
static inline void requantize_coeffs(MpegEncContext *s, DCTELEM block[64], int oldq, int newq, int n)
1856
{
1857
    int i;
1858

    
1859
    if(s->mb_intra){
1860
        i=1; //skip clipping of intra dc
1861
         //FIXME requantize, note (mpeg1/h263/h263p-aic dont need it,...)
1862
    }else
1863
        i=0;
1864
    
1865
    for(;i<=s->block_last_index[n]; i++){
1866
        const int j = s->intra_scantable.permutated[i];
1867
        int level = block[j];
1868
        
1869
        block[j]= ROUNDED_DIV(level*oldq, newq);
1870
    }
1871

    
1872
    for(i=s->block_last_index[n]; i>=0; i--){
1873
        const int j = s->intra_scantable.permutated[i];
1874
        if(block[j]) break;
1875
    }
1876
    s->block_last_index[n]= i;
1877
}
1878

    
1879
static inline void auto_requantize_coeffs(MpegEncContext *s, DCTELEM block[6][64])
1880
{
1881
    int i,n, newq;
1882
    const int maxlevel= s->max_qcoeff;
1883
    const int minlevel= s->min_qcoeff;
1884
    int largest=0, smallest=0;
1885

    
1886
    assert(s->adaptive_quant);
1887
    
1888
    for(n=0; n<6; n++){
1889
        if(s->mb_intra){
1890
            i=1; //skip clipping of intra dc
1891
             //FIXME requantize, note (mpeg1/h263/h263p-aic dont need it,...)
1892
        }else
1893
            i=0;
1894

    
1895
        for(;i<=s->block_last_index[n]; i++){
1896
            const int j = s->intra_scantable.permutated[i];
1897
            int level = block[n][j];
1898
            if(largest  < level) largest = level;
1899
            if(smallest > level) smallest= level;
1900
        }
1901
    }
1902
    
1903
    for(newq=s->qscale+1; newq<32; newq++){
1904
        if(   ROUNDED_DIV(smallest*s->qscale, newq) >= minlevel
1905
           && ROUNDED_DIV(largest *s->qscale, newq) <= maxlevel) 
1906
            break;
1907
    }
1908
        
1909
    if(s->out_format==FMT_H263){
1910
        /* h263 like formats cannot change qscale by more than 2 easiely */
1911
        if(s->avctx->qmin + 2 < newq)
1912
            newq= s->avctx->qmin + 2;
1913
    }
1914

    
1915
    for(n=0; n<6; n++){
1916
        requantize_coeffs(s, block[n], s->qscale, newq, n);
1917
        clip_coeffs(s, block[n], s->block_last_index[n]);
1918
    }
1919
     
1920
    s->dquant+= newq - s->qscale;
1921
    s->qscale= newq;
1922
}
1923
#if 0
1924
static int pix_vcmp16x8(UINT8 *s, int stride){ //FIXME move to dsputil & optimize
1925
    int score=0;
1926
    int x,y;
1927
    
1928
    for(y=0; y<7; y++){
1929
        for(x=0; x<16; x+=4){
1930
            score+= ABS(s[x  ] - s[x  +stride]) + ABS(s[x+1] - s[x+1+stride]) 
1931
                   +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
1932
        }
1933
        s+= stride;
1934
    }
1935
    
1936
    return score;
1937
}
1938

1939
static int pix_diff_vcmp16x8(UINT8 *s1, UINT8*s2, int stride){ //FIXME move to dsputil & optimize
1940
    int score=0;
1941
    int x,y;
1942
    
1943
    for(y=0; y<7; y++){
1944
        for(x=0; x<16; x++){
1945
            score+= ABS(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
1946
        }
1947
        s1+= stride;
1948
        s2+= stride;
1949
    }
1950
    
1951
    return score;
1952
}
1953
#else
1954
#define SQ(a) ((a)*(a))
1955

    
1956
static int pix_vcmp16x8(UINT8 *s, int stride){ //FIXME move to dsputil & optimize
1957
    int score=0;
1958
    int x,y;
1959
    
1960
    for(y=0; y<7; y++){
1961
        for(x=0; x<16; x+=4){
1962
            score+= SQ(s[x  ] - s[x  +stride]) + SQ(s[x+1] - s[x+1+stride]) 
1963
                   +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
1964
        }
1965
        s+= stride;
1966
    }
1967
    
1968
    return score;
1969
}
1970

    
1971
static int pix_diff_vcmp16x8(UINT8 *s1, UINT8*s2, int stride){ //FIXME move to dsputil & optimize
1972
    int score=0;
1973
    int x,y;
1974
    
1975
    for(y=0; y<7; y++){
1976
        for(x=0; x<16; x++){
1977
            score+= SQ(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
1978
        }
1979
        s1+= stride;
1980
        s2+= stride;
1981
    }
1982
    
1983
    return score;
1984
}
1985

    
1986
#endif
1987
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
1988
{
1989
    const int mb_x= s->mb_x;
1990
    const int mb_y= s->mb_y;
1991
    int i;
1992
    int skip_dct[6];
1993
    int dct_offset   = s->linesize*8; //default for progressive frames
1994
    
1995
    for(i=0; i<6; i++) skip_dct[i]=0;
1996
    
1997
    if(s->adaptive_quant){
1998
        s->dquant= s->qscale_table[mb_x + mb_y*s->mb_width] - s->qscale;
1999

    
2000
        if(s->out_format==FMT_H263){
2001
            if     (s->dquant> 2) s->dquant= 2;
2002
            else if(s->dquant<-2) s->dquant=-2;
2003
        }
2004
            
2005
        if(s->codec_id==CODEC_ID_MPEG4){        
2006
            if(!s->mb_intra){
2007
                assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
2008

    
2009
                if(s->mv_dir&MV_DIRECT)
2010
                    s->dquant=0;
2011
            }
2012
        }
2013
        s->qscale+= s->dquant;
2014
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2015
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2016
    }
2017

    
2018
    if (s->mb_intra) {
2019
        UINT8 *ptr;
2020
        int wrap_y;
2021
        int emu=0;
2022

    
2023
        wrap_y = s->linesize;
2024
        ptr = s->new_picture[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2025

    
2026
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2027
            emulated_edge_mc(s, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2028
            ptr= s->edge_emu_buffer;
2029
            emu=1;
2030
        }
2031
        
2032
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2033
            int progressive_score, interlaced_score;
2034
            
2035
            progressive_score= pix_vcmp16x8(ptr, wrap_y  ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
2036
            interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y  , wrap_y*2);
2037
            
2038
            if(progressive_score > interlaced_score + 100){
2039
                s->interlaced_dct=1;
2040
            
2041
                dct_offset= wrap_y;
2042
                wrap_y<<=1;
2043
            }else
2044
                s->interlaced_dct=0;
2045
        }
2046
        
2047
        get_pixels(s->block[0], ptr                 , wrap_y);
2048
        get_pixels(s->block[1], ptr              + 8, wrap_y);
2049
        get_pixels(s->block[2], ptr + dct_offset    , wrap_y);
2050
        get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
2051

    
2052
        if(s->flags&CODEC_FLAG_GRAY){
2053
            skip_dct[4]= 1;
2054
            skip_dct[5]= 1;
2055
        }else{
2056
            int wrap_c = s->uvlinesize;
2057
            ptr = s->new_picture[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2058
            if(emu){
2059
                emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2060
                ptr= s->edge_emu_buffer;
2061
            }
2062
            get_pixels(s->block[4], ptr, wrap_c);
2063

    
2064
            ptr = s->new_picture[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2065
            if(emu){
2066
                emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2067
                ptr= s->edge_emu_buffer;
2068
            }
2069
            get_pixels(s->block[5], ptr, wrap_c);
2070
        }
2071
    }else{
2072
        op_pixels_func (*op_pix)[4];
2073
        qpel_mc_func (*op_qpix)[16];
2074
        UINT8 *dest_y, *dest_cb, *dest_cr;
2075
        UINT8 *ptr_y, *ptr_cb, *ptr_cr;
2076
        int wrap_y, wrap_c;
2077
        int emu=0;
2078

    
2079
        dest_y  = s->current_picture[0] + (mb_y * 16 * s->linesize       ) + mb_x * 16;
2080
        dest_cb = s->current_picture[1] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2081
        dest_cr = s->current_picture[2] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2082
        wrap_y = s->linesize;
2083
        wrap_c = s->uvlinesize;
2084
        ptr_y  = s->new_picture[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2085
        ptr_cb = s->new_picture[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2086
        ptr_cr = s->new_picture[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2087

    
2088
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
2089
            op_pix = put_pixels_tab;
2090
            op_qpix= put_qpel_pixels_tab;
2091
        }else{
2092
            op_pix = put_no_rnd_pixels_tab;
2093
            op_qpix= put_no_rnd_qpel_pixels_tab;
2094
        }
2095

    
2096
        if (s->mv_dir & MV_DIR_FORWARD) {
2097
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture, op_pix, op_qpix);
2098
            op_pix = avg_pixels_tab;
2099
            op_qpix= avg_qpel_pixels_tab;
2100
        }
2101
        if (s->mv_dir & MV_DIR_BACKWARD) {
2102
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture, op_pix, op_qpix);
2103
        }
2104

    
2105
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2106
            emulated_edge_mc(s, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2107
            ptr_y= s->edge_emu_buffer;
2108
            emu=1;
2109
        }
2110
        
2111
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2112
            int progressive_score, interlaced_score;
2113
            
2114
            progressive_score= pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y  ) 
2115
                             + pix_diff_vcmp16x8(ptr_y + wrap_y*8, dest_y + wrap_y*8, wrap_y  );
2116
            interlaced_score = pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y*2)
2117
                             + pix_diff_vcmp16x8(ptr_y + wrap_y  , dest_y + wrap_y  , wrap_y*2);
2118
            
2119
            if(progressive_score > interlaced_score + 600){
2120
                s->interlaced_dct=1;
2121
            
2122
                dct_offset= wrap_y;
2123
                wrap_y<<=1;
2124
            }else
2125
                s->interlaced_dct=0;
2126
        }
2127
        
2128
        diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
2129
        diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
2130
        diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
2131
        diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
2132
        
2133
        if(s->flags&CODEC_FLAG_GRAY){
2134
            skip_dct[4]= 1;
2135
            skip_dct[5]= 1;
2136
        }else{
2137
            if(emu){
2138
                emulated_edge_mc(s, ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2139
                ptr_cb= s->edge_emu_buffer;
2140
            }
2141
            diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2142
            if(emu){
2143
                emulated_edge_mc(s, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2144
                ptr_cr= s->edge_emu_buffer;
2145
            }
2146
            diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2147
        }
2148

    
2149
        /* pre quantization */         
2150
        if(s->mc_mb_var[s->mb_width*mb_y+ mb_x]<2*s->qscale*s->qscale){
2151
            //FIXME optimize
2152
            if(pix_abs8x8(ptr_y               , dest_y               , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
2153
            if(pix_abs8x8(ptr_y            + 8, dest_y            + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
2154
            if(pix_abs8x8(ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
2155
            if(pix_abs8x8(ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
2156
            if(pix_abs8x8(ptr_cb              , dest_cb              , wrap_y) < 20*s->qscale) skip_dct[4]= 1;
2157
            if(pix_abs8x8(ptr_cr              , dest_cr              , wrap_y) < 20*s->qscale) skip_dct[5]= 1;
2158
#if 0
2159
{
2160
 static int stat[7];
2161
 int num=0;
2162
 for(i=0; i<6; i++)
2163
  if(skip_dct[i]) num++;
2164
 stat[num]++;
2165
 
2166
 if(s->mb_x==0 && s->mb_y==0){
2167
  for(i=0; i<7; i++){
2168
   printf("%6d %1d\n", stat[i], i);
2169
  }
2170
 }
2171
}
2172
#endif
2173
        }
2174

    
2175
    }
2176
            
2177
#if 0
2178
            {
2179
                float adap_parm;
2180
                
2181
                adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_width*mb_y+mb_x] + 1.0) /
2182
                            ((s->mb_var[s->mb_width*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);
2183
            
2184
                printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d", 
2185
                        (s->mb_type[s->mb_width*mb_y+mb_x] > 0) ? 'I' : 'P', 
2186
                        s->qscale, adap_parm, s->qscale*adap_parm,
2187
                        s->mb_var[s->mb_width*mb_y+mb_x], s->avg_mb_var);
2188
            }
2189
#endif
2190
    /* DCT & quantize */
2191
    if(s->out_format==FMT_MJPEG){
2192
        for(i=0;i<6;i++) {
2193
            int overflow;
2194
            s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
2195
            if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2196
        }
2197
    }else{
2198
        for(i=0;i<6;i++) {
2199
            if(!skip_dct[i]){
2200
                int overflow;
2201
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2202
            // FIXME we could decide to change to quantizer instead of clipping
2203
            // JS: I don't think that would be a good idea it could lower quality instead
2204
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
2205
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2206
            }else
2207
                s->block_last_index[i]= -1;
2208
        }
2209
        if(s->luma_elim_threshold && !s->mb_intra)
2210
            for(i=0; i<4; i++)
2211
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2212
        if(s->chroma_elim_threshold && !s->mb_intra)
2213
            for(i=4; i<6; i++)
2214
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2215
    }
2216

    
2217
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
2218
        s->block_last_index[4]=
2219
        s->block_last_index[5]= 0;
2220
        s->block[4][0]=
2221
        s->block[5][0]= 128;
2222
    }
2223

    
2224
    /* huffman encode */
2225
    switch(s->out_format) {
2226
    case FMT_MPEG1:
2227
        mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2228
        break;
2229
    case FMT_H263:
2230
        if (s->h263_msmpeg4)
2231
            msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2232
        else if(s->h263_pred)
2233
            mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2234
        else
2235
            h263_encode_mb(s, s->block, motion_x, motion_y);
2236
        break;
2237
    case FMT_MJPEG:
2238
        mjpeg_encode_mb(s, s->block);
2239
        break;
2240
    }
2241
}
2242

    
2243
void ff_copy_bits(PutBitContext *pb, UINT8 *src, int length)
2244
{
2245
    int bytes= length>>4;
2246
    int bits= length&15;
2247
    int i;
2248

    
2249
    if(length==0) return;
2250

    
2251
    for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
2252
    put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
2253
}
2254

    
2255
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2256
    int i;
2257

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

    
2260
    /* mpeg1 */
2261
    d->mb_incr= s->mb_incr;
2262
    for(i=0; i<3; i++)
2263
        d->last_dc[i]= s->last_dc[i];
2264
    
2265
    /* statistics */
2266
    d->mv_bits= s->mv_bits;
2267
    d->i_tex_bits= s->i_tex_bits;
2268
    d->p_tex_bits= s->p_tex_bits;
2269
    d->i_count= s->i_count;
2270
    d->f_count= s->f_count;
2271
    d->b_count= s->b_count;
2272
    d->skip_count= s->skip_count;
2273
    d->misc_bits= s->misc_bits;
2274
    d->last_bits= 0;
2275

    
2276
    d->mb_skiped= s->mb_skiped;
2277
}
2278

    
2279
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2280
    int i;
2281

    
2282
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
2283
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
2284
    
2285
    /* mpeg1 */
2286
    d->mb_incr= s->mb_incr;
2287
    for(i=0; i<3; i++)
2288
        d->last_dc[i]= s->last_dc[i];
2289
    
2290
    /* statistics */
2291
    d->mv_bits= s->mv_bits;
2292
    d->i_tex_bits= s->i_tex_bits;
2293
    d->p_tex_bits= s->p_tex_bits;
2294
    d->i_count= s->i_count;
2295
    d->f_count= s->f_count;
2296
    d->b_count= s->b_count;
2297
    d->skip_count= s->skip_count;
2298
    d->misc_bits= s->misc_bits;
2299

    
2300
    d->mb_intra= s->mb_intra;
2301
    d->mb_skiped= s->mb_skiped;
2302
    d->mv_type= s->mv_type;
2303
    d->mv_dir= s->mv_dir;
2304
    d->pb= s->pb;
2305
    if(s->data_partitioning){
2306
        d->pb2= s->pb2;
2307
        d->tex_pb= s->tex_pb;
2308
    }
2309
    d->block= s->block;
2310
    for(i=0; i<6; i++)
2311
        d->block_last_index[i]= s->block_last_index[i];
2312
}
2313

    
2314
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
2315
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2316
                           int *dmin, int *next_block, int motion_x, int motion_y)
2317
{
2318
    int bits_count;
2319
    
2320
    copy_context_before_encode(s, backup, type);
2321

    
2322
    s->block= s->blocks[*next_block];
2323
    s->pb= pb[*next_block];
2324
    if(s->data_partitioning){
2325
        s->pb2   = pb2   [*next_block];
2326
        s->tex_pb= tex_pb[*next_block];
2327
    }
2328

    
2329
    encode_mb(s, motion_x, motion_y);
2330

    
2331
    bits_count= get_bit_count(&s->pb);
2332
    if(s->data_partitioning){
2333
        bits_count+= get_bit_count(&s->pb2);
2334
        bits_count+= get_bit_count(&s->tex_pb);
2335
    }
2336

    
2337
    if(bits_count<*dmin){
2338
        *dmin= bits_count;
2339
        *next_block^=1;
2340

    
2341
        copy_context_after_encode(best, s, type);
2342
    }
2343
}
2344

    
2345
static void encode_picture(MpegEncContext *s, int picture_number)
2346
{
2347
    int mb_x, mb_y, last_gob, pdif = 0;
2348
    int i;
2349
    int bits;
2350
    MpegEncContext best_s, backup_s;
2351
    UINT8 bit_buf[2][3000];
2352
    UINT8 bit_buf2[2][3000];
2353
    UINT8 bit_buf_tex[2][3000];
2354
    PutBitContext pb[2], pb2[2], tex_pb[2];
2355

    
2356
    for(i=0; i<2; i++){
2357
        init_put_bits(&pb    [i], bit_buf    [i], 3000, NULL, NULL);
2358
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000, NULL, NULL);
2359
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
2360
    }
2361

    
2362
    s->picture_number = picture_number;
2363

    
2364
    s->block_wrap[0]=
2365
    s->block_wrap[1]=
2366
    s->block_wrap[2]=
2367
    s->block_wrap[3]= s->mb_width*2 + 2;
2368
    s->block_wrap[4]=
2369
    s->block_wrap[5]= s->mb_width + 2;
2370
    
2371
    /* Reset the average MB variance */
2372
    s->mb_var_sum = 0;
2373
    s->mc_mb_var_sum = 0;
2374

    
2375
    /* we need to initialize some time vars before we can encode b-frames */
2376
    if (s->h263_pred && !s->h263_msmpeg4)
2377
        ff_set_mpeg4_time(s, s->picture_number); 
2378

    
2379
    s->scene_change_score=0;
2380
    
2381
    s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
2382

    
2383
    /* Estimate motion for every MB */
2384
    if(s->pict_type != I_TYPE){
2385
        for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2386
            s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
2387
            s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
2388
            s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
2389
            s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
2390
            for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2391
                s->mb_x = mb_x;
2392
                s->mb_y = mb_y;
2393
                s->block_index[0]+=2;
2394
                s->block_index[1]+=2;
2395
                s->block_index[2]+=2;
2396
                s->block_index[3]+=2;
2397

    
2398
                /* compute motion vector & mb_type and store in context */
2399
                if(s->pict_type==B_TYPE)
2400
                    ff_estimate_b_frame_motion(s, mb_x, mb_y);
2401
                else
2402
                    ff_estimate_p_frame_motion(s, mb_x, mb_y);
2403
//                s->mb_type[mb_y*s->mb_width + mb_x]=MB_TYPE_INTER;
2404
            }
2405
        }
2406
        emms_c();
2407
    }else /* if(s->pict_type == I_TYPE) */{
2408
        /* I-Frame */
2409
        //FIXME do we need to zero them?
2410
        memset(s->motion_val[0], 0, sizeof(INT16)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
2411
        memset(s->p_mv_table   , 0, sizeof(INT16)*(s->mb_width+2)*(s->mb_height+2)*2);
2412
        memset(s->mb_type      , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
2413
        
2414
        if(!s->fixed_qscale){
2415
            /* finding spatial complexity for I-frame rate control */
2416
            for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2417
                for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2418
                    int xx = mb_x * 16;
2419
                    int yy = mb_y * 16;
2420
                    uint8_t *pix = s->new_picture[0] + (yy * s->linesize) + xx;
2421
                    int varc;
2422
                    int sum = pix_sum(pix, s->linesize);
2423
    
2424
                    sum= (sum+8)>>4;
2425
                    varc = (pix_norm1(pix, s->linesize) - sum*sum + 500 + 128)>>8;
2426

    
2427
                    s->mb_var [s->mb_width * mb_y + mb_x] = varc;
2428
                    s->mb_mean[s->mb_width * mb_y + mb_x] = (sum+7)>>4;
2429
                    s->mb_var_sum    += varc;
2430
                }
2431
            }
2432
        }
2433
    }
2434
    if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
2435
        s->pict_type= I_TYPE;
2436
        memset(s->mb_type   , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
2437
        if(s->max_b_frames==0){
2438
            s->input_pict_type= I_TYPE;
2439
            s->input_picture_in_gop_number=0;
2440
        }
2441
//printf("Scene change detected, encoding as I Frame %d %d\n", s->mb_var_sum, s->mc_mb_var_sum);
2442
    }
2443
    
2444
    if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) 
2445
        s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
2446
        ff_fix_long_p_mvs(s);
2447
    if(s->pict_type==B_TYPE){
2448
        s->f_code= ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
2449
        s->b_code= ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
2450

    
2451
        ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
2452
        ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
2453
        ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
2454
        ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
2455
    }
2456
    
2457
    if (s->fixed_qscale) 
2458
        s->frame_qscale = s->avctx->quality;
2459
    else
2460
        s->frame_qscale = ff_rate_estimate_qscale(s);
2461

    
2462
    if(s->adaptive_quant){
2463
        switch(s->codec_id){
2464
        case CODEC_ID_MPEG4:
2465
            ff_clean_mpeg4_qscales(s);
2466
            break;
2467
        case CODEC_ID_H263:
2468
        case CODEC_ID_H263P:
2469
            ff_clean_h263_qscales(s);
2470
            break;
2471
        }
2472

    
2473
        s->qscale= s->qscale_table[0];
2474
    }else
2475
        s->qscale= (int)(s->frame_qscale + 0.5);
2476
        
2477
    if (s->out_format == FMT_MJPEG) {
2478
        /* for mjpeg, we do include qscale in the matrix */
2479
        s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
2480
        for(i=1;i<64;i++){
2481
            int j= s->idct_permutation[i];
2482

    
2483
            s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
2484
        }
2485
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, 
2486
                       s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
2487
    }
2488

    
2489
    s->last_bits= get_bit_count(&s->pb);
2490
    switch(s->out_format) {
2491
    case FMT_MJPEG:
2492
        mjpeg_picture_header(s);
2493
        break;
2494
    case FMT_H263:
2495
        if (s->h263_msmpeg4) 
2496
            msmpeg4_encode_picture_header(s, picture_number);
2497
        else if (s->h263_pred)
2498
            mpeg4_encode_picture_header(s, picture_number);
2499
        else if (s->h263_rv10) 
2500
            rv10_encode_picture_header(s, picture_number);
2501
        else
2502
            h263_encode_picture_header(s, picture_number);
2503
        break;
2504
    case FMT_MPEG1:
2505
        mpeg1_encode_picture_header(s, picture_number);
2506
        break;
2507
    }
2508
    bits= get_bit_count(&s->pb);
2509
    s->header_bits= bits - s->last_bits;
2510
    s->last_bits= bits;
2511
    s->mv_bits=0;
2512
    s->misc_bits=0;
2513
    s->i_tex_bits=0;
2514
    s->p_tex_bits=0;
2515
    s->i_count=0;
2516
    s->f_count=0;
2517
    s->b_count=0;
2518
    s->skip_count=0;
2519

    
2520
    /* init last dc values */
2521
    /* note: quant matrix value (8) is implied here */
2522
    s->last_dc[0] = 128;
2523
    s->last_dc[1] = 128;
2524
    s->last_dc[2] = 128;
2525
    s->mb_incr = 1;
2526
    s->last_mv[0][0][0] = 0;
2527
    s->last_mv[0][0][1] = 0;
2528

    
2529
    /* Get the GOB height based on picture height */
2530
    if (s->out_format == FMT_H263 && !s->h263_pred && !s->h263_msmpeg4) {
2531
        if (s->height <= 400)
2532
            s->gob_index = 1;
2533
        else if (s->height <= 800)
2534
            s->gob_index = 2;
2535
        else
2536
            s->gob_index = 4;
2537
    }else if(s->codec_id==CODEC_ID_MPEG4){
2538
        s->gob_index = 1;
2539
    }
2540

    
2541
    if(s->codec_id==CODEC_ID_MPEG4 && s->data_partitioning && s->pict_type!=B_TYPE)
2542
        ff_mpeg4_init_partitions(s);
2543

    
2544
    s->resync_mb_x=0;
2545
    s->resync_mb_y=0;
2546
    for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2547
        /* Put GOB header based on RTP MTU for formats which support it per line (H263*)*/
2548
        /* TODO: Put all this stuff in a separate generic function */
2549
        if (s->rtp_mode) {
2550
            if (!mb_y) {
2551
                s->ptr_lastgob = s->pb.buf;
2552
                s->ptr_last_mb_line = s->pb.buf;
2553
            } else if (s->out_format == FMT_H263 && !s->h263_pred && !s->h263_msmpeg4 && !(mb_y % s->gob_index)) {
2554
                // MN: we could move the space check from h263 -> here, as its not h263 specific
2555
                last_gob = h263_encode_gob_header(s, mb_y);
2556
                if (last_gob) {
2557
                    s->first_slice_line = 1;
2558
                }else{
2559
                    /*MN: we reset it here instead at the end of each line cuz mpeg4 can have 
2560
                          slice lines starting & ending in the middle*/
2561
                    s->first_slice_line = 0;
2562
                }
2563
            }
2564
        }
2565

    
2566
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2567
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2568
        
2569
        s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
2570
        s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
2571
        s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
2572
        s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
2573
        s->block_index[4]= s->block_wrap[4]*(mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2);
2574
        s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
2575
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2576
            const int mb_type= s->mb_type[mb_y * s->mb_width + mb_x];
2577
            const int xy= (mb_y+1) * (s->mb_width+2) + mb_x + 1;
2578
//            int d;
2579
            int dmin=10000000;
2580

    
2581
            s->mb_x = mb_x;
2582
            s->mb_y = mb_y;
2583
            s->block_index[0]+=2;
2584
            s->block_index[1]+=2;
2585
            s->block_index[2]+=2;
2586
            s->block_index[3]+=2;
2587
            s->block_index[4]++;
2588
            s->block_index[5]++;
2589
            
2590
            /* write gob / video packet header for formats which support it at any MB (MPEG4) */
2591
            if(s->rtp_mode && s->mb_y>0 && s->codec_id==CODEC_ID_MPEG4){
2592
                int pdif= pbBufPtr(&s->pb) - s->ptr_lastgob;
2593

    
2594
                //the *2 is there so we stay below the requested size
2595
                if(pdif + s->mb_line_avgsize/s->mb_width >= s->rtp_payload_size){ 
2596
                    if(s->codec_id==CODEC_ID_MPEG4){
2597
                        if(s->data_partitioning && s->pict_type!=B_TYPE){
2598
                            ff_mpeg4_merge_partitions(s);
2599
                            ff_mpeg4_init_partitions(s);
2600
                        }
2601
                        ff_mpeg4_encode_video_packet_header(s);
2602

    
2603
                        if(s->flags&CODEC_FLAG_PASS1){
2604
                            int bits= get_bit_count(&s->pb);
2605
                            s->misc_bits+= bits - s->last_bits;
2606
                            s->last_bits= bits;
2607
                        }
2608
                        ff_mpeg4_clean_buffers(s);
2609
                    }
2610
                    s->ptr_lastgob = pbBufPtr(&s->pb);
2611
                    s->first_slice_line=1;
2612
                    s->resync_mb_x=mb_x;
2613
                    s->resync_mb_y=mb_y;
2614
                }
2615

    
2616
                if(  (s->resync_mb_x   == s->mb_x)
2617
                   && s->resync_mb_y+1 == s->mb_y){
2618
                    s->first_slice_line=0; 
2619
                }
2620
            }
2621

    
2622
            if(mb_type & (mb_type-1)){ // more than 1 MB type possible
2623
                int next_block=0;
2624
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2625

    
2626
                copy_context_before_encode(&backup_s, s, -1);
2627
                backup_s.pb= s->pb;
2628
                best_s.data_partitioning= s->data_partitioning;
2629
                if(s->data_partitioning){
2630
                    backup_s.pb2= s->pb2;
2631
                    backup_s.tex_pb= s->tex_pb;
2632
                }
2633

    
2634
                if(mb_type&MB_TYPE_INTER){
2635
                    s->mv_dir = MV_DIR_FORWARD;
2636
                    s->mv_type = MV_TYPE_16X16;
2637
                    s->mb_intra= 0;
2638
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
2639
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
2640
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb, 
2641
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2642
                }
2643
                if(mb_type&MB_TYPE_INTER4V){                 
2644
                    s->mv_dir = MV_DIR_FORWARD;
2645
                    s->mv_type = MV_TYPE_8X8;
2646
                    s->mb_intra= 0;
2647
                    for(i=0; i<4; i++){
2648
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
2649
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
2650
                    }
2651
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb, 
2652
                                 &dmin, &next_block, 0, 0);
2653
                }
2654
                if(mb_type&MB_TYPE_FORWARD){
2655
                    s->mv_dir = MV_DIR_FORWARD;
2656
                    s->mv_type = MV_TYPE_16X16;
2657
                    s->mb_intra= 0;
2658
                    s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2659
                    s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2660
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb, 
2661
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2662
                }
2663
                if(mb_type&MB_TYPE_BACKWARD){
2664
                    s->mv_dir = MV_DIR_BACKWARD;
2665
                    s->mv_type = MV_TYPE_16X16;
2666
                    s->mb_intra= 0;
2667
                    s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2668
                    s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2669
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb, 
2670
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2671
                }
2672
                if(mb_type&MB_TYPE_BIDIR){
2673
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2674
                    s->mv_type = MV_TYPE_16X16;
2675
                    s->mb_intra= 0;
2676
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2677
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2678
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2679
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2680
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb, 
2681
                                 &dmin, &next_block, 0, 0);
2682
                }
2683
                if(mb_type&MB_TYPE_DIRECT){
2684
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2685
                    s->mv_type = MV_TYPE_16X16; //FIXME
2686
                    s->mb_intra= 0;
2687
                    s->mv[0][0][0] = s->b_direct_forw_mv_table[xy][0];
2688
                    s->mv[0][0][1] = s->b_direct_forw_mv_table[xy][1];
2689
                    s->mv[1][0][0] = s->b_direct_back_mv_table[xy][0];
2690
                    s->mv[1][0][1] = s->b_direct_back_mv_table[xy][1];
2691
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb, 
2692
                                 &dmin, &next_block, s->b_direct_mv_table[xy][0], s->b_direct_mv_table[xy][1]);
2693
                }
2694
                if(mb_type&MB_TYPE_INTRA){
2695
                    s->mv_dir = MV_DIR_FORWARD;
2696
                    s->mv_type = MV_TYPE_16X16;
2697
                    s->mb_intra= 1;
2698
                    s->mv[0][0][0] = 0;
2699
                    s->mv[0][0][1] = 0;
2700
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb, 
2701
                                 &dmin, &next_block, 0, 0);
2702
                    /* force cleaning of ac/dc pred stuff if needed ... */
2703
                    if(s->h263_pred || s->h263_aic)
2704
                        s->mbintra_table[mb_x + mb_y*s->mb_width]=1;
2705
                }
2706
                copy_context_after_encode(s, &best_s, -1);
2707
                
2708
                pb_bits_count= get_bit_count(&s->pb);
2709
                flush_put_bits(&s->pb);
2710
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2711
                s->pb= backup_s.pb;
2712
                
2713
                if(s->data_partitioning){
2714
                    pb2_bits_count= get_bit_count(&s->pb2);
2715
                    flush_put_bits(&s->pb2);
2716
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2717
                    s->pb2= backup_s.pb2;
2718
                    
2719
                    tex_pb_bits_count= get_bit_count(&s->tex_pb);
2720
                    flush_put_bits(&s->tex_pb);
2721
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2722
                    s->tex_pb= backup_s.tex_pb;
2723
                }
2724
                s->last_bits= get_bit_count(&s->pb);
2725
            } else {
2726
                int motion_x, motion_y;
2727
                s->mv_type=MV_TYPE_16X16;
2728
                // only one MB-Type possible
2729
                switch(mb_type){
2730
                case MB_TYPE_INTRA:
2731
                    s->mv_dir = MV_DIR_FORWARD;
2732
                    s->mb_intra= 1;
2733
                    motion_x= s->mv[0][0][0] = 0;
2734
                    motion_y= s->mv[0][0][1] = 0;
2735
                    break;
2736
                case MB_TYPE_INTER:
2737
                    s->mv_dir = MV_DIR_FORWARD;
2738
                    s->mb_intra= 0;
2739
                    motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2740
                    motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2741
                    break;
2742
                case MB_TYPE_INTER4V:
2743
                    s->mv_dir = MV_DIR_FORWARD;
2744
                    s->mv_type = MV_TYPE_8X8;
2745
                    s->mb_intra= 0;
2746
                    for(i=0; i<4; i++){
2747
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
2748
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
2749
                    }
2750
                    motion_x= motion_y= 0;
2751
                    break;
2752
                case MB_TYPE_DIRECT:
2753
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2754
                    s->mb_intra= 0;
2755
                    motion_x=s->b_direct_mv_table[xy][0];
2756
                    motion_y=s->b_direct_mv_table[xy][1];
2757
                    s->mv[0][0][0] = s->b_direct_forw_mv_table[xy][0];
2758
                    s->mv[0][0][1] = s->b_direct_forw_mv_table[xy][1];
2759
                    s->mv[1][0][0] = s->b_direct_back_mv_table[xy][0];
2760
                    s->mv[1][0][1] = s->b_direct_back_mv_table[xy][1];
2761
                    break;
2762
                case MB_TYPE_BIDIR:
2763
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2764
                    s->mb_intra= 0;
2765
                    motion_x=0;
2766
                    motion_y=0;
2767
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2768
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2769
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2770
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2771
                    break;
2772
                case MB_TYPE_BACKWARD:
2773
                    s->mv_dir = MV_DIR_BACKWARD;
2774
                    s->mb_intra= 0;
2775
                    motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2776
                    motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2777
                    break;
2778
                case MB_TYPE_FORWARD:
2779
                    s->mv_dir = MV_DIR_FORWARD;
2780
                    s->mb_intra= 0;
2781
                    motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2782
                    motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2783
//                    printf(" %d %d ", motion_x, motion_y);
2784
                    break;
2785
                default:
2786
                    motion_x=motion_y=0; //gcc warning fix
2787
                    printf("illegal MB type\n");
2788
                }
2789
                encode_mb(s, motion_x, motion_y);
2790
            }
2791
            /* clean the MV table in IPS frames for direct mode in B frames */
2792
            if(s->mb_intra /* && I,P,S_TYPE */){
2793
                s->p_mv_table[xy][0]=0;
2794
                s->p_mv_table[xy][1]=0;
2795
            }
2796

    
2797
            MPV_decode_mb(s, s->block);
2798
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_width, get_bit_count(&s->pb));
2799
        }
2800

    
2801

    
2802
        /* Obtain average GOB size for RTP */
2803
        if (s->rtp_mode) {
2804
            if (!mb_y)
2805
                s->mb_line_avgsize = pbBufPtr(&s->pb) - s->ptr_last_mb_line;
2806
            else if (!(mb_y % s->gob_index)) {    
2807
                s->mb_line_avgsize = (s->mb_line_avgsize + pbBufPtr(&s->pb) - s->ptr_last_mb_line) >> 1;
2808
                s->ptr_last_mb_line = pbBufPtr(&s->pb);
2809
            }
2810
            //fprintf(stderr, "\nMB line: %d\tSize: %u\tAvg. Size: %u", s->mb_y, 
2811
            //                    (s->pb.buf_ptr - s->ptr_last_mb_line), s->mb_line_avgsize);
2812
            if(s->codec_id!=CODEC_ID_MPEG4) s->first_slice_line = 0; //FIXME clean
2813
        }
2814
    }
2815
    emms_c();
2816

    
2817
    if(s->codec_id==CODEC_ID_MPEG4 && s->data_partitioning && s->pict_type!=B_TYPE)
2818
        ff_mpeg4_merge_partitions(s);
2819

    
2820
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
2821
        msmpeg4_encode_ext_header(s);
2822

    
2823
    if(s->codec_id==CODEC_ID_MPEG4) 
2824
        ff_mpeg4_stuffing(&s->pb);
2825

    
2826
    //if (s->gob_number)
2827
    //    fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
2828
    
2829
    /* Send the last GOB if RTP */    
2830
    if (s->rtp_mode) {
2831
        flush_put_bits(&s->pb);
2832
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
2833
        /* Call the RTP callback to send the last GOB */
2834
        if (s->rtp_callback)
2835
            s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
2836
        s->ptr_lastgob = pbBufPtr(&s->pb);
2837
        //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
2838
    }
2839
}
2840

    
2841
static int dct_quantize_c(MpegEncContext *s, 
2842
                        DCTELEM *block, int n,
2843
                        int qscale, int *overflow)
2844
{
2845
    int i, j, level, last_non_zero, q;
2846
    const int *qmat;
2847
    int bias;
2848
    int max=0;
2849
    unsigned int threshold1, threshold2;
2850
    
2851
    s->fdct (block);
2852

    
2853
#ifndef ARCH_ALPHA              /* Alpha uses unpermuted matrix */
2854
    /* we need this permutation so that we correct the IDCT
2855
       permutation. will be moved into DCT code */
2856
    block_permute(block, s->idct_permutation); //FIXME remove
2857
#endif
2858

    
2859
    if (s->mb_intra) {
2860
        if (!s->h263_aic) {
2861
            if (n < 4)
2862
                q = s->y_dc_scale;
2863
            else
2864
                q = s->c_dc_scale;
2865
            q = q << 3;
2866
        } else
2867
            /* For AIC we skip quant/dequant of INTRADC */
2868
            q = 1 << 3;
2869
            
2870
        /* note: block[0] is assumed to be positive */
2871
        block[0] = (block[0] + (q >> 1)) / q;
2872
        i = 1;
2873
        last_non_zero = 0;
2874
        qmat = s->q_intra_matrix[qscale];
2875
        bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
2876
    } else {
2877
        i = 0;
2878
        last_non_zero = -1;
2879
        qmat = s->q_inter_matrix[qscale];
2880
        bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
2881
    }
2882
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
2883
    threshold2= (threshold1<<1);
2884

    
2885
    for(;i<64;i++) {
2886
        j = s->intra_scantable.permutated[i];
2887
        level = block[j];
2888
        level = level * qmat[j];
2889

    
2890
//        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
2891
//           || bias-level >= (1<<(QMAT_SHIFT - 3))){
2892
        if(((unsigned)(level+threshold1))>threshold2){
2893
            if(level>0){
2894
                level= (bias + level)>>QMAT_SHIFT;
2895
                block[j]= level;
2896
            }else{
2897
                level= (bias - level)>>QMAT_SHIFT;
2898
                block[j]= -level;
2899
            }
2900
            max |=level;
2901
            last_non_zero = i;
2902
        }else{
2903
            block[j]=0;
2904
        }
2905
    }
2906
    *overflow= s->max_qcoeff < max; //overflow might have happend
2907
    
2908
    return last_non_zero;
2909
}
2910

    
2911
static void dct_unquantize_mpeg1_c(MpegEncContext *s, 
2912
                                   DCTELEM *block, int n, int qscale)
2913
{
2914
    int i, level, nCoeffs;
2915
    const UINT16 *quant_matrix;
2916

    
2917
    nCoeffs= s->block_last_index[n];
2918
    
2919
    if (s->mb_intra) {
2920
        if (n < 4) 
2921
            block[0] = block[0] * s->y_dc_scale;
2922
        else
2923
            block[0] = block[0] * s->c_dc_scale;
2924
        /* XXX: only mpeg1 */
2925
        quant_matrix = s->intra_matrix;
2926
        for(i=1;i<=nCoeffs;i++) {
2927
            int j= s->intra_scantable.permutated[i];
2928
            level = block[j];
2929
            if (level) {
2930
                if (level < 0) {
2931
                    level = -level;
2932
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
2933
                    level = (level - 1) | 1;
2934
                    level = -level;
2935
                } else {
2936
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
2937
                    level = (level - 1) | 1;
2938
                }
2939
#ifdef PARANOID
2940
                if (level < -2048 || level > 2047)
2941
                    fprintf(stderr, "unquant error %d %d\n", i, level);
2942
#endif
2943
                block[j] = level;
2944
            }
2945
        }
2946
    } else {
2947
        i = 0;
2948
        quant_matrix = s->inter_matrix;
2949
        for(;i<=nCoeffs;i++) {
2950
            int j= s->intra_scantable.permutated[i];
2951
            level = block[j];
2952
            if (level) {
2953
                if (level < 0) {
2954
                    level = -level;
2955
                    level = (((level << 1) + 1) * qscale *
2956
                             ((int) (quant_matrix[j]))) >> 4;
2957
                    level = (level - 1) | 1;
2958
                    level = -level;
2959
                } else {
2960
                    level = (((level << 1) + 1) * qscale *
2961
                             ((int) (quant_matrix[j]))) >> 4;
2962
                    level = (level - 1) | 1;
2963
                }
2964
#ifdef PARANOID
2965
                if (level < -2048 || level > 2047)
2966
                    fprintf(stderr, "unquant error %d %d\n", i, level);
2967
#endif
2968
                block[j] = level;
2969
            }
2970
        }
2971
    }
2972
}
2973

    
2974
static void dct_unquantize_mpeg2_c(MpegEncContext *s, 
2975
                                   DCTELEM *block, int n, int qscale)
2976
{
2977
    int i, level, nCoeffs;
2978
    const UINT16 *quant_matrix;
2979

    
2980
    if(s->alternate_scan) nCoeffs= 63;
2981
    else nCoeffs= s->block_last_index[n];
2982
    
2983
    if (s->mb_intra) {
2984
        if (n < 4) 
2985
            block[0] = block[0] * s->y_dc_scale;
2986
        else
2987
            block[0] = block[0] * s->c_dc_scale;
2988
        quant_matrix = s->intra_matrix;
2989
        for(i=1;i<=nCoeffs;i++) {
2990
            int j= s->intra_scantable.permutated[i];
2991
            level = block[j];
2992
            if (level) {
2993
                if (level < 0) {
2994
                    level = -level;
2995
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
2996
                    level = -level;
2997
                } else {
2998
                    level = (int)(level * qscale * quant_matrix[j]) >> 3;
2999
                }
3000
#ifdef PARANOID
3001
                if (level < -2048 || level > 2047)
3002
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3003
#endif
3004
                block[j] = level;
3005
            }
3006
        }
3007
    } else {
3008
        int sum=-1;
3009
        i = 0;
3010
        quant_matrix = s->inter_matrix;
3011
        for(;i<=nCoeffs;i++) {
3012
            int j= s->intra_scantable.permutated[i];
3013
            level = block[j];
3014
            if (level) {
3015
                if (level < 0) {
3016
                    level = -level;
3017
                    level = (((level << 1) + 1) * qscale *
3018
                             ((int) (quant_matrix[j]))) >> 4;
3019
                    level = -level;
3020
                } else {
3021
                    level = (((level << 1) + 1) * qscale *
3022
                             ((int) (quant_matrix[j]))) >> 4;
3023
                }
3024
#ifdef PARANOID
3025
                if (level < -2048 || level > 2047)
3026
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3027
#endif
3028
                block[j] = level;
3029
                sum+=level;
3030
            }
3031
        }
3032
        block[63]^=sum&1;
3033
    }
3034
}
3035

    
3036

    
3037
static void dct_unquantize_h263_c(MpegEncContext *s, 
3038
                                  DCTELEM *block, int n, int qscale)
3039
{
3040
    int i, level, qmul, qadd;
3041
    int nCoeffs;
3042
    
3043
    assert(s->block_last_index[n]>=0);
3044
    
3045
    qadd = (qscale - 1) | 1;
3046
    qmul = qscale << 1;
3047
    
3048
    if (s->mb_intra) {
3049
        if (!s->h263_aic) {
3050
            if (n < 4) 
3051
                block[0] = block[0] * s->y_dc_scale;
3052
            else
3053
                block[0] = block[0] * s->c_dc_scale;
3054
        }else
3055
            qadd = 0;
3056
        i = 1;
3057
        nCoeffs= 63; //does not allways use zigzag table 
3058
    } else {
3059
        i = 0;
3060
        nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ];
3061
    }
3062

    
3063
    for(;i<=nCoeffs;i++) {
3064
        level = block[i];
3065
        if (level) {
3066
            if (level < 0) {
3067
                level = level * qmul - qadd;
3068
            } else {
3069
                level = level * qmul + qadd;
3070
            }
3071
#ifdef PARANOID
3072
                if (level < -2048 || level > 2047)
3073
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3074
#endif
3075
            block[i] = level;
3076
        }
3077
    }
3078
}
3079

    
3080
static void remove_ac(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int mb_x, int mb_y)
3081
{
3082
    int dc, dcb, dcr, y, i;
3083
    for(i=0; i<4; i++){
3084
        dc= s->dc_val[0][mb_x*2+1 + (i&1) + (mb_y*2+1 + (i>>1))*(s->mb_width*2+2)];
3085
        for(y=0; y<8; y++){
3086
            int x;
3087
            for(x=0; x<8; x++){
3088
                dest_y[x + (i&1)*8 + (y + (i>>1)*8)*s->linesize]= dc/8;
3089
            }
3090
        }
3091
    }
3092
    dcb = s->dc_val[1][mb_x+1 + (mb_y+1)*(s->mb_width+2)];
3093
    dcr= s->dc_val[2][mb_x+1 + (mb_y+1)*(s->mb_width+2)];
3094
    for(y=0; y<8; y++){
3095
        int x;
3096
        for(x=0; x<8; x++){
3097
            dest_cb[x + y*(s->uvlinesize)]= dcb/8;
3098
            dest_cr[x + y*(s->uvlinesize)]= dcr/8;
3099
        }
3100
    }
3101
}
3102

    
3103
/**
3104
 * will conceal past errors, and allso drop b frames if needed
3105
 *
3106
 */
3107
void ff_conceal_past_errors(MpegEncContext *s, int unknown_pos)
3108
{
3109
    int mb_x= s->mb_x;
3110
    int mb_y= s->mb_y;
3111
    int mb_dist=0;
3112
    int i, intra_count=0, inter_count=0;
3113
    int intra_conceal= s->msmpeg4_version ? 50 : 50; //FIXME finetune
3114
    int inter_conceal= s->msmpeg4_version ? 50 : 50;
3115

    
3116
    // for last block
3117
    if(mb_x>=s->mb_width)  mb_x= s->mb_width -1;
3118
    if(mb_y>=s->mb_height) mb_y= s->mb_height-1;
3119

    
3120
    if(s->decoding_error==0 && unknown_pos){
3121
        if(s->data_partitioning && s->pict_type!=B_TYPE)
3122
                s->decoding_error= DECODING_AC_LOST;
3123
        else
3124
                s->decoding_error= DECODING_DESYNC;
3125
    }
3126

    
3127
    if(s->decoding_error==DECODING_DESYNC && s->pict_type!=B_TYPE) s->next_p_frame_damaged=1;
3128

    
3129
    for(i=mb_x + mb_y*s->mb_width; i>=0; i--){
3130
        if(s->mbintra_table[i]) intra_count++;
3131
        else                    inter_count++;
3132
    }
3133
    
3134
    if(s->decoding_error==DECODING_AC_LOST){
3135
        intra_conceal*=2;
3136
        inter_conceal*=2;
3137
    }else if(s->decoding_error==DECODING_ACDC_LOST){
3138
        intra_conceal*=2;
3139
        inter_conceal*=2;
3140
    }
3141

    
3142
    if(unknown_pos && (intra_count<inter_count)){
3143
        intra_conceal= inter_conceal= s->mb_num; 
3144
//        printf("%d %d\n",intra_count, inter_count);
3145
    }
3146

    
3147
    fprintf(stderr, "concealing errors\n");
3148

    
3149
    /* for all MBs from the current one back until the last resync marker */
3150
    for(; mb_y>=0 && mb_y>=s->resync_mb_y; mb_y--){
3151
        for(; mb_x>=0; mb_x--){
3152
            uint8_t *dest_y  = s->current_picture[0] + (mb_y * 16*  s->linesize      ) + mb_x * 16;
3153
            uint8_t *dest_cb = s->current_picture[1] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8;
3154
            uint8_t *dest_cr = s->current_picture[2] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8;
3155
            int mb_x_backup= s->mb_x; //FIXME pass xy to mpeg_motion
3156
            int mb_y_backup= s->mb_y;
3157
            s->mb_x=mb_x;
3158
            s->mb_y=mb_y;
3159
            if(s->mbintra_table[mb_y*s->mb_width + mb_x] && mb_dist<intra_conceal){
3160
                if(s->decoding_error==DECODING_AC_LOST){
3161
                    remove_ac(s, dest_y, dest_cb, dest_cr, mb_x, mb_y);
3162
//                    printf("remove ac to %d %d\n", mb_x, mb_y);
3163
                }else{
3164
                    mpeg_motion(s, dest_y, dest_cb, dest_cr, 0, 
3165
                                s->last_picture, 0, 0, put_pixels_tab,
3166
                                0/*mx*/, 0/*my*/, 16);
3167
                }
3168
            }
3169
            else if(!s->mbintra_table[mb_y*s->mb_width + mb_x] && mb_dist<inter_conceal){
3170
                int mx=0;
3171
                int my=0;
3172

    
3173
                if(s->decoding_error!=DECODING_DESYNC){
3174
                    int xy= mb_x*2+1 + (mb_y*2+1)*(s->mb_width*2+2);
3175
                    mx= s->motion_val[ xy ][0];
3176
                    my= s->motion_val[ xy ][1];
3177
                }
3178

    
3179
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 0, 
3180
                            s->last_picture, 0, 0, put_pixels_tab,
3181
                            mx, my, 16);
3182
            }
3183
            s->mb_x= mb_x_backup;
3184
            s->mb_y= mb_y_backup;
3185

    
3186
            if(mb_x== s->resync_mb_x && mb_y== s->resync_mb_y) return;
3187
            if(!s->mbskip_table[mb_x + mb_y*s->mb_width]) mb_dist++;
3188
        }
3189
        mb_x=s->mb_width-1;
3190
    }
3191
}
3192

    
3193
AVCodec mpeg1video_encoder = {
3194
    "mpeg1video",
3195
    CODEC_TYPE_VIDEO,
3196
    CODEC_ID_MPEG1VIDEO,
3197
    sizeof(MpegEncContext),
3198
    MPV_encode_init,
3199
    MPV_encode_picture,
3200
    MPV_encode_end,
3201
};
3202

    
3203
AVCodec h263_encoder = {
3204
    "h263",
3205
    CODEC_TYPE_VIDEO,
3206
    CODEC_ID_H263,
3207
    sizeof(MpegEncContext),
3208
    MPV_encode_init,
3209
    MPV_encode_picture,
3210
    MPV_encode_end,
3211
};
3212

    
3213
AVCodec h263p_encoder = {
3214
    "h263p",
3215
    CODEC_TYPE_VIDEO,
3216
    CODEC_ID_H263P,
3217
    sizeof(MpegEncContext),
3218
    MPV_encode_init,
3219
    MPV_encode_picture,
3220
    MPV_encode_end,
3221
};
3222

    
3223
AVCodec rv10_encoder = {
3224
    "rv10",
3225
    CODEC_TYPE_VIDEO,
3226
    CODEC_ID_RV10,
3227
    sizeof(MpegEncContext),
3228
    MPV_encode_init,
3229
    MPV_encode_picture,
3230
    MPV_encode_end,
3231
};
3232

    
3233
AVCodec mjpeg_encoder = {
3234
    "mjpeg",
3235
    CODEC_TYPE_VIDEO,
3236
    CODEC_ID_MJPEG,
3237
    sizeof(MpegEncContext),
3238
    MPV_encode_init,
3239
    MPV_encode_picture,
3240
    MPV_encode_end,
3241
};
3242

    
3243
AVCodec mpeg4_encoder = {
3244
    "mpeg4",
3245
    CODEC_TYPE_VIDEO,
3246
    CODEC_ID_MPEG4,
3247
    sizeof(MpegEncContext),
3248
    MPV_encode_init,
3249
    MPV_encode_picture,
3250
    MPV_encode_end,
3251
};
3252

    
3253
AVCodec msmpeg4v1_encoder = {
3254
    "msmpeg4v1",
3255
    CODEC_TYPE_VIDEO,
3256
    CODEC_ID_MSMPEG4V1,
3257
    sizeof(MpegEncContext),
3258
    MPV_encode_init,
3259
    MPV_encode_picture,
3260
    MPV_encode_end,
3261
};
3262

    
3263
AVCodec msmpeg4v2_encoder = {
3264
    "msmpeg4v2",
3265
    CODEC_TYPE_VIDEO,
3266
    CODEC_ID_MSMPEG4V2,
3267
    sizeof(MpegEncContext),
3268
    MPV_encode_init,
3269
    MPV_encode_picture,
3270
    MPV_encode_end,
3271
};
3272

    
3273
AVCodec msmpeg4v3_encoder = {
3274
    "msmpeg4",
3275
    CODEC_TYPE_VIDEO,
3276
    CODEC_ID_MSMPEG4V3,
3277
    sizeof(MpegEncContext),
3278
    MPV_encode_init,
3279
    MPV_encode_picture,
3280
    MPV_encode_end,
3281
};
3282

    
3283
AVCodec wmv1_encoder = {
3284
    "wmv1",
3285
    CODEC_TYPE_VIDEO,
3286
    CODEC_ID_WMV1,
3287
    sizeof(MpegEncContext),
3288
    MPV_encode_init,
3289
    MPV_encode_picture,
3290
    MPV_encode_end,
3291
};
3292

    
3293
AVCodec wmv2_encoder = {
3294
    "wmv2",
3295
    CODEC_TYPE_VIDEO,
3296
    CODEC_ID_WMV2,
3297
    sizeof(MpegEncContext),
3298
    MPV_encode_init,
3299
    MPV_encode_picture,
3300
    MPV_encode_end,
3301
};