some fixes (still buggy though)
[ffmpeg.git] / libavcodec / mdec.c
1 /*
2  * PSX MDEC codec
3  * Copyright (c) 2003 Michael Niedermayer
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  *
19  * based upon code from Sebastian Jedruszkiewicz <elf@frogger.rules.pl>
20  */
21  
22 /**
23  * @file mdec.c
24  * PSX MDEC codec.
25  * This is very similar to intra only MPEG1.
26  */
27  
28 #include "avcodec.h"
29 #include "dsputil.h"
30 #include "mpegvideo.h"
31
32 //#undef NDEBUG
33 //#include <assert.h>
34
35 typedef struct MDECContext{
36     AVCodecContext *avctx;
37     DSPContext dsp;
38     AVFrame picture;
39     PutBitContext pb;
40     GetBitContext gb;
41     ScanTable scantable;
42     int version;
43     int qscale;
44     int last_dc[3];
45     int mb_width;
46     int mb_height;
47     int mb_x, mb_y;
48     DCTELEM __align8 block[6][64];
49     uint16_t __align8 intra_matrix[64];
50     int __align8 q_intra_matrix[64];
51     uint8_t *bitstream_buffer;
52     int bitstream_buffer_size;
53     int block_last_index[6];
54 } MDECContext;
55
56 //very similar to mpeg1
57 static inline int mdec_decode_block_intra(MDECContext *a, DCTELEM *block, int n)
58 {
59     int level, diff, i, j, run;
60     int component;
61     RLTable *rl = &rl_mpeg1;
62     uint8_t * const scantable= a->scantable.permutated;
63     const uint16_t *quant_matrix= ff_mpeg1_default_intra_matrix;
64     const int qscale= a->qscale;
65
66     /* DC coef */
67     if(a->version==2){
68         block[0]= get_sbits(&a->gb, 10);
69     }else{
70         component = (n <= 3 ? 0 : n - 4 + 1);
71         diff = decode_dc(&a->gb, component);
72         if (diff >= 0xffff)
73             return -1;
74         a->last_dc[component]+= diff;
75         block[0] = a->last_dc[component]<<3;
76     }
77     
78     i = 0;
79     {
80         OPEN_READER(re, &a->gb);    
81         /* now quantify & encode AC coefs */
82         for(;;) {
83             UPDATE_CACHE(re, &a->gb);
84             GET_RL_VLC(level, run, re, &a->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
85             
86             if(level == 127){
87                 break;
88             } else if(level != 0) {
89                 i += run;
90                 j = scantable[i];
91                 level= (level*qscale*quant_matrix[j])>>3;
92                 level= (level-1)|1;
93                 level = (level ^ SHOW_SBITS(re, &a->gb, 1)) - SHOW_SBITS(re, &a->gb, 1);
94                 LAST_SKIP_BITS(re, &a->gb, 1);
95             } else {
96                 /* escape */
97                 run = SHOW_UBITS(re, &a->gb, 6)+1; LAST_SKIP_BITS(re, &a->gb, 6);
98                 UPDATE_CACHE(re, &a->gb);
99                 level = SHOW_SBITS(re, &a->gb, 10); SKIP_BITS(re, &a->gb, 10);
100                 i += run;
101                 j = scantable[i];
102 /*                if(level<0){
103                     level= -level;
104                     level= (level*qscale*quant_matrix[j])>>4;
105                     level= (level-1)|1;
106                     level= -level;
107                 }else{*/
108                     level= (level*qscale*quant_matrix[j])>>4;
109 /*                    level= (level-1)|1;
110                 }*/
111             }
112             if (i > 63){
113                 fprintf(stderr, "ac-tex damaged at %d %d\n", a->mb_x, a->mb_y);
114                 return -1;
115             }
116
117             block[j] = level;
118         }
119         CLOSE_READER(re, &a->gb);
120     }
121     a->block_last_index[n] = i;
122     return 0;
123 }
124
125 static inline int decode_mb(MDECContext *a, DCTELEM block[6][64]){
126     int i;
127
128     a->dsp.clear_blocks(block[0]);
129     
130     for(i=5; i>=0; i--){
131         if( mdec_decode_block_intra(a, block[i], i) < 0) 
132             return -1;
133     }
134     return 0;
135 }
136
137 static inline void idct_put(MDECContext *a, int mb_x, int mb_y){
138     DCTELEM (*block)[64]= a->block;
139     int linesize= a->picture.linesize[0];
140     
141     uint8_t *dest_y  = a->picture.data[0] + (mb_y * 16* linesize              ) + mb_x * 16;
142     uint8_t *dest_cb = a->picture.data[1] + (mb_y * 8 * a->picture.linesize[1]) + mb_x * 8;
143     uint8_t *dest_cr = a->picture.data[2] + (mb_y * 8 * a->picture.linesize[2]) + mb_x * 8;
144
145     a->dsp.idct_put(dest_y                 , linesize, block[0]);
146     a->dsp.idct_put(dest_y              + 8, linesize, block[1]);
147     a->dsp.idct_put(dest_y + 8*linesize    , linesize, block[2]);
148     a->dsp.idct_put(dest_y + 8*linesize + 8, linesize, block[3]);
149
150     if(!(a->avctx->flags&CODEC_FLAG_GRAY)){
151         a->dsp.idct_put(dest_cb, a->picture.linesize[1], block[4]);
152         a->dsp.idct_put(dest_cr, a->picture.linesize[2], block[5]);
153     }
154 }
155
156 static int decode_frame(AVCodecContext *avctx, 
157                         void *data, int *data_size,
158                         uint8_t *buf, int buf_size)
159 {
160     MDECContext * const a = avctx->priv_data;
161     AVFrame *picture = data;
162     AVFrame * const p= (AVFrame*)&a->picture;
163     int i;
164
165     *data_size = 0;
166
167     /* special case for last picture */
168     if (buf_size == 0) {
169         return 0;
170     }
171
172     if(p->data[0])
173         avctx->release_buffer(avctx, p);
174
175     p->reference= 0;
176     if(avctx->get_buffer(avctx, p) < 0){
177         fprintf(stderr, "get_buffer() failed\n");
178         return -1;
179     }
180     p->pict_type= I_TYPE;
181     p->key_frame= 1;
182     a->last_dc[0]=
183     a->last_dc[1]=
184     a->last_dc[2]= 0;
185
186     a->bitstream_buffer= av_fast_realloc(a->bitstream_buffer, &a->bitstream_buffer_size, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
187     for(i=0; i<buf_size; i+=2){
188         a->bitstream_buffer[i]  = buf[i+1];
189         a->bitstream_buffer[i+1]= buf[i  ];
190     }
191     init_get_bits(&a->gb, a->bitstream_buffer, buf_size*8);
192     
193     /* skip over 4 preamble bytes in stream (typically 0xXX 0xXX 0x00 0x38) */
194     skip_bits(&a->gb, 32);
195
196     a->qscale=  get_bits(&a->gb, 16);
197     a->version= get_bits(&a->gb, 16);
198     
199     printf("qscale:%d (0x%X), version:%d (0x%X)\n", a->qscale, a->qscale, a->version, a->version);
200     
201     for(a->mb_x=0; a->mb_x<a->mb_width; a->mb_x++){
202         for(a->mb_y=0; a->mb_y<a->mb_height; a->mb_y++){
203             if( decode_mb(a, a->block) <0)
204                 return -1;
205              
206             idct_put(a, a->mb_x, a->mb_y);
207         }
208     }
209
210 //    p->quality= (32 + a->inv_qscale/2)/a->inv_qscale;
211 //    memset(p->qscale_table, p->quality, p->qstride*a->mb_height);
212     
213     *picture= *(AVFrame*)&a->picture;
214     *data_size = sizeof(AVPicture);
215
216     emms_c();
217     
218     return (get_bits_count(&a->gb)+31)/32*4;
219 }
220
221 static void mdec_common_init(AVCodecContext *avctx){
222     MDECContext * const a = avctx->priv_data;
223
224     dsputil_init(&a->dsp, avctx);
225
226     a->mb_width   = (avctx->width  + 15) / 16;
227     a->mb_height  = (avctx->height + 15) / 16;
228
229     avctx->coded_frame= (AVFrame*)&a->picture;
230     a->avctx= avctx;
231 }
232
233 static int decode_init(AVCodecContext *avctx){
234     MDECContext * const a = avctx->priv_data;
235     AVFrame *p= (AVFrame*)&a->picture;
236  
237     mdec_common_init(avctx);
238     init_vlcs();
239     ff_init_scantable(a->dsp.idct_permutation, &a->scantable, ff_zigzag_direct);
240 /*
241     for(i=0; i<64; i++){
242         int index= ff_zigzag_direct[i];
243         a->intra_matrix[i]= 64*ff_mpeg1_default_intra_matrix[index] / a->inv_qscale;
244     }
245 */
246     p->qstride= a->mb_width;
247     p->qscale_table= av_mallocz( p->qstride * a->mb_height);
248
249     return 0;
250 }
251
252 static int decode_end(AVCodecContext *avctx){
253     MDECContext * const a = avctx->priv_data;
254
255     av_freep(&a->bitstream_buffer);
256     av_freep(&a->picture.qscale_table);
257     a->bitstream_buffer_size=0;
258     
259     avcodec_default_free_buffers(avctx);
260
261     return 0;
262 }
263
264 AVCodec mdec_decoder = {
265     "mdec",
266     CODEC_TYPE_VIDEO,
267     CODEC_ID_MDEC,
268     sizeof(MDECContext),
269     decode_init,
270     NULL,
271     decode_end,
272     decode_frame,
273     CODEC_CAP_DR1,
274 };
275