Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ defdfc9a

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 dct for both encoder and decoder */
183
int DCT_common_init(MpegEncContext *s)
184
{
185
    int i;
186

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

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

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

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

    
230
    return 0;
231
}
232

    
233
/* init common structure for both encoder and decoder */
234
int MPV_common_init(MpegEncContext *s)
235
{
236
    int c_size, i;
237
    UINT8 *pict;
238

    
239
    DCT_common_init(s);
240

    
241
    s->mb_width = (s->width + 15) / 16;
242
    s->mb_height = (s->height + 15) / 16;
243
    
244
    /* set default edge pos, will be overriden in decode_header if needed */
245
    s->h_edge_pos= s->mb_width*16;
246
    s->v_edge_pos= s->mb_height*16;
247
    
248
    /* convert fourcc to upper case */
249
    s->avctx->fourcc=   toupper( s->avctx->fourcc     &0xFF)          
250
                     + (toupper((s->avctx->fourcc>>8 )&0xFF)<<8 )
251
                     + (toupper((s->avctx->fourcc>>16)&0xFF)<<16) 
252
                     + (toupper((s->avctx->fourcc>>24)&0xFF)<<24);
253

    
254
    s->mb_num = s->mb_width * s->mb_height;
255
    if(!(s->flags&CODEC_FLAG_DR1)){
256
      s->linesize   = s->mb_width * 16 + 2 * EDGE_WIDTH;
257
      s->uvlinesize = s->mb_width * 8  +     EDGE_WIDTH;
258

    
259
      for(i=0;i<3;i++) {
260
        int w, h, shift, pict_start;
261

    
262
        w = s->linesize;
263
        h = s->mb_height * 16 + 2 * EDGE_WIDTH;
264
        shift = (i == 0) ? 0 : 1;
265
        c_size = (s->linesize>>shift) * (h >> shift);
266
        pict_start = (s->linesize>>shift) * (EDGE_WIDTH >> shift) + (EDGE_WIDTH >> shift);
267

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

    
300
        /* Allocate MV tables */
301
        CHECKED_ALLOCZ(s->p_mv_table            , mv_table_size * 2 * sizeof(INT16))
302
        CHECKED_ALLOCZ(s->b_forw_mv_table       , mv_table_size * 2 * sizeof(INT16))
303
        CHECKED_ALLOCZ(s->b_back_mv_table       , mv_table_size * 2 * sizeof(INT16))
304
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table , mv_table_size * 2 * sizeof(INT16))
305
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table , mv_table_size * 2 * sizeof(INT16))
306
        CHECKED_ALLOCZ(s->b_direct_forw_mv_table, mv_table_size * 2 * sizeof(INT16))
307
        CHECKED_ALLOCZ(s->b_direct_back_mv_table, mv_table_size * 2 * sizeof(INT16))
308
        CHECKED_ALLOCZ(s->b_direct_mv_table     , mv_table_size * 2 * sizeof(INT16))
309

    
310
        CHECKED_ALLOCZ(s->me_scratchpad,  s->linesize*16*3*sizeof(uint8_t))
311
        
312
        CHECKED_ALLOCZ(s->me_map      , ME_MAP_SIZE*sizeof(uint32_t))
313
        CHECKED_ALLOCZ(s->me_score_map, ME_MAP_SIZE*sizeof(uint16_t))
314

    
315
        if(s->max_b_frames){
316
            for(j=0; j<REORDER_BUFFER_SIZE; j++){
317
                int i;
318
                for(i=0;i<3;i++) {
319
                    int w, h, shift;
320

    
321
                    w = s->linesize;
322
                    h = s->mb_height * 16;
323
                    shift = (i == 0) ? 0 : 1;
324
                    c_size = (w >> shift) * (h >> shift);
325

    
326
                    CHECKED_ALLOCZ(pict, c_size);
327
                    s->picture_buffer[j][i] = pict;
328
                }
329
            }
330
        }
331

    
332
        if(s->codec_id==CODEC_ID_MPEG4){
333
            CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
334
            CHECKED_ALLOCZ(   s->pb2_buffer, PB_BUFFER_SIZE);
335
        }
336
        
337
        if(s->msmpeg4_version){
338
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
339
        }
340
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
341
    }
342
    
343
    if (s->out_format == FMT_H263 || s->encoding) {
344
        int size;
345
        /* Allocate MB type table */
346
        CHECKED_ALLOCZ(s->mb_type  , s->mb_num * sizeof(UINT8))
347

    
348
        /* MV prediction */
349
        size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
350
        CHECKED_ALLOCZ(s->motion_val, size * 2 * sizeof(INT16));
351
    }
352

    
353
    if(s->codec_id==CODEC_ID_MPEG4){
354
        /* 4mv and interlaced direct mode decoding tables */
355
        CHECKED_ALLOCZ(s->co_located_type_table, s->mb_num * sizeof(UINT8))
356
        CHECKED_ALLOCZ(s->field_mv_table, s->mb_num*2*2 * sizeof(INT16))
357
        CHECKED_ALLOCZ(s->field_select_table, s->mb_num*2* sizeof(INT8))
358
    }
359

    
360
    if (s->h263_pred || s->h263_plus) {
361
        int y_size, c_size, i, size;
362
        
363
        /* dc values */
364

    
365
        y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
366
        c_size = (s->mb_width + 2) * (s->mb_height + 2);
367
        size = y_size + 2 * c_size;
368
        CHECKED_ALLOCZ(s->dc_val[0], size * sizeof(INT16));
369
        s->dc_val[1] = s->dc_val[0] + y_size;
370
        s->dc_val[2] = s->dc_val[1] + c_size;
371
        for(i=0;i<size;i++)
372
            s->dc_val[0][i] = 1024;
373

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

    
403
    s->context_initialized = 1;
404
    return 0;
405
 fail:
406
    MPV_common_end(s);
407
    return -1;
408
}
409

    
410

    
411
//extern int sads;
412

    
413
/* init common structure for both encoder and decoder */
414
void MPV_common_end(MpegEncContext *s)
415
{
416
    int i;
417

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

    
467
        for(j=0; j<REORDER_BUFFER_SIZE; j++){
468
            av_freep(&s->picture_buffer[j][i]);
469
        }
470
    }
471
    s->context_initialized = 0;
472
}
473

    
474
/* init video encoder */
475
int MPV_encode_init(AVCodecContext *avctx)
476
{
477
    MpegEncContext *s = avctx->priv_data;
478
    int i;
479

    
480
    avctx->pix_fmt = PIX_FMT_YUV420P;
481

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

    
518
    if (s->gop_size <= 1) {
519
        s->intra_only = 1;
520
        s->gop_size = 12;
521
    } else {
522
        s->intra_only = 0;
523
    }
524

    
525
    /* ME algorithm */
526
    if (avctx->me_method == 0)
527
        /* For compatibility */
528
        s->me_method = motion_estimation_method;
529
    else
530
        s->me_method = avctx->me_method;
531

    
532
    /* Fixed QSCALE */
533
    s->fixed_qscale = (avctx->flags & CODEC_FLAG_QSCALE);
534
    
535
    s->adaptive_quant= (   s->avctx->lumi_masking
536
                        || s->avctx->dark_masking
537
                        || s->avctx->temporal_cplx_masking 
538
                        || s->avctx->spatial_cplx_masking
539
                        || s->avctx->p_masking)
540
                       && !s->fixed_qscale;
541
    
542
    s->progressive_sequence= !(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
543

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

    
650
            for(i=-16; i<16; i++){
651
                default_fcode_tab[i + MAX_MV]= 1;
652
            }
653
        }
654
    }
655
    s->mv_penalty= default_mv_penalty;
656
    s->fcode_tab= default_fcode_tab;
657
    s->y_dc_scale_table=
658
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
659
 
660
    /* dont use mv_penalty table for crap MV as it would be confused */
661
    if (s->me_method < ME_EPZS) s->mv_penalty = default_mv_penalty;
662

    
663
    s->encoding = 1;
664

    
665
    /* init */
666
    if (MPV_common_init(s) < 0)
667
        return -1;
668
    
669
    if (s->out_format == FMT_H263)
670
        h263_encode_init(s);
671
    else if (s->out_format == FMT_MPEG1)
672
        ff_mpeg1_encode_init(s);
673
    if(s->msmpeg4_version)
674
        ff_msmpeg4_encode_init(s);
675

    
676
    /* init default q matrix */
677
    for(i=0;i<64;i++) {
678
        int j= s->idct_permutation[i];
679
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
680
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
681
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
682
        }else if(s->out_format == FMT_H263){
683
            s->intra_matrix[j] =
684
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
685
        }else{ /* mpeg1 */
686
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
687
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
688
        }
689
    }
690

    
691
    /* precompute matrix */
692
    /* for mjpeg, we do include qscale in the matrix */
693
    if (s->out_format != FMT_MJPEG) {
694
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, s->q_intra_matrix16_bias, 
695
                       s->intra_matrix, s->intra_quant_bias, 1, 31);
696
        convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16, s->q_inter_matrix16_bias, 
697
                       s->inter_matrix, s->inter_quant_bias, 1, 31);
698
    }
699

    
700
    if(ff_rate_control_init(s) < 0)
701
        return -1;
702

    
703
    s->picture_number = 0;
704
    s->picture_in_gop_number = 0;
705
    s->fake_picture_number = 0;
706
    /* motion detector init */
707
    s->f_code = 1;
708
    s->b_code = 1;
709

    
710
    return 0;
