Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpeg12.c @ 2d5e962b

History | View | Annotate | Download (85.8 KB)

1 de6d9b64 Fabrice Bellard
/*
2 983e3246 Michael Niedermayer
 * MPEG1 codec / MPEG2 decoder
3 ff4ec49e Fabrice Bellard
 * Copyright (c) 2000,2001 Fabrice Bellard.
4 de6d9b64 Fabrice Bellard
 *
5 ff4ec49e Fabrice Bellard
 * 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 de6d9b64 Fabrice Bellard
 *
10 ff4ec49e Fabrice Bellard
 * This library is distributed in the hope that it will be useful,
11 de6d9b64 Fabrice Bellard
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 ff4ec49e Fabrice Bellard
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14 de6d9b64 Fabrice Bellard
 *
15 ff4ec49e Fabrice Bellard
 * 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 de6d9b64 Fabrice Bellard
 */
19 983e3246 Michael Niedermayer
 
20
/**
21
 * @file mpeg12.c
22 029911d1 Michael Niedermayer
 * MPEG1/2 codec
23 983e3246 Michael Niedermayer
 */
24
 
25 a74127c0 Fabrice Bellard
//#define DEBUG
26 de6d9b64 Fabrice Bellard
#include "avcodec.h"
27
#include "dsputil.h"
28
#include "mpegvideo.h"
29
30
#include "mpeg12data.h"
31
32 d87c0267 Michael Niedermayer
33 de6d9b64 Fabrice Bellard
/* 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 4f68b084 Michael Niedermayer
#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 de6d9b64 Fabrice Bellard
static void mpeg1_encode_block(MpegEncContext *s, 
52
                         DCTELEM *block, 
53
                         int component);
54 63b15e55 Michael Niedermayer
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code);    // RAL: f_code parameter added
55 de6d9b64 Fabrice Bellard
static void mpeg1_skip_picture(MpegEncContext *s, int pict_num);
56 a0201736 Michael Niedermayer
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 de6d9b64 Fabrice Bellard
                              DCTELEM *block, 
61
                              int n);
62 3729c912 Michael Niedermayer
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 
63 de6d9b64 Fabrice Bellard
                                        DCTELEM *block, 
64
                                        int n);
65 3729c912 Michael Niedermayer
static inline int mpeg2_decode_block_intra(MpegEncContext *s, 
66 de6d9b64 Fabrice Bellard
                                    DCTELEM *block, 
67
                                    int n);
68
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred);
69
70 2e7b4c84 Ivan Kalvachev
#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 c442d75c Michael Niedermayer
#ifdef CONFIG_ENCODERS
76 30952237 Michael Niedermayer
static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
77 0c1a9eda Zdenek Kabelac
static uint8_t fcode_tab[MAX_MV*2+1];
78 11ce8834 Michael Niedermayer
79 c442d75c Michael Niedermayer
static uint32_t uni_mpeg1_ac_vlc_bits[64*64*2];
80
static uint8_t  uni_mpeg1_ac_vlc_len [64*64*2];
81 2a250222 Michael Niedermayer
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 c442d75c Michael Niedermayer
#endif
89
90 4f68b084 Michael Niedermayer
static void init_2d_vlc_rl(RLTable *rl)
91
{
92 07787186 Dominik Mierzejewski
    int i;
93 4f68b084 Michael Niedermayer
    
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 a0201736 Michael Niedermayer
                run= 0;
117
                level= 127;
118 4f68b084 Michael Niedermayer
            }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 2a250222 Michael Niedermayer
#ifdef CONFIG_ENCODERS
130 c442d75c Michael Niedermayer
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 4f68b084 Michael Niedermayer
176 de6d9b64 Fabrice Bellard
static void put_header(MpegEncContext *s, int header)
177
{
178
    align_put_bits(&s->pb);
179 80feb2a2 Michael Niedermayer
    put_bits(&s->pb, 16, header>>16);
180
    put_bits(&s->pb, 16, header&0xFFFF);
181 de6d9b64 Fabrice Bellard
}
182
183
/* put sequence header if needed */
184
static void mpeg1_encode_sequence_header(MpegEncContext *s)
185
{
186
        unsigned int vbv_buffer_size;
187 d78647e8 Fabrice Bellard
        unsigned int fps, v;
188 426b8061 Michael Niedermayer
        int n, i;
189 0c1a9eda Zdenek Kabelac
        uint64_t time_code;
190 426b8061 Michael Niedermayer
        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 de6d9b64 Fabrice Bellard
        
195 1e491e29 Michael Niedermayer
        if (s->current_picture.key_frame) {
196 de6d9b64 Fabrice Bellard
            /* 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 14bea432 Michael Niedermayer
                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 de6d9b64 Fabrice Bellard
                    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 426b8061 Michael Niedermayer
            
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 de6d9b64 Fabrice Bellard
            put_bits(&s->pb, 4, s->frame_rate_index);
230 b536d0aa Michael Niedermayer
            v = (s->bit_rate + 399) / 400;
231 029911d1 Michael Niedermayer
            if (v > 0x3ffff && s->codec_id == CODEC_ID_MPEG1VIDEO)
232 de6d9b64 Fabrice Bellard
                v = 0x3ffff;
233 029911d1 Michael Niedermayer
            put_bits(&s->pb, 18, v & 0x3FFFF);
234 de6d9b64 Fabrice Bellard
            put_bits(&s->pb, 1, 1); /* marker */
235 ecfd40b3 Henry Mason
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 029911d1 Michael Niedermayer
            put_bits(&s->pb, 10, ((vbv_buffer_size + 16383) / 16384) & 0x3FF); 
242 de6d9b64 Fabrice Bellard
            put_bits(&s->pb, 1, 1); /* constrained parameter flag */
243 d6eb3c50 Michael Niedermayer
            
244
            ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
245
            ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
246 de6d9b64 Fabrice Bellard
247 029911d1 Michael Niedermayer
            if(s->codec_id == CODEC_ID_MPEG2VIDEO){
248
                put_header(s, EXT_START_CODE);
249
                put_bits(&s->pb, 4, 1); //seq ext
250
                put_bits(&s->pb, 1, 0); //esc
251
                put_bits(&s->pb, 3, 4); //profile
252
                put_bits(&s->pb, 4, 8); //level
253
                put_bits(&s->pb, 1, s->progressive_sequence=1);
254
                put_bits(&s->pb, 2, 1); //chroma format 4:2:0
255
                put_bits(&s->pb, 2, 0); //horizontal size ext
256
                put_bits(&s->pb, 2, 0); //vertical size ext
257
                put_bits(&s->pb, 12, v>>18); //bitrate ext
258
                put_bits(&s->pb, 1, 1); //marker
259
                put_bits(&s->pb, 8, vbv_buffer_size >>10); //vbv buffer ext
260
                put_bits(&s->pb, 1, s->low_delay);
261
                put_bits(&s->pb, 2, 0); // frame_rate_ext_n
262
                put_bits(&s->pb, 5, 0); // frame_rate_ext_d
263
            }
264
            
265 de6d9b64 Fabrice Bellard
            put_header(s, GOP_START_CODE);
266
            put_bits(&s->pb, 1, 0); /* do drop frame */
267
            /* time code : we must convert from the real frame rate to a
268
               fake mpeg frame rate in case of low frame rate */
269
            fps = frame_rate_tab[s->frame_rate_index];
270 14bea432 Michael Niedermayer
            time_code = (int64_t)s->fake_picture_number * MPEG1_FRAME_RATE_BASE;
271 de6d9b64 Fabrice Bellard
            s->gop_picture_number = s->fake_picture_number;
272 0c1a9eda Zdenek Kabelac
            put_bits(&s->pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24));
273
            put_bits(&s->pb, 6, (uint32_t)((time_code / (fps * 60)) % 60));
274 de6d9b64 Fabrice Bellard
            put_bits(&s->pb, 1, 1);
275 0c1a9eda Zdenek Kabelac
            put_bits(&s->pb, 6, (uint32_t)((time_code / fps) % 60));
276 14bea432 Michael Niedermayer
            put_bits(&s->pb, 6, (uint32_t)((time_code % fps) / MPEG1_FRAME_RATE_BASE));
277 de6d9b64 Fabrice Bellard
            put_bits(&s->pb, 1, 1); /* closed gop */
278
            put_bits(&s->pb, 1, 0); /* broken link */
279
        }
280
281 14bea432 Michael Niedermayer
        if (s->avctx->frame_rate < (24 * s->avctx->frame_rate_base) && s->picture_number > 0) {
282 de6d9b64 Fabrice Bellard
            /* insert empty P pictures to slow down to the desired
283
               frame rate. Each fake pictures takes about 20 bytes */
284
            fps = frame_rate_tab[s->frame_rate_index];
285 14bea432 Michael Niedermayer
            n = av_rescale((int64_t)s->picture_number * s->avctx->frame_rate_base, fps, s->avctx->frame_rate) / MPEG1_FRAME_RATE_BASE - 1;
286 de6d9b64 Fabrice Bellard
            while (s->fake_picture_number < n) {
287
                mpeg1_skip_picture(s, s->fake_picture_number - 
288
                                   s->gop_picture_number); 
289
                s->fake_picture_number++;
290
            }
291
292
        }
293
}
294
295 9b8709d1 Michael Niedermayer
static inline void encode_mb_skip_run(MpegEncContext *s, int run){
296
    while (run >= 33) {
297
        put_bits(&s->pb, 11, 0x008);
298
        run -= 33;
299
    }
300
    put_bits(&s->pb, mbAddrIncrTable[run][1], 
301
             mbAddrIncrTable[run][0]);
302
}
303 de6d9b64 Fabrice Bellard
304
/* insert a fake P picture */
305
static void mpeg1_skip_picture(MpegEncContext *s, int pict_num)
306
{
307 029911d1 Michael Niedermayer
    assert(s->codec_id == CODEC_ID_MPEG1VIDEO); // mpeg2 can do these repeat things
308
309 de6d9b64 Fabrice Bellard
    /* mpeg1 picture header */
310
    put_header(s, PICTURE_START_CODE);
311
    /* temporal reference */
312
    put_bits(&s->pb, 10, pict_num & 0x3ff); 
313
    
314
    put_bits(&s->pb, 3, P_TYPE);
315
    put_bits(&s->pb, 16, 0xffff); /* non constant bit rate */
316
    
317
    put_bits(&s->pb, 1, 1); /* integer coordinates */
318
    put_bits(&s->pb, 3, 1); /* forward_f_code */
319
    
320
    put_bits(&s->pb, 1, 0); /* extra bit picture */
321
    
322
    /* only one slice */
323
    put_header(s, SLICE_MIN_START_CODE);
324
    put_bits(&s->pb, 5, 1); /* quantizer scale */
325
    put_bits(&s->pb, 1, 0); /* slice extra information */
326
    
327 9b8709d1 Michael Niedermayer
    encode_mb_skip_run(s, 0);
328 de6d9b64 Fabrice Bellard
    
329
    /* empty macroblock */
330
    put_bits(&s->pb, 3, 1); /* motion only */
331
    
332
    /* zero motion x & y */
333
    put_bits(&s->pb, 1, 1); 
334
    put_bits(&s->pb, 1, 1); 
335
336
    /* output a number of empty slice */
337 9b8709d1 Michael Niedermayer
    encode_mb_skip_run(s, s->mb_width * s->mb_height - 2);
338 de6d9b64 Fabrice Bellard
    
339
    /* empty macroblock */
340
    put_bits(&s->pb, 3, 1); /* motion only */
341
    
342
    /* zero motion x & y */
343
    put_bits(&s->pb, 1, 1); 
344
    put_bits(&s->pb, 1, 1); 
345
}
346 2a250222 Michael Niedermayer
#endif
347 de6d9b64 Fabrice Bellard
348 8f8402e4 Michael Niedermayer
static void common_init(MpegEncContext *s)
349 de6d9b64 Fabrice Bellard
{
350 8f8402e4 Michael Niedermayer
    s->y_dc_scale_table=
351
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
352
}
353 f004ca1c Michael Niedermayer
354 2a250222 Michael Niedermayer
void ff_mpeg1_clean_buffers(MpegEncContext *s){
355
    s->last_dc[0] = 1 << (7 + s->intra_dc_precision);
356
    s->last_dc[1] = s->last_dc[0];
357
    s->last_dc[2] = s->last_dc[0];
358
    memset(s->last_mv, 0, sizeof(s->last_mv));
359
}
360
361 7604246d Wolfgang Hesseler
#ifdef CONFIG_ENCODERS
362 9b8709d1 Michael Niedermayer
363
void ff_mpeg1_encode_slice_header(MpegEncContext *s){
364
    put_header(s, SLICE_MIN_START_CODE + s->mb_y);
365
    put_bits(&s->pb, 5, s->qscale); /* quantizer scale */
366
    put_bits(&s->pb, 1, 0); /* slice extra information */
367
}
368
369 8f8402e4 Michael Niedermayer
void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
370
{
371 de6d9b64 Fabrice Bellard
    mpeg1_encode_sequence_header(s);
372
373
    /* mpeg1 picture header */
374
    put_header(s, PICTURE_START_CODE);
375
    /* temporal reference */
376 63b15e55 Michael Niedermayer
377
    // RAL: s->picture_number instead of s->fake_picture_number
378
    put_bits(&s->pb, 10, (s->picture_number - 
379 de6d9b64 Fabrice Bellard
                          s->gop_picture_number) & 0x3ff); 
380 af469427 Juanjo
    s->fake_picture_number++;
381 de6d9b64 Fabrice Bellard
    
382
    put_bits(&s->pb, 3, s->pict_type);
383
    put_bits(&s->pb, 16, 0xffff); /* non constant bit rate */
384
    
385 63b15e55 Michael Niedermayer
    // RAL: Forward f_code also needed for B frames
386
    if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
387 de6d9b64 Fabrice Bellard
        put_bits(&s->pb, 1, 0); /* half pel coordinates */
388
        put_bits(&s->pb, 3, s->f_code); /* forward_f_code */
389
    }
390
    
391 63b15e55 Michael Niedermayer
    // RAL: Backward f_code necessary for B frames
392
    if (s->pict_type == B_TYPE) {
393
        put_bits(&s->pb, 1, 0); /* half pel coordinates */
394
        put_bits(&s->pb, 3, s->b_code); /* backward_f_code */
395 029911d1 Michael Niedermayer
    }
396 63b15e55 Michael Niedermayer
397 de6d9b64 Fabrice Bellard
    put_bits(&s->pb, 1, 0); /* extra bit picture */
398
    
399 029911d1 Michael Niedermayer
    if(s->codec_id == CODEC_ID_MPEG2VIDEO){
400
        put_header(s, EXT_START_CODE);
401
        put_bits(&s->pb, 4, 8); //pic ext
402
        put_bits(&s->pb, 4, s->f_code);
403
        put_bits(&s->pb, 4, s->f_code);
404
        put_bits(&s->pb, 4, s->b_code);
405
        put_bits(&s->pb, 4, s->b_code);
406
        put_bits(&s->pb, 2, s->intra_dc_precision);
407
        put_bits(&s->pb, 2, s->picture_structure= PICT_FRAME);
408
        put_bits(&s->pb, 1, s->top_field_first);
409
        put_bits(&s->pb, 1, s->frame_pred_frame_dct= 1);
410
        put_bits(&s->pb, 1, s->concealment_motion_vectors);
411
        put_bits(&s->pb, 1, s->q_scale_type);
412
        put_bits(&s->pb, 1, s->intra_vlc_format);
413
        put_bits(&s->pb, 1, s->alternate_scan);
414
        put_bits(&s->pb, 1, s->repeat_first_field);
415
        put_bits(&s->pb, 1, s->chroma_420_type=1);
416
        put_bits(&s->pb, 1, s->progressive_frame=1);
417
        put_bits(&s->pb, 1, 0); //composite_display_flag
418
    }
