Mercurial > libavcodec.hg
annotate mpc8.c @ 8228:416ffc3907bf libavcodec
Remove ineffectual hack that attempts to build ppc/check_altivec.o without
AltiVec flags. The flags are set by configure and used to compile all files
anyway. Setting extra AltiVec options here just duplicates them for the files
for which they are set.
author | diego |
---|---|
date | Sun, 30 Nov 2008 16:57:28 +0000 |
parents | f11197441364 |
children | 7a463923ecd1 |
rev | line source |
---|---|
5879 | 1 /* |
2 * Musepack SV8 decoder | |
3 * Copyright (c) 2007 Konstantin Shishkov | |
4 * | |
5 * This file is part of FFmpeg. | |
6 * | |
7 * FFmpeg is free software; you can redistribute it and/or | |
8 * modify it under the terms of the GNU Lesser General Public | |
9 * License as published by the Free Software Foundation; either | |
10 * version 2.1 of the License, or (at your option) any later version. | |
11 * | |
12 * FFmpeg is distributed in the hope that it will be useful, | |
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 * Lesser General Public License for more details. | |
16 * | |
17 * You should have received a copy of the GNU Lesser General Public | |
18 * License along with FFmpeg; if not, write to the Free Software | |
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
20 */ | |
21 | |
22 /** | |
23 * @file mpc8.c Musepack SV8 decoder | |
24 * MPEG Audio Layer 1/2 -like codec with frames of 1152 samples | |
25 * divided into 32 subbands. | |
26 */ | |
27 | |
6763 | 28 #include "libavutil/random.h" |
5879 | 29 #include "avcodec.h" |
30 #include "bitstream.h" | |
31 #include "dsputil.h" | |
32 | |
33 #ifdef CONFIG_MPEGAUDIO_HP | |
34 #define USE_HIGHPRECISION | |
35 #endif | |
36 #include "mpegaudio.h" | |
37 | |
38 #include "mpc.h" | |
39 #include "mpcdata.h" | |
40 #include "mpc8data.h" | |
41 #include "mpc8huff.h" | |
42 | |
43 static VLC band_vlc, scfi_vlc[2], dscf_vlc[2], res_vlc[2]; | |
44 static VLC q1_vlc, q2_vlc[2], q3_vlc[2], quant_vlc[4][2], q9up_vlc; | |
45 | |
46 static const int q3_offsets[2] = { MPC8_Q3_OFFSET, MPC8_Q4_OFFSET }; | |
47 static const int quant_offsets[6] = { MPC8_Q5_OFFSET, MPC8_Q6_OFFSET, MPC8_Q7_OFFSET, MPC8_Q8_OFFSET }; | |
48 | |
49 static inline int mpc8_dec_base(GetBitContext *gb, int k, int n) | |
50 { | |
51 int code = get_bits(gb, mpc8_cnk_len[k-1][n-1] - 1); | |
52 | |
53 if (code >= mpc8_cnk_lost[k-1][n-1]) | |
54 code = ((code << 1) | get_bits1(gb)) - mpc8_cnk_lost[k-1][n-1]; | |
55 | |
56 return code; | |
57 } | |
58 | |
59 static inline int mpc8_dec_enum(GetBitContext *gb, int k, int n) | |
60 { | |
61 int bits = 0; | |
62 const uint32_t * C = mpc8_cnk[k-1]; | |
63 int code = mpc8_dec_base(gb, k, n); | |
64 | |
65 do { | |
66 n--; | |
67 if (code >= C[n]) { | |
68 bits |= 1 << n; | |
69 code -= C[n]; | |
70 C -= 32; | |
71 k--; | |
72 } | |
73 } while(k > 0); | |
74 | |
75 return bits; | |
76 } | |
77 | |
78 static inline int mpc8_get_mod_golomb(GetBitContext *gb, int m) | |
79 { | |
80 if(mpc8_cnk_len[0][m] < 1) return 0; | |
81 return mpc8_dec_base(gb, 1, m+1); | |
82 } | |
83 | |
84 static int mpc8_get_mask(GetBitContext *gb, int size, int t) | |
85 { | |
86 int mask = 0; | |
87 | |
88 if(t && t != size) | |
89 mask = mpc8_dec_enum(gb, FFMIN(t, size - t), size); | |
90 if((t << 1) > size) mask = ~mask; | |
91 | |
92 return mask; | |
93 } | |
94 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6350
diff
changeset
|
95 static av_cold int mpc8_decode_init(AVCodecContext * avctx) |
5879 | 96 { |
97 int i; | |
98 MPCContext *c = avctx->priv_data; | |
99 GetBitContext gb; | |
6350 | 100 static int vlc_initialized = 0; |
5879 | 101 |
102 if(avctx->extradata_size < 2){ | |
103 av_log(avctx, AV_LOG_ERROR, "Too small extradata size (%i)!\n", avctx->extradata_size); | |
104 return -1; | |
105 } | |
106 memset(c->oldDSCF, 0, sizeof(c->oldDSCF)); | |
107 av_init_random(0xDEADBEEF, &c->rnd); | |
108 dsputil_init(&c->dsp, avctx); | |
109 | |
110 ff_mpc_init(); | |
111 | |
112 init_get_bits(&gb, avctx->extradata, 16); | |
113 | |
114 skip_bits(&gb, 3);//sample rate | |
115 c->maxbands = get_bits(&gb, 5) + 1; | |
116 skip_bits(&gb, 4);//channels | |
117 c->MSS = get_bits1(&gb); | |
118 c->frames = 1 << (get_bits(&gb, 3) * 2); | |
119 | |
6350 | 120 if(vlc_initialized) return 0; |
5879 | 121 av_log(avctx, AV_LOG_DEBUG, "Initing VLC\n"); |
122 | |
123 init_vlc(&band_vlc, MPC8_BANDS_BITS, MPC8_BANDS_SIZE, | |
124 mpc8_bands_bits, 1, 1, | |
125 mpc8_bands_codes, 1, 1, INIT_VLC_USE_STATIC); | |
126 | |
127 init_vlc(&q1_vlc, MPC8_Q1_BITS, MPC8_Q1_SIZE, | |
128 mpc8_q1_bits, 1, 1, | |
129 mpc8_q1_codes, 1, 1, INIT_VLC_USE_STATIC); | |
130 init_vlc(&q9up_vlc, MPC8_Q9UP_BITS, MPC8_Q9UP_SIZE, | |
131 mpc8_q9up_bits, 1, 1, | |
132 mpc8_q9up_codes, 1, 1, INIT_VLC_USE_STATIC); | |
133 | |
134 init_vlc(&scfi_vlc[0], MPC8_SCFI0_BITS, MPC8_SCFI0_SIZE, | |
135 mpc8_scfi0_bits, 1, 1, | |
136 mpc8_scfi0_codes, 1, 1, INIT_VLC_USE_STATIC); | |
137 init_vlc(&scfi_vlc[1], MPC8_SCFI1_BITS, MPC8_SCFI1_SIZE, | |
138 mpc8_scfi1_bits, 1, 1, | |
139 mpc8_scfi1_codes, 1, 1, INIT_VLC_USE_STATIC); | |
140 | |
141 init_vlc(&dscf_vlc[0], MPC8_DSCF0_BITS, MPC8_DSCF0_SIZE, | |
142 mpc8_dscf0_bits, 1, 1, | |
143 mpc8_dscf0_codes, 1, 1, INIT_VLC_USE_STATIC); | |
144 init_vlc(&dscf_vlc[1], MPC8_DSCF1_BITS, MPC8_DSCF1_SIZE, | |
145 mpc8_dscf1_bits, 1, 1, | |
146 mpc8_dscf1_codes, 1, 1, INIT_VLC_USE_STATIC); | |
147 | |
148 init_vlc_sparse(&q3_vlc[0], MPC8_Q3_BITS, MPC8_Q3_SIZE, | |
149 mpc8_q3_bits, 1, 1, | |
150 mpc8_q3_codes, 1, 1, | |
151 mpc8_q3_syms, 1, 1, INIT_VLC_USE_STATIC); | |
152 init_vlc_sparse(&q3_vlc[1], MPC8_Q4_BITS, MPC8_Q4_SIZE, | |
153 mpc8_q4_bits, 1, 1, | |
154 mpc8_q4_codes, 1, 1, | |
155 mpc8_q4_syms, 1, 1, INIT_VLC_USE_STATIC); | |
156 | |
157 for(i = 0; i < 2; i++){ | |
158 init_vlc(&res_vlc[i], MPC8_RES_BITS, MPC8_RES_SIZE, | |
159 &mpc8_res_bits[i], 1, 1, | |
160 &mpc8_res_codes[i], 1, 1, INIT_VLC_USE_STATIC); | |
161 | |
162 init_vlc(&q2_vlc[i], MPC8_Q2_BITS, MPC8_Q2_SIZE, | |
163 &mpc8_q2_bits[i], 1, 1, | |
164 &mpc8_q2_codes[i], 1, 1, INIT_VLC_USE_STATIC); | |
165 | |
166 init_vlc(&quant_vlc[0][i], MPC8_Q5_BITS, MPC8_Q5_SIZE, | |
167 &mpc8_q5_bits[i], 1, 1, | |
168 &mpc8_q5_codes[i], 1, 1, INIT_VLC_USE_STATIC); | |
169 init_vlc(&quant_vlc[1][i], MPC8_Q6_BITS, MPC8_Q6_SIZE, | |
170 &mpc8_q6_bits[i], 1, 1, | |
171 &mpc8_q6_codes[i], 1, 1, INIT_VLC_USE_STATIC); | |
172 init_vlc(&quant_vlc[2][i], MPC8_Q7_BITS, MPC8_Q7_SIZE, | |
173 &mpc8_q7_bits[i], 1, 1, | |
174 &mpc8_q7_codes[i], 1, 1, INIT_VLC_USE_STATIC); | |
175 init_vlc(&quant_vlc[3][i], MPC8_Q8_BITS, MPC8_Q8_SIZE, | |
176 &mpc8_q8_bits[i], 1, 1, | |
177 &mpc8_q8_codes[i], 1, 1, INIT_VLC_USE_STATIC); | |
178 } | |
6350 | 179 vlc_initialized = 1; |
7451
85ab7655ad4d
Modify all codecs to report their supported input and output sample format(s).
pross
parents:
7040
diff
changeset
|
180 avctx->sample_fmt = SAMPLE_FMT_S16; |
8174
f11197441364
Add channel layout to several audio decoders I maintain
kostya
parents:
7451
diff
changeset
|
181 avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO; |
5879 | 182 return 0; |
183 } | |
184 | |
185 static int mpc8_decode_frame(AVCodecContext * avctx, | |
186 void *data, int *data_size, | |
6218 | 187 const uint8_t * buf, int buf_size) |
5879 | 188 { |
189 MPCContext *c = avctx->priv_data; | |
190 GetBitContext gb2, *gb = &gb2; | |
191 int i, j, k, ch, cnt, res, t; | |
192 Band *bands = c->bands; | |
193 int off; | |
194 int maxband, keyframe; | |
195 int last[2]; | |
196 | |
197 keyframe = c->cur_frame == 0; | |
198 | |
199 if(keyframe){ | |
200 memset(c->Q, 0, sizeof(c->Q)); | |
201 c->last_bits_used = 0; | |
202 } | |
203 init_get_bits(gb, buf, buf_size * 8); | |
204 skip_bits(gb, c->last_bits_used & 7); | |
205 | |
206 if(keyframe) | |
207 maxband = mpc8_get_mod_golomb(gb, c->maxbands + 1); | |
208 else{ | |
209 maxband = c->last_max_band + get_vlc2(gb, band_vlc.table, MPC8_BANDS_BITS, 2); | |
210 if(maxband > 32) maxband -= 33; | |
211 } | |
212 c->last_max_band = maxband; | |
213 | |
214 /* read subband indexes */ | |
215 if(maxband){ | |
216 last[0] = last[1] = 0; | |
217 for(i = maxband - 1; i >= 0; i--){ | |
218 for(ch = 0; ch < 2; ch++){ | |
219 last[ch] = get_vlc2(gb, res_vlc[last[ch] > 2].table, MPC8_RES_BITS, 2) + last[ch]; | |
220 if(last[ch] > 15) last[ch] -= 17; | |
221 bands[i].res[ch] = last[ch]; | |
222 } | |
223 } | |
224 if(c->MSS){ | |
225 int mask; | |
226 | |
227 cnt = 0; | |
228 for(i = 0; i < maxband; i++) | |
229 if(bands[i].res[0] || bands[i].res[1]) | |
230 cnt++; | |
231 t = mpc8_get_mod_golomb(gb, cnt); | |
232 mask = mpc8_get_mask(gb, cnt, t); | |
233 for(i = maxband - 1; i >= 0; i--) | |
234 if(bands[i].res[0] || bands[i].res[1]){ | |
235 bands[i].msf = mask & 1; | |
236 mask >>= 1; | |
237 } | |
238 } | |
239 } | |
240 for(i = maxband; i < c->maxbands; i++) | |
241 bands[i].res[0] = bands[i].res[1] = 0; | |
242 | |
243 if(keyframe){ | |
244 for(i = 0; i < 32; i++) | |
245 c->oldDSCF[0][i] = c->oldDSCF[1][i] = 1; | |
246 } | |
247 | |
248 for(i = 0; i < maxband; i++){ | |
249 if(bands[i].res[0] || bands[i].res[1]){ | |
250 cnt = !!bands[i].res[0] + !!bands[i].res[1] - 1; | |
251 if(cnt >= 0){ | |
252 t = get_vlc2(gb, scfi_vlc[cnt].table, scfi_vlc[cnt].bits, 1); | |
253 if(bands[i].res[0]) bands[i].scfi[0] = t >> (2 * cnt); | |
254 if(bands[i].res[1]) bands[i].scfi[1] = t & 3; | |
255 } | |
256 } | |
257 } | |
258 | |
259 for(i = 0; i < maxband; i++){ | |
260 for(ch = 0; ch < 2; ch++){ | |
261 if(!bands[i].res[ch]) continue; | |
262 | |
263 if(c->oldDSCF[ch][i]){ | |
264 bands[i].scf_idx[ch][0] = get_bits(gb, 7) - 6; | |
265 c->oldDSCF[ch][i] = 0; | |
266 }else{ | |
267 t = get_vlc2(gb, dscf_vlc[1].table, MPC8_DSCF1_BITS, 2); | |
268 if(t == 64) | |
269 t += get_bits(gb, 6); | |
270 bands[i].scf_idx[ch][0] = ((bands[i].scf_idx[ch][2] + t - 25) & 0x7F) - 6; | |
271 } | |
272 for(j = 0; j < 2; j++){ | |
273 if((bands[i].scfi[ch] << j) & 2) | |
274 bands[i].scf_idx[ch][j + 1] = bands[i].scf_idx[ch][j]; | |
275 else{ | |
276 t = get_vlc2(gb, dscf_vlc[0].table, MPC8_DSCF0_BITS, 2); | |
277 if(t == 31) | |
278 t = 64 + get_bits(gb, 6); | |
279 bands[i].scf_idx[ch][j + 1] = ((bands[i].scf_idx[ch][j] + t - 25) & 0x7F) - 6; | |
280 } | |
281 } | |
282 } | |
283 } | |
284 | |
285 for(i = 0, off = 0; i < maxband; i++, off += SAMPLES_PER_BAND){ | |
286 for(ch = 0; ch < 2; ch++){ | |
287 res = bands[i].res[ch]; | |
288 switch(res){ | |
289 case -1: | |
290 for(j = 0; j < SAMPLES_PER_BAND; j++) | |
291 c->Q[ch][off + j] = (av_random(&c->rnd) & 0x3FC) - 510; | |
292 break; | |
293 case 0: | |
294 break; | |
295 case 1: | |
296 for(j = 0; j < SAMPLES_PER_BAND; j += SAMPLES_PER_BAND / 2){ | |
297 cnt = get_vlc2(gb, q1_vlc.table, MPC8_Q1_BITS, 2); | |
298 t = mpc8_get_mask(gb, 18, cnt); | |
299 for(k = 0; k < SAMPLES_PER_BAND / 2; k++, t <<= 1) | |
300 c->Q[ch][off + j + k] = (t & 0x20000) ? (get_bits1(gb) << 1) - 1 : 0; | |
301 } | |
302 break; | |
303 case 2: | |
304 cnt = 6;//2*mpc8_thres[res] | |
305 for(j = 0; j < SAMPLES_PER_BAND; j += 3){ | |
306 t = get_vlc2(gb, q2_vlc[cnt > 3].table, MPC8_Q2_BITS, 2); | |
307 c->Q[ch][off + j + 0] = mpc8_idx50[t]; | |
308 c->Q[ch][off + j + 1] = mpc8_idx51[t]; | |
309 c->Q[ch][off + j + 2] = mpc8_idx52[t]; | |
310 cnt = (cnt >> 1) + mpc8_huffq2[t]; | |
311 } | |
312 break; | |
313 case 3: | |
314 case 4: | |
315 for(j = 0; j < SAMPLES_PER_BAND; j += 2){ | |
316 t = get_vlc2(gb, q3_vlc[res - 3].table, MPC8_Q3_BITS, 2) + q3_offsets[res - 3]; | |
317 c->Q[ch][off + j + 1] = t >> 4; | |
318 c->Q[ch][off + j + 0] = (t & 8) ? (t & 0xF) - 16 : (t & 0xF); | |
319 } | |
320 break; | |
321 case 5: | |
322 case 6: | |
323 case 7: | |
324 case 8: | |
325 cnt = 2 * mpc8_thres[res]; | |
326 for(j = 0; j < SAMPLES_PER_BAND; j++){ | |
327 t = get_vlc2(gb, quant_vlc[res - 5][cnt > mpc8_thres[res]].table, quant_vlc[res - 5][cnt > mpc8_thres[res]].bits, 2) + quant_offsets[res - 5]; | |
328 c->Q[ch][off + j] = t; | |
329 cnt = (cnt >> 1) + FFABS(c->Q[ch][off + j]); | |
330 } | |
331 break; | |
332 default: | |
333 for(j = 0; j < SAMPLES_PER_BAND; j++){ | |
334 c->Q[ch][off + j] = get_vlc2(gb, q9up_vlc.table, MPC8_Q9UP_BITS, 2); | |
335 if(res != 9){ | |
336 c->Q[ch][off + j] <<= res - 9; | |
337 c->Q[ch][off + j] |= get_bits(gb, res - 9); | |
338 } | |
339 c->Q[ch][off + j] -= (1 << (res - 2)) - 1; | |
340 } | |
341 } | |
342 } | |
343 } | |
344 | |
345 ff_mpc_dequantize_and_synth(c, maxband, data); | |
346 | |
347 c->cur_frame++; | |
348 | |
349 c->last_bits_used = get_bits_count(gb); | |
350 if(c->cur_frame >= c->frames) | |
351 c->cur_frame = 0; | |
352 *data_size = MPC_FRAME_SIZE * 4; | |
353 | |
354 return c->cur_frame ? c->last_bits_used >> 3 : buf_size; | |
355 } | |
356 | |
357 AVCodec mpc8_decoder = { | |
6716 | 358 "mpc8", |
5879 | 359 CODEC_TYPE_AUDIO, |
360 CODEC_ID_MUSEPACK8, | |
361 sizeof(MPCContext), | |
362 mpc8_decode_init, | |
363 NULL, | |
364 NULL, | |
365 mpc8_decode_frame, | |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6763
diff
changeset
|
366 .long_name = NULL_IF_CONFIG_SMALL("Musepack SV8"), |
5879 | 367 }; |