711
}
712

    
713
int MPV_encode_end(AVCodecContext *avctx)
714
{
715
    MpegEncContext *s = avctx->priv_data;
716

    
717
#ifdef STATS
718
    print_stats();
719
#endif
720

    
721
    ff_rate_control_uninit(s);
722

    
723
    MPV_common_end(s);
724
    if (s->out_format == FMT_MJPEG)
725
        mjpeg_close(s);
726
      
727
    return 0;
728
}
729

    
730
/* draw the edges of width 'w' of an image of size width, height */
731
//FIXME check that this is ok for mpeg4 interlaced
732
static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w)
733
{
734
    UINT8 *ptr, *last_line;
735
    int i;
736

    
737
    last_line = buf + (height - 1) * wrap;
738
    for(i=0;i<w;i++) {
739
        /* top and bottom */
740
        memcpy(buf - (i + 1) * wrap, buf, width);
741
        memcpy(last_line + (i + 1) * wrap, last_line, width);
742
    }
743
    /* left and right */
744
    ptr = buf;
745
    for(i=0;i<height;i++) {
746
        memset(ptr - w, ptr[0], w);
747
        memset(ptr + width, ptr[width-1], w);
748
        ptr += wrap;
749
    }
750
    /* corners */
751
    for(i=0;i<w;i++) {
752
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
753
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
754
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
755
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
756
    }
757
}
758

    
759
/* generic function for encode/decode called before a frame is coded/decoded */
760
void MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
761
{
762
    int i;
763
    UINT8 *tmp;
764

    
765
    s->mb_skiped = 0;
766
    s->decoding_error=0;
767
    avctx->mbskip_table= s->mbskip_table;
768

    
769
    if(avctx->flags&CODEC_FLAG_DR1){
770
        avctx->get_buffer_callback(avctx, s->width, s->height, s->pict_type);
771

    
772
        s->linesize  = avctx->dr_stride;
773
        s->uvlinesize= avctx->dr_uvstride;
774
        s->ip_buffer_count= avctx->dr_ip_buffer_count;
775
    }
776
    avctx->dr_ip_buffer_count= s->ip_buffer_count;
777
    
778
    if (s->pict_type == B_TYPE) {
779
        for(i=0;i<3;i++) {
780
            if(avctx->flags&CODEC_FLAG_DR1)
781
                s->aux_picture[i]= avctx->dr_buffer[i];
782
            
783
            //FIXME the following should never be needed, the decoder should drop b frames if no reference is available
784
            if(s->next_picture[i]==NULL)
785
                s->next_picture[i]= s->aux_picture[i];
786
            if(s->last_picture[i]==NULL)
787
                s->last_picture[i]= s->next_picture[i];
788

    
789
            s->current_picture[i] = s->aux_picture[i];
790
        }
791
    } else {
792
        for(i=0;i<3;i++) {
793
            /* swap next and last */
794
            if(avctx->flags&CODEC_FLAG_DR1)
795
                tmp= avctx->dr_buffer[i];
796
            else
797
                tmp = s->last_picture[i];
798

    
799
            s->last_picture[i] = s->next_picture[i];
800
            s->next_picture[i] = tmp;
801
            s->current_picture[i] = tmp;
802

    
803
            if(s->last_picture[i]==NULL)
804
                s->last_picture[i]= s->next_picture[i];
805

    
806
            s->last_dr_opaque= s->next_dr_opaque;
807
            s->next_dr_opaque= avctx->dr_opaque_frame;
808

    
809
            if(s->has_b_frames && s->last_dr_opaque && s->codec_id!=CODEC_ID_SVQ1)
810
                avctx->dr_opaque_frame= s->last_dr_opaque;
811
            else
812
                avctx->dr_opaque_frame= s->next_dr_opaque;
813
        }
814
    }
815
    /* set dequantizer, we cant do it during init as it might change for mpeg4
816
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
817
    if(s->out_format == FMT_H263){
818
        if(s->mpeg_quant)
819
            s->dct_unquantize = s->dct_unquantize_mpeg2;
820
        else
821
            s->dct_unquantize = s->dct_unquantize_h263;
822
    }else 
823
        s->dct_unquantize = s->dct_unquantize_mpeg1;
824
}
825

    
826
/* generic function for encode/decode called after a frame has been coded/decoded */
827
void MPV_frame_end(MpegEncContext *s)
828
{
829
    s->avctx->key_frame   = (s->pict_type == I_TYPE);
830
    s->avctx->pict_type   = s->pict_type;
831

    
832
    /* draw edge for correct motion prediction if outside */
833
    if (s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
834
        draw_edges(s->current_picture[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
835
        draw_edges(s->current_picture[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
836
        draw_edges(s->current_picture[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
837
    }
838
    emms_c();
839
    
840
    s->last_pict_type    = s->pict_type;
841
    if(s->pict_type!=B_TYPE){
842
        s->last_non_b_pict_type= s->pict_type;
843
        s->num_available_buffers++;
844
        if(s->num_available_buffers>2) s->num_available_buffers= 2;
845
    }
846
}
847

    
848
/* reorder input for encoding */
849
void reorder_input(MpegEncContext *s, AVPicture *pict)
850
{
851
    int i, j, index;
852
            
853
    if(s->max_b_frames > FF_MAX_B_FRAMES) s->max_b_frames= FF_MAX_B_FRAMES;
854

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

    
857
    for(j=0; j<REORDER_BUFFER_SIZE-1; j++){
858
        s->coded_order[j]= s->coded_order[j+1];
859
    }
860
    s->coded_order[j].picture[0]= s->coded_order[j].picture[1]= s->coded_order[j].picture[2]= NULL; //catch uninitalized buffers
861
    s->coded_order[j].pict_type=0;
862

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

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

    
898
            if (i >= 1) {
899
                dest_wrap >>= 1;
900
                w >>= 1;
901
                h >>= 1;
902
            }
903

    
904
            s->coded_order[index].picture[i]= dest;
905
            for(j=0;j<h;j++) {
906
                memcpy(dest, src, w);
907
                dest += dest_wrap;
908
                src += src_wrap;
909
            }
910
        }
911
        if(index!=0){
912
            s->picture_buffer_index++;
913
            if(s->picture_buffer_index >= REORDER_BUFFER_SIZE) s->picture_buffer_index=0;
914
        }
915
    }
916
    s->coded_order[index].pict_type = s->input_pict_type;
917
    s->coded_order[index].qscale    = s->input_qscale;
918
    s->coded_order[index].force_type= s->force_input_type;
919
    s->coded_order[index].picture_in_gop_number= s->input_picture_in_gop_number;
920
    s->coded_order[index].picture_number= s->input_picture_number;
921

    
922
    for(i=0; i<3; i++){
923
        s->new_picture[i]= s->coded_order[0].picture[i];
924
    }
925
}
926

    
927
int MPV_encode_picture(AVCodecContext *avctx,
928
                       unsigned char *buf, int buf_size, void *data)
929
{
930
    MpegEncContext *s = avctx->priv_data;
931
    AVPicture *pict = data;
932

    
933
    s->input_qscale = avctx->quality;
934

    
935
    init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
936

    
937
    if(avctx->flags&CODEC_FLAG_TYPE){
938
        s->input_pict_type=
939
        s->force_input_type= avctx->key_frame ? I_TYPE : P_TYPE;
940
    }else if(s->flags&CODEC_FLAG_PASS2){
941
        s->input_pict_type=
942
        s->force_input_type= s->rc_context.entry[s->input_picture_number].new_pict_type;
943
    }else{
944
        s->force_input_type=0;
945
        if (!s->intra_only) {
946
            /* first picture of GOP is intra */
947
            if (s->input_picture_in_gop_number % s->gop_size==0){
948
                s->input_pict_type = I_TYPE;
949
            }else if(s->max_b_frames==0){
950
                s->input_pict_type = P_TYPE;
951
            }else{
952
                if(s->b_frames_since_non_b < s->max_b_frames) //FIXME more IQ
953
                    s->input_pict_type = B_TYPE;
954
                else
955
                    s->input_pict_type = P_TYPE;
956
            }
957
        } else {
958
            s->input_pict_type = I_TYPE;
959
        }
960
    }
961

    
962
    if(s->input_pict_type==I_TYPE)
963
        s->input_picture_in_gop_number=0;
964
    
965
    reorder_input(s, pict);
966
    
967
    /* output? */
968
    if(s->coded_order[0].picture[0]){
969

    
970
        s->pict_type= s->coded_order[0].pict_type;
971
        if (s->fixed_qscale) /* the ratecontrol needs the last qscale so we dont touch it for CBR */
972
            s->qscale= s->coded_order[0].qscale;
973
        s->force_type= s->coded_order[0].force_type;
974
        s->picture_in_gop_number= s->coded_order[0].picture_in_gop_number;
975
        s->picture_number= s->coded_order[0].picture_number;
976

    
977
        MPV_frame_start(s, avctx);
978

    
979
        encode_picture(s, s->picture_number);
980
        
981
        avctx->real_pict_num  = s->picture_number;
982
        avctx->header_bits = s->header_bits;
983
        avctx->mv_bits     = s->mv_bits;
984
        avctx->misc_bits   = s->misc_bits;
985
        avctx->i_tex_bits  = s->i_tex_bits;
986
        avctx->p_tex_bits  = s->p_tex_bits;
987
        avctx->i_count     = s->i_count;
988
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
989
        avctx->skip_count  = s->skip_count;
990

    
991
        MPV_frame_end(s);
992

    
993
        if (s->out_format == FMT_MJPEG)
994
            mjpeg_picture_trailer(s);
995

    
996
        if(!s->fixed_qscale)
997
            avctx->quality = s->qscale;
998
        
999
        if(s->flags&CODEC_FLAG_PASS1)
1000
            ff_write_pass1_stats(s);
1001
    
1002
    }
1003

    
1004
    s->input_picture_number++;
1005
    s->input_picture_in_gop_number++;
1006

    
1007
    flush_put_bits(&s->pb);
1008
    s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1009
    
1010
    s->total_bits += s->frame_bits;
1011
    avctx->frame_bits  = s->frame_bits;
1012
//printf("fcode: %d, type: %d, head: %d, mv: %d, misc: %d, frame: %d, itex: %d, ptex: %d\n", 
1013
//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);
1014
#if 0 //dump some stats to stats.txt for testing/debuging
1015
if(s->max_b_frames==0)
1016
{
1017
    static FILE *f=NULL;
1018
    if(!f) f= fopen("stats.txt", "wb");
1019
    get_psnr(pict->data, s->current_picture,
1020
             pict->linesize, s->linesize, avctx);
1021
    fprintf(f, "%7d, %7d, %2.4f\n", pbBufPtr(&s->pb) - s->pb.buf, s->qscale, avctx->psnr_y);
1022
}
1023
#endif
1024

    
1025
    if (avctx->get_psnr) {
1026
        /* At this point pict->data should have the original frame   */
1027
        /* an s->current_picture should have the coded/decoded frame */
1028
        get_psnr(pict->data, s->current_picture,
1029
                 pict->linesize, s->linesize, avctx);
1030
//        printf("%f\n", avctx->psnr_y);
1031
    }
1032
    return pbBufPtr(&s->pb) - s->pb.buf;
1033
}
1034

    
1035
static inline void gmc1_motion(MpegEncContext *s,
1036
                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1037
                               int dest_offset,
1038
                               UINT8 **ref_picture, int src_offset,
1039
                               int h)
1040
{
1041
    UINT8 *ptr;
1042
    int offset, src_x, src_y, linesize, uvlinesize;
1043
    int motion_x, motion_y;
1044
    int emu=0;
1045

    
1046
    if(s->real_sprite_warping_points>1) printf("more than 1 warp point isnt supported\n");
1047
    motion_x= s->sprite_offset[0][0];
1048
    motion_y= s->sprite_offset[0][1];
1049
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1050
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1051
    motion_x<<=(3-s->sprite_warping_accuracy);
1052
    motion_y<<=(3-s->sprite_warping_accuracy);
1053
    src_x = clip(src_x, -16, s->width);
1054
    if (src_x == s->width)
1055
        motion_x =0;
1056
    src_y = clip(src_y, -16, s->height);
1057
    if (src_y == s->height)
1058
        motion_y =0;
1059
    
1060
    linesize = s->linesize;
1061
    uvlinesize = s->uvlinesize;
1062
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1063

    
1064
    dest_y+=dest_offset;
1065
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1066
        if(src_x<0 || src_y<0 || src_x + (motion_x&15) + 16 > s->h_edge_pos
1067
                              || src_y + (motion_y&15) + h  > s->v_edge_pos){
1068
            emulated_edge_mc(s, ptr, linesize, 17, h+1, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1069
            ptr= s->edge_emu_buffer;
1070
            emu=1;
1071
        }
1072
    }
1073
    gmc1(dest_y  , ptr  , linesize, h, motion_x&15, motion_y&15, s->no_rounding);
1074
    gmc1(dest_y+8, ptr+8, linesize, h, motion_x&15, motion_y&15, s->no_rounding);
1075

    
1076
    motion_x= s->sprite_offset[1][0];
1077
    motion_y= s->sprite_offset[1][1];
1078
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
1079
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
1080
    motion_x<<=(3-s->sprite_warping_accuracy);
1081
    motion_y<<=(3-s->sprite_warping_accuracy);
1082
    src_x = clip(src_x, -8, s->width>>1);
1083
    if (src_x == s->width>>1)
1084
        motion_x =0;
1085
    src_y = clip(src_y, -8, s->height>>1);
1086
    if (src_y == s->height>>1)
1087
        motion_y =0;
1088

    
1089
    offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
1090
    ptr = ref_picture[1] + offset;
1091
    if(emu){
1092
        emulated_edge_mc(s, ptr, uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1093
        ptr= s->edge_emu_buffer;
1094
    }
1095
    gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, h>>1, motion_x&15, motion_y&15, s->no_rounding);
1096
    
1097
    ptr = ref_picture[2] + offset;
1098
    if(emu){
1099
        emulated_edge_mc(s, ptr, uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1100
        ptr= s->edge_emu_buffer;
1101
    }
1102
    gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, h>>1, motion_x&15, motion_y&15, s->no_rounding);
1103
    
1104
    return;
1105
}
1106

    
1107
static void emulated_edge_mc(MpegEncContext *s, UINT8 *src, int linesize, int block_w, int block_h, 
1108
                                    int src_x, int src_y, int w, int h){
1109
    int x, y;
1110
    int start_y, start_x, end_y, end_x;
1111
    UINT8 *buf= s->edge_emu_buffer;
1112
    
1113
    if(src_y>= h){
1114
        src+= (h-1-src_y)*linesize;
1115
        src_y=h-1;
1116
    }else if(src_y<=-block_h){
1117
        src+= (1-block_h-src_y)*linesize;
1118
        src_y=1-block_h;
1119
    }
1120
    if(src_x>= w){
1121
        src+= (w-1-src_x);
1122
        src_x=w-1;
1123
    }else if(src_x<=-block_w){
1124
        src+= (1-block_w-src_x);
1125
        src_x=1-block_w;
1126
    }
1127

    
1128
    start_y= MAX(0, -src_y);
1129
    start_x= MAX(0, -src_x);
1130
    end_y= MIN(block_h, h-src_y);
1131
    end_x= MIN(block_w, w-src_x);
1132

    
1133
    // copy existing part
1134
    for(y=start_y; y<end_y; y++){
1135
        for(x=start_x; x<end_x; x++){
1136
            buf[x + y*linesize]= src[x + y*linesize];
1137
        }
1138
    }
1139

    
1140
    //top
1141
    for(y=0; y<start_y; y++){
1142
        for(x=start_x; x<end_x; x++){
1143
            buf[x + y*linesize]= buf[x + start_y*linesize];
1144
        }
1145
    }
1146

    
1147
    //bottom
1148
    for(y=end_y; y<block_h; y++){
1149
        for(x=start_x; x<end_x; x++){
1150
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1151
        }
1152
    }
1153
                                    
1154
    for(y=0; y<block_h; y++){
1155
       //left
1156
        for(x=0; x<start_x; x++){
1157
            buf[x + y*linesize]= buf[start_x + y*linesize];
1158
        }
1159
       
1160
       //right
1161
        for(x=end_x; x<block_w; x++){
1162
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1163
        }
1164
    }
1165
}
1166

    
1167

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

    
1204
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1205
        if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 16 > s->h_edge_pos
1206
                              || src_y + (motion_y&1) + h  > v_edge_pos){
1207
            emulated_edge_mc(s, ptr, linesize, 17, h+1, src_x, src_y, s->h_edge_pos, v_edge_pos);
1208
            ptr= s->edge_emu_buffer;
1209
            emu=1;
1210
        }
1211
    }
1212
    pix_op[0][dxy](dest_y, ptr, linesize, h);
1213

    
1214
    if(s->flags&CODEC_FLAG_GRAY) return;
1215

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

    
1248
    ptr = ref_picture[2] + offset;
1249
    if(emu){
1250
        emulated_edge_mc(s, ptr, uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, v_edge_pos>>1);
1251
        ptr= s->edge_emu_buffer;
1252
    }
1253
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1254
}
1255

    
1256
static inline void qpel_motion(MpegEncContext *s,
1257
                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1258
                               int dest_offset,
1259
                               UINT8 **ref_picture, int src_offset,
1260
                               int field_based, op_pixels_func (*pix_op)[4],
1261
                               qpel_mc_func (*qpix_op)[16],
1262
                               int motion_x, int motion_y, int h)
1263
{
1264
    UINT8 *ptr;
1265
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1266
    int emu=0;
1267

    
1268
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1269
    src_x = s->mb_x * 16 + (motion_x >> 2);
1270
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
1271

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

    
1303
    if(s->flags&CODEC_FLAG_GRAY) return;
1304

    
1305
    if(field_based){
1306
        mx= motion_x/2;
1307
        my= motion_y>>1;
1308
    }else if(s->divx_version){
1309
        mx= (motion_x>>1)|(motion_x&1);
1310
        my= (motion_y>>1)|(motion_y&1);
1311
    }else{
1312
        mx= motion_x/2;
1313
        my= motion_y/2;
1314
    }
1315
    mx= (mx>>1)|(mx&1);
1316
    my= (my>>1)|(my&1);
1317
    dxy= (mx&1) | ((my&1)<<1);
1318
    mx>>=1;
1319
    my>>=1;
1320

    
1321
    src_x = s->mb_x * 8 + mx;
1322
    src_y = s->mb_y * (8 >> field_based) + my;
1323
    src_x = clip(src_x, -8, s->width >> 1);
1324
    if (src_x == (s->width >> 1))
1325
        dxy &= ~1;
1326
    src_y = clip(src_y, -8, height >> 1);
1327
    if (src_y == (height >> 1))
1328
        dxy &= ~2;
1329

    
1330
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1331
    ptr = ref_picture[1] + offset;
1332
    if(emu){
1333
        emulated_edge_mc(s, ptr,  uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, v_edge_pos>>1);
1334
        ptr= s->edge_emu_buffer;
1335
    }
1336
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1337
    
1338
    ptr = ref_picture[2] + offset;
1339
    if(emu){
1340
        emulated_edge_mc(s, ptr,  uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, v_edge_pos>>1);
1341
        ptr= s->edge_emu_buffer;
1342
    }
1343
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1344
}
1345

    
1346

    
1347
static inline void MPV_motion(MpegEncContext *s, 
1348
                              UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1349
                              int dir, UINT8 **ref_picture, 
1350
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
1351
{
1352
    int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
1353
    int mb_x, mb_y, i;
1354
    UINT8 *ptr, *dest;
1355
    int emu=0;
1356

    
1357
    mb_x = s->mb_x;
1358
    mb_y = s->mb_y;
1359

    
1360
    switch(s->mv_type) {
1361
    case MV_TYPE_16X16:
1362
        if(s->mcsel){
1363
            gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
1364
                        ref_picture, 0,
1365
                        16);
1366
        }else if(s->quarter_sample){
1367
            qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1368
                        ref_picture, 0,
1369
                        0, pix_op, qpix_op,
1370
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1371
        }else{
1372
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1373
                        ref_picture, 0,
1374
                        0, pix_op,
1375
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1376
        }           
1377
        break;
1378
    case MV_TYPE_8X8:
1379
        mx = 0;
1380
        my = 0;
1381
        if(s->quarter_sample){
1382
            for(i=0;i<4;i++) {
1383
                motion_x = s->mv[dir][i][0];
1384
                motion_y = s->mv[dir][i][1];
1385

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

    
1409
                mx += s->mv[dir][i][0]/2;
1410
                my += s->mv[dir][i][1]/2;
1411
            }
1412
        }else{
1413
            for(i=0;i<4;i++) {
1414
                motion_x = s->mv[dir][i][0];
1415
                motion_y = s->mv[dir][i][1];
1416

    
1417
                dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1418
                src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;
1419
                src_y = mb_y * 16 + (motion_y >> 1) + (i >>1) * 8;
1420
                    
1421
                /* WARNING: do no forget half pels */
1422
                src_x = clip(src_x, -16, s->width);
1423
                if (src_x == s->width)
1424
                    dxy &= ~1;
1425
                src_y = clip(src_y, -16, s->height);
1426
                if (src_y == s->height)
1427
                    dxy &= ~2;
1428
                    
1429
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1430
                if(s->flags&CODEC_FLAG_EMU_EDGE){
1431
                    if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 8 > s->h_edge_pos
1432
                                          || src_y + (motion_y&1) + 8 > s->v_edge_pos){
1433
                        emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1434
                        ptr= s->edge_emu_buffer;
1435
                    }
1436
                }
1437
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1438
                pix_op[1][dxy](dest, ptr, s->linesize, 8);
1439

    
1440
                mx += s->mv[dir][i][0];
1441
                my += s->mv[dir][i][1];
1442
            }
1443
        }
1444

    
1445
        if(s->flags&CODEC_FLAG_GRAY) break;
1446
        /* In case of 8X8, we construct a single chroma motion vector
1447
           with a special rounding */
1448
        for(i=0;i<4;i++) {
1449
        }
1450
        if (mx >= 0)
1451
            mx = (h263_chroma_roundtab[mx & 0xf] + ((mx >> 3) & ~1));
1452
        else {
1453
            mx = -mx;
1454
            mx = -(h263_chroma_roundtab[mx & 0xf] + ((mx >> 3) & ~1));
1455
        }
1456
        if (my >= 0)
1457
            my = (h263_chroma_roundtab[my & 0xf] + ((my >> 3) & ~1));
1458
        else {
1459
            my = -my;
1460
            my = -(h263_chroma_roundtab[my & 0xf] + ((my >> 3) & ~1));
1461
        }
1462
        dxy = ((my & 1) << 1) | (mx & 1);
1463
        mx >>= 1;
1464
        my >>= 1;
1465

    
1466
        src_x = mb_x * 8 + mx;
1467
        src_y = mb_y * 8 + my;
1468
        src_x = clip(src_x, -8, s->width/2);
1469
        if (src_x == s->width/2)
1470
            dxy &= ~1;
1471
        src_y = clip(src_y, -8, s->height/2);
1472
        if (src_y == s->height/2)
1473
            dxy &= ~2;
1474
        
1475
        offset = (src_y * (s->uvlinesize)) + src_x;
1476
        ptr = ref_picture[1] + offset;
1477
        if(s->flags&CODEC_FLAG_EMU_EDGE){
1478
                if(src_x<0 || src_y<0 || src_x + (dxy &1) + 8 > s->h_edge_pos>>1
1479
                                      || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
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
                    emu=1;
1483
                }
1484
            }
1485
        pix_op[1][dxy](dest_cb, ptr, s->uvlinesize, 8);
1486

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

    
1522
        }
1523
        break;
1524
    }
1525
}
1526

    
1527

    
1528
/* put block[] to dest[] */
1529
static inline void put_dct(MpegEncContext *s, 
1530
                           DCTELEM *block, int i, UINT8 *dest, int line_size)
