Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpeg12.c @ b928ec64

History | View | Annotate | Download (82.6 KB)

1
/*
2
 * MPEG1 codec / MPEG2 decoder
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
 
20
/**
21
 * @file mpeg12.c
22
 * MPEG1 codec / MPEG2 decoder.
23
 */
24
 
25
//#define DEBUG
26
#include "avcodec.h"
27
#include "dsputil.h"
28
#include "mpegvideo.h"
29

    
30
#include "mpeg12data.h"
31

    
32

    
33
/* Start codes. */
34
#define SEQ_END_CODE                0x000001b7
35
#define SEQ_START_CODE                0x000001b3
36
#define GOP_START_CODE                0x000001b8
37
#define PICTURE_START_CODE        0x00000100
38
#define SLICE_MIN_START_CODE        0x00000101
39
#define SLICE_MAX_START_CODE        0x000001af
40
#define EXT_START_CODE                0x000001b5
41
#define USER_START_CODE                0x000001b2
42

    
43
#define DC_VLC_BITS 9
44
#define MV_VLC_BITS 9
45
#define MBINCR_VLC_BITS 9
46
#define MB_PAT_VLC_BITS 9
47
#define MB_PTYPE_VLC_BITS 6
48
#define MB_BTYPE_VLC_BITS 6
49
#define TEX_VLC_BITS 9
50

    
51
static void mpeg1_encode_block(MpegEncContext *s, 
52
                         DCTELEM *block, 
53
                         int component);
54
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code);    // RAL: f_code parameter added
55
static void mpeg1_skip_picture(MpegEncContext *s, int pict_num);
56
static inline int mpeg1_decode_block_inter(MpegEncContext *s, 
57
                              DCTELEM *block, 
58
                              int n);
59
static inline int mpeg1_decode_block_intra(MpegEncContext *s, 
60
                              DCTELEM *block, 
61
                              int n);
62
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 
63
                                        DCTELEM *block, 
64
                                        int n);
65
static inline int mpeg2_decode_block_intra(MpegEncContext *s, 
66
                                    DCTELEM *block, 
67
                                    int n);
68
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred);
69

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

    
75
#ifdef CONFIG_ENCODERS
76
static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
77
static uint8_t fcode_tab[MAX_MV*2+1];
78

    
79
static uint32_t uni_mpeg1_ac_vlc_bits[64*64*2];
80
static uint8_t  uni_mpeg1_ac_vlc_len [64*64*2];
81

    
82
/* simple include everything table for dc, first byte is bits number next 3 are code*/
83
static uint32_t mpeg1_lum_dc_uni[512];
84
static uint32_t mpeg1_chr_dc_uni[512];
85

    
86
static uint8_t mpeg1_index_run[2][64];
87
static int8_t mpeg1_max_level[2][64];
88
#endif
89

    
90
static void init_2d_vlc_rl(RLTable *rl)
91
{
92
    int i;
93
    
94
    init_vlc(&rl->vlc, TEX_VLC_BITS, rl->n + 2, 
95
             &rl->table_vlc[0][1], 4, 2,
96
             &rl->table_vlc[0][0], 4, 2);
97

    
98
    
99
    rl->rl_vlc[0]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
100
    for(i=0; i<rl->vlc.table_size; i++){
101
        int code= rl->vlc.table[i][0];
102
        int len = rl->vlc.table[i][1];
103
        int level, run;
104
    
105
        if(len==0){ // illegal code
106
            run= 65;
107
            level= MAX_LEVEL;
108
        }else if(len<0){ //more bits needed
109
            run= 0;
110
            level= code;
111
        }else{
112
            if(code==rl->n){ //esc
113
                run= 65;
114
                level= 0;
115
            }else if(code==rl->n+1){ //eob
116
                run= 0;
117
                level= 127;
118
            }else{
119
                run=   rl->table_run  [code] + 1;
120
                level= rl->table_level[code];
121
            }
122
        }
123
        rl->rl_vlc[0][i].len= len;
124
        rl->rl_vlc[0][i].level= level;
125
        rl->rl_vlc[0][i].run= run;
126
    }
127
}
128

    
129
#ifdef CONFIG_ENCODERS
130
static void init_uni_ac_vlc(RLTable *rl, uint32_t *uni_ac_vlc_bits, uint8_t *uni_ac_vlc_len){
131
    int i;
132

    
133
    for(i=0; i<128; i++){
134
        int level= i-64;
135
        int run;
136
        for(run=0; run<64; run++){
137
            int len, bits, code;
138
            
139
            int alevel= ABS(level);
140
            int sign= (level>>31)&1;
141

    
142
            if (alevel > rl->max_level[0][run])
143
                code= 111; /*rl->n*/
144
            else
145
                code= rl->index_run[0][run] + alevel - 1;
146

    
147
            if (code < 111 /* rl->n */) {
148
                    /* store the vlc & sign at once */
149
                len=   mpeg1_vlc[code][1]+1;
150
                bits= (mpeg1_vlc[code][0]<<1) + sign;
151
            } else {
152
                len=  mpeg1_vlc[111/*rl->n*/][1]+6;
153
                bits= mpeg1_vlc[111/*rl->n*/][0]<<6;
154

    
155
                bits|= run;
156
                if (alevel < 128) {
157
                    bits<<=8; len+=8;
158
                    bits|= level & 0xff;
159
                } else {
160
                    bits<<=16; len+=16;
161
                    bits|= level & 0xff;
162
                    if (level < 0) {
163
                        bits|= 0x8001 + level + 255;
164
                    } else {
165
                        bits|= level & 0xffff;
166
                    }
167
                }
168
            }
169

    
170
            uni_ac_vlc_bits[UNI_AC_ENC_INDEX(run, i)]= bits;
171
            uni_ac_vlc_len [UNI_AC_ENC_INDEX(run, i)]= len;
172
        }
173
    }
174
}
175

    
176
static void put_header(MpegEncContext *s, int header)
177
{
178
    align_put_bits(&s->pb);
179
    put_bits(&s->pb, 16, header>>16);
180
    put_bits(&s->pb, 16, header&0xFFFF);
181
}
182

    
183
/* put sequence header if needed */
184
static void mpeg1_encode_sequence_header(MpegEncContext *s)
185
{
186
        unsigned int vbv_buffer_size;
187
        unsigned int fps, v;
188
        int n, i;
189
        uint64_t time_code;
190
        float best_aspect_error= 1E10;
191
        float aspect_ratio= s->avctx->aspect_ratio;
192
        
193
        if(aspect_ratio==0.0) aspect_ratio= s->width / (float)s->height; //pixel aspect 1:1 (VGA)
194
        
195
        if (s->current_picture.key_frame) {
196
            /* mpeg1 header repeated every gop */
197
            put_header(s, SEQ_START_CODE);
198
            
199
            /* search closest frame rate */
200
            {
201
                int i, dmin, d;
202
                s->frame_rate_index = 0;
203
                dmin = 0x7fffffff;
204
                for(i=1;i<14;i++) {
205
                    if(s->avctx->strict_std_compliance >= 0 && i>=9) break;
206
                     
207
                    d = abs(MPEG1_FRAME_RATE_BASE*(int64_t)s->avctx->frame_rate/s->avctx->frame_rate_base - frame_rate_tab[i]);
208
                    if (d < dmin) {
209
                        dmin = d;
210
                        s->frame_rate_index = i;
211
                    }
212
                }
213
            }
214
 
215
            put_bits(&s->pb, 12, s->width);
216
            put_bits(&s->pb, 12, s->height);
217
            
218
            for(i=1; i<15; i++){
219
                float error= mpeg1_aspect[i] - s->width/(s->height*aspect_ratio);
220
                error= ABS(error);
221
                
222
                if(error < best_aspect_error){
223
                    best_aspect_error= error;
224
                    s->aspect_ratio_info= i;
225
                }
226
            }
227
            
228
            put_bits(&s->pb, 4, s->aspect_ratio_info);
229
            put_bits(&s->pb, 4, s->frame_rate_index);
230
            v = (s->bit_rate + 399) / 400;
231
            if (v > 0x3ffff)
232
                v = 0x3ffff;
233
            put_bits(&s->pb, 18, v);
234
            put_bits(&s->pb, 1, 1); /* marker */
235

    
236
            if(s->avctx->rc_buffer_size)
237
                vbv_buffer_size = s->avctx->rc_buffer_size;
238
            else
239
                /* VBV calculation: Scaled so that a VCD has the proper VBV size of 40 kilobytes */
240
                vbv_buffer_size = (( 20 * s->bit_rate) / (1151929 / 2)) * 8 * 1024;         
241
            put_bits(&s->pb, 10, (vbv_buffer_size + 16383) / 16384); 
242
            put_bits(&s->pb, 1, 1); /* constrained parameter flag */
243
            put_bits(&s->pb, 1, 0); /* no custom intra matrix */
244
            put_bits(&s->pb, 1, 0); /* no custom non intra matrix */
245

    
246
            put_header(s, GOP_START_CODE);
247
            put_bits(&s->pb, 1, 0); /* do drop frame */
248
            /* time code : we must convert from the real frame rate to a
249
               fake mpeg frame rate in case of low frame rate */
250
            fps = frame_rate_tab[s->frame_rate_index];
251
            time_code = (int64_t)s->fake_picture_number * MPEG1_FRAME_RATE_BASE;
252
            s->gop_picture_number = s->fake_picture_number;
253
            put_bits(&s->pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24));
254
            put_bits(&s->pb, 6, (uint32_t)((time_code / (fps * 60)) % 60));
255
            put_bits(&s->pb, 1, 1);
256
            put_bits(&s->pb, 6, (uint32_t)((time_code / fps) % 60));
257
            put_bits(&s->pb, 6, (uint32_t)((time_code % fps) / MPEG1_FRAME_RATE_BASE));
258
            put_bits(&s->pb, 1, 1); /* closed gop */
259
            put_bits(&s->pb, 1, 0); /* broken link */
260
        }
261

    
262
        if (s->avctx->frame_rate < (24 * s->avctx->frame_rate_base) && s->picture_number > 0) {
263
            /* insert empty P pictures to slow down to the desired
264
               frame rate. Each fake pictures takes about 20 bytes */
265
            fps = frame_rate_tab[s->frame_rate_index];
266
            n = av_rescale((int64_t)s->picture_number * s->avctx->frame_rate_base, fps, s->avctx->frame_rate) / MPEG1_FRAME_RATE_BASE - 1;
267
            while (s->fake_picture_number < n) {
268
                mpeg1_skip_picture(s, s->fake_picture_number - 
269
                                   s->gop_picture_number); 
270
                s->fake_picture_number++;
271
            }
272

    
273
        }
