Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpeg12.c @ 58c2182d

History | View | Annotate | Download (101 KB)

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