1531
{
1532
    s->dct_unquantize(s, block, i, s->qscale);
1533
    s->idct_put (dest, line_size, block);
1534
}
1535

    
1536
/* add block[] to dest[] */
1537
static inline void add_dct(MpegEncContext *s, 
1538
                           DCTELEM *block, int i, UINT8 *dest, int line_size)
1539
{
1540
    if (s->block_last_index[i] >= 0) {
1541
        s->idct_add (dest, line_size, block);
1542
    }
1543
}
1544

    
1545
static inline void add_dequant_dct(MpegEncContext *s, 
1546
                           DCTELEM *block, int i, UINT8 *dest, int line_size)
1547
{
1548
    if (s->block_last_index[i] >= 0) {
1549
        s->dct_unquantize(s, block, i, s->qscale);
1550

    
1551
        s->idct_add (dest, line_size, block);
1552
    }
1553
}
1554

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

    
1588
/* generic function called after a macroblock has been parsed by the
1589
   decoder or after it has been encoded by the encoder.
1590

1591
   Important variables used:
1592
   s->mb_intra : true if intra macroblock
1593
   s->mv_dir   : motion vector direction
1594
   s->mv_type  : motion vector type
1595
   s->mv       : motion vector
1596
   s->interlaced_dct : true if interlaced dct used (mpeg2)
1597
 */