419
    
420 9b8709d1 Michael Niedermayer
    s->mb_y=0;
421
    ff_mpeg1_encode_slice_header(s);
422 de6d9b64 Fabrice Bellard
}
423
424
void mpeg1_encode_mb(MpegEncContext *s,
425
                     DCTELEM block[6][64],
426
                     int motion_x, int motion_y)
427
{
428 9b8709d1 Michael Niedermayer
    int i, cbp;
429
    const int mb_x = s->mb_x;
430
    const int mb_y = s->mb_y;
431
    const int first_mb= mb_x == s->resync_mb_x && mb_y == s->resync_mb_y;
432 de6d9b64 Fabrice Bellard
433
    /* compute cbp */
434
    cbp = 0;
435
    for(i=0;i<6;i++) {
436
        if (s->block_last_index[i] >= 0)
437
            cbp |= 1 << (5 - i);
438
    }
439
440 029911d1 Michael Niedermayer
    if (cbp == 0 && !first_mb && (mb_x != s->mb_width - 1 || (mb_y != s->mb_height - 1 && s->codec_id == CODEC_ID_MPEG1VIDEO)) && 
441 63b15e55 Michael Niedermayer
        ((s->pict_type == P_TYPE && (motion_x | motion_y) == 0) ||
442
        (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) |
443
        ((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))) {
444 9b8709d1 Michael Niedermayer
        s->mb_skip_run++;
445 d87c0267 Michael Niedermayer
        s->qscale -= s->dquant;
446 49733979 Michael Niedermayer
        s->skip_count++;
447
        s->misc_bits++;
448
        s->last_bits++;
449 de6d9b64 Fabrice Bellard
    } else {
450 9b8709d1 Michael Niedermayer
        if(first_mb){
451
            assert(s->mb_skip_run == 0);
452
            encode_mb_skip_run(s, s->mb_x);
453
        }else{
454
            encode_mb_skip_run(s, s->mb_skip_run);
455 de6d9b64 Fabrice Bellard
        }
456
        
457
        if (s->pict_type == I_TYPE) {
458 d87c0267 Michael Niedermayer
            if(s->dquant && cbp){
459
                put_bits(&s->pb, 2, 1); /* macroblock_type : macroblock_quant = 1 */
460
                put_bits(&s->pb, 5, s->qscale);
461
            }else{
462
                put_bits(&s->pb, 1, 1); /* macroblock_type : macroblock_quant = 0 */
463
                s->qscale -= s->dquant;
464
            }
465 49733979 Michael Niedermayer
            s->misc_bits+= get_bits_diff(s);
466
            s->i_count++;
467 63b15e55 Michael Niedermayer
        } else if (s->mb_intra) {
468
            if(s->dquant && cbp){
469
                put_bits(&s->pb, 6, 0x01);
470
                put_bits(&s->pb, 5, s->qscale);
471
            }else{
472
                put_bits(&s->pb, 5, 0x03);
473
                s->qscale -= s->dquant;
474
            }
475
            s->misc_bits+= get_bits_diff(s);
476
            s->i_count++;
477
            s->last_mv[0][0][0] = 
478
            s->last_mv[0][0][1] = 0;
479
        } else if (s->pict_type == P_TYPE) { 
480 de6d9b64 Fabrice Bellard
                if (cbp != 0) {
481
                    if (motion_x == 0 && motion_y == 0) {
482 d87c0267 Michael Niedermayer
                        if(s->dquant){
483
                            put_bits(&s->pb, 5, 1); /* macroblock_pattern & quant */
484
                            put_bits(&s->pb, 5, s->qscale);
485
                        }else{
486
                            put_bits(&s->pb, 2, 1); /* macroblock_pattern only */
487
                        }
488 49733979 Michael Niedermayer
                        s->misc_bits+= get_bits_diff(s);
489 de6d9b64 Fabrice Bellard
                        put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
490
                    } else {
491 d87c0267 Michael Niedermayer
                        if(s->dquant){
492
                            put_bits(&s->pb, 5, 2); /* motion + cbp */
493
                            put_bits(&s->pb, 5, s->qscale);
494
                        }else{
495
                            put_bits(&s->pb, 1, 1); /* motion + cbp */
496
                        }
497 49733979 Michael Niedermayer
                        s->misc_bits+= get_bits_diff(s);
498 63b15e55 Michael Niedermayer
                        mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);    // RAL: f_code parameter added
499
                        mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);    // RAL: f_code parameter added
500 49733979 Michael Niedermayer
                        s->mv_bits+= get_bits_diff(s);
501 de6d9b64 Fabrice Bellard
                        put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
502
                    }
503
                } else {
504
                    put_bits(&s->pb, 3, 1); /* motion only */
505 63b15e55 Michael Niedermayer
                    mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);    // RAL: f_code parameter added
506
                    mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);    // RAL: f_code parameter added
507 d87c0267 Michael Niedermayer
                    s->qscale -= s->dquant;
508 49733979 Michael Niedermayer
                    s->mv_bits+= get_bits_diff(s);
509 de6d9b64 Fabrice Bellard
                }
510 49733979 Michael Niedermayer
                s->f_count++;
511 63b15e55 Michael Niedermayer
        } else
512
            {    // RAL: All the following bloc added for B frames:
513
                if (cbp != 0)
514
                    {    // With coded bloc pattern
515
                    if (s->mv_dir == (MV_DIR_FORWARD | MV_DIR_BACKWARD))
516
                        {    // Bi-directional motion
517
                        if (s->dquant)
518
                            {    // With QScale
519
                            put_bits(&s->pb, 5, 2);
520
                            put_bits(&s->pb, 5, s->qscale);
521
                            }
522
                        else    // Without QScale
523
                            put_bits(&s->pb, 2, 3);
524
                        s->misc_bits += get_bits_diff(s);
525
                        mpeg1_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
526
                        mpeg1_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
527
                        mpeg1_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
528
                        mpeg1_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
529
                        s->b_count++;
530
                        s->f_count++;
531
                        s->mv_bits += get_bits_diff(s);
532
                        put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
533
                        }
534
                    else if (s->mv_dir == MV_DIR_BACKWARD)
535
                        {    // Backward motion
536
                        if (s->dquant)
537
                            {    // With QScale
538
                            put_bits(&s->pb, 6, 2);
539
                            put_bits(&s->pb, 5, s->qscale);
540
                            }
541
                        else    // Without QScale
542
                            put_bits(&s->pb, 3, 3);
543
                        s->misc_bits += get_bits_diff(s);
544
                        mpeg1_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code); 
545
                        mpeg1_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code); 
546
                        s->b_count++;
547
                        s->mv_bits += get_bits_diff(s);
548
                        put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
549
                        }
550
                    else if (s->mv_dir == MV_DIR_FORWARD)
551
                        {    // Forward motion
552
                        if (s->dquant)
553
                            {    // With QScale
554
                            put_bits(&s->pb, 6, 3);
555
                            put_bits(&s->pb, 5, s->qscale);
556
                            }
557
                        else    // Without QScale
558
                            put_bits(&s->pb, 4, 3);
559
                        s->misc_bits += get_bits_diff(s);
560
                        mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code); 
561
                        mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code); 
562
                        s->f_count++;
563
                        s->mv_bits += get_bits_diff(s);
564
                        put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
565
                        }
566
                    }
567
                else
568
                    {    // No coded bloc pattern
569
                    if (s->mv_dir == (MV_DIR_FORWARD | MV_DIR_BACKWARD))
570 7604246d Wolfgang Hesseler
                        {    // Bi-directional motion 
571 63b15e55 Michael Niedermayer
                        put_bits(&s->pb, 2, 2); /* backward & forward motion */
572
                        mpeg1_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
573
                        mpeg1_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
574
                        mpeg1_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
575
                        mpeg1_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
576
                        s->b_count++;
577
                        s->f_count++;
578
                        }
579
                    else if (s->mv_dir == MV_DIR_BACKWARD)
580
                        {    // Backward motion
581
                        put_bits(&s->pb, 3, 2); /* backward motion only */
582
                        mpeg1_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code); 
583
                        mpeg1_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code); 
584
                        s->b_count++;
585
                        }
586
                    else if (s->mv_dir == MV_DIR_FORWARD)
587
                        {    // Forward motion
588
                        put_bits(&s->pb, 4, 2); /* forward motion only */
589
                        mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code); 
590
                        mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code); 
591
                        s->f_count++;
592
                        }
593
                    s->qscale -= s->dquant;
594
                    s->mv_bits += get_bits_diff(s);
595
                    }
596
            // End of bloc from RAL
597 de6d9b64 Fabrice Bellard
            }
598
        for(i=0;i<6;i++) {
599
            if (cbp & (1 << (5 - i))) {
600
                mpeg1_encode_block(s, block[i], i);
601
            }
602
        }
603 9b8709d1 Michael Niedermayer
        s->mb_skip_run = 0;
604 49733979 Michael Niedermayer
        if(s->mb_intra)
605
            s->i_tex_bits+= get_bits_diff(s);
606
        else
607
            s->p_tex_bits+= get_bits_diff(s);
608 de6d9b64 Fabrice Bellard
    }
609 63b15e55 Michael Niedermayer
610
    // RAL: By this:
611
    if (s->mv_dir & MV_DIR_FORWARD)
612
        {
613
        s->last_mv[0][0][0]= s->mv[0][0][0];
614
        s->last_mv[0][0][1]= s->mv[0][0][1];
615
        }
616
    if (s->mv_dir & MV_DIR_BACKWARD)
617
        {
618
        s->last_mv[1][0][0]= s->mv[1][0][0];
619
        s->last_mv[1][0][1]= s->mv[1][0][1];
620
        }
621 de6d9b64 Fabrice Bellard
}
622
623 63b15e55 Michael Niedermayer
// RAL: Parameter added: f_or_b_code
624
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code)
625 de6d9b64 Fabrice Bellard
{
626
    int code, bit_size, l, m, bits, range, sign;
627
628
    if (val == 0) {
629
        /* zero vector */
630
        code = 0;
631
        put_bits(&s->pb,
632
                 mbMotionVectorTable[0][1], 
633
                 mbMotionVectorTable[0][0]); 
634
    } else {
635 63b15e55 Michael Niedermayer
        bit_size = f_or_b_code - 1;
636 de6d9b64 Fabrice Bellard
        range = 1 << bit_size;
637
        /* modulo encoding */
638
        l = 16 * range;
639
        m = 2 * l;
640
        if (val < -l) {
641
            val += m;
642
        } else if (val >= l) {
643
            val -= m;
644
        }
645
646
        if (val >= 0) {
647
            val--;
648
            code = (val >> bit_size) + 1;
649
            bits = val & (range - 1);
650
            sign = 0;
651
        } else {
652
            val = -val;
653
            val--;
654
            code = (val >> bit_size) + 1;
655
            bits = val & (range - 1);
656
            sign = 1;
657
        }
658 63b15e55 Michael Niedermayer
659
        assert(code > 0 && code <= 16);
660
661 de6d9b64 Fabrice Bellard
        put_bits(&s->pb,
662
                 mbMotionVectorTable[code][1], 
663
                 mbMotionVectorTable[code][0]); 
664 63b15e55 Michael Niedermayer
665 de6d9b64 Fabrice Bellard
        put_bits(&s->pb, 1, sign);
666
        if (bit_size > 0) {
667
            put_bits(&s->pb, bit_size, bits);
668
        }
669
    }
670
}
671
672 8f8402e4 Michael Niedermayer
void ff_mpeg1_encode_init(MpegEncContext *s)
673 11ce8834 Michael Niedermayer
{
674
    static int done=0;
675 8f8402e4 Michael Niedermayer
676
    common_init(s);
677
678 11ce8834 Michael Niedermayer
    if(!done){
679
        int f_code;
680
        int mv;
681 8f8402e4 Michael Niedermayer
        int i;
682 11ce8834 Michael Niedermayer
683
        done=1;
684 8f8402e4 Michael Niedermayer
        init_rl(&rl_mpeg1);
685 c442d75c Michael Niedermayer
686 8f8402e4 Michael Niedermayer
        for(i=0; i<64; i++)
687
        {
688
                mpeg1_max_level[0][i]= rl_mpeg1.max_level[0][i];
689
                mpeg1_index_run[0][i]= rl_mpeg1.index_run[0][i];
690
        }
691 c442d75c Michael Niedermayer
        
692
        init_uni_ac_vlc(&rl_mpeg1, uni_mpeg1_ac_vlc_bits, uni_mpeg1_ac_vlc_len);
693 8f8402e4 Michael Niedermayer
694
        /* build unified dc encoding tables */
695
        for(i=-255; i<256; i++)
696
        {
697
                int adiff, index;
698
                int bits, code;
699
                int diff=i;
700
701
                adiff = ABS(diff);
702
                if(diff<0) diff--;
703
                index = vlc_dc_table[adiff];
704
705
                bits= vlc_dc_lum_bits[index] + index;
706
                code= (vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1));
707
                mpeg1_lum_dc_uni[i+255]= bits + (code<<8);
708
                
709
                bits= vlc_dc_chroma_bits[index] + index;
710
                code= (vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1));
711
                mpeg1_chr_dc_uni[i+255]= bits + (code<<8);
712
        }
713
714 30952237 Michael Niedermayer
        mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
715
716 11ce8834 Michael Niedermayer
        for(f_code=1; f_code<=MAX_FCODE; f_code++){
717
            for(mv=-MAX_MV; mv<=MAX_MV; mv++){
718
                int len;
719
720
                if(mv==0) len= mbMotionVectorTable[0][1];
721
                else{
722
                    int val, bit_size, range, code;
723
724
                    bit_size = s->f_code - 1;
725
                    range = 1 << bit_size;
726
727
                    val=mv;
728
                    if (val < 0) 
729
                        val = -val;
730
                    val--;
731
                    code = (val >> bit_size) + 1;
732
                    if(code<17){
733
                        len= mbMotionVectorTable[code][1] + 1 + bit_size;
734
                    }else{
735
                        len= mbMotionVectorTable[16][1] + 2 + bit_size;
736
                    }
737
                }
738
739
                mv_penalty[f_code][mv+MAX_MV]= len;
740
            }
741
        }
742
        
743
744
        for(f_code=MAX_FCODE; f_code>0; f_code--){
745
            for(mv=-(8<<f_code); mv<(8<<f_code); mv++){
746
                fcode_tab[mv+MAX_MV]= f_code;
747
            }
748
        }
749
    }
750 1457ab52 Michael Niedermayer
    s->me.mv_penalty= mv_penalty;
751 11ce8834 Michael Niedermayer
    s->fcode_tab= fcode_tab;