274
}
275

    
276
static inline void encode_mb_skip_run(MpegEncContext *s, int run){
277
    while (run >= 33) {
278
        put_bits(&s->pb, 11, 0x008);
279
        run -= 33;
280
    }
281
    put_bits(&s->pb, mbAddrIncrTable[run][1], 
282
             mbAddrIncrTable[run][0]);
283
}
284

    
285
/* insert a fake P picture */
286
static void mpeg1_skip_picture(MpegEncContext *s, int pict_num)
287
{
288
    /* mpeg1 picture header */
289
    put_header(s, PICTURE_START_CODE);
290
    /* temporal reference */
291
    put_bits(&s->pb, 10, pict_num & 0x3ff); 
292
    
293
    put_bits(&s->pb, 3, P_TYPE);
294
    put_bits(&s->pb, 16, 0xffff); /* non constant bit rate */
295
    
296
    put_bits(&s->pb, 1, 1); /* integer coordinates */
297
    put_bits(&s->pb, 3, 1); /* forward_f_code */
298
    
299
    put_bits(&s->pb, 1, 0); /* extra bit picture */
300
    
301
    /* only one slice */
302
    put_header(s, SLICE_MIN_START_CODE);
303
    put_bits(&s->pb, 5, 1); /* quantizer scale */
304
    put_bits(&s->pb, 1, 0); /* slice extra information */
305
    
306
    encode_mb_skip_run(s, 0);
307
    
308
    /* empty macroblock */
309
    put_bits(&s->pb, 3, 1); /* motion only */
310
    
311
    /* zero motion x & y */
312
    put_bits(&s->pb, 1, 1); 
313
    put_bits(&s->pb, 1, 1); 
314

    
315
    /* output a number of empty slice */
316
    encode_mb_skip_run(s, s->mb_width * s->mb_height - 2);
317
    
318
    /* empty macroblock */
319
    put_bits(&s->pb, 3, 1); /* motion only */
320
    
321
    /* zero motion x & y */
322
    put_bits(&s->pb, 1, 1); 
323
    put_bits(&s->pb, 1, 1); 
324
}
325
#endif
326

    
327
static void common_init(MpegEncContext *s)
328
{
329
    s->y_dc_scale_table=
330
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
331
}
332

    
333
void ff_mpeg1_clean_buffers(MpegEncContext *s){
334
    s->last_dc[0] = 1 << (7 + s->intra_dc_precision);
335
    s->last_dc[1] = s->last_dc[0];
336
    s->last_dc[2] = s->last_dc[0];
337
    memset(s->last_mv, 0, sizeof(s->last_mv));
338
}
339

    
340
#ifdef CONFIG_ENCODERS
341

    
342
void ff_mpeg1_encode_slice_header(MpegEncContext *s){
343
    put_header(s, SLICE_MIN_START_CODE + s->mb_y);
344
    put_bits(&s->pb, 5, s->qscale); /* quantizer scale */
345
    put_bits(&s->pb, 1, 0); /* slice extra information */
346
}
347

    
348
void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
349
{
350
    mpeg1_encode_sequence_header(s);
351

    
352
    /* mpeg1 picture header */
353
    put_header(s, PICTURE_START_CODE);
354
    /* temporal reference */
355

    
356
    // RAL: s->picture_number instead of s->fake_picture_number
357
    put_bits(&s->pb, 10, (s->picture_number - 
358
                          s->gop_picture_number) & 0x3ff); 
359
    s->fake_picture_number++;
360
    
361
    put_bits(&s->pb, 3, s->pict_type);
362
    put_bits(&s->pb, 16, 0xffff); /* non constant bit rate */
363
    
364
    // RAL: Forward f_code also needed for B frames
365
    if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
366
        put_bits(&s->pb, 1, 0); /* half pel coordinates */
367
        put_bits(&s->pb, 3, s->f_code); /* forward_f_code */
368
    }
369
    
370
    // RAL: Backward f_code necessary for B frames
371
    if (s->pict_type == B_TYPE) {
372
        put_bits(&s->pb, 1, 0); /* half pel coordinates */
373
        put_bits(&s->pb, 3, s->b_code); /* backward_f_code */
374
        }
375

    
376
    put_bits(&s->pb, 1, 0); /* extra bit picture */
377
    
378
    s->mb_y=0;
379
    ff_mpeg1_encode_slice_header(s);
380
}
381

    
382
void mpeg1_encode_mb(MpegEncContext *s,
383
                     DCTELEM block[6][64],
384
                     int motion_x, int motion_y)
385
{
386
    int i, cbp;
387
    const int mb_x = s->mb_x;
388
    const int mb_y = s->mb_y;
389
    const int first_mb= mb_x == s->resync_mb_x && mb_y == s->resync_mb_y;
390

    
391
    /* compute cbp */
392
    cbp = 0;
393
    for(i=0;i<6;i++) {
394
        if (s->block_last_index[i] >= 0)
395
            cbp |= 1 << (5 - i);
396
    }
397

    
398
    if (cbp == 0 && !first_mb && (mb_x != s->mb_width - 1 || mb_y != s->mb_height - 1) && 
399
        ((s->pict_type == P_TYPE && (motion_x | motion_y) == 0) ||
400
        (s->pict_type == B_TYPE && s->mv_dir == s->last_mv_dir && (((s->mv_dir & MV_DIR_FORWARD) ? ((s->mv[0][0][0] - s->last_mv[0][0][0])|(s->mv[0][0][1] - s->last_mv[0][0][1])) : 0) |
401
        ((s->mv_dir & MV_DIR_BACKWARD) ? ((s->mv[1][0][0] - s->last_mv[1][0][0])|(s->mv[1][0][1] - s->last_mv[1][0][1])) : 0)) == 0))) {
402
        s->mb_skip_run++;
403
        s->qscale -= s->dquant;
404
        s->skip_count++;
405
        s->misc_bits++;
406
        s->last_bits++;
407
    } else {
408
        if(first_mb){
409
            assert(s->mb_skip_run == 0);
410
            encode_mb_skip_run(s, s->mb_x);
411
        }else{
412
            encode_mb_skip_run(s, s->mb_skip_run);
413
        }
414
        
415
        if (s->pict_type == I_TYPE) {
416
            if(s->dquant && cbp){
417
                put_bits(&s->pb, 2, 1); /* macroblock_type : macroblock_quant = 1 */
418
                put_bits(&s->pb, 5, s->qscale);
419
            }else{
420
                put_bits(&s->pb, 1, 1); /* macroblock_type : macroblock_quant = 0 */
421
                s->qscale -= s->dquant;
422
            }
423
            s->misc_bits+= get_bits_diff(s);
424
            s->i_count++;
425
        } else if (s->mb_intra) {
426
            if(s->dquant && cbp){
427
                put_bits(&s->pb, 6, 0x01);
428
                put_bits(&s->pb, 5, s->qscale);
429
            }else{
430
                put_bits(&s->pb, 5, 0x03);
431
                s->qscale -= s->dquant;
432
            }
433
            s->misc_bits+= get_bits_diff(s);
434
            s->i_count++;
435
            s->last_mv[0][0][0] = 
436
            s->last_mv[0][0][1] = 0;
437
        } else if (s->pict_type == P_TYPE) { 
438
                if (cbp != 0) {
439
                    if (motion_x == 0 && motion_y == 0) {
440
                        if(s->dquant){
441
                            put_bits(&s->pb, 5, 1); /* macroblock_pattern & quant */
442
                            put_bits(&s->pb, 5, s->qscale);
443
                        }else{
444
                            put_bits(&s->pb, 2, 1); /* macroblock_pattern only */
445
                        }
446
                        s->misc_bits+= get_bits_diff(s);
447
                        put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
448
                    } else {
449
                        if(s->dquant){
450
                            put_bits(&s->pb, 5, 2); /* motion + cbp */
451
                            put_bits(&s->pb, 5, s->qscale);
452
                        }else{
453
                            put_bits(&s->pb, 1, 1); /* motion + cbp */
454
                        }
455
                        s->misc_bits+= get_bits_diff(s);
456
                        mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);    // RAL: f_code parameter added
457
                        mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);    // RAL: f_code parameter added
458
                        s->mv_bits+= get_bits_diff(s);
459
                        put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
460
                    }
461
                } else {
462
                    put_bits(&s->pb, 3, 1); /* motion only */
463
                    mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);    // RAL: f_code parameter added
464
                    mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);    // RAL: f_code parameter added
465
                    s->qscale -= s->dquant;
466
                    s->mv_bits+= get_bits_diff(s);
467
                }
468
                s->f_count++;
469
        } else
470
            {    // RAL: All the following bloc added for B frames:
471
                if (cbp != 0)
472
                    {    // With coded bloc pattern
473
                    if (s->mv_dir == (MV_DIR_FORWARD | MV_DIR_BACKWARD))
474
                        {    // Bi-directional motion
475
                        if (s->dquant)
476
                            {    // With QScale
477
                            put_bits(&s->pb, 5, 2);
478
                            put_bits(&s->pb, 5, s->qscale);
479
                            }
480
                        else    // Without QScale
481
                            put_bits(&s->pb, 2, 3);
482
                        s->misc_bits += get_bits_diff(s);
483
                        mpeg1_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
484
                        mpeg1_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
485
                        mpeg1_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
486
                        mpeg1_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
487
                        s->b_count++;
488
                        s->f_count++;
489
                        s->mv_bits += get_bits_diff(s);
490
                        put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
491
                        }
492
                    else if (s->mv_dir == MV_DIR_BACKWARD)
493
                        {    // Backward motion
494
                        if (s->dquant)
495
                            {    // With QScale
496
                            put_bits(&s->pb, 6, 2);
497
                            put_bits(&s->pb, 5, s->qscale);
498
                            }
499
                        else    // Without QScale
500
                            put_bits(&s->pb, 3, 3);
501
                        s->misc_bits += get_bits_diff(s);
502
                        mpeg1_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code); 
503
                        mpeg1_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code); 
504
                        s->b_count++;
505
                        s->mv_bits += get_bits_diff(s);
506
                        put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
507
                        }
508
                    else if (s->mv_dir == MV_DIR_FORWARD)
509
                        {    // Forward motion
510
                        if (s->dquant)
511
                            {    // With QScale
512
                            put_bits(&s->pb, 6, 3);
513
                            put_bits(&s->pb, 5, s->qscale);
514
                            }
515
                        else    // Without QScale
516
                            put_bits(&s->pb, 4, 3);
517
                        s->misc_bits += get_bits_diff(s);
518
                        mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code); 
519
                        mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code); 
520
                        s->f_count++;
521
                        s->mv_bits += get_bits_diff(s);
522
                        put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
523
                        }
524
                    }
525
                else
526
                    {    // No coded bloc pattern
527
                    if (s->mv_dir == (MV_DIR_FORWARD | MV_DIR_BACKWARD))
528
                        {    // Bi-directional motion 
529
                        put_bits(&s->pb, 2, 2); /* backward & forward motion */
530
                        mpeg1_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
531
                        mpeg1_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
532
                        mpeg1_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
533
                        mpeg1_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
534
                        s->b_count++;
535
                        s->f_count++;
536
                        }
537
                    else if (s->mv_dir == MV_DIR_BACKWARD)
538
                        {    // Backward motion
539
                        put_bits(&s->pb, 3, 2); /* backward motion only */
540
                        mpeg1_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code); 
541
                        mpeg1_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code); 
542
                        s->b_count++;
543
                        }
544
                    else if (s->mv_dir == MV_DIR_FORWARD)
545
                        {    // Forward motion
546
                        put_bits(&s->pb, 4, 2); /* forward motion only */
547
                        mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code); 
548
                        mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code); 
549
                        s->f_count++;
550
                        }
551
                    s->qscale -= s->dquant;
552
                    s->mv_bits += get_bits_diff(s);
553
                    }
554
            // End of bloc from RAL
555
            }
556
        for(i=0;i<6;i++) {
557
            if (cbp & (1 << (5 - i))) {
558
                mpeg1_encode_block(s, block[i], i);
559
            }
560
        }
561
        s->mb_skip_run = 0;
562
        if(s->mb_intra)
563
            s->i_tex_bits+= get_bits_diff(s);
564
        else
565
            s->p_tex_bits+= get_bits_diff(s);
566
    }
567

    
568
    // RAL: By this:
569
    if (s->mv_dir & MV_DIR_FORWARD)
570
        {
571
        s->last_mv[0][0][0]= s->mv[0][0][0];
572
        s->last_mv[0][0][1]= s->mv[0][0][1];
573
        }
574
    if (s->mv_dir & MV_DIR_BACKWARD)
575
        {
576
        s->last_mv[1][0][0]= s->mv[1][0][0];
577
        s->last_mv[1][0][1]= s->mv[1][0][1];
578
        }