1598
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1599
{
1600
    int mb_x, mb_y;
1601
    const int mb_xy = s->mb_y * s->mb_width + s->mb_x;
1602

    
1603
    mb_x = s->mb_x;
1604
    mb_y = s->mb_y;
1605

    
1606
#ifdef FF_POSTPROCESS
1607
    /* Obsolete. Exists for compatibility with mplayer only. */
1608
    quant_store[mb_y][mb_x]=s->qscale;
1609
    //printf("[%02d][%02d] %d\n",mb_x,mb_y,s->qscale);
1610
#else
1611
    /* even more obsolete, exists for mplayer xp only */
1612
    if(s->avctx->quant_store) s->avctx->quant_store[mb_y*s->avctx->qstride+mb_x] = s->qscale;
1613
#endif
1614
    s->qscale_table[mb_xy]= s->qscale;
1615

    
1616
    /* update DC predictors for P macroblocks */
1617
    if (!s->mb_intra) {
1618
        if (s->h263_pred || s->h263_aic) {
1619
            if(s->mbintra_table[mb_xy])
1620
                ff_clean_intra_table_entries(s);
1621
        } else {
1622
            s->last_dc[0] =
1623
            s->last_dc[1] =
1624
            s->last_dc[2] = 128 << s->intra_dc_precision;
1625
        }
1626
    }
1627
    else if (s->h263_pred || s->h263_aic)
1628
        s->mbintra_table[mb_xy]=1;
1629

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

    
1680
        /* avoid copy if macroblock skipped in last frame too 
1681
           dont touch it for B-frames as they need the skip info from the next p-frame */
1682
        if (s->pict_type != B_TYPE) {
1683
            UINT8 *mbskip_ptr = &s->mbskip_table[mb_xy];
1684
            if (s->mb_skiped) {
1685
                s->mb_skiped = 0;
1686

    
1687
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
1688
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
1689

    
1690
                /* if previous was skipped too, then nothing to do ! 
1691
                   skip only during decoding as we might trash the buffers during encoding a bit */
1692
                if (*mbskip_ptr >= s->ip_buffer_count  && !s->encoding) 
1693
                    goto the_end;
1694
            } else {
1695
                *mbskip_ptr = 0; /* not skipped */
1696
            }
1697
        }
1698

    
1699
        if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band){
1700
            dest_y = s->current_picture [0] + mb_x * 16;
1701
            dest_cb = s->current_picture[1] + mb_x * 8;
1702
            dest_cr = s->current_picture[2] + mb_x * 8;
1703
        }else{
1704
            dest_y = s->current_picture [0] + (mb_y * 16* s->linesize  ) + mb_x * 16;
1705
            dest_cb = s->current_picture[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
1706
            dest_cr = s->current_picture[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
1707
        }
1708

    
1709
        if (s->interlaced_dct) {
1710
            dct_linesize = s->linesize * 2;
1711
            dct_offset = s->linesize;
1712
        } else {
1713
            dct_linesize = s->linesize;
1714
            dct_offset = s->linesize * 8;
1715
        }
1716

    
1717
        if (!s->mb_intra) {
1718
            /* motion handling */
1719
            /* decoding or more than one mb_type (MC was allready done otherwise) */
1720
            if((!s->encoding) || (s->mb_type[mb_xy]&(s->mb_type[mb_xy]-1))){
1721
                if ((!s->no_rounding) || s->pict_type==B_TYPE){                
1722
                    op_pix = put_pixels_tab;
1723
                    op_qpix= put_qpel_pixels_tab;
1724
                }else{
1725
                    op_pix = put_no_rnd_pixels_tab;
1726
                    op_qpix= put_no_rnd_qpel_pixels_tab;
1727
                }
1728

    
1729
                if (s->mv_dir & MV_DIR_FORWARD) {
1730
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture, op_pix, op_qpix);
1731
                    op_pix = avg_pixels_tab;
1732
                    op_qpix= avg_qpel_pixels_tab;
1733
                }
1734
                if (s->mv_dir & MV_DIR_BACKWARD) {
1735
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture, op_pix, op_qpix);
1736
                }
1737
            }
1738

    
1739
            /* skip dequant / idct if we are really late ;) */
1740
            if(s->hurry_up>1) goto the_end;
1741

    
1742
            /* add dct residue */
1743
            if(s->encoding || !(   s->mpeg2 || s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO 
1744
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1745
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
1746
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
1747
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
1748
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
1749

    
1750
                if(!(s->flags&CODEC_FLAG_GRAY)){
1751
                    add_dequant_dct(s, block[4], 4, dest_cb, s->uvlinesize);
1752
                    add_dequant_dct(s, block[5], 5, dest_cr, s->uvlinesize);
1753
                }
1754
            } else {
1755
                add_dct(s, block[0], 0, dest_y, dct_linesize);
1756
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
1757
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
1758
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
1759

    
1760
                if(!(s->flags&CODEC_FLAG_GRAY)){
1761
                    add_dct(s, block[4], 4, dest_cb, s->uvlinesize);
1762
                    add_dct(s, block[5], 5, dest_cr, s->uvlinesize);
1763
                }
1764
            }
1765
        } else {
1766
            /* dct only in intra block */
1767
            if(s->encoding || !(s->mpeg2 || s->codec_id==CODEC_ID_MPEG1VIDEO)){
1768
                put_dct(s, block[0], 0, dest_y, dct_linesize);
1769
                put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
1770
                put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
1771
                put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
1772

    
1773
                if(!(s->flags&CODEC_FLAG_GRAY)){
1774
                    put_dct(s, block[4], 4, dest_cb, s->uvlinesize);
1775
                    put_dct(s, block[5], 5, dest_cr, s->uvlinesize);
1776
                }
1777
            }else{
1778
                s->idct_put(dest_y                 , dct_linesize, block[0]);
1779
                s->idct_put(dest_y              + 8, dct_linesize, block[1]);
1780
                s->idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
1781
                s->idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
1782

    
1783
                if(!(s->flags&CODEC_FLAG_GRAY)){
1784
                    s->idct_put(dest_cb, s->uvlinesize, block[4]);
1785
                    s->idct_put(dest_cr, s->uvlinesize, block[5]);
1786
                }
1787
            }
1788
        }
1789
    }