752 029911d1 Michael Niedermayer
    if(s->codec_id == CODEC_ID_MPEG1VIDEO){
753
        s->min_qcoeff=-255;
754
        s->max_qcoeff= 255;
755
    }else{
756
        s->min_qcoeff=-2047;
757
        s->max_qcoeff= 2047;
758
    }
759 c442d75c Michael Niedermayer
    s->intra_ac_vlc_length=
760
    s->inter_ac_vlc_length= uni_mpeg1_ac_vlc_len;
761 11ce8834 Michael Niedermayer
}
762 8f8402e4 Michael Niedermayer
763 de6d9b64 Fabrice Bellard
static inline void encode_dc(MpegEncContext *s, int diff, int component)
764
{
765
    if (component == 0) {
766 f004ca1c Michael Niedermayer
        put_bits(
767
            &s->pb, 
768
            mpeg1_lum_dc_uni[diff+255]&0xFF,
769
            mpeg1_lum_dc_uni[diff+255]>>8);
770 de6d9b64 Fabrice Bellard
    } else {
771 f004ca1c Michael Niedermayer
        put_bits(
772
            &s->pb, 
773
            mpeg1_chr_dc_uni[diff+255]&0xFF,
774
            mpeg1_chr_dc_uni[diff+255]>>8);
775 de6d9b64 Fabrice Bellard
    }
776
}
777
778
static void mpeg1_encode_block(MpegEncContext *s, 
779
                               DCTELEM *block, 
780
                               int n)
781
{
782
    int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;
783
    int code, component;
784 80feb2a2 Michael Niedermayer
//    RLTable *rl = &rl_mpeg1;
785 de6d9b64 Fabrice Bellard
786
    last_index = s->block_last_index[n];
787
788
    /* DC coef */
789
    if (s->mb_intra) {
790
        component = (n <= 3 ? 0 : n - 4 + 1);
791
        dc = block[0]; /* overflow is impossible */
792
        diff = dc - s->last_dc[component];
793
        encode_dc(s, diff, component);
794
        s->last_dc[component] = dc;
795
        i = 1;
796 029911d1 Michael Niedermayer
/*
797
        if (s->intra_vlc_format)
798
            rl = &rl_mpeg2;
799
        else
800
            rl = &rl_mpeg1;
801
*/
802 de6d9b64 Fabrice Bellard
    } else {
803
        /* encode the first coefficient : needs to be done here because
804
           it is handled slightly differently */
805
        level = block[0];
806
        if (abs(level) == 1) {
807 0c1a9eda Zdenek Kabelac
                code = ((uint32_t)level >> 31); /* the sign bit */
808 de6d9b64 Fabrice Bellard
                put_bits(&s->pb, 2, code | 0x02);
809
                i = 1;
810
        } else {
811
            i = 0;
812
            last_non_zero = -1;
813
            goto next_coef;
814
        }
815
    }
816
817
    /* now quantify & encode AC coefs */
818
    last_non_zero = i - 1;
819 80feb2a2 Michael Niedermayer
820 de6d9b64 Fabrice Bellard
    for(;i<=last_index;i++) {
821 2ad1516a Michael Niedermayer
        j = s->intra_scantable.permutated[i];
822 de6d9b64 Fabrice Bellard
        level = block[j];
823
    next_coef:
824
#if 0
825
        if (level != 0)
826
            dprintf("level[%d]=%d\n", i, level);
827
#endif            
828
        /* encode using VLC */
829
        if (level != 0) {
830
            run = i - last_non_zero - 1;
831 2ad1516a Michael Niedermayer
            
832
            alevel= level;
833
            MASK_ABS(sign, alevel)
834
            sign&=1;
835
836 80feb2a2 Michael Niedermayer
//            code = get_rl_index(rl, 0, run, alevel);
837 c442d75c Michael Niedermayer
            if (alevel <= mpeg1_max_level[0][run]){
838 80feb2a2 Michael Niedermayer
                code= mpeg1_index_run[0][run] + alevel - 1;
839
                    /* store the vlc & sign at once */
840
                put_bits(&s->pb, mpeg1_vlc[code][1]+1, (mpeg1_vlc[code][0]<<1) + sign);
841 de6d9b64 Fabrice Bellard
            } else {
842 80feb2a2 Michael Niedermayer
                /* escape seems to be pretty rare <5% so i dont optimize it */
843
                put_bits(&s->pb, mpeg1_vlc[111/*rl->n*/][1], mpeg1_vlc[111/*rl->n*/][0]);
844 de6d9b64 Fabrice Bellard
                /* escape: only clip in this case */
845
                put_bits(&s->pb, 6, run);
846 029911d1 Michael Niedermayer
                if(s->codec_id == CODEC_ID_MPEG1VIDEO){
847
                    if (alevel < 128) {
848
                        put_bits(&s->pb, 8, level & 0xff);
849 de6d9b64 Fabrice Bellard
                    } else {
850 029911d1 Michael Niedermayer
                        if (level < 0) {
851
                            put_bits(&s->pb, 16, 0x8001 + level + 255);
852
                        } else {
853
                            put_bits(&s->pb, 16, level & 0xffff);
854
                        }
855 de6d9b64 Fabrice Bellard
                    }
856 029911d1 Michael Niedermayer
                }else{
857
                    put_bits(&s->pb, 12, level & 0xfff);
858 de6d9b64 Fabrice Bellard
                }
859
            }
860
            last_non_zero = i;
861
        }
862
    }
863
    /* end of block */
864
    put_bits(&s->pb, 2, 0x2);
865
}
866 7604246d Wolfgang Hesseler
#endif //CONFIG_ENCODERS
867 de6d9b64 Fabrice Bellard
868
/******************************************/
869
/* decoding */
870
871
static VLC dc_lum_vlc;
872
static VLC dc_chroma_vlc;
873
static VLC mv_vlc;
874
static VLC mbincr_vlc;
875
static VLC mb_ptype_vlc;
876
static VLC mb_btype_vlc;
877
static VLC mb_pat_vlc;
878
879 c3bf0288 Michael Niedermayer
static void init_vlcs()
880 de6d9b64 Fabrice Bellard
{
881
    static int done = 0;
882
883
    if (!done) {
884 915bbac6 Fabrice Bellard
        done = 1;
885 de6d9b64 Fabrice Bellard
886 9ac7ecd6 Michael Niedermayer
        init_vlc(&dc_lum_vlc, DC_VLC_BITS, 12, 
887 de6d9b64 Fabrice Bellard
                 vlc_dc_lum_bits, 1, 1,
888
                 vlc_dc_lum_code, 2, 2);
889 9ac7ecd6 Michael Niedermayer
        init_vlc(&dc_chroma_vlc,  DC_VLC_BITS, 12, 
890 de6d9b64 Fabrice Bellard
                 vlc_dc_chroma_bits, 1, 1,
891
                 vlc_dc_chroma_code, 2, 2);
892 8ed2ddb2 Michael Niedermayer
        init_vlc(&mv_vlc, MV_VLC_BITS, 17, 
893 de6d9b64 Fabrice Bellard
                 &mbMotionVectorTable[0][1], 2, 1,
894
                 &mbMotionVectorTable[0][0], 2, 1);
895 9c00c3af Michael Niedermayer
        init_vlc(&mbincr_vlc, MBINCR_VLC_BITS, 36, 
896 de6d9b64 Fabrice Bellard
                 &mbAddrIncrTable[0][1], 2, 1,
897
                 &mbAddrIncrTable[0][0], 2, 1);
898 8ed2ddb2 Michael Niedermayer
        init_vlc(&mb_pat_vlc, MB_PAT_VLC_BITS, 63, 
899 de6d9b64 Fabrice Bellard
                 &mbPatTable[0][1], 2, 1,
900
                 &mbPatTable[0][0], 2, 1);
901
        
902 7bc9090a Michael Niedermayer
        init_vlc(&mb_ptype_vlc, MB_PTYPE_VLC_BITS, 7, 
903 de6d9b64 Fabrice Bellard
                 &table_mb_ptype[0][1], 2, 1,
904
                 &table_mb_ptype[0][0], 2, 1);
905 7bc9090a Michael Niedermayer
        init_vlc(&mb_btype_vlc, MB_BTYPE_VLC_BITS, 11, 
906 de6d9b64 Fabrice Bellard
                 &table_mb_btype[0][1], 2, 1,
907
                 &table_mb_btype[0][0], 2, 1);
908
        init_rl(&rl_mpeg1);
909
        init_rl(&rl_mpeg2);
910 4f68b084 Michael Niedermayer
911
        init_2d_vlc_rl(&rl_mpeg1);
912
        init_2d_vlc_rl(&rl_mpeg2);
913 de6d9b64 Fabrice Bellard
    }
914
}
915
916
static inline int get_dmv(MpegEncContext *s)
917
{
918 612476ef Arpi
    if(get_bits1(&s->gb)) 
919
        return 1 - (get_bits1(&s->gb) << 1);
920 de6d9b64 Fabrice Bellard
    else
921
        return 0;
922
}
923
924 0ee50938 Fabrice Bellard
static inline int get_qscale(MpegEncContext *s)
925
{
926 7062fad6 BERO
    int qscale = get_bits(&s->gb, 5);
927 029911d1 Michael Niedermayer
    if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
928 0ee50938 Fabrice Bellard
        if (s->q_scale_type) {
929 7062fad6 BERO
            return non_linear_qscale[qscale];
930 0ee50938 Fabrice Bellard
        } else {
931 7062fad6 BERO
            return qscale << 1;
932 0ee50938 Fabrice Bellard
        }
933
    }
934
    return qscale;
935
}
936
937 de6d9b64 Fabrice Bellard
/* motion type (for mpeg2) */
938
#define MT_FIELD 1
939
#define MT_FRAME 2
940
#define MT_16X8  2
941
#define MT_DMV   3
942
943
static int mpeg_decode_mb(MpegEncContext *s,
944
                          DCTELEM block[6][64])
