ffmpeg / libavcodec / mdec.c @ 5509bffa
History | View | Annotate | Download (7.83 KB)
1 | c3bf0288 | Michael Niedermayer | /*
|
---|---|---|---|
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 | 5509bffa | Diego Biurrun | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
18 | c3bf0288 | Michael Niedermayer | *
|
19 | * based upon code from Sebastian Jedruszkiewicz <elf@frogger.rules.pl>
|
||
20 | */
|
||
21 | 115329f1 | Diego Biurrun | |
22 | c3bf0288 | Michael Niedermayer | /**
|
23 | * @file mdec.c
|
||
24 | * PSX MDEC codec.
|
||
25 | * This is very similar to intra only MPEG1.
|
||
26 | */
|
||
27 | 115329f1 | Diego Biurrun | |
28 | c3bf0288 | Michael Niedermayer | #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 | 67b04c1a | Michael Niedermayer | block[0]= 2*get_sbits(&a->gb, 10) + 1024; |
69 | c3bf0288 | Michael Niedermayer | }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 | 115329f1 | Diego Biurrun | |
78 | c3bf0288 | Michael Niedermayer | i = 0;
|
79 | { |
||
80 | 115329f1 | Diego Biurrun | OPEN_READER(re, &a->gb); |
81 | c3bf0288 | Michael Niedermayer | /* now quantify & encode AC coefs */
|
82 | for(;;) {
|
||
83 | UPDATE_CACHE(re, &a->gb); |
||
84 | e91f4bf1 | Michael Niedermayer | GET_RL_VLC(level, run, re, &a->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0); |
85 | 115329f1 | Diego Biurrun | |
86 | c3bf0288 | Michael Niedermayer | 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 | 67b04c1a | Michael Niedermayer | // level= (level-1)|1;
|
93 | c3bf0288 | Michael Niedermayer | 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 | bf5d0505 | Michael Niedermayer | level = SHOW_SBITS(re, &a->gb, 10); SKIP_BITS(re, &a->gb, 10); |
100 | c3bf0288 | Michael Niedermayer | i += run; |
101 | j = scantable[i]; |
||
102 | 67b04c1a | Michael Niedermayer | if(level<0){ |
103 | c3bf0288 | Michael Niedermayer | level= -level; |
104 | 67b04c1a | Michael Niedermayer | level= (level*qscale*quant_matrix[j])>>3;
|
105 | c3bf0288 | Michael Niedermayer | level= (level-1)|1; |
106 | level= -level; |
||
107 | 67b04c1a | Michael Niedermayer | }else{
|
108 | level= (level*qscale*quant_matrix[j])>>3;
|
||
109 | level= (level-1)|1; |
||
110 | } |
||
111 | c3bf0288 | Michael Niedermayer | } |
112 | if (i > 63){ |
||
113 | 9b879566 | Michel Bardiaux | av_log(a->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", a->mb_x, a->mb_y);
|
114 | c3bf0288 | Michael Niedermayer | 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 | 77ee78bc | Michael Niedermayer | const int block_index[6]= {5,4,0,1,2,3}; |
128 | c3bf0288 | Michael Niedermayer | |
129 | a->dsp.clear_blocks(block[0]);
|
||
130 | 115329f1 | Diego Biurrun | |
131 | 67b04c1a | Michael Niedermayer | for(i=0; i<6; i++){ |
132 | 115329f1 | Diego Biurrun | if( mdec_decode_block_intra(a, block[ block_index[i] ], block_index[i]) < 0) |
133 | c3bf0288 | Michael Niedermayer | return -1; |
134 | } |
||
135 | return 0; |
||
136 | } |
||
137 | |||
138 | static inline void idct_put(MDECContext *a, int mb_x, int mb_y){ |
||
139 | DCTELEM (*block)[64]= a->block;
|
||
140 | int linesize= a->picture.linesize[0]; |
||
141 | 115329f1 | Diego Biurrun | |
142 | c3bf0288 | Michael Niedermayer | uint8_t *dest_y = a->picture.data[0] + (mb_y * 16* linesize ) + mb_x * 16; |
143 | uint8_t *dest_cb = a->picture.data[1] + (mb_y * 8 * a->picture.linesize[1]) + mb_x * 8; |
||
144 | uint8_t *dest_cr = a->picture.data[2] + (mb_y * 8 * a->picture.linesize[2]) + mb_x * 8; |
||
145 | |||
146 | a->dsp.idct_put(dest_y , linesize, block[0]);
|
||
147 | a->dsp.idct_put(dest_y + 8, linesize, block[1]); |
||
148 | a->dsp.idct_put(dest_y + 8*linesize , linesize, block[2]); |
||
149 | a->dsp.idct_put(dest_y + 8*linesize + 8, linesize, block[3]); |
||
150 | |||
151 | if(!(a->avctx->flags&CODEC_FLAG_GRAY)){
|
||
152 | a->dsp.idct_put(dest_cb, a->picture.linesize[1], block[4]); |
||
153 | a->dsp.idct_put(dest_cr, a->picture.linesize[2], block[5]); |
||
154 | } |
||
155 | } |
||
156 | |||
157 | 115329f1 | Diego Biurrun | static int decode_frame(AVCodecContext *avctx, |
158 | c3bf0288 | Michael Niedermayer | void *data, int *data_size, |
159 | uint8_t *buf, int buf_size)
|
||
160 | { |
||
161 | MDECContext * const a = avctx->priv_data;
|
||
162 | AVFrame *picture = data; |
||
163 | AVFrame * const p= (AVFrame*)&a->picture;
|
||
164 | int i;
|
||
165 | |||
166 | if(p->data[0]) |
||
167 | avctx->release_buffer(avctx, p); |
||
168 | |||
169 | p->reference= 0;
|
||
170 | if(avctx->get_buffer(avctx, p) < 0){ |
||
171 | 9b879566 | Michel Bardiaux | av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
|
172 | c3bf0288 | Michael Niedermayer | return -1; |
173 | } |
||
174 | p->pict_type= I_TYPE; |
||
175 | p->key_frame= 1;
|
||
176 | a->last_dc[0]=
|
||
177 | a->last_dc[1]=
|
||
178 | a->last_dc[2]= 0; |
||
179 | |||
180 | a->bitstream_buffer= av_fast_realloc(a->bitstream_buffer, &a->bitstream_buffer_size, buf_size + FF_INPUT_BUFFER_PADDING_SIZE); |
||
181 | dc98fc8d | Michael Niedermayer | for(i=0; i<buf_size; i+=2){ |
182 | a->bitstream_buffer[i] = buf[i+1];
|
||
183 | a->bitstream_buffer[i+1]= buf[i ];
|
||
184 | c3bf0288 | Michael Niedermayer | } |
185 | init_get_bits(&a->gb, a->bitstream_buffer, buf_size*8);
|
||
186 | 115329f1 | Diego Biurrun | |
187 | 421e0859 | Mike Melanson | /* skip over 4 preamble bytes in stream (typically 0xXX 0xXX 0x00 0x38) */
|
188 | skip_bits(&a->gb, 32);
|
||
189 | |||
190 | c3bf0288 | Michael Niedermayer | a->qscale= get_bits(&a->gb, 16);
|
191 | a->version= get_bits(&a->gb, 16);
|
||
192 | 115329f1 | Diego Biurrun | |
193 | e986b6e2 | Mike Melanson | // printf("qscale:%d (0x%X), version:%d (0x%X)\n", a->qscale, a->qscale, a->version, a->version);
|
194 | 115329f1 | Diego Biurrun | |
195 | bf5d0505 | Michael Niedermayer | for(a->mb_x=0; a->mb_x<a->mb_width; a->mb_x++){ |
196 | for(a->mb_y=0; a->mb_y<a->mb_height; a->mb_y++){ |
||
197 | c3bf0288 | Michael Niedermayer | if( decode_mb(a, a->block) <0) |
198 | return -1; |
||
199 | 115329f1 | Diego Biurrun | |
200 | c3bf0288 | Michael Niedermayer | idct_put(a, a->mb_x, a->mb_y); |
201 | } |
||
202 | } |
||
203 | |||
204 | // p->quality= (32 + a->inv_qscale/2)/a->inv_qscale;
|
||
205 | // memset(p->qscale_table, p->quality, p->qstride*a->mb_height);
|
||
206 | 115329f1 | Diego Biurrun | |
207 | c3bf0288 | Michael Niedermayer | *picture= *(AVFrame*)&a->picture; |
208 | *data_size = sizeof(AVPicture);
|
||
209 | |||
210 | emms_c(); |
||
211 | 115329f1 | Diego Biurrun | |
212 | c3bf0288 | Michael Niedermayer | return (get_bits_count(&a->gb)+31)/32*4; |
213 | } |
||
214 | |||
215 | static void mdec_common_init(AVCodecContext *avctx){ |
||
216 | MDECContext * const a = avctx->priv_data;
|
||
217 | |||
218 | dsputil_init(&a->dsp, avctx); |
||
219 | |||
220 | 21adafec | Michael Niedermayer | a->mb_width = (avctx->coded_width + 15) / 16; |
221 | a->mb_height = (avctx->coded_height + 15) / 16; |
||
222 | c3bf0288 | Michael Niedermayer | |
223 | avctx->coded_frame= (AVFrame*)&a->picture; |
||
224 | a->avctx= avctx; |
||
225 | } |
||
226 | |||
227 | static int decode_init(AVCodecContext *avctx){ |
||
228 | MDECContext * const a = avctx->priv_data;
|
||
229 | AVFrame *p= (AVFrame*)&a->picture; |
||
230 | 115329f1 | Diego Biurrun | |
231 | c3bf0288 | Michael Niedermayer | mdec_common_init(avctx); |
232 | init_vlcs(); |
||
233 | ff_init_scantable(a->dsp.idct_permutation, &a->scantable, ff_zigzag_direct); |
||
234 | /*
|
||
235 | for(i=0; i<64; i++){
|
||
236 | int index= ff_zigzag_direct[i];
|
||
237 | a->intra_matrix[i]= 64*ff_mpeg1_default_intra_matrix[index] / a->inv_qscale;
|
||
238 | }
|
||
239 | */
|
||
240 | p->qstride= a->mb_width; |
||
241 | p->qscale_table= av_mallocz( p->qstride * a->mb_height); |
||
242 | 2eca4a44 | Michael Niedermayer | avctx->pix_fmt= PIX_FMT_YUV420P; |
243 | c3bf0288 | Michael Niedermayer | |
244 | return 0; |
||
245 | } |
||
246 | |||
247 | static int decode_end(AVCodecContext *avctx){ |
||
248 | MDECContext * const a = avctx->priv_data;
|
||
249 | |||
250 | av_freep(&a->bitstream_buffer); |
||
251 | av_freep(&a->picture.qscale_table); |
||
252 | a->bitstream_buffer_size=0;
|
||
253 | 115329f1 | Diego Biurrun | |
254 | c3bf0288 | Michael Niedermayer | return 0; |
255 | } |
||
256 | |||
257 | AVCodec mdec_decoder = { |
||
258 | "mdec",
|
||
259 | CODEC_TYPE_VIDEO, |
||
260 | CODEC_ID_MDEC, |
||
261 | sizeof(MDECContext),
|
||
262 | decode_init, |
||
263 | NULL,
|
||
264 | decode_end, |
||
265 | decode_frame, |
||
266 | CODEC_CAP_DR1, |
||
267 | }; |