1790
 the_end:
1791
    emms_c(); //FIXME remove
1792
}
1793

    
1794
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
1795
{
1796
    static const char tab[64]=
1797
        {3,2,2,1,1,1,1,1,
1798
         1,1,1,1,1,1,1,1,
1799
         1,1,1,1,1,1,1,1,
1800
         0,0,0,0,0,0,0,0,
1801
         0,0,0,0,0,0,0,0,
1802
         0,0,0,0,0,0,0,0,
1803
         0,0,0,0,0,0,0,0,
1804
         0,0,0,0,0,0,0,0};
1805
    int score=0;
1806
    int run=0;
1807
    int i;
1808
    DCTELEM *block= s->block[n];
1809
    const int last_index= s->block_last_index[n];
1810
    int skip_dc;
1811

    
1812
    if(threshold<0){
1813
        skip_dc=0;
1814
        threshold= -threshold;
1815
    }else
1816
        skip_dc=1;
1817

    
1818
    /* are all which we could set to zero are allready zero? */
1819
    if(last_index<=skip_dc - 1) return;
1820

    
1821
    for(i=0; i<=last_index; i++){
1822
        const int j = s->intra_scantable.permutated[i];
1823
        const int level = ABS(block[j]);
1824
        if(level==1){
1825
            if(skip_dc && i==0) continue;
1826
            score+= tab[run];
1827
            run=0;
1828
        }else if(level>1){
1829
            return;
1830
        }else{
1831
            run++;
1832
        }
1833
    }
1834
    if(score >= threshold) return;
1835
    for(i=skip_dc; i<=last_index; i++){
1836
        const int j = s->intra_scantable.permutated[i];
1837
        block[j]=0;
1838
    }
1839
    if(block[0]) s->block_last_index[n]= 0;
1840
    else         s->block_last_index[n]= -1;
1841
}
1842

    
1843
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
1844
{
1845
    int i;
1846
    const int maxlevel= s->max_qcoeff;
1847
    const int minlevel= s->min_qcoeff;
1848
    
1849
    if(s->mb_intra){
1850
        i=1; //skip clipping of intra dc
1851
    }else
1852
        i=0;
1853
    
1854
    for(;i<=last_index; i++){
1855
        const int j= s->intra_scantable.permutated[i];
1856
        int level = block[j];
1857
       
1858
        if     (level>maxlevel) level=maxlevel;
1859
        else if(level<minlevel) level=minlevel;
1860
        block[j]= level;
1861
    }
1862
}
1863

    
1864
static inline void requantize_coeffs(MpegEncContext *s, DCTELEM block[64], int oldq, int newq, int n)
1865
{
1866
    int i;
1867

    
1868
    if(s->mb_intra){
1869
        i=1; //skip clipping of intra dc
1870
         //FIXME requantize, note (mpeg1/h263/h263p-aic dont need it,...)
1871
    }else
1872
        i=0;
1873
    
1874
    for(;i<=s->block_last_index[n]; i++){
1875
        const int j = s->intra_scantable.permutated[i];
1876
        int level = block[j];
1877
        
1878
        block[j]= ROUNDED_DIV(level*oldq, newq);
1879
    }
1880

    
1881
    for(i=s->block_last_index[n]; i>=0; i--){
1882
        const int j = s->intra_scantable.permutated[i];
1883
        if(block[j]) break;
1884
    }
1885
    s->block_last_index[n]= i;
1886
}
1887

    
1888
static inline void auto_requantize_coeffs(MpegEncContext *s, DCTELEM block[6][64])
1889
{
1890
    int i,n, newq;
1891
    const int maxlevel= s->max_qcoeff;
1892
    const int minlevel= s->min_qcoeff;
1893
    int largest=0, smallest=0;
1894

    
1895
    assert(s->adaptive_quant);
1896
    
1897
    for(n=0; n<6; n++){
1898
        if(s->mb_intra){
1899
            i=1; //skip clipping of intra dc
1900
             //FIXME requantize, note (mpeg1/h263/h263p-aic dont need it,...)
1901
        }else
1902
            i=0;
1903

    
1904
        for(;i<=s->block_last_index[n]; i++){
1905
            const int j = s->intra_scantable.permutated[i];
1906
            int level = block[n][j];
1907
            if(largest  < level) largest = level;
1908
            if(smallest > level) smallest= level;
1909
        }
1910
    }
1911
    
1912
    for(newq=s->qscale+1; newq<32; newq++){
1913
        if(   ROUNDED_DIV(smallest*s->qscale, newq) >= minlevel
1914
           && ROUNDED_DIV(largest *s->qscale, newq) <= maxlevel) 
1915
            break;
1916
    }
1917
        
1918
    if(s->out_format==FMT_H263){
1919
        /* h263 like formats cannot change qscale by more than 2 easiely */
1920
        if(s->avctx->qmin + 2 < newq)
1921
            newq= s->avctx->qmin + 2;
1922
    }
1923

    
1924
    for(n=0; n<6; n++){
1925
        requantize_coeffs(s, block[n], s->qscale, newq, n);
1926
        clip_coeffs(s, block[n], s->block_last_index[n]);
1927
    }
1928
     
1929
    s->dquant+= newq - s->qscale;
1930
    s->qscale= newq;
1931
}
1932
#if 0
1933
static int pix_vcmp16x8(UINT8 *s, int stride){ //FIXME move to dsputil & optimize
1934
    int score=0;
1935
    int x,y;
1936
    
1937
    for(y=0; y<7; y++){
1938
        for(x=0; x<16; x+=4){
1939
            score+= ABS(s[x  ] - s[x  +stride]) + ABS(s[x+1] - s[x+1+stride]) 
1940
                   +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
1941
        }
1942
        s+= stride;
1943
    }
1944
    
1945
    return score;
1946
}
1947