945
{
946 d2975f8d Michael Niedermayer
    int i, j, k, cbp, val, mb_type, motion_type;
947 de6d9b64 Fabrice Bellard
    
948
    dprintf("decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
949
950 f943e138 Michael Niedermayer
    assert(s->mb_skiped==0);
951
952 9b8709d1 Michael Niedermayer
    if (s->mb_skip_run-- != 0) {
953 7bc9090a Michael Niedermayer
        if(s->pict_type == I_TYPE){
954
            fprintf(stderr, "skiped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
955
            return -1;
956
        }
957
    
958 de6d9b64 Fabrice Bellard
        /* skip mb */
959
        s->mb_intra = 0;
960
        for(i=0;i<6;i++)
961
            s->block_last_index[i] = -1;
962
        s->mv_type = MV_TYPE_16X16;
963
        if (s->pict_type == P_TYPE) {
964
            /* if P type, zero motion vector is implied */
965
            s->mv_dir = MV_DIR_FORWARD;
966
            s->mv[0][0][0] = s->mv[0][0][1] = 0;
967
            s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
968 25ed7f92 Fabrice Bellard
            s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
969 f943e138 Michael Niedermayer
            s->mb_skiped = 1;
970 7bc9090a Michael Niedermayer
            s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
971 de6d9b64 Fabrice Bellard
        } else {
972
            /* if B type, reuse previous vectors and directions */
973
            s->mv[0][0][0] = s->last_mv[0][0][0];
974
            s->mv[0][0][1] = s->last_mv[0][0][1];
975
            s->mv[1][0][0] = s->last_mv[1][0][0];
976
            s->mv[1][0][1] = s->last_mv[1][0][1];
977 f943e138 Michael Niedermayer
978 7bc9090a Michael Niedermayer
            s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= 
979
                s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1] | MB_TYPE_SKIP;
980
//            assert(s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1]&(MB_TYPE_16x16|MB_TYPE_16x8));
981
982 f943e138 Michael Niedermayer
            if((s->mv[0][0][0]|s->mv[0][0][1]|s->mv[1][0][0]|s->mv[1][0][1])==0) 
983
                s->mb_skiped = 1;
984 de6d9b64 Fabrice Bellard
        }
985 59b571c1 Michael Niedermayer
986 de6d9b64 Fabrice Bellard
        return 0;
987
    }
988
989
    switch(s->pict_type) {
990
    default:
991
    case I_TYPE:
992 612476ef Arpi
        if (get_bits1(&s->gb) == 0) {
993 e94bc100 Michael Niedermayer
            if (get_bits1(&s->gb) == 0){
994 008f0851 Michael Niedermayer
                fprintf(stderr, "invalid mb type in I Frame at %d %d\n", s->mb_x, s->mb_y);
995 de6d9b64 Fabrice Bellard
                return -1;
996 e94bc100 Michael Niedermayer
            }
997 7bc9090a Michael Niedermayer
            mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
998 de6d9b64 Fabrice Bellard
        } else {
999 7bc9090a Michael Niedermayer
            mb_type = MB_TYPE_INTRA;
1000 de6d9b64 Fabrice Bellard
        }
1001
        break;
1002
    case P_TYPE:
1003 8ed2ddb2 Michael Niedermayer
        mb_type = get_vlc2(&s->gb, mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
1004 9ac7ecd6 Michael Niedermayer
        if (mb_type < 0){
1005
            fprintf(stderr, "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y);
1006 de6d9b64 Fabrice Bellard
            return -1;
1007 9ac7ecd6 Michael Niedermayer
        }
1008 7bc9090a Michael Niedermayer
        mb_type = ptype2mb_type[ mb_type ];
1009 de6d9b64 Fabrice Bellard
        break;
1010
    case B_TYPE:
1011 8ed2ddb2 Michael Niedermayer
        mb_type = get_vlc2(&s->gb, mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
1012 9ac7ecd6 Michael Niedermayer
        if (mb_type < 0){
1013
            fprintf(stderr, "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y);
1014 de6d9b64 Fabrice Bellard
            return -1;
1015 9ac7ecd6 Michael Niedermayer
        }
1016 7bc9090a Michael Niedermayer
        mb_type = btype2mb_type[ mb_type ];
1017 de6d9b64 Fabrice Bellard
        break;
1018
    }
1019
    dprintf("mb_type=%x\n", mb_type);
1020 7bc9090a Michael Niedermayer
//    motion_type = 0; /* avoid warning */
1021
    if (IS_INTRA(mb_type)) {
1022
        /* compute dct type */
1023
        if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
1024
            !s->frame_pred_frame_dct) {
1025
            s->interlaced_dct = get_bits1(&s->gb);
1026
        }
1027 de6d9b64 Fabrice Bellard
1028 7bc9090a Michael Niedermayer
        if (IS_QUANT(mb_type))
1029
            s->qscale = get_qscale(s);
1030
        
1031 de6d9b64 Fabrice Bellard
        if (s->concealment_motion_vectors) {
1032
            /* just parse them */
1033
            if (s->picture_structure != PICT_FRAME) 
1034 612476ef Arpi
                skip_bits1(&s->gb); /* field select */
1035 daab3296 Michael Niedermayer
            
1036
            s->mv[0][0][0]= s->last_mv[0][0][0]= s->last_mv[0][1][0] = 
1037
                mpeg_decode_motion(s, s->mpeg_f_code[0][0], s->last_mv[0][0][0]);
1038
            s->mv[0][0][1]= s->last_mv[0][0][1]= s->last_mv[0][1][1] = 
1039
                mpeg_decode_motion(s, s->mpeg_f_code[0][1], s->last_mv[0][0][1]);
1040
1041 7bc9090a Michael Niedermayer
            skip_bits1(&s->gb); /* marker */
1042 daab3296 Michael Niedermayer
        }else
1043
            memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */
1044 de6d9b64 Fabrice Bellard
        s->mb_intra = 1;
1045 7bc9090a Michael Niedermayer
1046 029911d1 Michael Niedermayer
        if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
1047 7bc9090a Michael Niedermayer
            for(i=0;i<6;i++) {
1048
                if (mpeg2_decode_block_intra(s, block[i], i) < 0)
1049
                    return -1;
1050
            }
1051
        } else {
1052
            for(i=0;i<6;i++) {
1053
                if (mpeg1_decode_block_intra(s, block[i], i) < 0)
1054
                    return -1;
1055
            }
1056
        }
1057 de6d9b64 Fabrice Bellard
    } else {
1058 7bc9090a Michael Niedermayer
        if (mb_type & MB_TYPE_ZERO_MV){
1059
            assert(mb_type & MB_TYPE_PAT);
1060
1061
            /* compute dct type */
1062
            if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
1063
                !s->frame_pred_frame_dct) {
1064
                s->interlaced_dct = get_bits1(&s->gb);
1065
            }
1066
1067
            if (IS_QUANT(mb_type))
1068
                s->qscale = get_qscale(s);
1069
1070
            s->mv_dir = MV_DIR_FORWARD;
1071
            s->mv_type = MV_TYPE_16X16;
1072
            s->last_mv[0][0][0] = 0;
1073
            s->last_mv[0][0][1] = 0;
1074
            s->last_mv[0][1][0] = 0;
1075
            s->last_mv[0][1][1] = 0;
1076
            s->mv[0][0][0] = 0;
1077
            s->mv[0][0][1] = 0;
1078
        }else{
1079
            assert(mb_type & MB_TYPE_L0L1);
1080
//FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
1081
            /* get additionnal motion vector type */
1082
            if (s->frame_pred_frame_dct) 
1083
                motion_type = MT_FRAME;
1084
            else{
1085
                motion_type = get_bits(&s->gb, 2);
1086
            }
1087
1088
            /* compute dct type */
1089
            if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
1090
                !s->frame_pred_frame_dct && IS_PAT(mb_type)) {
1091
                s->interlaced_dct = get_bits1(&s->gb);
1092
            }
1093
1094
            if (IS_QUANT(mb_type))
1095
                s->qscale = get_qscale(s);
1096
1097
            /* motion vectors */
1098
            s->mv_dir = 0;
1099
            for(i=0;i<2;i++) {
1100
                if (USES_LIST(mb_type, i)) {
1101
                    s->mv_dir |= (MV_DIR_FORWARD >> i);
1102
                    dprintf("motion_type=%d\n", motion_type);
1103
                    switch(motion_type) {
1104
                    case MT_FRAME: /* or MT_16X8 */
1105
                        if (s->picture_structure == PICT_FRAME) {
1106
                            /* MT_FRAME */
1107
                            mb_type |= MB_TYPE_16x16; 
1108
                            s->mv_type = MV_TYPE_16X16;
1109
                            s->mv[i][0][0]= s->last_mv[i][0][0]= s->last_mv[i][1][0] = 
1110
                                mpeg_decode_motion(s, s->mpeg_f_code[i][0], s->last_mv[i][0][0]);
1111
                            s->mv[i][0][1]= s->last_mv[i][0][1]= s->last_mv[i][1][1] = 
1112
                                mpeg_decode_motion(s, s->mpeg_f_code[i][1], s->last_mv[i][0][1]);
1113 de6d9b64 Fabrice Bellard
                            /* full_pel: only for mpeg1 */
1114 7bc9090a Michael Niedermayer
                            if (s->full_pel[i]){
1115
                                s->mv[i][0][0] <<= 1;
1116
                                s->mv[i][0][1] <<= 1;
1117
                            }
1118
                        } else {
1119
                            /* MT_16X8 */
1120
                            mb_type |= MB_TYPE_16x8; 
1121
                            s->mv_type = MV_TYPE_16X8;
1122
                            for(j=0;j<2;j++) {
1123
                                s->field_select[i][j] = get_bits1(&s->gb);
1124
                                for(k=0;k<2;k++) {
1125
                                    val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
1126
                                                             s->last_mv[i][j][k]);
1127
                                    s->last_mv[i][j][k] = val;
1128
                                    s->mv[i][j][k] = val;
1129
                                }
1130
                            }
1131 de6d9b64 Fabrice Bellard
                        }
1132 7bc9090a Michael Niedermayer
                        break;
1133
                    case MT_FIELD:
1134
                        s->mv_type = MV_TYPE_FIELD;
1135
                        if (s->picture_structure == PICT_FRAME) {
1136
                            mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED; 
1137
                            for(j=0;j<2;j++) {
1138
                                s->field_select[i][j] = get_bits1(&s->gb);
1139
                                val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
1140
                                                         s->last_mv[i][j][0]);
1141
                                s->last_mv[i][j][0] = val;
1142
                                s->mv[i][j][0] = val;
1143
                                dprintf("fmx=%d\n", val);
1144
                                val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
1145
                                                         s->last_mv[i][j][1] >> 1);
1146
                                s->last_mv[i][j][1] = val << 1;
1147
                                s->mv[i][j][1] = val;
1148
                                dprintf("fmy=%d\n", val);
1149
                            }
1150
                        } else {
1151
                            mb_type |= MB_TYPE_16x16; 
1152
                            s->field_select[i][0] = get_bits1(&s->gb);
1153 de6d9b64 Fabrice Bellard
                            for(k=0;k<2;k++) {
1154
                                val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
1155 7bc9090a Michael Niedermayer
                                                         s->last_mv[i][0][k]);
1156
                                s->last_mv[i][0][k] = val;
1157
                                s->last_mv[i][1][k] = val;
1158
                                s->mv[i][0][k] = val;
1159 de6d9b64 Fabrice Bellard
                            }
1160
                        }
1161 7bc9090a Michael Niedermayer
                        break;
1162
                    case MT_DMV:
1163
                        {
1164
                            int dmx, dmy, mx, my, m;
1165
1166
                            mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0], 
1167
                                                    s->last_mv[i][0][0]);
1168
                            s->last_mv[i][0][0] = mx;
1169
                            s->last_mv[i][1][0] = mx;
1170
                            dmx = get_dmv(s);
1171
                            my = mpeg_decode_motion(s, s->mpeg_f_code[i][1], 
1172
                                                    s->last_mv[i][0][1] >> 1);
1173
                            dmy = get_dmv(s);
1174
                            s->mv_type = MV_TYPE_DMV;
1175 1dff7d56 Ivan Kalvachev
1176
1177
                            s->last_mv[i][0][1] = my<<1;
1178
                            s->last_mv[i][1][1] = my<<1;
1179
1180
                            s->mv[i][0][0] = mx;
1181
                            s->mv[i][0][1] = my;
1182
                            s->mv[i][1][0] = mx;//not used
1183
                            s->mv[i][1][1] = my;//not used
1184
1185 7bc9090a Michael Niedermayer
                            if (s->picture_structure == PICT_FRAME) {
1186
                                mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED; 
1187
1188 1dff7d56 Ivan Kalvachev
                                //m = 1 + 2 * s->top_field_first;
1189 7bc9090a Michael Niedermayer
                                m = s->top_field_first ? 1 : 3;
1190 1dff7d56 Ivan Kalvachev
1191 7bc9090a Michael Niedermayer
                                /* top -> top pred */
1192 1dff7d56 Ivan Kalvachev
                                s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1193
                                s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
1194 7bc9090a Michael Niedermayer
                                m = 4 - m;
1195
                                s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1196
                                s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
1197
                            } else {
1198
                                mb_type |= MB_TYPE_16x16;
1199
1200 1dff7d56 Ivan Kalvachev
                                s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
1201
                                s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
1202
                                if(s->picture_structure == PICT_TOP_FIELD)
1203
                                    s->mv[i][2][1]--;
1204
                                else 
1205
                                    s->mv[i][2][1]++;
1206 7bc9090a Michael Niedermayer
                            }
1207 de6d9b64 Fabrice Bellard
                        }
1208 7bc9090a Michael Niedermayer
                        break;
1209 de6d9b64 Fabrice Bellard
                    }
1210
                }
1211
            }
1212
        }
1213 7bc9090a Michael Niedermayer
        
1214
        s->mb_intra = 0;
1215 de6d9b64 Fabrice Bellard
1216 7bc9090a Michael Niedermayer
        if (IS_PAT(mb_type)) {
1217
            cbp = get_vlc2(&s->gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
1218
            if (cbp < 0){
1219
                fprintf(stderr, "invalid cbp at %d %d\n", s->mb_x, s->mb_y);
1220
                return -1;
1221 de6d9b64 Fabrice Bellard
            }
1222 7bc9090a Michael Niedermayer
            cbp++;
1223
1224 029911d1 Michael Niedermayer
            if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
1225 7bc9090a Michael Niedermayer
                for(i=0;i<6;i++) {
1226
                    if (cbp & 32) {
1227
                        if (mpeg2_decode_block_non_intra(s, block[i], i) < 0)
1228
                            return -1;
1229
                    } else {
1230
                        s->block_last_index[i] = -1;
1231
                    }
1232
                    cbp+=cbp;
1233 de6d9b64 Fabrice Bellard
                }
1234 7bc9090a Michael Niedermayer
            } else {
1235
                for(i=0;i<6;i++) {
1236
                    if (cbp & 32) {
1237
                        if (mpeg1_decode_block_inter(s, block[i], i) < 0)
1238
                            return -1;
1239
                    } else {
1240
                        s->block_last_index[i] = -1;
1241
                    }
1242
                    cbp+=cbp;
1243 a0201736 Michael Niedermayer
                }
1244 de6d9b64 Fabrice Bellard
            }
1245 7bc9090a Michael Niedermayer
        }else{
1246
            for(i=0;i<6;i++)
1247
                s->block_last_index[i] = -1;
1248 de6d9b64 Fabrice Bellard
        }
1249
    }
1250 7bc9090a Michael Niedermayer
1251
    s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= mb_type;
1252
1253 de6d9b64 Fabrice Bellard
    return 0;
1254
}
1255
1256
/* as h263, but only 17 codes */
1257
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
1258
{
1259 05858889 BERO
    int code, sign, val, l, shift;
1260 de6d9b64 Fabrice Bellard
1261 8ed2ddb2 Michael Niedermayer
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
1262 de6d9b64 Fabrice Bellard
    if (code == 0) {
1263
        return pred;
1264
    }
1265 7bc9090a Michael Niedermayer
    if (code < 0) {
1266
        return 0xffff;
1267
    }
1268
1269 612476ef Arpi
    sign = get_bits1(&s->gb);
1270 de6d9b64 Fabrice Bellard
    shift = fcode - 1;
1271 05858889 BERO
    val = code;
1272
    if (shift) {
1273
        val = (val - 1) << shift;
1274 de6d9b64 Fabrice Bellard
        val |= get_bits(&s->gb, shift);
1275 05858889 BERO
        val++;
1276
    }
1277 de6d9b64 Fabrice Bellard
    if (sign)
1278
        val = -val;
1279
    val += pred;
1280
    
1281
    /* modulo decoding */
1282 7bc9090a Michael Niedermayer
    l = 1 << (shift+4);
1283 05858889 BERO
    val = ((val + l)&(l*2-1)) - l;
1284 de6d9b64 Fabrice Bellard
    return val;
1285
}
1286
1287 c3bf0288 Michael Niedermayer
static inline int decode_dc(GetBitContext *gb, int component)
1288 de6d9b64 Fabrice Bellard
{
1289
    int code, diff;
1290
1291
    if (component == 0) {
1292 c3bf0288 Michael Niedermayer
        code = get_vlc2(gb, dc_lum_vlc.table, DC_VLC_BITS, 2);
1293 de6d9b64 Fabrice Bellard
    } else {
1294 c3bf0288 Michael Niedermayer
        code = get_vlc2(gb, dc_chroma_vlc.table, DC_VLC_BITS, 2);
1295 de6d9b64 Fabrice Bellard
    }
1296 9ac7ecd6 Michael Niedermayer
    if (code < 0){
1297 c3bf0288 Michael Niedermayer
        fprintf(stderr, "invalid dc code at\n");
1298 de6d9b64 Fabrice Bellard
        return 0xffff;
1299 9ac7ecd6 Michael Niedermayer
    }
1300 de6d9b64 Fabrice Bellard
    if (code == 0) {
1301
        diff = 0;
1302
    } else {
1303 c3bf0288 Michael Niedermayer
        diff = get_xbits(gb, code);
1304 de6d9b64 Fabrice Bellard
    }
1305
    return diff;
1306
}
1307
1308 a0201736 Michael Niedermayer
static inline int mpeg1_decode_block_intra(MpegEncContext *s, 
1309 de6d9b64 Fabrice Bellard
                               DCTELEM *block, 
1310
                               int n)
1311
{
1312
    int level, dc, diff, i, j, run;
1313 a0201736 Michael Niedermayer
    int component;
1314 de6d9b64 Fabrice Bellard
    RLTable *rl = &rl_mpeg1;
1315 0c1a9eda Zdenek Kabelac
    uint8_t * const scantable= s->intra_scantable.permutated;
1316
    const uint16_t *quant_matrix= s->intra_matrix;
1317 a0201736 Michael Niedermayer
    const int qscale= s->qscale;
1318 de6d9b64 Fabrice Bellard
1319 a0201736 Michael Niedermayer
    /* DC coef */
1320
    component = (n <= 3 ? 0 : n - 4 + 1);
1321 c3bf0288 Michael Niedermayer
    diff = decode_dc(&s->gb, component);
1322 a0201736 Michael Niedermayer
    if (diff >= 0xffff)
1323
        return -1;
1324
    dc = s->last_dc[component];
1325
    dc += diff;
1326
    s->last_dc[component] = dc;
1327
    block[0] = dc<<3;
1328
    dprintf("dc=%d diff=%d\n", dc, diff);
1329
    i = 0;
1330
    {
1331
        OPEN_READER(re, &s->gb);    
1332
        /* now quantify & encode AC coefs */
1333
        for(;;) {
1334
            UPDATE_CACHE(re, &s->gb);
1335
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1336
            
1337
            if(level == 127){
1338
                break;
1339
            } else if(level != 0) {
1340
                i += run;
1341
                j = scantable[i];
1342
                level= (level*qscale*quant_matrix[j])>>3;
1343
                level= (level-1)|1;
1344
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1345
                LAST_SKIP_BITS(re, &s->gb, 1);
1346
            } else {
1347
                /* escape */
1348
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1349
                UPDATE_CACHE(re, &s->gb);
1350
                level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1351
                if (level == -128) {
1352
                    level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
1353
                } else if (level == 0) {
1354
                    level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);
1355
                }
1356
                i += run;
1357
                j = scantable[i];
1358
                if(level<0){
1359
                    level= -level;
1360
                    level= (level*qscale*quant_matrix[j])>>3;
1361
                    level= (level-1)|1;
1362
                    level= -level;
1363
                }else{
1364
                    level= (level*qscale*quant_matrix[j])>>3;
1365
                    level= (level-1)|1;
1366
                }
1367
            }
1368
            if (i > 63){
1369
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1370
                return -1;
1371
            }
1372
1373
            block[j] = level;
1374
        }
1375
        CLOSE_READER(re, &s->gb);
1376
    }
