Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpeg12.c @ c53d2d90

History | View | Annotate | Download (115 KB)

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