1948
static int pix_diff_vcmp16x8(UINT8 *s1, UINT8*s2, int stride){ //FIXME move to dsputil & optimize
1949
    int score=0;
1950
    int x,y;
1951
    
1952
    for(y=0; y<7; y++){
1953
        for(x=0; x<16; x++){
1954
            score+= ABS(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
1955
        }
1956
        s1+= stride;
1957
        s2+= stride;
1958
    }
1959
    
1960
    return score;
1961
}
1962
#else
1963
#define SQ(a) ((a)*(a))
1964

    
1965
static int pix_vcmp16x8(UINT8 *s, int stride){ //FIXME move to dsputil & optimize
1966
    int score=0;
1967
    int x,y;
1968
    
1969
    for(y=0; y<7; y++){
1970
        for(x=0; x<16; x+=4){
1971
            score+= SQ(s[x  ] - s[x  +stride]) + SQ(s[x+1] - s[x+1+stride]) 
1972
                   +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
1973
        }
1974
        s+= stride;
1975
    }
1976
    
1977
    return score;
1978
}
1979

    
1980
static int pix_diff_vcmp16x8(UINT8 *s1, UINT8*s2, int stride){ //FIXME move to dsputil & optimize
1981
    int score=0;
1982
    int x,y;
1983
    
1984
    for(y=0; y<7; y++){
1985
        for(x=0; x<16; x++){
1986
            score+= SQ(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
1987
        }
1988
        s1+= stride;
1989
        s2+= stride;
1990
    }
1991
    
1992
    return score;
1993
}
1994

    
1995
#endif
1996
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
1997
{
1998
    const int mb_x= s->mb_x;
1999
    const int mb_y= s->mb_y;
2000
    int i;
2001
    int skip_dct[6];
2002
    int dct_offset   = s->linesize*8; //default for progressive frames
2003
    
2004
    for(i=0; i<6; i++) skip_dct[i]=0;
2005
    
2006
    if(s->adaptive_quant){
2007
        s->dquant= s->qscale_table[mb_x + mb_y*s->mb_width] - s->qscale;
2008

    
2009
        if(s->out_format==FMT_H263){
2010
            if     (s->dquant> 2) s->dquant= 2;
2011
            else if(s->dquant<-2) s->dquant=-2;
2012
        }
2013
            
2014
        if(s->codec_id==CODEC_ID_MPEG4){        
2015
            if(!s->mb_intra){
2016
                assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
2017

    
2018
                if(s->mv_dir&MV_DIRECT)
2019
                    s->dquant=0;
2020
            }
2021
        }
2022
        s->qscale+= s->dquant;
2023
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2024
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2025
    }
2026

    
2027
    if (s->mb_intra) {
2028
        UINT8 *ptr;
2029
        int wrap_y;
2030
        int emu=0;
2031

    
2032
        wrap_y = s->linesize;
2033
        ptr = s->new_picture[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2034

    
2035
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2036
            emulated_edge_mc(s, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2037
            ptr= s->edge_emu_buffer;
2038
            emu=1;
2039
        }
2040
        
2041
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2042
            int progressive_score, interlaced_score;
2043
            
2044
            progressive_score= pix_vcmp16x8(ptr, wrap_y  ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
2045
            interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y  , wrap_y*2);
2046
            
2047
            if(progressive_score > interlaced_score + 100){
2048
                s->interlaced_dct=1;
2049
            
2050
                dct_offset= wrap_y;
2051
                wrap_y<<=1;
2052
            }else
2053
                s->interlaced_dct=0;
2054
        }
2055
        
2056
        get_pixels(s->block[0], ptr                 , wrap_y);
2057
        get_pixels(s->block[1], ptr              + 8, wrap_y);
2058
        get_pixels(s->block[2], ptr + dct_offset    , wrap_y);
2059
        get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
2060

    
2061
        if(s->flags&CODEC_FLAG_GRAY){
2062
            skip_dct[4]= 1;
2063
            skip_dct[5]= 1;
2064
        }else{
2065
            int wrap_c = s->uvlinesize;
2066
            ptr = s->new_picture[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2067
            if(emu){
2068
                emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2069
                ptr= s->edge_emu_buffer;
2070
            }
2071
            get_pixels(s->block[4], ptr, wrap_c);
2072

    
2073
            ptr = s->new_picture[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2074
            if(emu){
2075
                emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2076
                ptr= s->edge_emu_buffer;
2077
            }
2078
            get_pixels(s->block[5], ptr, wrap_c);
2079
        }
2080
    }else{
2081
        op_pixels_func (*op_pix)[4];
2082
        qpel_mc_func (*op_qpix)[16];
2083
        UINT8 *dest_y, *dest_cb, *dest_cr;
2084
        UINT8 *ptr_y, *ptr_cb, *ptr_cr;
2085
        int wrap_y, wrap_c;
2086
        int emu=0;
2087

    
2088
        dest_y  = s->current_picture[0] + (mb_y * 16 * s->linesize       ) + mb_x * 16;
2089
        dest_cb = s->current_picture[1] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2090
        dest_cr = s->current_picture[2] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2091
        wrap_y = s->linesize;
2092
        wrap_c = s->uvlinesize;
2093
        ptr_y  = s->new_picture[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2094
        ptr_cb = s->new_picture[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2095
        ptr_cr = s->new_picture[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2096

    
2097
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
2098
            op_pix = put_pixels_tab;
2099
            op_qpix= put_qpel_pixels_tab;
2100
        }else{
2101
            op_pix = put_no_rnd_pixels_tab;
2102
            op_qpix= put_no_rnd_qpel_pixels_tab;
2103
        }
2104

    
2105
        if (s->mv_dir & MV_DIR_FORWARD) {
2106
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture, op_pix, op_qpix);
2107
            op_pix = avg_pixels_tab;
2108
            op_qpix= avg_qpel_pixels_tab;
2109
        }
2110
        if (s->mv_dir & MV_DIR_BACKWARD) {
2111
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture, op_pix, op_qpix);
2112
        }
2113

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

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

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

    
2226
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
2227
        s->block_last_index[4]=
2228
        s->block_last_index[5]= 0;
2229
        s->block[4][0]=
2230
        s->block[5][0]= 128;
2231
    }
2232

    
2233
    /* huffman encode */
2234
    switch(s->out_format) {
2235
    case FMT_MPEG1:
2236
        mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2237
        break;
2238
    case FMT_H263:
2239
        if (s->h263_msmpeg4)
2240
            msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2241
        else if(s->h263_pred)
2242
            mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2243
        else
2244
            h263_encode_mb(s, s->block, motion_x, motion_y);
2245
        break;
2246
    case FMT_MJPEG:
2247
        mjpeg_encode_mb(s, s->block);
2248
        break;
2249
    }
2250
}
2251

    
2252
void ff_copy_bits(PutBitContext *pb, UINT8 *src, int length)
2253
{
2254
    int bytes= length>>4;
2255
    int bits= length&15;
2256
    int i;
2257

    
2258
    if(length==0) return;
2259

    
2260
    for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
2261
    put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
2262
}
2263

    
2264
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2265
    int i;
2266

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

    
2269
    /* mpeg1 */
2270
    d->mb_incr= s->mb_incr;
2271
    for(i=0; i<3; i++)
2272
        d->last_dc[i]= s->last_dc[i];
2273
    
2274
    /* statistics */
2275
    d->mv_bits= s->mv_bits;
2276
    d->i_tex_bits= s->i_tex_bits;
2277
    d->p_tex_bits= s->p_tex_bits;
2278
    d->i_count= s->i_count;
2279
    d->f_count= s->f_count;
2280
    d->b_count= s->b_count;
2281
    d->skip_count= s->skip_count;
2282
    d->misc_bits= s->misc_bits;
2283
    d->last_bits= 0;
2284

    
2285
    d->mb_skiped= s->mb_skiped;
2286
}
2287

    
2288
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2289
    int i;
2290

    
2291
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
2292
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
2293
    
2294
    /* mpeg1 */
2295
    d->mb_incr= s->mb_incr;
2296
    for(i=0; i<3; i++)
2297
        d->last_dc[i]= s->last_dc[i];
2298
    
2299
    /* statistics */
2300
    d->mv_bits= s->mv_bits;
2301
    d->i_tex_bits= s->i_tex_bits;
2302
    d->p_tex_bits= s->p_tex_bits;
2303
    d->i_count= s->i_count;
2304
    d->f_count= s->f_count;
2305
    d->b_count= s->b_count;
2306
    d->skip_count= s->skip_count;
2307
    d->misc_bits= s->misc_bits;
2308

    
2309
    d->mb_intra= s->mb_intra;
2310
    d->mb_skiped= s->mb_skiped;
2311
    d->mv_type= s->mv_type;
2312
    d->mv_dir= s->mv_dir;
2313
    d->pb= s->pb;
2314
    if(s->data_partitioning){
2315
        d->pb2= s->pb2;
2316
        d->tex_pb= s->tex_pb;
2317
    }
2318
    d->block= s->block;
2319
    for(i=0; i<6; i++)
2320
        d->block_last_index[i]= s->block_last_index[i];
2321
}
2322

    
2323
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
2324
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2325
                           int *dmin, int *next_block, int motion_x, int motion_y)
2326
{
2327
    int bits_count;
2328
    
2329
    copy_context_before_encode(s, backup, type);
2330

    
2331
    s->block= s->blocks[*next_block];
2332
    s->pb= pb[*next_block];
2333
    if(s->data_partitioning){
2334
        s->pb2   = pb2   [*next_block];
2335
        s->tex_pb= tex_pb[*next_block];
2336
    }
2337

    
2338
    encode_mb(s, motion_x, motion_y);
2339

    
2340
    bits_count= get_bit_count(&s->pb);
2341
    if(s->data_partitioning){
2342
        bits_count+= get_bit_count(&s->pb2);
2343
        bits_count+= get_bit_count(&s->tex_pb);
2344
    }
2345

    
2346
    if(bits_count<*dmin){
2347
        *dmin= bits_count;
2348
        *next_block^=1;
2349

    
2350
        copy_context_after_encode(best, s, type);
2351
    }
2352
}
2353

    
2354
static void encode_picture(MpegEncContext *s, int picture_number)
2355
{
2356
    int mb_x, mb_y, last_gob, pdif = 0;
2357
    int i;
2358
    int bits;
2359
    MpegEncContext best_s, backup_s;
2360
    UINT8 bit_buf[2][3000];
2361
    UINT8 bit_buf2[2][3000];
2362
    UINT8 bit_buf_tex[2][3000];
2363
    PutBitContext pb[2], pb2[2], tex_pb[2];
2364

    
2365
    for(i=0; i<2; i++){
2366
        init_put_bits(&pb    [i], bit_buf    [i], 3000, NULL, NULL);
2367
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000, NULL, NULL);
2368
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
2369
    }
2370

    
2371
    s->picture_number = picture_number;
2372

    
2373
    s->block_wrap[0]=
2374
    s->block_wrap[1]=
2375
    s->block_wrap[2]=
2376
    s->block_wrap[3]= s->mb_width*2 + 2;
2377
    s->block_wrap[4]=
2378
    s->block_wrap[5]= s->mb_width + 2;
2379
    
2380
    /* Reset the average MB variance */
2381
    s->mb_var_sum = 0;
2382
    s->mc_mb_var_sum = 0;
2383

    
2384
    /* we need to initialize some time vars before we can encode b-frames */
2385
    if (s->h263_pred && !s->h263_msmpeg4)
2386
        ff_set_mpeg4_time(s, s->picture_number); 
2387

    
2388
    s->scene_change_score=0;
2389
    
2390
    s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
2391

    
2392
    /* Estimate motion for every MB */
2393
    if(s->pict_type != I_TYPE){
2394
        for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2395
            s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
2396
            s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
2397
            s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
2398
            s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
2399
            for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2400
                s->mb_x = mb_x;
2401
                s->mb_y = mb_y;
2402
                s->block_index[0]+=2;
2403
                s->block_index[1]+=2;
2404
                s->block_index[2]+=2;
2405
                s->block_index[3]+=2;
2406

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

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

    
2460
        ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
2461
        ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
2462
        ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
2463
        ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
2464
    }
2465
    
2466
    if (s->fixed_qscale) 
2467
        s->frame_qscale = s->avctx->quality;
2468
    else
2469
        s->frame_qscale = ff_rate_estimate_qscale(s);
2470

    
2471
    if(s->adaptive_quant){
2472
        switch(s->codec_id){
2473
        case CODEC_ID_MPEG4:
2474
            ff_clean_mpeg4_qscales(s);
2475
            break;
2476
        case CODEC_ID_H263:
2477
        case CODEC_ID_H263P:
2478
            ff_clean_h263_qscales(s);
2479
            break;
2480
        }
2481

    
2482
        s->qscale= s->qscale_table[0];
2483
    }else
2484
        s->qscale= (int)(s->frame_qscale + 0.5);
2485
        
2486
    if (s->out_format == FMT_MJPEG) {
2487
        /* for mjpeg, we do include qscale in the matrix */
2488
        s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
2489
        for(i=1;i<64;i++){
2490
            int j= s->idct_permutation[i];
2491

    
2492
            s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
2493
        }
2494
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, 
2495
                       s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
2496
    }
2497

    
2498
    s->last_bits= get_bit_count(&s->pb);
2499
    switch(s->out_format) {
2500
    case FMT_MJPEG:
2501
        mjpeg_picture_header(s);
2502
        break;
2503
    case FMT_H263:
2504
        if (s->h263_msmpeg4) 
2505
            msmpeg4_encode_picture_header(s, picture_number);
2506
        else if (s->h263_pred)
2507
            mpeg4_encode_picture_header(s, picture_number);
2508
        else if (s->h263_rv10) 
2509
            rv10_encode_picture_header(s, picture_number);
2510
        else
2511
            h263_encode_picture_header(s, picture_number);
2512
        break;
2513
    case FMT_MPEG1:
2514
        mpeg1_encode_picture_header(s, picture_number);
2515
        break;
2516
    }
2517
    bits= get_bit_count(&s->pb);
2518
    s->header_bits= bits - s->last_bits;
2519
    s->last_bits= bits;
2520
    s->mv_bits=0;
2521
    s->misc_bits=0;
2522
    s->i_tex_bits=0;
2523
    s->p_tex_bits=0;
2524
    s->i_count=0;
2525
    s->f_count=0;
2526
    s->b_count=0;
2527
    s->skip_count=0;
2528

    
2529
    /* init last dc values */
2530
    /* note: quant matrix value (8) is implied here */
2531
    s->last_dc[0] = 128;
2532
    s->last_dc[1] = 128;
2533
    s->last_dc[2] = 128;
2534
    s->mb_incr = 1;
2535
    s->last_mv[0][0][0] = 0;
2536
    s->last_mv[0][0][1] = 0;
2537

    
2538
    /* Get the GOB height based on picture height */
2539
    if (s->out_format == FMT_H263 && !s->h263_pred && !s->h263_msmpeg4) {
2540
        if (s->height <= 400)
2541
            s->gob_index = 1;
2542
        else if (s->height <= 800)
2543
            s->gob_index = 2;
2544
        else
2545
            s->gob_index = 4;
2546
    }else if(s->codec_id==CODEC_ID_MPEG4){
2547
        s->gob_index = 1;
2548
    }
2549

    
2550
    if(s->codec_id==CODEC_ID_MPEG4 && s->data_partitioning && s->pict_type!=B_TYPE)
2551
        ff_mpeg4_init_partitions(s);
2552

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

    
2575
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2576
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2577
        
2578
        s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
2579
        s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
2580
        s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
2581
        s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
2582
        s->block_index[4]= s->block_wrap[4]*(mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2);
2583
        s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
2584
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2585
            const int mb_type= s->mb_type[mb_y * s->mb_width + mb_x];
2586
            const int xy= (mb_y+1) * (s->mb_width+2) + mb_x + 1;
2587
//            int d;
2588
            int dmin=10000000;
2589

    
2590
            s->mb_x = mb_x;
2591
            s->mb_y = mb_y;
2592
            s->block_index[0]+=2;
2593
            s->block_index[1]+=2;
2594
            s->block_index[2]+=2;
2595
            s->block_index[3]+=2;
2596
            s->block_index[4]++;
2597
            s->block_index[5]++;
2598
            
2599
            /* write gob / video packet header for formats which support it at any MB (MPEG4) */
2600
            if(s->rtp_mode && s->mb_y>0 && s->codec_id==CODEC_ID_MPEG4){
2601
                int pdif= pbBufPtr(&s->pb) - s->ptr_lastgob;
2602

    
2603
                //the *2 is there so we stay below the requested size
2604
                if(pdif + s->mb_line_avgsize/s->mb_width >= s->rtp_payload_size){ 
2605
                    if(s->codec_id==CODEC_ID_MPEG4){
2606
                        if(s->data_partitioning && s->pict_type!=B_TYPE){
2607
                            ff_mpeg4_merge_partitions(s);
2608
                            ff_mpeg4_init_partitions(s);
2609
                        }
2610
                        ff_mpeg4_encode_video_packet_header(s);
2611

    
2612
                        if(s->flags&CODEC_FLAG_PASS1){
2613
                            int bits= get_bit_count(&s->pb);
2614
                            s->misc_bits+= bits - s->last_bits;
2615
                            s->last_bits= bits;
2616
                        }
2617
                        ff_mpeg4_clean_buffers(s);
2618
                    }
2619
                    s->ptr_lastgob = pbBufPtr(&s->pb);
2620
                    s->first_slice_line=1;
2621
                    s->resync_mb_x=mb_x;
2622
                    s->resync_mb_y=mb_y;
2623
                }
2624

    
2625
                if(  (s->resync_mb_x   == s->mb_x)
2626
                   && s->resync_mb_y+1 == s->mb_y){
2627
                    s->first_slice_line=0; 
2628
                }
2629
            }
2630

    
2631
            if(mb_type & (mb_type-1)){ // more than 1 MB type possible
2632
                int next_block=0;
2633
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2634

    
2635
                copy_context_before_encode(&backup_s, s, -1);
2636
                backup_s.pb= s->pb;
2637
                best_s.data_partitioning= s->data_partitioning;
2638
                if(s->data_partitioning){
2639
                    backup_s.pb2= s->pb2;
2640
                    backup_s.tex_pb= s->tex_pb;
2641
                }
2642

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

    
2806
            MPV_decode_mb(s, s->block);
2807
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_width, get_bit_count(&s->pb));
2808
        }