1377
    s->block_last_index[n] = i;
1378
   return 0;
1379
}
1380
1381
static inline int mpeg1_decode_block_inter(MpegEncContext *s, 
1382
                               DCTELEM *block, 
1383
                               int n)
1384
{
1385
    int level, i, j, run;
1386
    RLTable *rl = &rl_mpeg1;
1387 0c1a9eda Zdenek Kabelac
    uint8_t * const scantable= s->intra_scantable.permutated;
1388
    const uint16_t *quant_matrix= s->inter_matrix;
1389 a0201736 Michael Niedermayer
    const int qscale= s->qscale;
1390
1391
    {
1392 8db1a1dd Michael Niedermayer
        int v;
1393
        OPEN_READER(re, &s->gb);
1394 a0201736 Michael Niedermayer
        i = -1;
1395 de6d9b64 Fabrice Bellard
        /* special case for the first coef. no need to add a second vlc table */
1396 8db1a1dd Michael Niedermayer
        UPDATE_CACHE(re, &s->gb);
1397
        v= SHOW_UBITS(re, &s->gb, 2);
1398 de6d9b64 Fabrice Bellard
        if (v & 2) {
1399 3729c912 Michael Niedermayer
            LAST_SKIP_BITS(re, &s->gb, 2);
1400 a0201736 Michael Niedermayer
            level= (3*qscale*quant_matrix[0])>>4;
1401
            level= (level-1)|1;
1402
            if(v&1)
1403
                level= -level;
1404 3729c912 Michael Niedermayer
            block[0] = level;
1405 a0201736 Michael Niedermayer
            i++;
1406 de6d9b64 Fabrice Bellard
        }
1407 3729c912 Michael Niedermayer
1408 a0201736 Michael Niedermayer
        /* now quantify & encode AC coefs */
1409
        for(;;) {
1410
            UPDATE_CACHE(re, &s->gb);
1411
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1412
            
1413
            if(level == 127){
1414
                break;
1415
            } else if(level != 0) {
1416
                i += run;
1417
                j = scantable[i];
1418
                level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1419
                level= (level-1)|1;
1420
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1421
                LAST_SKIP_BITS(re, &s->gb, 1);
1422
            } else {
1423
                /* escape */
1424
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1425
                UPDATE_CACHE(re, &s->gb);
1426
                level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1427
                if (level == -128) {
1428
                    level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
1429
                } else if (level == 0) {
1430
                    level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);
1431
                }
1432
                i += run;
1433
                j = scantable[i];
1434
                if(level<0){
1435
                    level= -level;
1436
                    level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1437
                    level= (level-1)|1;
1438
                    level= -level;
1439
                }else{
1440
                    level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1441
                    level= (level-1)|1;
1442
                }
1443 de6d9b64 Fabrice Bellard
            }
1444 a0201736 Michael Niedermayer
            if (i > 63){
1445
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1446
                return -1;
1447
            }
1448
1449
            block[j] = level;
1450 de6d9b64 Fabrice Bellard
        }
1451 a0201736 Michael Niedermayer
        CLOSE_READER(re, &s->gb);
1452 de6d9b64 Fabrice Bellard
    }
1453 a0201736 Michael Niedermayer
    s->block_last_index[n] = i;
1454 de6d9b64 Fabrice Bellard
    return 0;
1455
}
1456
1457
/* Also does unquantization here, since I will never support mpeg2
1458
   encoding */
1459 3729c912 Michael Niedermayer
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 
1460
                               DCTELEM *block, 
1461
                               int n)
1462 de6d9b64 Fabrice Bellard
{
1463
    int level, i, j, run;
1464
    RLTable *rl = &rl_mpeg1;
1465 0c1a9eda Zdenek Kabelac
    uint8_t * const scantable= s->intra_scantable.permutated;
1466
    const uint16_t *quant_matrix;
1467 3729c912 Michael Niedermayer
    const int qscale= s->qscale;
1468 de6d9b64 Fabrice Bellard
    int mismatch;
1469
1470
    mismatch = 1;
1471
1472
    {
1473 8db1a1dd Michael Niedermayer
        int v;
1474
        OPEN_READER(re, &s->gb);
1475 3729c912 Michael Niedermayer
        i = -1;
1476 8db1a1dd Michael Niedermayer
        if (n < 4)
1477 3729c912 Michael Niedermayer
            quant_matrix = s->inter_matrix;
1478 de6d9b64 Fabrice Bellard
        else
1479 3729c912 Michael Niedermayer
            quant_matrix = s->chroma_inter_matrix;
1480 8db1a1dd Michael Niedermayer
1481 de6d9b64 Fabrice Bellard
        /* special case for the first coef. no need to add a second vlc table */
1482 8db1a1dd Michael Niedermayer
        UPDATE_CACHE(re, &s->gb);
1483
        v= SHOW_UBITS(re, &s->gb, 2);
1484 de6d9b64 Fabrice Bellard
        if (v & 2) {
1485 3729c912 Michael Niedermayer
            LAST_SKIP_BITS(re, &s->gb, 2);
1486
            level= (3*qscale*quant_matrix[0])>>5;
1487
            if(v&1)
1488
                level= -level;
1489
            block[0] = level;
1490
            mismatch ^= level;
1491
            i++;
1492 de6d9b64 Fabrice Bellard
        }
1493
1494 3729c912 Michael Niedermayer
        /* now quantify & encode AC coefs */
1495
        for(;;) {
1496
            UPDATE_CACHE(re, &s->gb);
1497
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1498
            
1499
            if(level == 127){
1500
                break;
1501
            } else if(level != 0) {
1502
                i += run;
1503
                j = scantable[i];
1504
                level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1505
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1506
                LAST_SKIP_BITS(re, &s->gb, 1);
1507
            } else {
1508
                /* escape */
1509
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1510
                UPDATE_CACHE(re, &s->gb);
1511
                level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1512
1513
                i += run;
1514
                j = scantable[i];
1515
                if(level<0){
1516
                    level= ((-level*2+1)*qscale*quant_matrix[j])>>5;
1517
                    level= -level;
1518
                }else{
1519
                    level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1520
                }
1521
            }
1522
            if (i > 63){
1523
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1524
                return -1;
1525
            }
1526
            
1527
            mismatch ^= level;
1528
            block[j] = level;
1529 25ed7f92 Fabrice Bellard
        }
1530 3729c912 Michael Niedermayer
        CLOSE_READER(re, &s->gb);
1531 de6d9b64 Fabrice Bellard
    }
1532
    block[63] ^= (mismatch & 1);
1533 3729c912 Michael Niedermayer
    
1534 de6d9b64 Fabrice Bellard
    s->block_last_index[n] = i;
1535
    return 0;
1536
}
1537
1538 3729c912 Michael Niedermayer
static inline int mpeg2_decode_block_intra(MpegEncContext *s, 
1539
                               DCTELEM *block, 
1540
                               int n)
1541 de6d9b64 Fabrice Bellard
{
1542
    int level, dc, diff, i, j, run;
1543 3729c912 Michael Niedermayer
    int component;
1544 de6d9b64 Fabrice Bellard
    RLTable *rl;
1545 0c1a9eda Zdenek Kabelac
    uint8_t * const scantable= s->intra_scantable.permutated;
1546
    const uint16_t *quant_matrix;
1547 3729c912 Michael Niedermayer
    const int qscale= s->qscale;
1548 de6d9b64 Fabrice Bellard
    int mismatch;
1549
1550
    /* DC coef */
1551 3729c912 Michael Niedermayer
    if (n < 4){
1552
        quant_matrix = s->intra_matrix;
1553
        component = 0; 
1554
    }else{
1555
        quant_matrix = s->chroma_intra_matrix;
1556
        component = n - 3;
1557
    }
1558 c3bf0288 Michael Niedermayer
    diff = decode_dc(&s->gb, component);
1559 de6d9b64 Fabrice Bellard
    if (diff >= 0xffff)
1560
        return -1;
1561
    dc = s->last_dc[component];
1562
    dc += diff;
1563
    s->last_dc[component] = dc;
1564
    block[0] = dc << (3 - s->intra_dc_precision);
1565
    dprintf("dc=%d\n", block[0]);
1566 d753173a Fabrice Bellard
    mismatch = block[0] ^ 1;
1567 3729c912 Michael Niedermayer
    i = 0;
1568 de6d9b64 Fabrice Bellard
    if (s->intra_vlc_format)
1569
        rl = &rl_mpeg2;
1570
    else
1571
        rl = &rl_mpeg1;
1572 25ed7f92 Fabrice Bellard
1573 3729c912 Michael Niedermayer
    {
1574
        OPEN_READER(re, &s->gb);    
1575
        /* now quantify & encode AC coefs */
1576
        for(;;) {
1577
            UPDATE_CACHE(re, &s->gb);
1578
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1579
            
1580
            if(level == 127){
1581
                break;
1582
            } else if(level != 0) {
1583
                i += run;
1584
                j = scantable[i];
1585
                level= (level*qscale*quant_matrix[j])>>4;
1586
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1587
                LAST_SKIP_BITS(re, &s->gb, 1);
1588
            } else {
1589
                /* escape */
1590
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1591
                UPDATE_CACHE(re, &s->gb);
1592
                level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1593
                i += run;
1594
                j = scantable[i];
1595
                if(level<0){
1596
                    level= (-level*qscale*quant_matrix[j])>>4;
1597
                    level= -level;
1598
                }else{
1599
                    level= (level*qscale*quant_matrix[j])>>4;
1600
                }
1601
            }
1602
            if (i > 63){
1603
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1604
                return -1;
1605
            }
1606
            
1607
            mismatch^= level;
1608
            block[j] = level;
1609 9ac7ecd6 Michael Niedermayer
        }
1610 3729c912 Michael Niedermayer
        CLOSE_READER(re, &s->gb);
1611 de6d9b64 Fabrice Bellard
    }
1612 3729c912 Michael Niedermayer
    block[63]^= mismatch&1;
1613
    
1614 de6d9b64 Fabrice Bellard
    s->block_last_index[n] = i;
1615
    return 0;
1616
}
1617
1618
typedef struct Mpeg1Context {
1619
    MpegEncContext mpeg_enc_ctx;
1620
    int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
1621 1cb0edb4 Juanjo
    int repeat_field; /* true if we must repeat the field */
1622 de6d9b64 Fabrice Bellard
} Mpeg1Context;
1623
1624
static int mpeg_decode_init(AVCodecContext *avctx)
1625
{
1626
    Mpeg1Context *s = avctx->priv_data;
1627 8f8402e4 Michael Niedermayer
    
1628 94aec31f Michael Niedermayer
    s->mpeg_enc_ctx.flags= avctx->flags;
1629 8f8402e4 Michael Niedermayer
    common_init(&s->mpeg_enc_ctx);
1630 c3bf0288 Michael Niedermayer
    init_vlcs();
1631 de6d9b64 Fabrice Bellard
1632
    s->mpeg_enc_ctx_allocated = 0;
1633
    s->mpeg_enc_ctx.picture_number = 0;
1634 1cb0edb4 Juanjo
    s->repeat_field = 0;
1635 d7e9533a Michael Niedermayer
    s->mpeg_enc_ctx.codec_id= avctx->codec->id;
1636 de6d9b64 Fabrice Bellard
    return 0;
1637
}
1638
1639
/* return the 8 bit start code value and update the search
1640
   state. Return -1 if no start code found */
1641 80097bbf Michael Niedermayer
static int find_start_code(uint8_t **pbuf_ptr, uint8_t *buf_end)
1642 de6d9b64 Fabrice Bellard
{
1643 0c1a9eda Zdenek Kabelac
    uint8_t *buf_ptr;
1644 80097bbf Michael Niedermayer
    unsigned int state=0xFFFFFFFF, v;
1645 de6d9b64 Fabrice Bellard
    int val;
1646
1647
    buf_ptr = *pbuf_ptr;
1648
    while (buf_ptr < buf_end) {
1649
        v = *buf_ptr++;
1650
        if (state == 0x000001) {
1651
            state = ((state << 8) | v) & 0xffffff;
1652
            val = state;
1653
            goto found;
1654
        }
1655
        state = ((state << 8) | v) & 0xffffff;
1656
    }
1657
    val = -1;
1658
 found:
1659
    *pbuf_ptr = buf_ptr;
1660
    return val;
1661
}
1662
1663
static int mpeg1_decode_picture(AVCodecContext *avctx, 
1664 0c1a9eda Zdenek Kabelac
                                uint8_t *buf, int buf_size)
1665 de6d9b64 Fabrice Bellard
{
1666
    Mpeg1Context *s1 = avctx->priv_data;
1667
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1668
    int ref, f_code;
1669
1670 68f593b4 Michael Niedermayer
    init_get_bits(&s->gb, buf, buf_size*8);
1671 de6d9b64 Fabrice Bellard
1672
    ref = get_bits(&s->gb, 10); /* temporal ref */
1673
    s->pict_type = get_bits(&s->gb, 3);
1674 b9ecd1ee Fabrice Bellard
    dprintf("pict_type=%d number=%d\n", s->pict_type, s->picture_number);
1675 58bfafbe Michael Niedermayer
1676 612476ef Arpi
    skip_bits(&s->gb, 16);
1677 de6d9b64 Fabrice Bellard
    if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
1678 612476ef Arpi
        s->full_pel[0] = get_bits1(&s->gb);
1679 de6d9b64 Fabrice Bellard
        f_code = get_bits(&s->gb, 3);
1680
        if (f_code == 0)
1681
            return -1;
1682
        s->mpeg_f_code[0][0] = f_code;
1683
        s->mpeg_f_code[0][1] = f_code;
1684
    }
1685
    if (s->pict_type == B_TYPE) {
1686 612476ef Arpi
        s->full_pel[1] = get_bits1(&s->gb);
1687 de6d9b64 Fabrice Bellard
        f_code = get_bits(&s->gb, 3);
1688
        if (f_code == 0)
1689
            return -1;
1690
        s->mpeg_f_code[1][0] = f_code;
1691
        s->mpeg_f_code[1][1] = f_code;
1692
    }
1693 1e491e29 Michael Niedermayer
    s->current_picture.pict_type= s->pict_type;
1694
    s->current_picture.key_frame= s->pict_type == I_TYPE;
1695 d9cb5429 Michael Niedermayer
    
1696 de6d9b64 Fabrice Bellard
    s->y_dc_scale = 8;
1697
    s->c_dc_scale = 8;
1698
    s->first_slice = 1;
1699
    return 0;