579
}
580

    
581
// RAL: Parameter added: f_or_b_code
582
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code)
583
{
584
    int code, bit_size, l, m, bits, range, sign;
585

    
586
    if (val == 0) {
587
        /* zero vector */
588
        code = 0;
589
        put_bits(&s->pb,
590
                 mbMotionVectorTable[0][1], 
591
                 mbMotionVectorTable[0][0]); 
592
    } else {
593
        bit_size = f_or_b_code - 1;
594
        range = 1 << bit_size;
595
        /* modulo encoding */
596
        l = 16 * range;
597
        m = 2 * l;
598
        if (val < -l) {
599
            val += m;
600
        } else if (val >= l) {
601
            val -= m;
602
        }
603

    
604
        if (val >= 0) {
605
            val--;
606
            code = (val >> bit_size) + 1;
607
            bits = val & (range - 1);
608
            sign = 0;
609
        } else {
610
            val = -val;
611
            val--;
612
            code = (val >> bit_size) + 1;
613
            bits = val & (range - 1);
614
            sign = 1;
615
        }
616

    
617
        assert(code > 0 && code <= 16);
618

    
619
        put_bits(&s->pb,
620
                 mbMotionVectorTable[code][1], 
621
                 mbMotionVectorTable[code][0]); 
622

    
623
        put_bits(&s->pb, 1, sign);
624
        if (bit_size > 0) {
625
            put_bits(&s->pb, bit_size, bits);
626
        }
627
    }
628
}
629

    
630
void ff_mpeg1_encode_init(MpegEncContext *s)
631
{
632
    static int done=0;
633

    
634
    common_init(s);
635

    
636
    if(!done){
637
        int f_code;
638
        int mv;
639
        int i;
640

    
641
        done=1;
642
        init_rl(&rl_mpeg1);
643

    
644
        for(i=0; i<64; i++)
645
        {
646
                mpeg1_max_level[0][i]= rl_mpeg1.max_level[0][i];
647
                mpeg1_index_run[0][i]= rl_mpeg1.index_run[0][i];
648
        }
649
        
650
        init_uni_ac_vlc(&rl_mpeg1, uni_mpeg1_ac_vlc_bits, uni_mpeg1_ac_vlc_len);
651

    
652
        /* build unified dc encoding tables */
653
        for(i=-255; i<256; i++)
654
        {
655
                int adiff, index;
656
                int bits, code;
657
                int diff=i;
658

    
659
                adiff = ABS(diff);
660
                if(diff<0) diff--;
661
                index = vlc_dc_table[adiff];
662

    
663
                bits= vlc_dc_lum_bits[index] + index;
664
                code= (vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1));
665
                mpeg1_lum_dc_uni[i+255]= bits + (code<<8);
666
                
667
                bits= vlc_dc_chroma_bits[index] + index;
668
                code= (vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1));
669
                mpeg1_chr_dc_uni[i+255]= bits + (code<<8);
670
        }
671

    
672
        mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
673

    
674
        for(f_code=1; f_code<=MAX_FCODE; f_code++){
675
            for(mv=-MAX_MV; mv<=MAX_MV; mv++){
676
                int len;
677

    
678
                if(mv==0) len= mbMotionVectorTable[0][1];
679
                else{
680
                    int val, bit_size, range, code;
681

    
682
                    bit_size = s->f_code - 1;
683
                    range = 1 << bit_size;
684

    
685
                    val=mv;
686
                    if (val < 0) 
687
                        val = -val;
688
                    val--;
689
                    code = (val >> bit_size) + 1;
690
                    if(code<17){
691
                        len= mbMotionVectorTable[code][1] + 1 + bit_size;
692
                    }else{
693
                        len= mbMotionVectorTable[16][1] + 2 + bit_size;
694
                    }
695
                }
696

    
697
                mv_penalty[f_code][mv+MAX_MV]= len;
698
            }
699
        }
700
        
701

    
702
        for(f_code=MAX_FCODE; f_code>0; f_code--){
703
            for(mv=-(8<<f_code); mv<(8<<f_code); mv++){
704
                fcode_tab[mv+MAX_MV]= f_code;
705
            }
706
        }
707
    }
708
    s->me.mv_penalty= mv_penalty;
709
    s->fcode_tab= fcode_tab;
710
    s->min_qcoeff=-255;
711
    s->max_qcoeff= 255;
712
    s->intra_ac_vlc_length=
713
    s->inter_ac_vlc_length= uni_mpeg1_ac_vlc_len;
714
}
715

    
716
static inline void encode_dc(MpegEncContext *s, int diff, int component)
717
{
718
    if (component == 0) {
719
        put_bits(
720
            &s->pb, 
721
            mpeg1_lum_dc_uni[diff+255]&0xFF,
722
            mpeg1_lum_dc_uni[diff+255]>>8);
723
    } else {
724
        put_bits(
725
            &s->pb, 
726
            mpeg1_chr_dc_uni[diff+255]&0xFF,
727
            mpeg1_chr_dc_uni[diff+255]>>8);
728
    }
729
}
730

    
731
static void mpeg1_encode_block(MpegEncContext *s, 
732
                               DCTELEM *block, 
733
                               int n)
734
{
735
    int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;
736
    int code, component;
737
//    RLTable *rl = &rl_mpeg1;
738

    
739
    last_index = s->block_last_index[n];
740

    
741
    /* DC coef */
742
    if (s->mb_intra) {
743
        component = (n <= 3 ? 0 : n - 4 + 1);
744
        dc = block[0]; /* overflow is impossible */
745
        diff = dc - s->last_dc[component];
746
        encode_dc(s, diff, component);
747
        s->last_dc[component] = dc;
748
        i = 1;
749
    } else {
750
        /* encode the first coefficient : needs to be done here because
751
           it is handled slightly differently */
752
        level = block[0];
753
        if (abs(level) == 1) {
754
                code = ((uint32_t)level >> 31); /* the sign bit */
755
                put_bits(&s->pb, 2, code | 0x02);
756
                i = 1;
757
        } else {
758
            i = 0;
759
            last_non_zero = -1;
760
            goto next_coef;
761
        }
762
    }
763

    
764
    /* now quantify & encode AC coefs */
765
    last_non_zero = i - 1;
766

    
767
    for(;i<=last_index;i++) {
768
        j = s->intra_scantable.permutated[i];
769
        level = block[j];
770
    next_coef:
771
#if 0
772
        if (level != 0)
773
            dprintf("level[%d]=%d\n", i, level);
774
#endif            
775
        /* encode using VLC */
776
        if (level != 0) {
777
            run = i - last_non_zero - 1;
778
            
779
            alevel= level;
780
            MASK_ABS(sign, alevel)
781
            sign&=1;
782

    
783
//            code = get_rl_index(rl, 0, run, alevel);
784
            if (alevel <= mpeg1_max_level[0][run]){
785
                code= mpeg1_index_run[0][run] + alevel - 1;
786
                    /* store the vlc & sign at once */
787
                put_bits(&s->pb, mpeg1_vlc[code][1]+1, (mpeg1_vlc[code][0]<<1) + sign);
788
            } else {
789
                /* escape seems to be pretty rare <5% so i dont optimize it */
790
                put_bits(&s->pb, mpeg1_vlc[111/*rl->n*/][1], mpeg1_vlc[111/*rl->n*/][0]);
791
                /* escape: only clip in this case */
792
                put_bits(&s->pb, 6, run);
793
                if (alevel < 128) {
794
                    put_bits(&s->pb, 8, level & 0xff);
795
                } else {
796
                    if (level < 0) {
797
                        put_bits(&s->pb, 16, 0x8001 + level + 255);
798
                    } else {
799
                        put_bits(&s->pb, 16, level & 0xffff);
800
                    }
801
                }
802
            }
803
            last_non_zero = i;
804
        }
805
    }
806
    /* end of block */
807
    put_bits(&s->pb, 2, 0x2);
808
}
809
#endif //CONFIG_ENCODERS
810

    
811
/******************************************/
812
/* decoding */
813

    
814
static VLC dc_lum_vlc;
815
static VLC dc_chroma_vlc;
816
static VLC mv_vlc;
817
static VLC mbincr_vlc;
818
static VLC mb_ptype_vlc;
819
static VLC mb_btype_vlc;
820
static VLC mb_pat_vlc;
821

    
822
static void init_vlcs(MpegEncContext *s)
823
{
824
    static int done = 0;
825

    
826
    if (!done) {
827
        done = 1;
828

    
829
        init_vlc(&dc_lum_vlc, DC_VLC_BITS, 12, 
830
                 vlc_dc_lum_bits, 1, 1,
831
                 vlc_dc_lum_code, 2, 2);
832
        init_vlc(&dc_chroma_vlc,  DC_VLC_BITS, 12, 
833
                 vlc_dc_chroma_bits, 1, 1,
834
                 vlc_dc_chroma_code, 2, 2);
835
        init_vlc(&mv_vlc, MV_VLC_BITS, 17, 
836
                 &mbMotionVectorTable[0][1], 2, 1,
837
                 &mbMotionVectorTable[0][0], 2, 1);
838
        init_vlc(&mbincr_vlc, MBINCR_VLC_BITS, 36, 
839
                 &mbAddrIncrTable[0][1], 2, 1,
840
                 &mbAddrIncrTable[0][0], 2, 1);
841
        init_vlc(&mb_pat_vlc, MB_PAT_VLC_BITS, 63, 
842
                 &mbPatTable[0][1], 2, 1,
843
                 &mbPatTable[0][0], 2, 1);
844
        
845
        init_vlc(&mb_ptype_vlc, MB_PTYPE_VLC_BITS, 7, 
846
                 &table_mb_ptype[0][1], 2, 1,
847
                 &table_mb_ptype[0][0], 2, 1);
848
        init_vlc(&mb_btype_vlc, MB_BTYPE_VLC_BITS, 11, 
849
                 &table_mb_btype[0][1], 2, 1,
850
                 &table_mb_btype[0][0], 2, 1);
851
        init_rl(&rl_mpeg1);
852
        init_rl(&rl_mpeg2);
853

    
854
        init_2d_vlc_rl(&rl_mpeg1);
855
        init_2d_vlc_rl(&rl_mpeg2);
856
    }
857
}
858

    
859
static inline int get_dmv(MpegEncContext *s)
860
{
861
    if(get_bits1(&s->gb)) 
862
        return 1 - (get_bits1(&s->gb) << 1);
863
    else
864
        return 0;
865
}
866

    
867
static inline int get_qscale(MpegEncContext *s)
868
{
869
    int qscale = get_bits(&s->gb, 5);
870
    if (s->mpeg2) {
871
        if (s->q_scale_type) {
872
            return non_linear_qscale[qscale];
873
        } else {
874
            return qscale << 1;
875
        }
876
    }
877
    return qscale;
878
}
879

    
880
/* motion type (for mpeg2) */
881
#define MT_FIELD 1
882
#define MT_FRAME 2
883
#define MT_16X8  2
884
#define MT_DMV   3
885

    
886
static int mpeg_decode_mb(MpegEncContext *s,
887
                          DCTELEM block[6][64])