2809

    
2810

    
2811
        /* Obtain average GOB size for RTP */
2812
        if (s->rtp_mode) {
2813
            if (!mb_y)
2814
                s->mb_line_avgsize = pbBufPtr(&s->pb) - s->ptr_last_mb_line;
2815
            else if (!(mb_y % s->gob_index)) {    
2816
                s->mb_line_avgsize = (s->mb_line_avgsize + pbBufPtr(&s->pb) - s->ptr_last_mb_line) >> 1;
2817
                s->ptr_last_mb_line = pbBufPtr(&s->pb);
2818
            }
2819
            //fprintf(stderr, "\nMB line: %d\tSize: %u\tAvg. Size: %u", s->mb_y, 
2820
            //                    (s->pb.buf_ptr - s->ptr_last_mb_line), s->mb_line_avgsize);
2821
            if(s->codec_id!=CODEC_ID_MPEG4) s->first_slice_line = 0; //FIXME clean
2822
        }
2823
    }
2824
    emms_c();
2825

    
2826
    if(s->codec_id==CODEC_ID_MPEG4 && s->data_partitioning && s->pict_type!=B_TYPE)
2827
        ff_mpeg4_merge_partitions(s);
2828

    
2829
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
2830
        msmpeg4_encode_ext_header(s);
2831

    
2832
    if(s->codec_id==CODEC_ID_MPEG4) 
2833
        ff_mpeg4_stuffing(&s->pb);
2834

    
2835
    //if (s->gob_number)
2836
    //    fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
2837
    
2838
    /* Send the last GOB if RTP */    
2839
    if (s->rtp_mode) {
2840
        flush_put_bits(&s->pb);
2841
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
2842
        /* Call the RTP callback to send the last GOB */
2843
        if (s->rtp_callback)
2844
            s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
2845
        s->ptr_lastgob = pbBufPtr(&s->pb);
2846
        //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
2847
    }
2848
}
2849

    
2850
static int dct_quantize_c(MpegEncContext *s, 
2851
                        DCTELEM *block, int n,
2852
                        int qscale, int *overflow)
2853
{
2854
    int i, j, level, last_non_zero, q;
2855
    const int *qmat;
2856
    int bias;
2857
    int max=0;
2858
    unsigned int threshold1, threshold2;
2859
    
2860
    s->fdct (block);
2861

    
2862
#ifndef ARCH_ALPHA              /* Alpha uses unpermuted matrix */
2863
    /* we need this permutation so that we correct the IDCT
2864
       permutation. will be moved into DCT code */
2865
    block_permute(block, s->idct_permutation); //FIXME remove
2866
#endif
2867

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

    
2894
    for(;i<64;i++) {
2895
        j = s->intra_scantable.permutated[i];
2896
        level = block[j];
2897
        level = level * qmat[j];
2898

    
2899
//        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
2900
//           || bias-level >= (1<<(QMAT_SHIFT - 3))){
2901
        if(((unsigned)(level+threshold1))>threshold2){
2902
            if(level>0){
2903
                level= (bias + level)>>QMAT_SHIFT;
2904
                block[j]= level;
2905
            }else{
2906
                level= (bias - level)>>QMAT_SHIFT;
2907
                block[j]= -level;
2908
            }
2909
            max |=level;
2910
            last_non_zero = i;
2911
        }else{
2912
            block[j]=0;
2913
        }
2914
    }
2915
    *overflow= s->max_qcoeff < max; //overflow might have happend
2916
    
2917
    return last_non_zero;
2918
}
2919

    
2920
static void dct_unquantize_mpeg1_c(MpegEncContext *s, 
2921
                                   DCTELEM *block, int n, int qscale)