1700
}
1701
1702
static void mpeg_decode_sequence_extension(MpegEncContext *s)
1703
{
1704
    int horiz_size_ext, vert_size_ext;
1705 945f15b7 Michael Niedermayer
    int bit_rate_ext, vbv_buf_ext;
1706 de6d9b64 Fabrice Bellard
    int frame_rate_ext_n, frame_rate_ext_d;
1707 029911d1 Michael Niedermayer
    int level, profile;
1708 945f15b7 Michael Niedermayer
    float aspect;
1709 de6d9b64 Fabrice Bellard
1710 029911d1 Michael Niedermayer
    skip_bits(&s->gb, 1); /* profil and level esc*/
1711
    profile= get_bits(&s->gb, 3);
1712
    level= get_bits(&s->gb, 4);
1713 1cb0edb4 Juanjo
    s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1714 612476ef Arpi
    skip_bits(&s->gb, 2); /* chroma_format */
1715 de6d9b64 Fabrice Bellard
    horiz_size_ext = get_bits(&s->gb, 2);
1716
    vert_size_ext = get_bits(&s->gb, 2);
1717
    s->width |= (horiz_size_ext << 12);
1718
    s->height |= (vert_size_ext << 12);
1719
    bit_rate_ext = get_bits(&s->gb, 12);  /* XXX: handle it */
1720
    s->bit_rate = ((s->bit_rate / 400) | (bit_rate_ext << 12)) * 400;
1721 612476ef Arpi
    skip_bits1(&s->gb); /* marker */
1722 de6d9b64 Fabrice Bellard
    vbv_buf_ext = get_bits(&s->gb, 8);
1723 e0560448 Michael Niedermayer
1724 945f15b7 Michael Niedermayer
    s->low_delay = get_bits1(&s->gb);
1725 e0560448 Michael Niedermayer
    if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1;
1726
1727 de6d9b64 Fabrice Bellard
    frame_rate_ext_n = get_bits(&s->gb, 2);
1728
    frame_rate_ext_d = get_bits(&s->gb, 5);
1729 14bea432 Michael Niedermayer
    av_reduce(
1730
        &s->avctx->frame_rate, 
1731
        &s->avctx->frame_rate_base, 
1732
        frame_rate_tab[s->frame_rate_index] * (frame_rate_ext_n+1),
1733
        MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d+1),
1734
        1<<30);
1735
1736 de6d9b64 Fabrice Bellard
    dprintf("sequence extension\n");
1737 029911d1 Michael Niedermayer
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
1738 fb4a4a56 Fabrice Bellard
    s->avctx->sub_id = 2; /* indicates mpeg2 found */
1739 945f15b7 Michael Niedermayer
1740
    aspect= mpeg2_aspect[s->aspect_ratio_info];
1741
    if(aspect>0.0)      s->avctx->aspect_ratio= s->width/(aspect*s->height);
1742
    else if(aspect<0.0) s->avctx->aspect_ratio= -1.0/aspect;
1743 029911d1 Michael Niedermayer
    
1744
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1745
        printf("profile: %d, level: %d \n", profile, level);
1746 de6d9b64 Fabrice Bellard
}
1747
1748
static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1749
{
1750 60832448 Fabrice Bellard
    int i, v, j;
1751 de6d9b64 Fabrice Bellard
1752 25ed7f92 Fabrice Bellard
    dprintf("matrix extension\n");
1753
1754 612476ef Arpi
    if (get_bits1(&s->gb)) {
1755 de6d9b64 Fabrice Bellard
        for(i=0;i<64;i++) {
1756
            v = get_bits(&s->gb, 8);
1757 b0368839 Michael Niedermayer
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1758 60832448 Fabrice Bellard
            s->intra_matrix[j] = v;
1759
            s->chroma_intra_matrix[j] = v;
1760 de6d9b64 Fabrice Bellard
        }
1761
    }
1762 612476ef Arpi
    if (get_bits1(&s->gb)) {
1763 de6d9b64 Fabrice Bellard
        for(i=0;i<64;i++) {
1764
            v = get_bits(&s->gb, 8);
1765 b0368839 Michael Niedermayer
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1766 d7e9533a Michael Niedermayer
            s->inter_matrix[j] = v;
1767
            s->chroma_inter_matrix[j] = v;
1768 de6d9b64 Fabrice Bellard
        }
1769
    }
1770 612476ef Arpi
    if (get_bits1(&s->gb)) {
1771 de6d9b64 Fabrice Bellard
        for(i=0;i<64;i++) {
1772
            v = get_bits(&s->gb, 8);
1773 b0368839 Michael Niedermayer
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1774 60832448 Fabrice Bellard
            s->chroma_intra_matrix[j] = v;
1775 de6d9b64 Fabrice Bellard
        }
1776
    }
1777 612476ef Arpi
    if (get_bits1(&s->gb)) {
1778 de6d9b64 Fabrice Bellard
        for(i=0;i<64;i++) {
1779
            v = get_bits(&s->gb, 8);
1780 b0368839 Michael Niedermayer
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1781 d7e9533a Michael Niedermayer
            s->chroma_inter_matrix[j] = v;
1782 de6d9b64 Fabrice Bellard
        }
1783
    }
1784
}
1785
1786
static void mpeg_decode_picture_coding_extension(MpegEncContext *s)
1787
{
1788
    s->full_pel[0] = s->full_pel[1] = 0;
1789
    s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1790
    s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1791
    s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1792
    s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1793
    s->intra_dc_precision = get_bits(&s->gb, 2);
1794
    s->picture_structure = get_bits(&s->gb, 2);
1795 612476ef Arpi
    s->top_field_first = get_bits1(&s->gb);
1796
    s->frame_pred_frame_dct = get_bits1(&s->gb);
1797
    s->concealment_motion_vectors = get_bits1(&s->gb);
1798
    s->q_scale_type = get_bits1(&s->gb);
1799
    s->intra_vlc_format = get_bits1(&s->gb);
1800
    s->alternate_scan = get_bits1(&s->gb);
1801
    s->repeat_first_field = get_bits1(&s->gb);
1802
    s->chroma_420_type = get_bits1(&s->gb);
1803
    s->progressive_frame = get_bits1(&s->gb);
1804 acf44abb Michael Niedermayer
    
1805 dfb476cb Michael Niedermayer
    if(s->picture_structure == PICT_FRAME)
1806
        s->first_field=0;
1807
    else{
1808
        s->first_field ^= 1;
1809 7bc9090a Michael Niedermayer
        memset(s->mbskip_table, 0, s->mb_stride*s->mb_height);
1810 dfb476cb Michael Niedermayer
    }
1811
    
1812 acf44abb Michael Niedermayer
    if(s->alternate_scan){
1813 3d2e8cce Michael Niedermayer
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
1814
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
1815
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
1816
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
1817 acf44abb Michael Niedermayer
    }else{
1818 3d2e8cce Michael Niedermayer
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
1819
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
1820
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
1821
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
1822 acf44abb Michael Niedermayer
    }
1823
    
1824 de6d9b64 Fabrice Bellard
    /* composite display not parsed */
1825 1cb0edb4 Juanjo
    dprintf("intra_dc_precision=%d\n", s->intra_dc_precision);
1826 25ed7f92 Fabrice Bellard
    dprintf("picture_structure=%d\n", s->picture_structure);
1827 e0a3d744 Juanjo
    dprintf("top field first=%d\n", s->top_field_first);
1828
    dprintf("repeat first field=%d\n", s->repeat_first_field);
1829 de6d9b64 Fabrice Bellard
    dprintf("conceal=%d\n", s->concealment_motion_vectors);
1830 25ed7f92 Fabrice Bellard
    dprintf("intra_vlc_format=%d\n", s->intra_vlc_format);
1831
    dprintf("alternate_scan=%d\n", s->alternate_scan);
1832 de6d9b64 Fabrice Bellard
    dprintf("frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1833 1cb0edb4 Juanjo
    dprintf("progressive_frame=%d\n", s->progressive_frame);
1834 de6d9b64 Fabrice Bellard
}
1835
1836
static void mpeg_decode_extension(AVCodecContext *avctx, 
1837 0c1a9eda Zdenek Kabelac
                                  uint8_t *buf, int buf_size)
1838 de6d9b64 Fabrice Bellard
{
1839
    Mpeg1Context *s1 = avctx->priv_data;
1840
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1841
    int ext_type;
1842
1843 68f593b4 Michael Niedermayer
    init_get_bits(&s->gb, buf, buf_size*8);
1844 de6d9b64 Fabrice Bellard
    
1845
    ext_type = get_bits(&s->gb, 4);
1846
    switch(ext_type) {
1847
    case 0x1:
1848
        /* sequence ext */
1849
        mpeg_decode_sequence_extension(s);
1850
        break;
1851
    case 0x3:
1852
        /* quant matrix extension */
1853
        mpeg_decode_quant_matrix_extension(s);
1854
        break;
1855
    case 0x8:
1856
        /* picture extension */
1857
        mpeg_decode_picture_coding_extension(s);
1858
        break;
1859
    }
1860
}
1861
1862 ff862be5 Michael Niedermayer
static void exchange_uv(AVFrame *f){
1863
    uint8_t *t= f->data[1];
1864
    f->data[1]= f->data[2];
1865
    f->data[2]= t;
1866
}
1867
1868 86f85dca Michael Niedermayer
#define DECODE_SLICE_FATAL_ERROR -2
1869
#define DECODE_SLICE_ERROR -1
1870
#define DECODE_SLICE_OK 0
1871
1872
/**
1873
 * decodes a slice.
1874
 * @return DECODE_SLICE_FATAL_ERROR if a non recoverable error occured<br>
1875
 *         DECODE_SLICE_ERROR if the slice is damaged<br>
1876
 *         DECODE_SLICE_OK if this slice is ok<br>
1877
 */
1878 de6d9b64 Fabrice Bellard
static int mpeg_decode_slice(AVCodecContext *avctx, 
1879 492cd3a9 Michael Niedermayer
                              AVFrame *pict,
1880 de6d9b64 Fabrice Bellard
                              int start_code,
1881 80097bbf Michael Niedermayer
                              uint8_t **buf, int buf_size)
1882 de6d9b64 Fabrice Bellard
{
1883
    Mpeg1Context *s1 = avctx->priv_data;
1884
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1885
    int ret;
1886 dfb476cb Michael Niedermayer
    const int field_pic= s->picture_structure != PICT_FRAME;
1887 de6d9b64 Fabrice Bellard
1888 db6e7795 Michael Niedermayer
    s->resync_mb_x= s->mb_x = 
1889
    s->resync_mb_y= s->mb_y = -1;
1890
    
1891 de6d9b64 Fabrice Bellard
    start_code = (start_code - 1) & 0xff;
1892 9ac7ecd6 Michael Niedermayer
    if (start_code >= s->mb_height){
1893 14207b27 Michael Niedermayer
        fprintf(stderr, "slice below image (%d >= %d)\n", start_code, s->mb_height);
1894 db6e7795 Michael Niedermayer
        return -1;
1895 9ac7ecd6 Michael Niedermayer
    }
1896 9b8709d1 Michael Niedermayer
    
1897
    ff_mpeg1_clean_buffers(s);
1898 7bc9090a Michael Niedermayer
    s->interlaced_dct = 0;
1899 dfb476cb Michael Niedermayer
        
1900 de6d9b64 Fabrice Bellard
    /* start frame decoding */
1901 b536d0aa Michael Niedermayer
    if (s->first_slice) {
1902
      if(s->first_field || s->picture_structure==PICT_FRAME){
1903 d6db1c9c Michael Niedermayer
        if(MPV_frame_start(s, avctx) < 0)
1904 86f85dca Michael Niedermayer
            return DECODE_SLICE_FATAL_ERROR;
1905 7bc9090a Michael Niedermayer
1906
        ff_er_frame_start(s);
1907
1908 2ec23b6d Michael Niedermayer
        /* first check if we must repeat the frame */
1909 9ee2c20e Fabrice Bellard
        s->current_picture_ptr->repeat_pict = 0;
1910 2ec23b6d Michael Niedermayer
        if (s->repeat_first_field) {
1911
            if (s->progressive_sequence) {
1912
                if (s->top_field_first)
1913 9ee2c20e Fabrice Bellard
                    s->current_picture_ptr->repeat_pict = 4;
1914 2ec23b6d Michael Niedermayer
                else
1915 9ee2c20e Fabrice Bellard
                    s->current_picture_ptr->repeat_pict = 2;
1916 2ec23b6d Michael Niedermayer
            } else if (s->progressive_frame) {
1917 9ee2c20e Fabrice Bellard
                s->current_picture_ptr->repeat_pict = 1;
1918 2ec23b6d Michael Niedermayer
            }
1919
        }         
1920 9ee2c20e Fabrice Bellard
        //printf("%d\n", s->current_picture_ptr->repeat_pict);
1921 2ec23b6d Michael Niedermayer
1922 59b571c1 Michael Niedermayer
        if(s->avctx->debug&FF_DEBUG_PICT_INFO){
1923 f943e138 Michael Niedermayer
             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", 
1924 59b571c1 Michael Niedermayer
                 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],
1925
                 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")), 
1926
                 s->progressive_sequence ? "pro" :"", s->alternate_scan ? "alt" :"", s->top_field_first ? "top" :"", 
1927
                 s->intra_dc_precision, s->picture_structure, s->frame_pred_frame_dct, s->concealment_motion_vectors,
1928
                 s->q_scale_type, s->intra_vlc_format, s->repeat_first_field, s->chroma_420_type ? "420" :"");
1929
        }
1930 b536d0aa Michael Niedermayer
      }else{ //second field
1931
            int i;
1932 37b787f1 Michael Niedermayer
            
1933
            if(!s->current_picture_ptr){
1934
                fprintf(stderr, "first field missing\n");
1935
                return -1;
1936
            }
1937
            
1938 b536d0aa Michael Niedermayer
            for(i=0; i<4; i++){
1939
                s->current_picture.data[i] = s->current_picture_ptr->data[i];
1940
                if(s->picture_structure == PICT_BOTTOM_FIELD){
1941
                    s->current_picture.data[i] += s->current_picture_ptr->linesize[i];
1942
                } 
1943
            }
1944
      }
1945 2e7b4c84 Ivan Kalvachev
#ifdef HAVE_XVMC
1946
// MPV_frame_start will call this function too,
1947
// but we need to call it on every field
1948
      if(s->avctx->xvmc_acceleration)
1949
         XVMC_field_start(s,avctx);
1950
#endif
1951
    }//fi(s->first_slice)
1952 dfb476cb Michael Niedermayer
    s->first_slice = 0;
1953 de6d9b64 Fabrice Bellard
1954 80097bbf Michael Niedermayer
    init_get_bits(&s->gb, *buf, buf_size*8);
1955 de6d9b64 Fabrice Bellard
1956 0ee50938 Fabrice Bellard
    s->qscale = get_qscale(s);
1957 7bc9090a Michael Niedermayer
    if(s->qscale == 0){
1958
        fprintf(stderr, "qscale == 0\n");
1959 db6e7795 Michael Niedermayer
        return -1;
1960 7bc9090a Michael Niedermayer
    }
1961
    
1962 de6d9b64 Fabrice Bellard
    /* extra slice info */
1963 612476ef Arpi
    while (get_bits1(&s->gb) != 0) {
1964
        skip_bits(&s->gb, 8);
1965 de6d9b64 Fabrice Bellard
    }
1966 7bc9090a Michael Niedermayer
    
1967 ce5b7c5e Michael Niedermayer
    s->mb_x=0;