888
{
889
    int i, j, k, cbp, val, mb_type, motion_type;
890
    
891
    dprintf("decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
892

    
893
    assert(s->mb_skiped==0);
894

    
895
    if (s->mb_skip_run-- != 0) {
896
        if(s->pict_type == I_TYPE){
897
            fprintf(stderr, "skiped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
898
            return -1;
899
        }
900
    
901
        /* skip mb */
902
        s->mb_intra = 0;
903
        for(i=0;i<6;i++)
904
            s->block_last_index[i] = -1;
905
        s->mv_type = MV_TYPE_16X16;
906
        if (s->pict_type == P_TYPE) {
907
            /* if P type, zero motion vector is implied */
908
            s->mv_dir = MV_DIR_FORWARD;
909
            s->mv[0][0][0] = s->mv[0][0][1] = 0;
910
            s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
911
            s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
912
            s->mb_skiped = 1;
913
            s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
914
        } else {
915
            /* if B type, reuse previous vectors and directions */
916
            s->mv[0][0][0] = s->last_mv[0][0][0];
917
            s->mv[0][0][1] = s->last_mv[0][0][1];
918
            s->mv[1][0][0] = s->last_mv[1][0][0];
919
            s->mv[1][0][1] = s->last_mv[1][0][1];
920

    
921
            s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= 
922
                s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1] | MB_TYPE_SKIP;
923
//            assert(s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1]&(MB_TYPE_16x16|MB_TYPE_16x8));
924

    
925
            if((s->mv[0][0][0]|s->mv[0][0][1]|s->mv[1][0][0]|s->mv[1][0][1])==0) 
926
                s->mb_skiped = 1;
927
        }
928

    
929
        return 0;
930
    }
931

    
932
    switch(s->pict_type) {
933
    default:
934
    case I_TYPE:
935
        if (get_bits1(&s->gb) == 0) {
936
            if (get_bits1(&s->gb) == 0){
937
                fprintf(stderr, "invalid mb type in I Frame at %d %d\n", s->mb_x, s->mb_y);
938
                return -1;
939
            }
940
            mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
941
        } else {
942
            mb_type = MB_TYPE_INTRA;
943
        }
944
        break;
945
    case P_TYPE:
946
        mb_type = get_vlc2(&s->gb, mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
947
        if (mb_type < 0){
948
            fprintf(stderr, "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y);
949
            return -1;
950
        }
951
        mb_type = ptype2mb_type[ mb_type ];
952
        break;
953
    case B_TYPE:
954
        mb_type = get_vlc2(&s->gb, mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
955
        if (mb_type < 0){
956
            fprintf(stderr, "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y);
957
            return -1;
958
        }
959
        mb_type = btype2mb_type[ mb_type ];
960
        break;
961
    }
962
    dprintf("mb_type=%x\n", mb_type);
963
//    motion_type = 0; /* avoid warning */
964
    if (IS_INTRA(mb_type)) {
965
        /* compute dct type */
966
        if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
967
            !s->frame_pred_frame_dct) {
968
            s->interlaced_dct = get_bits1(&s->gb);
969
        }
970

    
971
        if (IS_QUANT(mb_type))
972
            s->qscale = get_qscale(s);
973
        
974
        if (s->concealment_motion_vectors) {
975
            /* just parse them */
976
            if (s->picture_structure != PICT_FRAME) 
977
                skip_bits1(&s->gb); /* field select */
978
            
979
            s->mv[0][0][0]= s->last_mv[0][0][0]= s->last_mv[0][1][0] = 
980
                mpeg_decode_motion(s, s->mpeg_f_code[0][0], s->last_mv[0][0][0]);
981
            s->mv[0][0][1]= s->last_mv[0][0][1]= s->last_mv[0][1][1] = 
982
                mpeg_decode_motion(s, s->mpeg_f_code[0][1], s->last_mv[0][0][1]);
983

    
984
            skip_bits1(&s->gb); /* marker */
985
        }else
986
            memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */
987
        s->mb_intra = 1;
988

    
989
        if (s->mpeg2) {
990
            for(i=0;i<6;i++) {
991
                if (mpeg2_decode_block_intra(s, block[i], i) < 0)
992
                    return -1;
993
            }
994
        } else {
995
            for(i=0;i<6;i++) {
996
                if (mpeg1_decode_block_intra(s, block[i], i) < 0)
997
                    return -1;
998
            }
999
        }
1000
    } else {
1001
        if (mb_type & MB_TYPE_ZERO_MV){
1002
            assert(mb_type & MB_TYPE_PAT);
1003

    
1004
            /* compute dct type */
1005
            if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
1006
                !s->frame_pred_frame_dct) {
1007
                s->interlaced_dct = get_bits1(&s->gb);
1008
            }
1009

    
1010
            if (IS_QUANT(mb_type))
1011
                s->qscale = get_qscale(s);
1012

    
1013
            s->mv_dir = MV_DIR_FORWARD;
1014
            s->mv_type = MV_TYPE_16X16;
1015
            s->last_mv[0][0][0] = 0;
1016
            s->last_mv[0][0][1] = 0;
1017
            s->last_mv[0][1][0] = 0;
1018
            s->last_mv[0][1][1] = 0;
1019
            s->mv[0][0][0] = 0;
1020
            s->mv[0][0][1] = 0;
1021
        }else{
1022
            assert(mb_type & MB_TYPE_L0L1);
1023
//FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
1024
            /* get additionnal motion vector type */
1025
            if (s->frame_pred_frame_dct) 
1026
                motion_type = MT_FRAME;
1027
            else{
1028
                motion_type = get_bits(&s->gb, 2);
1029
            }
1030

    
1031
            /* compute dct type */
1032
            if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
1033
                !s->frame_pred_frame_dct && IS_PAT(mb_type)) {
1034
                s->interlaced_dct = get_bits1(&s->gb);
1035
            }
1036

    
1037
            if (IS_QUANT(mb_type))
1038
                s->qscale = get_qscale(s);
1039

    
1040
            /* motion vectors */
1041
            s->mv_dir = 0;
1042
            for(i=0;i<2;i++) {
1043
                if (USES_LIST(mb_type, i)) {
1044
                    s->mv_dir |= (MV_DIR_FORWARD >> i);
1045
                    dprintf("motion_type=%d\n", motion_type);
1046
                    switch(motion_type) {
1047
                    case MT_FRAME: /* or MT_16X8 */
1048
                        if (s->picture_structure == PICT_FRAME) {
1049
                            /* MT_FRAME */
1050
                            mb_type |= MB_TYPE_16x16; 
1051
                            s->mv_type = MV_TYPE_16X16;
1052
                            s->mv[i][0][0]= s->last_mv[i][0][0]= s->last_mv[i][1][0] = 
1053
                                mpeg_decode_motion(s, s->mpeg_f_code[i][0], s->last_mv[i][0][0]);
1054
                            s->mv[i][0][1]= s->last_mv[i][0][1]= s->last_mv[i][1][1] = 
1055
                                mpeg_decode_motion(s, s->mpeg_f_code[i][1], s->last_mv[i][0][1]);
1056
                            /* full_pel: only for mpeg1 */
1057
                            if (s->full_pel[i]){
1058
                                s->mv[i][0][0] <<= 1;
1059
                                s->mv[i][0][1] <<= 1;
1060
                            }
1061
                        } else {
1062
                            /* MT_16X8 */
1063
                            mb_type |= MB_TYPE_16x8; 
1064
                            s->mv_type = MV_TYPE_16X8;
1065
                            for(j=0;j<2;j++) {
1066
                                s->field_select[i][j] = get_bits1(&s->gb);
1067
                                for(k=0;k<2;k++) {
1068
                                    val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
1069
                                                             s->last_mv[i][j][k]);
1070
                                    s->last_mv[i][j][k] = val;
1071
                                    s->mv[i][j][k] = val;
1072
                                }
1073
                            }
1074
                        }
1075
                        break;
1076
                    case MT_FIELD:
1077
                        s->mv_type = MV_TYPE_FIELD;
1078
                        if (s->picture_structure == PICT_FRAME) {
1079
                            mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED; 
1080
                            for(j=0;j<2;j++) {
1081
                                s->field_select[i][j] = get_bits1(&s->gb);
1082
                                val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
1083
                                                         s->last_mv[i][j][0]);
1084
                                s->last_mv[i][j][0] = val;
1085
                                s->mv[i][j][0] = val;
1086
                                dprintf("fmx=%d\n", val);
1087
                                val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
1088
                                                         s->last_mv[i][j][1] >> 1);
1089
                                s->last_mv[i][j][1] = val << 1;
1090
                                s->mv[i][j][1] = val;
1091
                                dprintf("fmy=%d\n", val);
1092
                            }
1093
                        } else {
1094
                            mb_type |= MB_TYPE_16x16; 
1095
                            s->field_select[i][0] = get_bits1(&s->gb);
1096
                            for(k=0;k<2;k++) {
1097
                                val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
1098
                                                         s->last_mv[i][0][k]);
1099
                                s->last_mv[i][0][k] = val;
1100
                                s->last_mv[i][1][k] = val;
1101
                                s->mv[i][0][k] = val;
1102
                            }
1103
                        }
1104
                        break;
1105
                    case MT_DMV:
1106
                        {
1107
                            int dmx, dmy, mx, my, m;
1108

    
1109
                            mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0], 
1110
                                                    s->last_mv[i][0][0]);
1111
                            s->last_mv[i][0][0] = mx;
1112
                            s->last_mv[i][1][0] = mx;
1113
                            dmx = get_dmv(s);
1114
                            my = mpeg_decode_motion(s, s->mpeg_f_code[i][1], 
1115
                                                    s->last_mv[i][0][1] >> 1);
1116
                            dmy = get_dmv(s);
1117
                            s->mv_type = MV_TYPE_DMV;
1118

    
1119

    
1120
                            s->last_mv[i][0][1] = my<<1;
1121
                            s->last_mv[i][1][1] = my<<1;
1122

    
1123
                            s->mv[i][0][0] = mx;
1124
                            s->mv[i][0][1] = my;
1125
                            s->mv[i][1][0] = mx;//not used
1126
                            s->mv[i][1][1] = my;//not used
1127

    
1128
                            if (s->picture_structure == PICT_FRAME) {
1129
                                mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED; 
1130

    
1131
                                //m = 1 + 2 * s->top_field_first;
1132
                                m = s->top_field_first ? 1 : 3;
1133

    
1134
                                /* top -> top pred */
1135
                                s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1136
                                s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
1137
                                m = 4 - m;
1138
                                s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1139
                                s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
1140
                            } else {
1141
                                mb_type |= MB_TYPE_16x16;
1142

    
1143
                                s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
1144
                                s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
1145
                                if(s->picture_structure == PICT_TOP_FIELD)
1146
                                    s->mv[i][2][1]--;
1147
                                else 
1148
                                    s->mv[i][2][1]++;
1149
                            }
1150
                        }
1151
                        break;
1152
                    }
1153
                }
1154
            }
1155
        }
1156
        
1157
        s->mb_intra = 0;
1158

    
1159
        if (IS_PAT(mb_type)) {
1160
            cbp = get_vlc2(&s->gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
1161
            if (cbp < 0){
1162
                fprintf(stderr, "invalid cbp at %d %d\n", s->mb_x, s->mb_y);
1163
                return -1;
1164
            }
1165
            cbp++;
1166

    
1167
            if (s->mpeg2) {
1168
                for(i=0;i<6;i++) {
1169
                    if (cbp & 32) {
1170
                        if (mpeg2_decode_block_non_intra(s, block[i], i) < 0)
1171
                            return -1;
1172
                    } else {
1173
                        s->block_last_index[i] = -1;
1174
                    }
1175
                    cbp+=cbp;
1176
                }
1177
            } else {
1178
                for(i=0;i<6;i++) {
1179
                    if (cbp & 32) {
1180
                        if (mpeg1_decode_block_inter(s, block[i], i) < 0)
1181
                            return -1;
1182
                    } else {
1183
                        s->block_last_index[i] = -1;
1184
                    }
1185
                    cbp+=cbp;
1186
                }
1187
            }
1188
        }else{
1189
            for(i=0;i<6;i++)
1190
                s->block_last_index[i] = -1;
1191
        }
1192
    }
1193

    
1194
    s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= mb_type;
1195

    
1196
    return 0;