2922
{
2923
    int i, level, nCoeffs;
2924
    const UINT16 *quant_matrix;
2925

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

    
2983
static void dct_unquantize_mpeg2_c(MpegEncContext *s, 
2984
                                   DCTELEM *block, int n, int qscale)
2985
{
2986
    int i, level, nCoeffs;
2987
    const UINT16 *quant_matrix;
2988

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

    
3045

    
3046
static void dct_unquantize_h263_c(MpegEncContext *s, 
3047
                                  DCTELEM *block, int n, int qscale)
3048
{
3049
    int i, level, qmul, qadd;
3050
    int nCoeffs;
3051
    
3052
    assert(s->block_last_index[n]>=0);
3053
    
3054
    qadd = (qscale - 1) | 1;
3055
    qmul = qscale << 1;
3056
    
3057
    if (s->mb_intra) {
3058
        if (!s->h263_aic) {
3059
            if (n < 4) 
3060
                block[0] = block[0] * s->y_dc_scale;
3061
            else
3062
                block[0] = block[0] * s->c_dc_scale;
3063
        }else
3064
            qadd = 0;
3065
        i = 1;
3066
        nCoeffs= 63; //does not allways use zigzag table 
3067
    } else {
3068
        i = 0;
3069
        nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ];
3070
    }
3071

    
3072
    for(;i<=nCoeffs;i++) {
3073
        level = block[i];
3074
        if (level) {
3075
            if (level < 0) {
3076
                level = level * qmul - qadd;
3077
            } else {
3078
                level = level * qmul + qadd;
3079
            }
3080
#ifdef PARANOID
3081
                if (level < -2048 || level > 2047)
3082
                    fprintf(stderr, "unquant error %d %d\n", i, level);
3083
#endif
3084
            block[i] = level;
3085
        }
3086
    }
3087
}
3088

    
3089
static void remove_ac(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int mb_x, int mb_y)
3090
{
3091
    int dc, dcb, dcr, y, i;
3092
    for(i=0; i<4; i++){
3093
        dc= s->dc_val[0][mb_x*2+1 + (i&1) + (mb_y*2+1 + (i>>1))*(s->mb_width*2+2)];
3094
        for(y=0; y<8; y++){
3095
            int x;
3096
            for(x=0; x<8; x++){
3097
                dest_y[x + (i&1)*8 + (y + (i>>1)*8)*s->linesize]= dc/8;
3098
            }
3099
        }
3100
    }
3101
    dcb = s->dc_val[1][mb_x+1 + (mb_y+1)*(s->mb_width+2)];
3102
    dcr= s->dc_val[2][mb_x+1 + (mb_y+1)*(s->mb_width+2)];
3103
    for(y=0; y<8; y++){
3104
        int x;
3105
        for(x=0; x<8; x++){
3106
            dest_cb[x + y*(s->uvlinesize)]= dcb/8;
3107
            dest_cr[x + y*(s->uvlinesize)]= dcr/8;
3108
        }
3109
    }
3110
}
3111

    
3112
/**
3113
 * will conceal past errors, and allso drop b frames if needed
3114
 *
3115
 */
3116
void ff_conceal_past_errors(MpegEncContext *s, int unknown_pos)
3117
{
3118
    int mb_x= s->mb_x;
3119
    int mb_y= s->mb_y;
3120
    int mb_dist=0;
3121
    int i, intra_count=0, inter_count=0;
3122
    int intra_conceal= s->msmpeg4_version ? 50 : 50; //FIXME finetune
3123
    int inter_conceal= s->msmpeg4_version ? 50 : 50;
3124

    
3125
    // for last block
3126
    if(mb_x>=s->mb_width)  mb_x= s->mb_width -1;
3127
    if(mb_y>=s->mb_height) mb_y= s->mb_height-1;
3128

    
3129
    if(s->decoding_error==0 && unknown_pos){
3130
        if(s->data_partitioning && s->pict_type!=B_TYPE)
3131
                s->decoding_error= DECODING_AC_LOST;
3132
        else
3133
                s->decoding_error= DECODING_DESYNC;
3134
    }
3135

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

    
3138
    for(i=mb_x + mb_y*s->mb_width; i>=0; i--){
3139
        if(s->mbintra_table[i]) intra_count++;
3140
        else                    inter_count++;
3141
    }
3142
    
3143
    if(s->decoding_error==DECODING_AC_LOST){
3144
        intra_conceal*=2;
3145
        inter_conceal*=2;
3146
    }else if(s->decoding_error==DECODING_ACDC_LOST){
3147
        intra_conceal*=2;
3148
        inter_conceal*=2;
3149
    }
3150

    
3151
    if(unknown_pos && (intra_count<inter_count)){
3152
        intra_conceal= inter_conceal= s->mb_num; 
3153
//        printf("%d %d\n",intra_count, inter_count);
3154
    }
3155

    
3156
    fprintf(stderr, "concealing errors\n");
3157

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

    
3182
                if(s->decoding_error!=DECODING_DESYNC){
3183
                    int xy= mb_x*2+1 + (mb_y*2+1)*(s->mb_width*2+2);
3184
                    mx= s->motion_val[ xy ][0];
3185
                    my= s->motion_val[ xy ][1];
3186
                }
3187

    
3188
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 0, 
3189
                            s->last_picture, 0, 0, put_pixels_tab,
3190
                            mx, my, 16);
3191
            }
3192
            s->mb_x= mb_x_backup;
3193
            s->mb_y= mb_y_backup;
3194

    
3195
            if(mb_x== s->resync_mb_x && mb_y== s->resync_mb_y) return;
3196
            if(!s->mbskip_table[mb_x + mb_y*s->mb_width]) mb_dist++;
3197
        }
3198
        mb_x=s->mb_width-1;
3199
    }
3200
}
3201

    
3202
AVCodec mpeg1video_encoder = {
3203
    "mpeg1video",
3204
    CODEC_TYPE_VIDEO,
3205
    CODEC_ID_MPEG1VIDEO,
3206
    sizeof(MpegEncContext),
3207
    MPV_encode_init,
3208
    MPV_encode_picture,
3209
    MPV_encode_end,
3210
};
3211

    
3212
AVCodec h263_encoder = {
3213
    "h263",
3214
    CODEC_TYPE_VIDEO,
3215
    CODEC_ID_H263,
3216
    sizeof(MpegEncContext),
3217
    MPV_encode_init,
3218
    MPV_encode_picture,
3219
    MPV_encode_end,
3220
};
3221

    
3222
AVCodec h263p_encoder = {
3223
    "h263p",
3224
    CODEC_TYPE_VIDEO,
3225
    CODEC_ID_H263P,
3226
    sizeof(MpegEncContext),
3227
    MPV_encode_init,
3228
    MPV_encode_picture,
3229
    MPV_encode_end,
3230
};
3231

    
3232
AVCodec rv10_encoder = {
3233
    "rv10",
3234
    CODEC_TYPE_VIDEO,
3235
    CODEC_ID_RV10,
3236
    sizeof(MpegEncContext),
3237
    MPV_encode_init,
3238
    MPV_encode_picture,
3239
    MPV_encode_end,
3240
};
3241

    
3242
AVCodec mjpeg_encoder = {
3243
    "mjpeg",
3244
    CODEC_TYPE_VIDEO,
3245
    CODEC_ID_MJPEG,
3246
    sizeof(MpegEncContext),
3247
    MPV_encode_init,
3248
    MPV_encode_picture,
3249
    MPV_encode_end,
3250
};
3251

    
3252
AVCodec mpeg4_encoder = {
3253
    "mpeg4",
3254
    CODEC_TYPE_VIDEO,
3255
    CODEC_ID_MPEG4,
3256
    sizeof(MpegEncContext),
3257
    MPV_encode_init,
3258
    MPV_encode_picture,
3259
    MPV_encode_end,
3260
};
3261

    
3262
AVCodec msmpeg4v1_encoder = {
3263
    "msmpeg4v1",
3264
    CODEC_TYPE_VIDEO,
3265
    CODEC_ID_MSMPEG4V1,
3266
    sizeof(MpegEncContext),
3267
    MPV_encode_init,
3268
    MPV_encode_picture,
3269
    MPV_encode_end,
3270
};
3271

    
3272
AVCodec msmpeg4v2_encoder = {
3273
    "msmpeg4v2",
3274
    CODEC_TYPE_VIDEO,
3275
    CODEC_ID_MSMPEG4V2,
3276
    sizeof(MpegEncContext),
3277
    MPV_encode_init,
3278
    MPV_encode_picture,
3279
    MPV_encode_end,
3280
};
3281

    
3282
AVCodec msmpeg4v3_encoder = {
3283
    "msmpeg4",
3284
    CODEC_TYPE_VIDEO,
3285
    CODEC_ID_MSMPEG4V3,
3286
    sizeof(MpegEncContext),
3287
    MPV_encode_init,
3288
    MPV_encode_picture,
3289
    MPV_encode_end,
3290
};
3291

    
3292
AVCodec wmv1_encoder = {
3293
    "wmv1",
3294
    CODEC_TYPE_VIDEO,
3295
    CODEC_ID_WMV1,
3296
    sizeof(MpegEncContext),
3297
    MPV_encode_init,
3298
    MPV_encode_picture,
3299
    MPV_encode_end,
3300
};
3301

    
3302
AVCodec wmv2_encoder = {
3303
    "wmv2",
3304
    CODEC_TYPE_VIDEO,
3305
    CODEC_ID_WMV2,
3306
    sizeof(MpegEncContext),
3307
    MPV_encode_init,
3308
    MPV_encode_picture,
3309
    MPV_encode_end,
3310
};