1968 7bc9090a Michael Niedermayer
1969 ce5b7c5e Michael Niedermayer
    for(;;) {
1970
        int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1971 7bc9090a Michael Niedermayer
        if (code < 0){
1972
            fprintf(stderr, "first mb_incr damaged\n");
1973 db6e7795 Michael Niedermayer
            return -1;
1974 7bc9090a Michael Niedermayer
        }
1975 ce5b7c5e Michael Niedermayer
        if (code >= 33) {
1976
            if (code == 33) {
1977
                s->mb_x += 33;
1978
            }
1979
            /* otherwise, stuffing, nothing to do */
1980
        } else {
1981
            s->mb_x += code;
1982
            break;
1983
        }
1984
    }
1985 9b8709d1 Michael Niedermayer
    
1986 7bc9090a Michael Niedermayer
    s->resync_mb_x= s->mb_x;
1987
    s->resync_mb_y= s->mb_y = start_code;
1988 9b8709d1 Michael Niedermayer
    s->mb_skip_run= 0;
1989 7d1c3fc1 Michael Niedermayer
    ff_init_block_index(s);
1990 ce5b7c5e Michael Niedermayer
1991 de6d9b64 Fabrice Bellard
    for(;;) {
1992 eb4b3dd3 Zdenek Kabelac
        s->dsp.clear_blocks(s->block[0]);
1993 7bc9090a Michael Niedermayer
1994 b7ec19d3 Fabrice Bellard
        ret = mpeg_decode_mb(s, s->block);
1995 7bc9090a Michael Niedermayer
1996 de6d9b64 Fabrice Bellard
        dprintf("ret=%d\n", ret);
1997
        if (ret < 0)
1998
            return -1;
1999 7bc9090a Michael Niedermayer
            
2000
        if(s->motion_val && s->pict_type != B_TYPE){ //note motion_val is normally NULL unless we want to extract the MVs
2001
            const int wrap = s->block_wrap[0];
2002
            const int xy = s->mb_x*2 + 1 + (s->mb_y*2 +1)*wrap;
2003
            int motion_x, motion_y;
2004
2005 db6e7795 Michael Niedermayer
            if (s->mb_intra) {
2006
                motion_x = motion_y = 0;
2007
            }else if (s->mv_type == MV_TYPE_16X16) {
2008 7bc9090a Michael Niedermayer
                motion_x = s->mv[0][0][0];
2009
                motion_y = s->mv[0][0][1];
2010
            } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
2011
                motion_x = s->mv[0][0][0] + s->mv[0][1][0];
2012
                motion_y = s->mv[0][0][1] + s->mv[0][1][1];
2013
                motion_x = (motion_x>>1) | (motion_x&1);
2014
            }
2015
            s->motion_val[xy][0] = motion_x;
2016
            s->motion_val[xy][1] = motion_y;
2017
            s->motion_val[xy + 1][0] = motion_x;
2018
            s->motion_val[xy + 1][1] = motion_y;
2019
            s->motion_val[xy + wrap][0] = motion_x;
2020
            s->motion_val[xy + wrap][1] = motion_y;
2021
            s->motion_val[xy + 1 + wrap][0] = motion_x;
2022
            s->motion_val[xy + 1 + wrap][1] = motion_y;
2023
        }
2024 b536d0aa Michael Niedermayer
        
2025 7d1c3fc1 Michael Niedermayer
        s->dest[0] += 16;
2026
        s->dest[1] += 8;
2027
        s->dest[2] += 8;
2028 ce5b7c5e Michael Niedermayer
2029 7d1c3fc1 Michael Niedermayer
        MPV_decode_mb(s, s->block);
2030
        
2031 ce5b7c5e Michael Niedermayer
        if (++s->mb_x >= s->mb_width) {
2032 ff862be5 Michael Niedermayer
            if(s->avctx->codec_tag == ff_get_fourcc("VCR2"))
2033
                exchange_uv((AVFrame*)s->current_picture_ptr);
2034
2035 3bb07d61 Michael Niedermayer
            ff_draw_horiz_band(s, 16*s->mb_y, 16);
2036 ce5b7c5e Michael Niedermayer
2037 ff862be5 Michael Niedermayer
            if(s->avctx->codec_tag == ff_get_fourcc("VCR2"))
2038
                exchange_uv((AVFrame*)s->current_picture_ptr);
2039
2040 ce5b7c5e Michael Niedermayer
            s->mb_x = 0;
2041
            s->mb_y++;
2042 cf713bb8 Michael Niedermayer
2043
            if(s->mb_y<<field_pic >= s->mb_height){
2044
                int left= s->gb.size_in_bits - get_bits_count(&s->gb);
2045
2046
                if(left < 0 || (left && show_bits(&s->gb, FFMIN(left, 23)))
2047
                   || (avctx->error_resilience >= FF_ER_AGGRESSIVE && left>8)){
2048
                    fprintf(stderr, "end missmatch left=%d\n", left);
2049
                    return -1;
2050
                }else
2051
                    goto eos;
2052
            }
2053 7d1c3fc1 Michael Niedermayer
            
2054
            ff_init_block_index(s);
2055 ce5b7c5e Michael Niedermayer
        }
2056
2057
        /* skip mb handling */
2058 9b8709d1 Michael Niedermayer
        if (s->mb_skip_run == -1) {
2059 ce5b7c5e Michael Niedermayer
            /* read again increment */
2060 9b8709d1 Michael Niedermayer
            s->mb_skip_run = 0;
2061 ce5b7c5e Michael Niedermayer
            for(;;) {
2062
                int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
2063 7bc9090a Michael Niedermayer
                if (code < 0){
2064 9c00c3af Michael Niedermayer
                    fprintf(stderr, "mb incr damaged\n");
2065
                    return -1;
2066 7bc9090a Michael Niedermayer
                }
2067 ce5b7c5e Michael Niedermayer
                if (code >= 33) {
2068
                    if (code == 33) {
2069 9b8709d1 Michael Niedermayer
                        s->mb_skip_run += 33;
2070 9c00c3af Michael Niedermayer
                    }else if(code == 35){
2071
                        if(s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0){
2072
                            fprintf(stderr, "slice missmatch\n");
2073
                            return -1;
2074
                        }
2075
                        goto eos; /* end of slice */
2076 ce5b7c5e Michael Niedermayer
                    }
2077
                    /* otherwise, stuffing, nothing to do */
2078
                } else {
2079 9b8709d1 Michael Niedermayer
                    s->mb_skip_run += code;
2080 ce5b7c5e Michael Niedermayer
                    break;
2081
                }
2082
            }
2083
        }
2084 de6d9b64 Fabrice Bellard
    }
2085 db6e7795 Michael Niedermayer
eos: // end of slice
2086
    *buf += get_bits_count(&s->gb)/8 - 1;
2087 7bc9090a Michael Niedermayer
//printf("y %d %d %d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
2088 db6e7795 Michael Niedermayer
    return 0;
2089
}
2090 7bc9090a Michael Niedermayer
2091 db6e7795 Michael Niedermayer
/**
2092
 * handles slice ends.
2093
 * @return 1 if it seems to be the last slice of 
2094
 */
2095
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
2096
{
2097
    Mpeg1Context *s1 = avctx->priv_data;
2098
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2099
       
2100 36b58e85 Roman Shaposhnik
    if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
2101 855127bc Fabrice Bellard
        return 0;
2102
2103 2e7b4c84 Ivan Kalvachev
#ifdef HAVE_XVMC
2104
    if(s->avctx->xvmc_acceleration)
2105
        XVMC_field_end(s);
2106
#endif
2107 de6d9b64 Fabrice Bellard
    /* end of slice reached */
2108 db6e7795 Michael Niedermayer
    if (/*s->mb_y<<field_pic == s->mb_height &&*/ !s->first_field) {
2109 de6d9b64 Fabrice Bellard
        /* end of image */
2110 1e491e29 Michael Niedermayer
2111 029911d1 Michael Niedermayer
        if(s->codec_id == CODEC_ID_MPEG2VIDEO){
2112 0426af31 Michael Niedermayer
            s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG2;
2113
        }else
2114
            s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG1;
2115
2116 7bc9090a Michael Niedermayer
        ff_er_frame_end(s);
2117 de6d9b64 Fabrice Bellard
2118
        MPV_frame_end(s);
2119
2120 4e00e76b Michael Niedermayer
        if (s->pict_type == B_TYPE || s->low_delay) {
2121 8e937a4a Michael Niedermayer
            *pict= *(AVFrame*)s->current_picture_ptr;
2122 7bc9090a Michael Niedermayer
            ff_print_debug_info(s, s->current_picture_ptr);
2123 de6d9b64 Fabrice Bellard
        } else {
2124 1e491e29 Michael Niedermayer
            s->picture_number++;
2125 de6d9b64 Fabrice Bellard
            /* latency of 1 frame for I and P frames */
2126
            /* XXX: use another variable than picture_number */
2127 80097bbf Michael Niedermayer
            if (s->last_picture_ptr != NULL) {
2128 8e937a4a Michael Niedermayer
                *pict= *(AVFrame*)s->last_picture_ptr;
2129 7bc9090a Michael Niedermayer
                 ff_print_debug_info(s, s->last_picture_ptr);
2130 de6d9b64 Fabrice Bellard
            }
2131
        }
2132 ff862be5 Michael Niedermayer
        if(s->avctx->codec_tag == ff_get_fourcc("VCR2"))
2133
            exchange_uv(pict);
2134
2135 db6e7795 Michael Niedermayer
        return 1;
2136 de6d9b64 Fabrice Bellard
    } else {
2137 db6e7795 Michael Niedermayer
        return 0;
2138 de6d9b64 Fabrice Bellard
    }
2139
}
2140
2141
static int mpeg1_decode_sequence(AVCodecContext *avctx, 
2142 0c1a9eda Zdenek Kabelac
                                 uint8_t *buf, int buf_size)
2143 de6d9b64 Fabrice Bellard
{
2144
    Mpeg1Context *s1 = avctx->priv_data;
2145
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2146 60832448 Fabrice Bellard
    int width, height, i, v, j;
2147 945f15b7 Michael Niedermayer
    float aspect;
2148 fb4a4a56 Fabrice Bellard
2149 68f593b4 Michael Niedermayer
    init_get_bits(&s->gb, buf, buf_size*8);
2150 de6d9b64 Fabrice Bellard
2151
    width = get_bits(&s->gb, 12);
2152
    height = get_bits(&s->gb, 12);
2153 945f15b7 Michael Niedermayer
    s->aspect_ratio_info= get_bits(&s->gb, 4);
2154 029911d1 Michael Niedermayer
    if(s->codec_id == CODEC_ID_MPEG1VIDEO){
2155 945f15b7 Michael Niedermayer
        aspect= mpeg1_aspect[s->aspect_ratio_info];
2156
        if(aspect!=0.0) avctx->aspect_ratio= width/(aspect*height);
2157
    }
2158
2159 de6d9b64 Fabrice Bellard
    s->frame_rate_index = get_bits(&s->gb, 4);
2160
    if (s->frame_rate_index == 0)
2161
        return -1;
2162
    s->bit_rate = get_bits(&s->gb, 18) * 400;
2163 612476ef Arpi
    if (get_bits1(&s->gb) == 0) /* marker */
2164 de6d9b64 Fabrice Bellard
        return -1;
2165
    if (width <= 0 || height <= 0 ||
2166
        (width % 2) != 0 || (height % 2) != 0)
2167
        return -1;
2168
    if (width != s->width ||
2169
        height != s->height) {
2170
        /* start new mpeg1 context decoding */
2171
        s->out_format = FMT_MPEG1;
2172
        if (s1->mpeg_enc_ctx_allocated) {
2173
            MPV_common_end(s);
2174
        }
2175
        s->width = width;
2176
        s->height = height;
2177 4e00e76b Michael Niedermayer
        avctx->has_b_frames= 1;
2178 0c23ead1 Fabrice Bellard
        s->avctx = avctx;
2179 de6d9b64 Fabrice Bellard
        avctx->width = width;
2180
        avctx->height = height;
2181 14bea432 Michael Niedermayer
        av_reduce(
2182
            &avctx->frame_rate, 
2183
            &avctx->frame_rate_base,
2184
            frame_rate_tab[s->frame_rate_index],
2185
            MPEG1_FRAME_RATE_BASE, //FIXME store in allready reduced form 
2186
            1<<30
2187
            );
2188 de6d9b64 Fabrice Bellard
        avctx->bit_rate = s->bit_rate;
2189
        
2190 2e7b4c84 Ivan Kalvachev
        //get_format() or set_video(width,height,aspect,pix_fmt);
2191
        //until then pix_fmt may be changed right after codec init
2192
        if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT )
2193
            avctx->idct_algo = FF_IDCT_SIMPLE;
2194
2195 de6d9b64 Fabrice Bellard
        if (MPV_common_init(s) < 0)
2196
            return -1;
2197
        s1->mpeg_enc_ctx_allocated = 1;
2198
    }
2199
2200 612476ef Arpi
    skip_bits(&s->gb, 10); /* vbv_buffer_size */
2201
    skip_bits(&s->gb, 1);
2202 de6d9b64 Fabrice Bellard
2203
    /* get matrix */
2204 612476ef Arpi
    if (get_bits1(&s->gb)) {
2205 de6d9b64 Fabrice Bellard
        for(i=0;i<64;i++) {
2206
            v = get_bits(&s->gb, 8);
2207 2ad1516a Michael Niedermayer
            j = s->intra_scantable.permutated[i];
2208 60832448 Fabrice Bellard
            s->intra_matrix[j] = v;
2209
            s->chroma_intra_matrix[j] = v;
2210 de6d9b64 Fabrice Bellard
        }
2211 25ed7f92 Fabrice Bellard
#ifdef DEBUG
2212
        dprintf("intra matrix present\n");
2213
        for(i=0;i<64;i++)
2214 8e1652dc Michael Niedermayer
            dprintf(" %d", s->intra_matrix[s->intra_scantable.permutated[i]]);
2215 25ed7f92 Fabrice Bellard
        printf("\n");
2216
#endif
2217 de6d9b64 Fabrice Bellard
    } else {
2218
        for(i=0;i<64;i++) {
2219 b0368839 Michael Niedermayer
            int j= s->dsp.idct_permutation[i];
2220 adc09b2e Marko Kreen
            v = ff_mpeg1_default_intra_matrix[i];
2221 2ad1516a Michael Niedermayer
            s->intra_matrix[j] = v;
2222
            s->chroma_intra_matrix[j] = v;
2223 de6d9b64 Fabrice Bellard
        }
2224
    }
2225 612476ef Arpi
    if (get_bits1(&s->gb)) {
2226 de6d9b64 Fabrice Bellard
        for(i=0;i<64;i++) {
2227
            v = get_bits(&s->gb, 8);
2228 2ad1516a Michael Niedermayer
            j = s->intra_scantable.permutated[i];
2229 d7e9533a Michael Niedermayer
            s->inter_matrix[j] = v;
2230
            s->chroma_inter_matrix[j] = v;
2231 de6d9b64 Fabrice Bellard
        }
2232 25ed7f92 Fabrice Bellard
#ifdef DEBUG
2233
        dprintf("non intra matrix present\n");
2234
        for(i=0;i<64;i++)
2235 8e1652dc Michael Niedermayer
            dprintf(" %d", s->inter_matrix[s->intra_scantable.permutated[i]]);
2236 25ed7f92 Fabrice Bellard
        printf("\n");
2237
#endif
2238 de6d9b64 Fabrice Bellard
    } else {
2239
        for(i=0;i<64;i++) {
2240 b0368839 Michael Niedermayer
            int j= s->dsp.idct_permutation[i];
2241 adc09b2e Marko Kreen
            v = ff_mpeg1_default_non_intra_matrix[i];
2242 2ad1516a Michael Niedermayer
            s->inter_matrix[j] = v;
2243
            s->chroma_inter_matrix[j] = v;
2244 de6d9b64 Fabrice Bellard
        }
2245
    }