1197
}
1198

    
1199
/* as h263, but only 17 codes */
1200
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
1201
{
1202
    int code, sign, val, l, shift;
1203

    
1204
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
1205
    if (code == 0) {
1206
        return pred;
1207
    }
1208
    if (code < 0) {
1209
        return 0xffff;
1210
    }
1211

    
1212
    sign = get_bits1(&s->gb);
1213
    shift = fcode - 1;
1214
    val = code;
1215
    if (shift) {
1216
        val = (val - 1) << shift;
1217
        val |= get_bits(&s->gb, shift);
1218
        val++;
1219
    }
1220
    if (sign)
1221
        val = -val;
1222
    val += pred;
1223
    
1224
    /* modulo decoding */
1225
    l = 1 << (shift+4);
1226
    val = ((val + l)&(l*2-1)) - l;
1227
    return val;
1228
}
1229

    
1230
static inline int decode_dc(MpegEncContext *s, int component)
1231
{
1232
    int code, diff;
1233

    
1234
    if (component == 0) {
1235
        code = get_vlc2(&s->gb, dc_lum_vlc.table, DC_VLC_BITS, 2);
1236
    } else {
1237
        code = get_vlc2(&s->gb, dc_chroma_vlc.table, DC_VLC_BITS, 2);
1238
    }
1239
    if (code < 0){
1240
        fprintf(stderr, "invalid dc code at %d %d\n", s->mb_x, s->mb_y);
1241
        return 0xffff;
1242
    }
1243
    if (code == 0) {
1244
        diff = 0;
1245
    } else {
1246
        diff = get_xbits(&s->gb, code);
1247
    }
1248
    return diff;
1249
}
1250

    
1251
static inline int mpeg1_decode_block_intra(MpegEncContext *s, 
1252
                               DCTELEM *block, 
1253
                               int n)
1254
{
1255
    int level, dc, diff, i, j, run;
1256
    int component;
1257
    RLTable *rl = &rl_mpeg1;
1258
    uint8_t * const scantable= s->intra_scantable.permutated;
1259
    const uint16_t *quant_matrix= s->intra_matrix;
1260
    const int qscale= s->qscale;
1261

    
1262
    /* DC coef */
1263
    component = (n <= 3 ? 0 : n - 4 + 1);
1264
    diff = decode_dc(s, component);
1265
    if (diff >= 0xffff)
1266
        return -1;
1267
    dc = s->last_dc[component];
1268
    dc += diff;
1269
    s->last_dc[component] = dc;
1270
    block[0] = dc<<3;
1271
    dprintf("dc=%d diff=%d\n", dc, diff);
1272
    i = 0;
1273
    {
1274
        OPEN_READER(re, &s->gb);    
1275
        /* now quantify & encode AC coefs */
1276
        for(;;) {
1277
            UPDATE_CACHE(re, &s->gb);
1278
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1279
            
1280
            if(level == 127){
1281
                break;
1282
            } else if(level != 0) {
1283
                i += run;
1284
                j = scantable[i];
1285
                level= (level*qscale*quant_matrix[j])>>3;
1286
                level= (level-1)|1;
1287
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1288
                LAST_SKIP_BITS(re, &s->gb, 1);
1289
            } else {
1290
                /* escape */
1291
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1292
                UPDATE_CACHE(re, &s->gb);
1293
                level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1294
                if (level == -128) {
1295
                    level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
1296
                } else if (level == 0) {
1297
                    level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);
1298
                }
1299
                i += run;
1300
                j = scantable[i];
1301
                if(level<0){
1302
                    level= -level;
1303
                    level= (level*qscale*quant_matrix[j])>>3;
1304
                    level= (level-1)|1;
1305
                    level= -level;
1306
                }else{
1307
                    level= (level*qscale*quant_matrix[j])>>3;
1308
                    level= (level-1)|1;
1309
                }
1310
            }
1311
            if (i > 63){
1312
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1313
                return -1;
1314
            }
1315

    
1316
            block[j] = level;
1317
        }
1318
        CLOSE_READER(re, &s->gb);
1319
    }
1320
    s->block_last_index[n] = i;
1321
   return 0;
1322
}
1323

    
1324
static inline int mpeg1_decode_block_inter(MpegEncContext *s, 
1325
                               DCTELEM *block, 
1326
                               int n)
1327
{
1328
    int level, i, j, run;
1329
    RLTable *rl = &rl_mpeg1;
1330
    uint8_t * const scantable= s->intra_scantable.permutated;
1331
    const uint16_t *quant_matrix= s->inter_matrix;
1332
    const int qscale= s->qscale;
1333

    
1334
    {
1335
        int v;
1336
        OPEN_READER(re, &s->gb);
1337
        i = -1;
1338
        /* special case for the first coef. no need to add a second vlc table */
1339
        UPDATE_CACHE(re, &s->gb);
1340
        v= SHOW_UBITS(re, &s->gb, 2);
1341
        if (v & 2) {
1342
            LAST_SKIP_BITS(re, &s->gb, 2);
1343
            level= (3*qscale*quant_matrix[0])>>4;
1344
            level= (level-1)|1;
1345
            if(v&1)
1346
                level= -level;
1347
            block[0] = level;
1348
            i++;
1349
        }
1350

    
1351
        /* now quantify & encode AC coefs */
1352
        for(;;) {
1353
            UPDATE_CACHE(re, &s->gb);
1354
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1355
            
1356
            if(level == 127){
1357
                break;
1358
            } else if(level != 0) {
1359
                i += run;
1360
                j = scantable[i];
1361
                level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1362
                level= (level-1)|1;
1363
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1364
                LAST_SKIP_BITS(re, &s->gb, 1);
1365
            } else {
1366
                /* escape */
1367
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1368
                UPDATE_CACHE(re, &s->gb);
1369
                level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1370
                if (level == -128) {
1371
                    level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
1372
                } else if (level == 0) {
1373
                    level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);
1374
                }
1375
                i += run;
1376
                j = scantable[i];
1377
                if(level<0){
1378
                    level= -level;
1379
                    level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1380
                    level= (level-1)|1;
1381
                    level= -level;
1382
                }else{
1383
                    level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1384
                    level= (level-1)|1;
1385
                }
1386
            }
1387
            if (i > 63){
1388
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1389
                return -1;
1390
            }
1391

    
1392
            block[j] = level;
1393
        }
1394
        CLOSE_READER(re, &s->gb);
1395
    }
1396
    s->block_last_index[n] = i;
1397
    return 0;
1398
}
1399

    
1400
/* Also does unquantization here, since I will never support mpeg2
1401
   encoding */
1402
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 
1403
                               DCTELEM *block, 
1404
                               int n)
1405
{
1406
    int level, i, j, run;
1407
    RLTable *rl = &rl_mpeg1;
1408
    uint8_t * const scantable= s->intra_scantable.permutated;
1409
    const uint16_t *quant_matrix;
1410
    const int qscale= s->qscale;
1411
    int mismatch;
1412

    
1413
    mismatch = 1;
1414

    
1415
    {
1416
        int v;
1417
        OPEN_READER(re, &s->gb);
1418
        i = -1;
1419
        if (n < 4)
1420
            quant_matrix = s->inter_matrix;
1421
        else
1422
            quant_matrix = s->chroma_inter_matrix;
1423

    
1424
        /* special case for the first coef. no need to add a second vlc table */
1425
        UPDATE_CACHE(re, &s->gb);
1426
        v= SHOW_UBITS(re, &s->gb, 2);
1427
        if (v & 2) {
1428
            LAST_SKIP_BITS(re, &s->gb, 2);
1429
            level= (3*qscale*quant_matrix[0])>>5;
1430
            if(v&1)
1431
                level= -level;
1432
            block[0] = level;
1433
            mismatch ^= level;
1434
            i++;
1435
        }
1436

    
1437
        /* now quantify & encode AC coefs */
1438
        for(;;) {
1439
            UPDATE_CACHE(re, &s->gb);
1440
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1441
            
1442
            if(level == 127){
1443
                break;
1444
            } else if(level != 0) {
1445
                i += run;
1446
                j = scantable[i];
1447
                level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1448
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1449
                LAST_SKIP_BITS(re, &s->gb, 1);
1450
            } else {
1451
                /* escape */
1452
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1453
                UPDATE_CACHE(re, &s->gb);
1454
                level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1455

    
1456
                i += run;
1457
                j = scantable[i];
1458
                if(level<0){
1459
                    level= ((-level*2+1)*qscale*quant_matrix[j])>>5;
1460
                    level= -level;
1461
                }else{
1462
                    level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1463
                }
1464
            }
1465
            if (i > 63){
1466
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1467
                return -1;
1468
            }
1469
            
1470
            mismatch ^= level;
1471
            block[j] = level;
1472
        }
1473
        CLOSE_READER(re, &s->gb);
1474
    }
1475
    block[63] ^= (mismatch & 1);
1476
    
1477
    s->block_last_index[n] = i;
1478
    return 0;
1479
}
1480

    
1481
static inline int mpeg2_decode_block_intra(MpegEncContext *s, 
1482
                               DCTELEM *block, 
1483
                               int n)
1484
{
1485
    int level, dc, diff, i, j, run;
1486
    int component;
1487
    RLTable *rl;
1488
    uint8_t * const scantable= s->intra_scantable.permutated;
1489
    const uint16_t *quant_matrix;
1490
    const int qscale= s->qscale;
1491
    int mismatch;
1492

    
1493
    /* DC coef */
1494
    if (n < 4){
1495
        quant_matrix = s->intra_matrix;
1496
        component = 0; 
1497
    }else{
1498
        quant_matrix = s->chroma_intra_matrix;
1499
        component = n - 3;
1500
    }
1501
    diff = decode_dc(s, component);
1502
    if (diff >= 0xffff)
1503
        return -1;
1504
    dc = s->last_dc[component];
1505
    dc += diff;
1506
    s->last_dc[component] = dc;
1507
    block[0] = dc << (3 - s->intra_dc_precision);
1508
    dprintf("dc=%d\n", block[0]);
1509
    mismatch = block[0] ^ 1;
1510
    i = 0;
1511
    if (s->intra_vlc_format)
1512
        rl = &rl_mpeg2;
1513
    else
1514
        rl = &rl_mpeg1;
1515

    
1516
    {
1517
        OPEN_READER(re, &s->gb);    
1518
        /* now quantify & encode AC coefs */
1519
        for(;;) {
1520
            UPDATE_CACHE(re, &s->gb);
1521
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1522
            
1523
            if(level == 127){
1524
                break;
1525
            } else if(level != 0) {
1526
                i += run;
1527
                j = scantable[i];
1528
                level= (level*qscale*quant_matrix[j])>>4;
1529
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1530
                LAST_SKIP_BITS(re, &s->gb, 1);
1531
            } else {
1532
                /* escape */
1533
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1534
                UPDATE_CACHE(re, &s->gb);
1535
                level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1536
                i += run;
1537
                j = scantable[i];
1538
                if(level<0){
1539
                    level= (-level*qscale*quant_matrix[j])>>4;
1540
                    level= -level;
1541
                }else{
1542
                    level= (level*qscale*quant_matrix[j])>>4;
1543
                }
1544
            }
1545
            if (i > 63){
1546
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1547
                return -1;
1548
            }
1549
            
1550
            mismatch^= level;
1551
            block[j] = level;
1552
        }
1553
        CLOSE_READER(re, &s->gb);
1554
    }
1555
    block[63]^= mismatch&1;
1556
    
1557
    s->block_last_index[n] = i;
1558
    return 0;
1559
}
1560

    
1561
typedef struct Mpeg1Context {
1562
    MpegEncContext mpeg_enc_ctx;
1563
    int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
1564
    int repeat_field; /* true if we must repeat the field */
1565
} Mpeg1Context;
1566

    
1567
static int mpeg_decode_init(AVCodecContext *avctx)
1568
{
1569
    Mpeg1Context *s = avctx->priv_data;
1570
    
1571
    s->mpeg_enc_ctx.flags= avctx->flags;
1572
    common_init(&s->mpeg_enc_ctx);
1573
    init_vlcs(&s->mpeg_enc_ctx);
1574

    
1575
    s->mpeg_enc_ctx_allocated = 0;
1576
    s->mpeg_enc_ctx.picture_number = 0;
1577
    s->repeat_field = 0;
1578
    s->mpeg_enc_ctx.codec_id= avctx->codec->id;
1579
    return 0;
1580
}
1581

    
1582
/* return the 8 bit start code value and update the search
1583
   state. Return -1 if no start code found */
1584
static int find_start_code(uint8_t **pbuf_ptr, uint8_t *buf_end)
1585
{
1586
    uint8_t *buf_ptr;
1587
    unsigned int state=0xFFFFFFFF, v;
1588
    int val;
1589

    
1590
    buf_ptr = *pbuf_ptr;
1591
    while (buf_ptr < buf_end) {
1592
        v = *buf_ptr++;
1593
        if (state == 0x000001) {
1594
            state = ((state << 8) | v) & 0xffffff;
1595
            val = state;
1596
            goto found;
1597
        }
1598
        state = ((state << 8) | v) & 0xffffff;
1599
    }
1600
    val = -1;
1601
 found:
1602
    *pbuf_ptr = buf_ptr;
1603
    return val;
1604
}
1605

    
1606
static int mpeg1_decode_picture(AVCodecContext *avctx, 
1607
                                uint8_t *buf, int buf_size)
1608
{
1609
    Mpeg1Context *s1 = avctx->priv_data;
1610
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1611
    int ref, f_code;
1612

    
1613
    init_get_bits(&s->gb, buf, buf_size*8);
1614

    
1615
    ref = get_bits(&s->gb, 10); /* temporal ref */
1616
    s->pict_type = get_bits(&s->gb, 3);
1617
    dprintf("pict_type=%d number=%d\n", s->pict_type, s->picture_number);
1618

    
1619
    skip_bits(&s->gb, 16);
1620
    if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
1621
        s->full_pel[0] = get_bits1(&s->gb);
1622
        f_code = get_bits(&s->gb, 3);
1623
        if (f_code == 0)
1624
            return -1;
1625
        s->mpeg_f_code[0][0] = f_code;
1626
        s->mpeg_f_code[0][1] = f_code;
1627
    }
1628
    if (s->pict_type == B_TYPE) {
1629
        s->full_pel[1] = get_bits1(&s->gb);
1630
        f_code = get_bits(&s->gb, 3);
1631
        if (f_code == 0)
1632
            return -1;
1633
        s->mpeg_f_code[1][0] = f_code;
1634
        s->mpeg_f_code[1][1] = f_code;
1635
    }
1636
    s->current_picture.pict_type= s->pict_type;
1637
    s->current_picture.key_frame= s->pict_type == I_TYPE;
1638
    
1639
    s->y_dc_scale = 8;
1640
    s->c_dc_scale = 8;
1641
    s->first_slice = 1;
1642
    return 0;
1643
}
1644

    
1645
static void mpeg_decode_sequence_extension(MpegEncContext *s)
1646
{
1647
    int horiz_size_ext, vert_size_ext;
1648
    int bit_rate_ext, vbv_buf_ext;
1649
    int frame_rate_ext_n, frame_rate_ext_d;
1650
    float aspect;
1651

    
1652
    skip_bits(&s->gb, 8); /* profil and level */
1653
    s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1654
    skip_bits(&s->gb, 2); /* chroma_format */
1655
    horiz_size_ext = get_bits(&s->gb, 2);
1656
    vert_size_ext = get_bits(&s->gb, 2);
1657
    s->width |= (horiz_size_ext << 12);
1658
    s->height |= (vert_size_ext << 12);
1659
    bit_rate_ext = get_bits(&s->gb, 12);  /* XXX: handle it */
1660
    s->bit_rate = ((s->bit_rate / 400) | (bit_rate_ext << 12)) * 400;
1661
    skip_bits1(&s->gb); /* marker */
1662
    vbv_buf_ext = get_bits(&s->gb, 8);
1663

    
1664
    s->low_delay = get_bits1(&s->gb);
1665
    if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1;
1666

    
1667
    frame_rate_ext_n = get_bits(&s->gb, 2);
1668
    frame_rate_ext_d = get_bits(&s->gb, 5);
1669
    av_reduce(
1670
        &s->avctx->frame_rate, 
1671
        &s->avctx->frame_rate_base, 
1672
        frame_rate_tab[s->frame_rate_index] * (frame_rate_ext_n+1),
1673
        MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d+1),
1674
        1<<30);
1675

    
1676
    dprintf("sequence extension\n");
1677
    s->mpeg2 = 1;
1678
    s->avctx->sub_id = 2; /* indicates mpeg2 found */
1679

    
1680
    aspect= mpeg2_aspect[s->aspect_ratio_info];
1681
    if(aspect>0.0)      s->avctx->aspect_ratio= s->width/(aspect*s->height);
1682
    else if(aspect<0.0) s->avctx->aspect_ratio= -1.0/aspect;
1683
}
1684

    
1685
static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1686
{
1687
    int i, v, j;
1688

    
1689
    dprintf("matrix extension\n");
1690

    
1691
    if (get_bits1(&s->gb)) {
1692
        for(i=0;i<64;i++) {
1693
            v = get_bits(&s->gb, 8);
1694
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1695
            s->intra_matrix[j] = v;
1696
            s->chroma_intra_matrix[j] = v;
1697
        }
1698
    }
1699
    if (get_bits1(&s->gb)) {
1700
        for(i=0;i<64;i++) {
1701
            v = get_bits(&s->gb, 8);
1702
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1703
            s->inter_matrix[j] = v;
1704
            s->chroma_inter_matrix[j] = v;
1705
        }
1706
    }
1707
    if (get_bits1(&s->gb)) {
1708
        for(i=0;i<64;i++) {
1709
            v = get_bits(&s->gb, 8);
1710
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1711
            s->chroma_intra_matrix[j] = v;
1712
        }
1713
    }
1714
    if (get_bits1(&s->gb)) {
1715
        for(i=0;i<64;i++) {
1716
            v = get_bits(&s->gb, 8);
1717
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1718
            s->chroma_inter_matrix[j] = v;
1719
        }
1720
    }
1721
}
1722

    
1723
static void mpeg_decode_picture_coding_extension(MpegEncContext *s)
1724
{
1725
    s->full_pel[0] = s->full_pel[1] = 0;
1726
    s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1727
    s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1728
    s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1729
    s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1730
    s->intra_dc_precision = get_bits(&s->gb, 2);
1731
    s->picture_structure = get_bits(&s->gb, 2);
1732
    s->top_field_first = get_bits1(&s->gb);
1733
    s->frame_pred_frame_dct = get_bits1(&s->gb);
1734
    s->concealment_motion_vectors = get_bits1(&s->gb);
1735
    s->q_scale_type = get_bits1(&s->gb);
1736
    s->intra_vlc_format = get_bits1(&s->gb);
1737
    s->alternate_scan = get_bits1(&s->gb);
1738
    s->repeat_first_field = get_bits1(&s->gb);
1739
    s->chroma_420_type = get_bits1(&s->gb);
1740
    s->progressive_frame = get_bits1(&s->gb);
1741
    
1742
    if(s->picture_structure == PICT_FRAME)
1743
        s->first_field=0;
1744
    else{
1745
        s->first_field ^= 1;
1746
        memset(s->mbskip_table, 0, s->mb_stride*s->mb_height);
1747
    }
1748
    
1749
    if(s->alternate_scan){
1750
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
1751
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
1752
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
1753
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
1754
    }else{
1755
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
1756
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
1757
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
1758
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
1759
    }
1760
    
1761
    /* composite display not parsed */
1762
    dprintf("intra_dc_precision=%d\n", s->intra_dc_precision);
1763
    dprintf("picture_structure=%d\n", s->picture_structure);
1764
    dprintf("top field first=%d\n", s->top_field_first);
1765
    dprintf("repeat first field=%d\n", s->repeat_first_field);
1766
    dprintf("conceal=%d\n", s->concealment_motion_vectors);
1767
    dprintf("intra_vlc_format=%d\n", s->intra_vlc_format);
1768
    dprintf("alternate_scan=%d\n", s->alternate_scan);
1769
    dprintf("frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1770
    dprintf("progressive_frame=%d\n", s->progressive_frame);
1771
}
1772

    
1773
static void mpeg_decode_extension(AVCodecContext *avctx, 
1774
                                  uint8_t *buf, int buf_size)
1775
{
1776
    Mpeg1Context *s1 = avctx->priv_data;
1777
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1778
    int ext_type;
1779

    
1780
    init_get_bits(&s->gb, buf, buf_size*8);
1781
    
1782
    ext_type = get_bits(&s->gb, 4);
1783
    switch(ext_type) {
1784
    case 0x1:
1785
        /* sequence ext */
1786
        mpeg_decode_sequence_extension(s);
1787
        break;
1788
    case 0x3:
1789
        /* quant matrix extension */
1790
        mpeg_decode_quant_matrix_extension(s);
1791
        break;
1792
    case 0x8:
1793
        /* picture extension */
1794
        mpeg_decode_picture_coding_extension(s);
1795
        break;
1796
    }
1797
}
1798

    
1799
static void exchange_uv(AVFrame *f){
1800
    uint8_t *t= f->data[1];
1801
    f->data[1]= f->data[2];
1802
    f->data[2]= t;
1803
}
1804

    
1805
#define DECODE_SLICE_FATAL_ERROR -2
1806
#define DECODE_SLICE_ERROR -1
1807
#define DECODE_SLICE_OK 0
1808

    
1809
/**
1810
 * decodes a slice.
1811
 * @return DECODE_SLICE_FATAL_ERROR if a non recoverable error occured<br>
1812
 *         DECODE_SLICE_ERROR if the slice is damaged<br>
1813
 *         DECODE_SLICE_OK if this slice is ok<br>
1814
 */
1815
static int mpeg_decode_slice(AVCodecContext *avctx, 
1816
                              AVFrame *pict,
1817
                              int start_code,
1818
                              uint8_t **buf, int buf_size)
1819
{
1820
    Mpeg1Context *s1 = avctx->priv_data;
1821
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1822
    int ret;
1823
    const int field_pic= s->picture_structure != PICT_FRAME;
1824

    
1825
    s->resync_mb_x= s->mb_x = 
1826
    s->resync_mb_y= s->mb_y = -1;
1827
    
1828
    start_code = (start_code - 1) & 0xff;
1829
    if (start_code >= s->mb_height){
1830
        fprintf(stderr, "slice below image (%d >= %d)\n", start_code, s->mb_height);
1831
        return -1;
1832
    }
1833
    
1834
    ff_mpeg1_clean_buffers(s);
1835
    s->interlaced_dct = 0;
1836
        
1837
    /* start frame decoding */
1838
    if (s->first_slice) {
1839
      if(s->first_field || s->picture_structure==PICT_FRAME){
1840
        if(MPV_frame_start(s, avctx) < 0)
1841
            return DECODE_SLICE_FATAL_ERROR;
1842

    
1843
        ff_er_frame_start(s);
1844

    
1845
        /* first check if we must repeat the frame */
1846
        s->current_picture.repeat_pict = 0;
1847

    
1848
        if (s->repeat_first_field) {
1849
            if (s->progressive_sequence) {
1850
                if (s->top_field_first)
1851
                    s->current_picture.repeat_pict = 4;
1852
                else
1853
                    s->current_picture.repeat_pict = 2;
1854
            } else if (s->progressive_frame) {
1855
                s->current_picture.repeat_pict = 1;
1856
            }
1857
        }         
1858
//        printf("%d \n", s->current_picture.repeat_pict);
1859

    
1860
        if(s->avctx->debug&FF_DEBUG_PICT_INFO){
1861
             printf("qp:%d fc:%2d%2d%2d%2d %s %s %s %s dc:%d pstruct:%d fdct:%d cmv:%d qtype:%d ivlc:%d rff:%d %s\n", 
1862
                 s->qscale, s->mpeg_f_code[0][0],s->mpeg_f_code[0][1],s->mpeg_f_code[1][0],s->mpeg_f_code[1][1],
1863
                 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")), 
1864
                 s->progressive_sequence ? "pro" :"", s->alternate_scan ? "alt" :"", s->top_field_first ? "top" :"", 
1865
                 s->intra_dc_precision, s->picture_structure, s->frame_pred_frame_dct, s->concealment_motion_vectors,
1866
                 s->q_scale_type, s->intra_vlc_format, s->repeat_first_field, s->chroma_420_type ? "420" :"");
1867
        }
1868
      }else{ //second field
1869
            int i;
1870
            
1871
            if(!s->current_picture_ptr){
1872
                fprintf(stderr, "first field missing\n");
1873
                return -1;
1874
            }
1875
            
1876
            for(i=0; i<4; i++){
1877
                s->current_picture.data[i] = s->current_picture_ptr->data[i];
1878
                if(s->picture_structure == PICT_BOTTOM_FIELD){
1879
                    s->current_picture.data[i] += s->current_picture_ptr->linesize[i];
1880
                } 
1881
            }
1882
      }
1883
#ifdef HAVE_XVMC
1884
// MPV_frame_start will call this function too,
1885
// but we need to call it on every field
1886
      if(s->avctx->xvmc_acceleration)
1887
         XVMC_field_start(s,avctx);
1888
#endif
1889
    }//fi(s->first_slice)
1890
    s->first_slice = 0;
1891

    
1892
    init_get_bits(&s->gb, *buf, buf_size*8);
1893

    
1894
    s->qscale = get_qscale(s);
1895
    if(s->qscale == 0){
1896
        fprintf(stderr, "qscale == 0\n");
1897
        return -1;
1898
    }
1899
    
1900
    /* extra slice info */
1901
    while (get_bits1(&s->gb) != 0) {
1902
        skip_bits(&s->gb, 8);
1903
    }
1904
    
1905
    s->mb_x=0;
1906

    
1907
    for(;;) {
1908
        int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1909
        if (code < 0){
1910
            fprintf(stderr, "first mb_incr damaged\n");
1911
            return -1;
1912
        }
1913
        if (code >= 33) {
1914
            if (code == 33) {
1915
                s->mb_x += 33;
1916
            }
1917
            /* otherwise, stuffing, nothing to do */
1918
        } else {
1919
            s->mb_x += code;
1920
            break;
1921
        }
1922
    }
1923
    
1924
    s->resync_mb_x= s->mb_x;
1925
    s->resync_mb_y= s->mb_y = start_code;
1926
    s->mb_skip_run= 0;
1927
    ff_init_block_index(s);
1928

    
1929
    for(;;) {
1930
        s->dsp.clear_blocks(s->block[0]);
1931

    
1932
        ret = mpeg_decode_mb(s, s->block);
1933

    
1934
        dprintf("ret=%d\n", ret);
1935
        if (ret < 0)
1936
            return -1;
1937
            
1938
        if(s->motion_val && s->pict_type != B_TYPE){ //note motion_val is normally NULL unless we want to extract the MVs
1939
            const int wrap = s->block_wrap[0];
1940
            const int xy = s->mb_x*2 + 1 + (s->mb_y*2 +1)*wrap;
1941
            int motion_x, motion_y;
1942

    
1943
            if (s->mb_intra) {
1944
                motion_x = motion_y = 0;
1945
            }else if (s->mv_type == MV_TYPE_16X16) {
1946
                motion_x = s->mv[0][0][0];
1947
                motion_y = s->mv[0][0][1];
1948
            } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
1949
                motion_x = s->mv[0][0][0] + s->mv[0][1][0];
1950
                motion_y = s->mv[0][0][1] + s->mv[0][1][1];
1951
                motion_x = (motion_x>>1) | (motion_x&1);
1952
            }
1953
            s->motion_val[xy][0] = motion_x;
1954
            s->motion_val[xy][1] = motion_y;
1955
            s->motion_val[xy + 1][0] = motion_x;
1956
            s->motion_val[xy + 1][1] = motion_y;
1957
            s->motion_val[xy + wrap][0] = motion_x;
1958
            s->motion_val[xy + wrap][1] = motion_y;
1959
            s->motion_val[xy + 1 + wrap][0] = motion_x;
1960
            s->motion_val[xy + 1 + wrap][1] = motion_y;
1961
        }
1962
        
1963
        s->dest[0] += 16;
1964
        s->dest[1] += 8;
1965
        s->dest[2] += 8;
1966

    
1967
        MPV_decode_mb(s, s->block);
1968
        
1969
        if (++s->mb_x >= s->mb_width) {
1970
            if(s->avctx->codec_tag == ff_get_fourcc("VCR2"))
1971
                exchange_uv((AVFrame*)s->current_picture_ptr);
1972

    
1973
            ff_draw_horiz_band(s, 16*s->mb_y, 16);
1974

    
1975
            if(s->avctx->codec_tag == ff_get_fourcc("VCR2"))
1976
                exchange_uv((AVFrame*)s->current_picture_ptr);
1977

    
1978
            s->mb_x = 0;
1979
            s->mb_y++;
1980

    
1981
            if(s->mb_y<<field_pic >= s->mb_height){
1982
                int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1983

    
1984
                if(left < 0 || (left && show_bits(&s->gb, FFMIN(left, 23)))
1985
                   || (avctx->error_resilience >= FF_ER_AGGRESSIVE && left>8)){
1986
                    fprintf(stderr, "end missmatch left=%d\n", left);
1987
                    return -1;
1988
                }else
1989
                    goto eos;
1990
            }
1991
            
1992
            ff_init_block_index(s);
1993
        }
1994

    
1995
        /* skip mb handling */
1996
        if (s->mb_skip_run == -1) {
1997
            /* read again increment */
1998
            s->mb_skip_run = 0;
1999
            for(;;) {
2000
                int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
2001
                if (code < 0){
2002
                    fprintf(stderr, "mb incr damaged\n");
2003
                    return -1;
2004
                }
2005
                if (code >= 33) {
2006
                    if (code == 33) {
2007
                        s->mb_skip_run += 33;
2008
                    }else if(code == 35){
2009
                        if(s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0){
2010
                            fprintf(stderr, "slice missmatch\n");
2011
                            return -1;
2012
                        }
2013
                        goto eos; /* end of slice */
2014
                    }
2015
                    /* otherwise, stuffing, nothing to do */
2016
                } else {
2017
                    s->mb_skip_run += code;
2018
                    break;
2019
                }
2020
            }
2021
        }
2022
    }
2023
eos: // end of slice
2024
    *buf += get_bits_count(&s->gb)/8 - 1;
2025
//printf("y %d %d %d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
2026
    return 0;
2027
}
2028

    
2029
/**
2030
 * handles slice ends.
2031
 * @return 1 if it seems to be the last slice of 
2032
 */