2246
2247
    /* we set mpeg2 parameters so that it emulates mpeg1 */
2248
    s->progressive_sequence = 1;
2249
    s->progressive_frame = 1;
2250
    s->picture_structure = PICT_FRAME;
2251
    s->frame_pred_frame_dct = 1;
2252 029911d1 Michael Niedermayer
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG1VIDEO;
2253 fb4a4a56 Fabrice Bellard
    avctx->sub_id = 1; /* indicates mpeg1 */
2254 de6d9b64 Fabrice Bellard
    return 0;
2255
}
2256
2257 e94bc100 Michael Niedermayer
static int vcr2_init_sequence(AVCodecContext *avctx)
2258
{
2259
    Mpeg1Context *s1 = avctx->priv_data;
2260
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2261 008f0851 Michael Niedermayer
    int i, v;
2262 e94bc100 Michael Niedermayer
2263
    /* start new mpeg1 context decoding */
2264
    s->out_format = FMT_MPEG1;
2265
    if (s1->mpeg_enc_ctx_allocated) {
2266
        MPV_common_end(s);
2267
    }
2268
    s->width = avctx->width;
2269
    s->height = avctx->height;
2270
    avctx->has_b_frames= 0; //true?
2271 ff862be5 Michael Niedermayer
    s->low_delay= 1;
2272 e94bc100 Michael Niedermayer
    s->avctx = avctx;
2273 2e7b4c84 Ivan Kalvachev
2274
    //get_format() or set_video(width,height,aspect,pix_fmt);
2275
    //until then pix_fmt may be changed right after codec init
2276
    if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT )
2277
        avctx->idct_algo = FF_IDCT_SIMPLE;
2278 e94bc100 Michael Niedermayer
    
2279
    if (MPV_common_init(s) < 0)
2280
        return -1;
2281
    s1->mpeg_enc_ctx_allocated = 1;
2282
2283
    for(i=0;i<64;i++) {
2284
        int j= s->dsp.idct_permutation[i];
2285
        v = ff_mpeg1_default_intra_matrix[i];
2286
        s->intra_matrix[j] = v;
2287
        s->chroma_intra_matrix[j] = v;
2288
2289
        v = ff_mpeg1_default_non_intra_matrix[i];
2290
        s->inter_matrix[j] = v;
2291
        s->chroma_inter_matrix[j] = v;
2292
    }
2293
2294
    s->progressive_sequence = 1;
2295
    s->progressive_frame = 1;
2296
    s->picture_structure = PICT_FRAME;
2297
    s->frame_pred_frame_dct = 1;
2298 029911d1 Michael Niedermayer
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
2299 008f0851 Michael Niedermayer
    avctx->sub_id = 2; /* indicates mpeg2 */
2300 e94bc100 Michael Niedermayer
    return 0;
2301
}
2302
2303
2304 e2f9490e Fabrice Bellard
static void mpeg_decode_user_data(AVCodecContext *avctx, 
2305
                                  const uint8_t *buf, int buf_size)
2306
{
2307
    const uint8_t *p;
2308
    int len, flags;
2309
    p = buf;
2310
    len = buf_size;
2311
2312
    /* we parse the DTG active format information */
2313
    if (len >= 5 &&
2314
        p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2315
        flags = p[4];
2316
        p += 5;
2317
        len -= 5;
2318
        if (flags & 0x80) {
2319
            /* skip event id */
2320
            if (len < 2)
2321
                return;
2322
            p += 2;
2323
            len -= 2;
2324
        }
2325
        if (flags & 0x40) {
2326
            if (len < 1)
2327
                return;
2328
            avctx->dtg_active_format = p[0] & 0x0f;
2329
        }
2330
    }
2331
}
2332
2333 80097bbf Michael Niedermayer
/**
2334
 * finds the end of the current frame in the bitstream.
2335
 * @return the position of the first byte of the next frame, or -1
2336
 */
2337
static int mpeg1_find_frame_end(MpegEncContext *s, uint8_t *buf, int buf_size){
2338
    ParseContext *pc= &s->parse_context;
2339
    int i;
2340
    uint32_t state;
2341
    
2342
    state= pc->state;
2343
    
2344
    i=0;
2345
    if(!pc->frame_start_found){
2346
        for(i=0; i<buf_size; i++){
2347
            state= (state<<8) | buf[i];
2348
            if(state >= SLICE_MIN_START_CODE && state <= SLICE_MAX_START_CODE){
2349
                i++;
2350
                pc->frame_start_found=1;
2351
                break;
2352
            }
2353
        }
2354
    }
2355
    
2356
    if(pc->frame_start_found){
2357
        for(; i<buf_size; i++){
2358
            state= (state<<8) | buf[i];
2359
            if((state&0xFFFFFF00) == 0x100){
2360
                if(state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE){
2361
                    pc->frame_start_found=0;
2362
                    pc->state=-1; 
2363
                    return i-3;
2364
                }
2365
            }
2366
        }
2367
    }        
2368
    pc->state= state;
2369 bb463d81 Michael Niedermayer
    return END_NOT_FOUND;
2370 80097bbf Michael Niedermayer
}
2371
2372 de6d9b64 Fabrice Bellard
/* handle buffering and image synchronisation */
2373
static int mpeg_decode_frame(AVCodecContext *avctx, 
2374
                             void *data, int *data_size,
2375 0c1a9eda Zdenek Kabelac
                             uint8_t *buf, int buf_size)
2376 de6d9b64 Fabrice Bellard
{
2377
    Mpeg1Context *s = avctx->priv_data;
2378 80097bbf Michael Niedermayer
    uint8_t *buf_end, *buf_ptr;
2379
    int ret, start_code, input_size;
2380 492cd3a9 Michael Niedermayer
    AVFrame *picture = data;
2381 1cb0edb4 Juanjo
    MpegEncContext *s2 = &s->mpeg_enc_ctx;
2382 de6d9b64 Fabrice Bellard
    dprintf("fill_buffer\n");
2383
2384
    *data_size = 0;
2385 d7e9533a Michael Niedermayer
2386 de6d9b64 Fabrice Bellard
    /* special case for last picture */
2387 e9174ba4 Michael Niedermayer
    if (buf_size == 0 && s2->low_delay==0 && s2->next_picture_ptr) {
2388
        *picture= *(AVFrame*)s2->next_picture_ptr;
2389
        s2->next_picture_ptr= NULL;
2390 1e491e29 Michael Niedermayer
2391 e9174ba4 Michael Niedermayer
        *data_size = sizeof(AVFrame);
2392 de6d9b64 Fabrice Bellard
        return 0;
2393
    }
2394
2395 80097bbf Michael Niedermayer
    if(s2->flags&CODEC_FLAG_TRUNCATED){
2396 bb463d81 Michael Niedermayer
        int next= mpeg1_find_frame_end(s2, buf, buf_size);
2397 80097bbf Michael Niedermayer
        
2398
        if( ff_combine_frame(s2, next, &buf, &buf_size) < 0 )
2399
            return buf_size;
2400
    }    
2401
    
2402 de6d9b64 Fabrice Bellard
    buf_ptr = buf;
2403
    buf_end = buf + buf_size;
2404 e0a3d744 Juanjo
2405
#if 0    
2406
    if (s->repeat_field % 2 == 1) { 
2407 1cb0edb4 Juanjo
        s->repeat_field++;
2408
        //fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number,
2409 e0a3d744 Juanjo
        //        s2->picture_number, s->repeat_field);
2410
        if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) {
2411
            *data_size = sizeof(AVPicture);
2412
            goto the_end;
2413
        }
2414 1cb0edb4 Juanjo
    }
2415 e0a3d744 Juanjo
#endif
2416 e94bc100 Michael Niedermayer
2417
    if(s->mpeg_enc_ctx_allocated==0 && avctx->codec_tag == ff_get_fourcc("VCR2"))
2418
        vcr2_init_sequence(avctx);
2419
2420 80097bbf Michael Niedermayer
    for(;;) {
2421 de6d9b64 Fabrice Bellard
        /* find start next code */
2422 80097bbf Michael Niedermayer
        start_code = find_start_code(&buf_ptr, buf_end);
2423 cfcff636 Michael Niedermayer
        if (start_code < 0){
2424 db6e7795 Michael Niedermayer
            if (slice_end(avctx, picture)) {
2425
                if(s2->last_picture_ptr) //FIXME merge with the stuff in mpeg_decode_slice
2426
                    *data_size = sizeof(AVPicture);
2427
            }
2428 cfcff636 Michael Niedermayer
            return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2429 de6d9b64 Fabrice Bellard
        }
2430 cf713bb8 Michael Niedermayer
        
2431
        input_size = buf_end - buf_ptr;
2432
2433
        if(avctx->debug & FF_DEBUG_STARTCODE){
2434
            printf("%3X at %d left %d\n", start_code, buf_ptr-buf, input_size);
2435
        }
2436 80097bbf Michael Niedermayer
2437 de6d9b64 Fabrice Bellard
                /* prepare data for next start code */
2438
                switch(start_code) {
2439
                case SEQ_START_CODE:
2440 80097bbf Michael Niedermayer
                    mpeg1_decode_sequence(avctx, buf_ptr, 
2441 de6d9b64 Fabrice Bellard
                                          input_size);
2442
                    break;
2443
                            
2444
                case PICTURE_START_CODE:
2445
                    /* we have a complete image : we try to decompress it */
2446
                    mpeg1_decode_picture(avctx, 
2447 80097bbf Michael Niedermayer
                                         buf_ptr, input_size);
2448 de6d9b64 Fabrice Bellard
                    break;
2449
                case EXT_START_CODE:
2450
                    mpeg_decode_extension(avctx,
2451 80097bbf Michael Niedermayer
                                          buf_ptr, input_size);
2452 e2f9490e Fabrice Bellard
                    break;
2453
                case USER_START_CODE:
2454
                    mpeg_decode_user_data(avctx, 
2455 80097bbf Michael Niedermayer
                                          buf_ptr, input_size);
2456 de6d9b64 Fabrice Bellard
                    break;
2457 05fd1577 Michael Niedermayer
                case GOP_START_CODE:
2458
                    s2->first_field=0;
2459
                    break;
2460 de6d9b64 Fabrice Bellard
                default:
2461
                    if (start_code >= SLICE_MIN_START_CODE &&
2462 d9cb5429 Michael Niedermayer
                        start_code <= SLICE_MAX_START_CODE) {
2463 945f15b7 Michael Niedermayer
                        
2464
                        /* skip b frames if we dont have reference frames */
2465 b536d0aa Michael Niedermayer
                        if(s2->last_picture_ptr==NULL && s2->pict_type==B_TYPE) break;
2466 945f15b7 Michael Niedermayer
                        /* skip b frames if we are in a hurry */
2467
                        if(avctx->hurry_up && s2->pict_type==B_TYPE) break;
2468
                        /* skip everything if we are in a hurry>=5 */
2469
                        if(avctx->hurry_up>=5) break;
2470 80097bbf Michael Niedermayer
                        
2471 37b787f1 Michael Niedermayer
                        if (!s->mpeg_enc_ctx_allocated) break;
2472
2473 de6d9b64 Fabrice Bellard
                        ret = mpeg_decode_slice(avctx, picture,
2474 80097bbf Michael Niedermayer
                                                start_code, &buf_ptr, input_size);
2475 db6e7795 Michael Niedermayer
                        emms_c();
2476 dfb476cb Michael Niedermayer
2477 db6e7795 Michael Niedermayer
                        if(ret < 0){
2478
                            if(s2->resync_mb_x>=0 && s2->resync_mb_y>=0)
2479 7bc9090a Michael Niedermayer
                                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);
2480 db6e7795 Michael Niedermayer
                            if(ret==DECODE_SLICE_FATAL_ERROR) return -1;
2481
                        }else{
2482
                            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);
2483 de6d9b64 Fabrice Bellard
                        }
2484
                    }
2485
                    break;
2486
                }
2487
    }
2488
}
2489
2490
static int mpeg_decode_end(AVCodecContext *avctx)
2491
{
2492
    Mpeg1Context *s = avctx->priv_data;
2493
2494
    if (s->mpeg_enc_ctx_allocated)
2495
        MPV_common_end(&s->mpeg_enc_ctx);
2496
    return 0;
2497
}
2498
2499 922bc38d Michael Niedermayer
AVCodec mpeg1video_decoder = {
2500
    "mpeg1video",
2501 de6d9b64 Fabrice Bellard
    CODEC_TYPE_VIDEO,
2502
    CODEC_ID_MPEG1VIDEO,
2503
    sizeof(Mpeg1Context),
2504
    mpeg_decode_init,
2505
    NULL,
2506
    mpeg_decode_end,
2507
    mpeg_decode_frame,
2508 d7425f59 Michael Niedermayer
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
2509 922bc38d Michael Niedermayer
    .flush= ff_mpeg_flush,
2510
};
2511
2512
AVCodec mpeg2video_decoder = {
2513
    "mpeg2video",
2514
    CODEC_TYPE_VIDEO,
2515
    CODEC_ID_MPEG2VIDEO,
2516
    sizeof(Mpeg1Context),
2517
    mpeg_decode_init,
2518
    NULL,
2519
    mpeg_decode_end,
2520
    mpeg_decode_frame,
2521
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
2522 7a06ff14 Michael Niedermayer
    .flush= ff_mpeg_flush,
2523 de6d9b64 Fabrice Bellard
};
2524 2e7b4c84 Ivan Kalvachev
2525
#ifdef HAVE_XVMC
2526
static int mpeg_mc_decode_init(AVCodecContext *avctx){
2527
    Mpeg1Context *s;
2528
2529
    if( !(avctx->slice_flags & SLICE_FLAG_CODED_ORDER) )
2530
        return -1;
2531
    if( !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD) )
2532
        dprintf("mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
2533
2534
    mpeg_decode_init(avctx);
2535
    s = avctx->priv_data;
2536
2537
    avctx->pix_fmt = PIX_FMT_XVMC_MPEG2_IDCT;
2538
    avctx->xvmc_acceleration = 1;
2539
2540
    return 0;
2541
}
2542
2543
AVCodec mpeg_xvmc_decoder = {
2544
    "mpegvideo_xvmc",
2545
    CODEC_TYPE_VIDEO,
2546
    CODEC_ID_MPEG2VIDEO_XVMC,
2547
    sizeof(Mpeg1Context),
2548
    mpeg_mc_decode_init,
2549
    NULL,
2550
    mpeg_decode_end,
2551
    mpeg_decode_frame,
2552
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
2553
};
2554
2555
#endif
2556 c3bf0288 Michael Niedermayer
2557
/* this is ugly i know, but the alternative is too make 
2558
   hundreds of vars global and prefix them with ff_mpeg1_
2559
   which is far uglier. */
2560
#include "mdec.c"