2033
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
2034
{
2035
    Mpeg1Context *s1 = avctx->priv_data;
2036
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2037
       
2038
    if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
2039
        return 0;
2040

    
2041
#ifdef HAVE_XVMC
2042
    if(s->avctx->xvmc_acceleration)
2043
        XVMC_field_end(s);
2044
#endif
2045
    /* end of slice reached */
2046
    if (/*s->mb_y<<field_pic == s->mb_height &&*/ !s->first_field) {
2047
        /* end of image */
2048

    
2049
        if(s->mpeg2){
2050
            s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG2;
2051
        }else
2052
            s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG1;
2053

    
2054
        ff_er_frame_end(s);
2055

    
2056
        MPV_frame_end(s);
2057

    
2058
        if (s->pict_type == B_TYPE || s->low_delay) {
2059
            *pict= *(AVFrame*)s->current_picture_ptr;
2060
            ff_print_debug_info(s, s->current_picture_ptr);
2061
        } else {
2062
            s->picture_number++;
2063
            /* latency of 1 frame for I and P frames */
2064
            /* XXX: use another variable than picture_number */
2065
            if (s->last_picture_ptr != NULL) {
2066
                *pict= *(AVFrame*)s->last_picture_ptr;
2067
                 ff_print_debug_info(s, s->last_picture_ptr);
2068
            }
2069
        }
2070
        if(s->avctx->codec_tag == ff_get_fourcc("VCR2"))
2071
            exchange_uv(pict);
2072

    
2073
        return 1;
2074
    } else {
2075
        return 0;
2076
    }
2077
}
2078

    
2079
static int mpeg1_decode_sequence(AVCodecContext *avctx, 
2080
                                 uint8_t *buf, int buf_size)
2081
{
2082
    Mpeg1Context *s1 = avctx->priv_data;
2083
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2084
    int width, height, i, v, j;
2085
    float aspect;
2086

    
2087
    init_get_bits(&s->gb, buf, buf_size*8);
2088

    
2089
    width = get_bits(&s->gb, 12);
2090
    height = get_bits(&s->gb, 12);
2091
    s->aspect_ratio_info= get_bits(&s->gb, 4);
2092
    if(!s->mpeg2){
2093
        aspect= mpeg1_aspect[s->aspect_ratio_info];
2094
        if(aspect!=0.0) avctx->aspect_ratio= width/(aspect*height);
2095
    }
2096

    
2097
    s->frame_rate_index = get_bits(&s->gb, 4);
2098
    if (s->frame_rate_index == 0)
2099
        return -1;
2100
    s->bit_rate = get_bits(&s->gb, 18) * 400;
2101
    if (get_bits1(&s->gb) == 0) /* marker */
2102
        return -1;
2103
    if (width <= 0 || height <= 0 ||
2104
        (width % 2) != 0 || (height % 2) != 0)
2105
        return -1;
2106
    if (width != s->width ||
2107
        height != s->height) {
2108
        /* start new mpeg1 context decoding */
2109
        s->out_format = FMT_MPEG1;
2110
        if (s1->mpeg_enc_ctx_allocated) {
2111
            MPV_common_end(s);
2112
        }
2113
        s->width = width;
2114
        s->height = height;
2115
        avctx->has_b_frames= 1;
2116
        s->avctx = avctx;
2117
        avctx->width = width;
2118
        avctx->height = height;
2119
        av_reduce(
2120
            &avctx->frame_rate, 
2121
            &avctx->frame_rate_base,
2122
            frame_rate_tab[s->frame_rate_index],
2123
            MPEG1_FRAME_RATE_BASE, //FIXME store in allready reduced form 
2124
            1<<30
2125
            );
2126
        avctx->bit_rate = s->bit_rate;
2127
        
2128
        //get_format() or set_video(width,height,aspect,pix_fmt);
2129
        //until then pix_fmt may be changed right after codec init
2130
        if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT )
2131
            avctx->idct_algo = FF_IDCT_SIMPLE;
2132

    
2133
        if (MPV_common_init(s) < 0)
2134
            return -1;
2135
        s1->mpeg_enc_ctx_allocated = 1;
2136
    }
2137

    
2138
    skip_bits(&s->gb, 10); /* vbv_buffer_size */
2139
    skip_bits(&s->gb, 1);
2140

    
2141
    /* get matrix */
2142
    if (get_bits1(&s->gb)) {
2143
        for(i=0;i<64;i++) {
2144
            v = get_bits(&s->gb, 8);
2145
            j = s->intra_scantable.permutated[i];
2146
            s->intra_matrix[j] = v;
2147
            s->chroma_intra_matrix[j] = v;
2148
        }
2149
#ifdef DEBUG
2150
        dprintf("intra matrix present\n");
2151
        for(i=0;i<64;i++)
2152
            dprintf(" %d", s->intra_matrix[s->intra_scantable.permutated[i]]);
2153
        printf("\n");
2154
#endif
2155
    } else {
2156
        for(i=0;i<64;i++) {
2157
            int j= s->dsp.idct_permutation[i];
2158
            v = ff_mpeg1_default_intra_matrix[i];
2159
            s->intra_matrix[j] = v;
2160
            s->chroma_intra_matrix[j] = v;
2161
        }
2162
    }
2163
    if (get_bits1(&s->gb)) {
2164
        for(i=0;i<64;i++) {
2165
            v = get_bits(&s->gb, 8);
2166
            j = s->intra_scantable.permutated[i];
2167
            s->inter_matrix[j] = v;
2168
            s->chroma_inter_matrix[j] = v;
2169
        }
2170
#ifdef DEBUG
2171
        dprintf("non intra matrix present\n");
2172
        for(i=0;i<64;i++)
2173
            dprintf(" %d", s->inter_matrix[s->intra_scantable.permutated[i]]);
2174
        printf("\n");
2175
#endif
2176
    } else {
2177
        for(i=0;i<64;i++) {
2178
            int j= s->dsp.idct_permutation[i];
2179
            v = ff_mpeg1_default_non_intra_matrix[i];
2180
            s->inter_matrix[j] = v;
2181
            s->chroma_inter_matrix[j] = v;
2182
        }
2183
    }
2184

    
2185
    /* we set mpeg2 parameters so that it emulates mpeg1 */
2186
    s->progressive_sequence = 1;
2187
    s->progressive_frame = 1;
2188
    s->picture_structure = PICT_FRAME;
2189
    s->frame_pred_frame_dct = 1;
2190
    s->mpeg2 = 0;
2191
    avctx->sub_id = 1; /* indicates mpeg1 */
2192
    return 0;
2193
}
2194

    
2195
static int vcr2_init_sequence(AVCodecContext *avctx)
2196
{
2197
    Mpeg1Context *s1 = avctx->priv_data;
2198
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2199
    int i, v;
2200

    
2201
    /* start new mpeg1 context decoding */
2202
    s->out_format = FMT_MPEG1;
2203
    if (s1->mpeg_enc_ctx_allocated) {
2204
        MPV_common_end(s);
2205
    }
2206
    s->width = avctx->width;
2207
    s->height = avctx->height;
2208
    avctx->has_b_frames= 0; //true?
2209
    s->low_delay= 1;
2210
    s->avctx = avctx;
2211

    
2212
    //get_format() or set_video(width,height,aspect,pix_fmt);
2213
    //until then pix_fmt may be changed right after codec init
2214
    if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT )
2215
        avctx->idct_algo = FF_IDCT_SIMPLE;
2216
    
2217
    if (MPV_common_init(s) < 0)
2218
        return -1;
2219
    s1->mpeg_enc_ctx_allocated = 1;
2220

    
2221
    for(i=0;i<64;i++) {
2222
        int j= s->dsp.idct_permutation[i];
2223
        v = ff_mpeg1_default_intra_matrix[i];
2224
        s->intra_matrix[j] = v;
2225
        s->chroma_intra_matrix[j] = v;
2226

    
2227
        v = ff_mpeg1_default_non_intra_matrix[i];
2228
        s->inter_matrix[j] = v;
2229
        s->chroma_inter_matrix[j] = v;
2230
    }
2231

    
2232
    s->progressive_sequence = 1;
2233
    s->progressive_frame = 1;
2234
    s->picture_structure = PICT_FRAME;
2235
    s->frame_pred_frame_dct = 1;
2236
    s->mpeg2 = 1;
2237
    avctx->sub_id = 2; /* indicates mpeg2 */
2238
    return 0;
2239
}
2240

    
2241

    
2242
static void mpeg_decode_user_data(AVCodecContext *avctx, 
2243
                                  const uint8_t *buf, int buf_size)
2244
{
2245
    const uint8_t *p;
2246
    int len, flags;
2247
    p = buf;
2248
    len = buf_size;
2249

    
2250
    /* we parse the DTG active format information */
2251
    if (len >= 5 &&
2252
        p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2253
        flags = p[4];
2254
        p += 5;
2255
        len -= 5;
2256
        if (flags & 0x80) {
2257
            /* skip event id */
2258
            if (len < 2)
2259
                return;
2260
            p += 2;
2261
            len -= 2;
2262
        }
2263
        if (flags & 0x40) {
2264
            if (len < 1)
2265
                return;
2266
            avctx->dtg_active_format = p[0] & 0x0f;
2267
        }
2268
    }
2269
}
2270

    
2271
/**
2272
 * finds the end of the current frame in the bitstream.
2273
 * @return the position of the first byte of the next frame, or -1
2274
 */
2275
static int mpeg1_find_frame_end(MpegEncContext *s, uint8_t *buf, int buf_size){
2276
    ParseContext *pc= &s->parse_context;
2277
    int i;
2278
    uint32_t state;
2279
    
2280
    state= pc->state;
2281
    
2282
    i=0;
2283
    if(!pc->frame_start_found){
2284
        for(i=0; i<buf_size; i++){
2285
            state= (state<<8) | buf[i];
2286
            if(state >= SLICE_MIN_START_CODE && state <= SLICE_MAX_START_CODE){
2287
                i++;
2288
                pc->frame_start_found=1;
2289
                break;
2290
            }
2291
        }
2292
    }
2293
    
2294
    if(pc->frame_start_found){
2295
        for(; i<buf_size; i++){
2296
            state= (state<<8) | buf[i];
2297
            if((state&0xFFFFFF00) == 0x100){
2298
                if(state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE){
2299
                    pc->frame_start_found=0;
2300
                    pc->state=-1; 
2301
                    return i-3;
2302
                }
2303
            }
2304
        }
2305
    }        
2306
    pc->state= state;
2307
    return END_NOT_FOUND;
2308
}
2309

    
2310
/* handle buffering and image synchronisation */
2311
static int mpeg_decode_frame(AVCodecContext *avctx, 
2312
                             void *data, int *data_size,
2313
                             uint8_t *buf, int buf_size)
2314
{
2315
    Mpeg1Context *s = avctx->priv_data;
2316
    uint8_t *buf_end, *buf_ptr;
2317
    int ret, start_code, input_size;
2318
    AVFrame *picture = data;
2319
    MpegEncContext *s2 = &s->mpeg_enc_ctx;
2320
    dprintf("fill_buffer\n");
2321

    
2322
    *data_size = 0;
2323

    
2324
    /* special case for last picture */
2325
    if (buf_size == 0 && s2->low_delay==0 && s2->next_picture_ptr) {
2326
        *picture= *(AVFrame*)s2->next_picture_ptr;
2327
        s2->next_picture_ptr= NULL;
2328

    
2329
        *data_size = sizeof(AVFrame);
2330
        return 0;
2331
    }
2332

    
2333
    if(s2->flags&CODEC_FLAG_TRUNCATED){
2334
        int next= mpeg1_find_frame_end(s2, buf, buf_size);
2335
        
2336
        if( ff_combine_frame(s2, next, &buf, &buf_size) < 0 )
2337
            return buf_size;
2338
    }    
2339
    
2340
    buf_ptr = buf;
2341
    buf_end = buf + buf_size;
2342

    
2343
#if 0    
2344
    if (s->repeat_field % 2 == 1) { 
2345
        s->repeat_field++;
2346
        //fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number,
2347
        //        s2->picture_number, s->repeat_field);
2348
        if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) {
2349
            *data_size = sizeof(AVPicture);
2350
            goto the_end;
2351
        }
2352
    }
2353
#endif
2354

    
2355
    if(s->mpeg_enc_ctx_allocated==0 && avctx->codec_tag == ff_get_fourcc("VCR2"))
2356
        vcr2_init_sequence(avctx);
2357

    
2358
    for(;;) {
2359
        /* find start next code */
2360
        start_code = find_start_code(&buf_ptr, buf_end);
2361
        if (start_code < 0){
2362
            if (slice_end(avctx, picture)) {
2363
                if(s2->last_picture_ptr) //FIXME merge with the stuff in mpeg_decode_slice
2364
                    *data_size = sizeof(AVPicture);
2365
            }
2366
            return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2367
        }
2368
        
2369
        input_size = buf_end - buf_ptr;
2370

    
2371
        if(avctx->debug & FF_DEBUG_STARTCODE){
2372
            printf("%3X at %d left %d\n", start_code, buf_ptr-buf, input_size);
2373
        }
2374

    
2375
                /* prepare data for next start code */
2376
                switch(start_code) {
2377
                case SEQ_START_CODE:
2378
                    mpeg1_decode_sequence(avctx, buf_ptr, 
2379
                                          input_size);
2380
                    break;
2381
                            
2382
                case PICTURE_START_CODE:
2383
                    /* we have a complete image : we try to decompress it */
2384
                    mpeg1_decode_picture(avctx, 
2385
                                         buf_ptr, input_size);
2386
                    break;
2387
                case EXT_START_CODE:
2388
                    mpeg_decode_extension(avctx,
2389
                                          buf_ptr, input_size);
2390
                    break;
2391
                case USER_START_CODE:
2392
                    mpeg_decode_user_data(avctx, 
2393
                                          buf_ptr, input_size);
2394
                    break;
2395
                case GOP_START_CODE:
2396
                    s2->first_field=0;
2397
                    break;
2398
                default:
2399
                    if (start_code >= SLICE_MIN_START_CODE &&
2400
                        start_code <= SLICE_MAX_START_CODE) {
2401
                        
2402
                        /* skip b frames if we dont have reference frames */
2403
                        if(s2->last_picture_ptr==NULL && s2->pict_type==B_TYPE) break;
2404
                        /* skip b frames if we are in a hurry */
2405
                        if(avctx->hurry_up && s2->pict_type==B_TYPE) break;
2406
                        /* skip everything if we are in a hurry>=5 */
2407
                        if(avctx->hurry_up>=5) break;
2408
                        
2409
                        if (!s->mpeg_enc_ctx_allocated) break;
2410

    
2411
                        ret = mpeg_decode_slice(avctx, picture,
2412
                                                start_code, &buf_ptr, input_size);
2413
                        emms_c();
2414

    
2415
                        if(ret < 0){
2416
                            if(s2->resync_mb_x>=0 && s2->resync_mb_y>=0)
2417
                                ff_er_add_slice(s2, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x, s2->mb_y, AC_ERROR|DC_ERROR|MV_ERROR);
2418
                            if(ret==DECODE_SLICE_FATAL_ERROR) return -1;
2419
                        }else{
2420
                            ff_er_add_slice(s2, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x-1, s2->mb_y, AC_END|DC_END|MV_END);
2421
                        }
2422
                    }
2423
                    break;
2424
                }
2425
    }
2426
}
2427

    
2428
static int mpeg_decode_end(AVCodecContext *avctx)
2429
{
2430
    Mpeg1Context *s = avctx->priv_data;
2431

    
2432
    if (s->mpeg_enc_ctx_allocated)
2433
        MPV_common_end(&s->mpeg_enc_ctx);
2434
    return 0;
2435
}
2436

    
2437
AVCodec mpeg_decoder = {
2438
    "mpegvideo",
2439
    CODEC_TYPE_VIDEO,
2440
    CODEC_ID_MPEG1VIDEO,
2441
    sizeof(Mpeg1Context),
2442
    mpeg_decode_init,
2443
    NULL,
2444
    mpeg_decode_end,
2445
    mpeg_decode_frame,
2446
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
2447
    .flush= ff_mpeg_flush,
2448
};
2449

    
2450
#ifdef HAVE_XVMC
2451
static int mpeg_mc_decode_init(AVCodecContext *avctx){
2452
    Mpeg1Context *s;
2453

    
2454
    if( !(avctx->slice_flags & SLICE_FLAG_CODED_ORDER) )
2455
        return -1;
2456
    if( !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD) )
2457
        dprintf("mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
2458

    
2459
    mpeg_decode_init(avctx);
2460
    s = avctx->priv_data;
2461

    
2462
    avctx->pix_fmt = PIX_FMT_XVMC_MPEG2_IDCT;
2463
    avctx->xvmc_acceleration = 1;
2464

    
2465
    return 0;
2466
}
2467

    
2468
AVCodec mpeg_xvmc_decoder = {
2469
    "mpegvideo_xvmc",
2470
    CODEC_TYPE_VIDEO,
2471
    CODEC_ID_MPEG2VIDEO_XVMC,
2472
    sizeof(Mpeg1Context),
2473
    mpeg_mc_decode_init,
2474
    NULL,
2475
    mpeg_decode_end,
2476
    mpeg_decode_frame,
2477
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
2478
};
2479

    
2480
#endif