Mercurial > libavcodec.hg

comparison mpc8.c @ 5879:ad73103623ab libavcodec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Musepack SV8 demuxer and decoder
author kostya
date Wed, 07 Nov 2007 05:35:46 +0000
parents
children dfdff1ca78a7
comparison
equal deleted inserted replaced
5878:6c962a4004a1 5879:ad73103623ab
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
28 #include "avcodec.h"
29 #include "bitstream.h"
30 #include "dsputil.h"
31 #include "random.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
95 static int mpc8_decode_init(AVCodecContext * avctx)
96 {
97 int i;
98 MPCContext *c = avctx->priv_data;
99 GetBitContext gb;
100 static int vlc_inited = 0;
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
120 if(vlc_inited) return 0;
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 }
179 vlc_inited = 1;
180 return 0;
181 }
182
183 static int mpc8_decode_frame(AVCodecContext * avctx,
184 void *data, int *data_size,
185 uint8_t * buf, int buf_size)
186 {
187 MPCContext *c = avctx->priv_data;
188 GetBitContext gb2, *gb = &gb2;
189 int i, j, k, ch, cnt, res, t;
190 Band *bands = c->bands;
191 int off;
192 int maxband, keyframe;
193 int last[2];
194
195 keyframe = c->cur_frame == 0;
196
197 if(keyframe){
198 memset(c->Q, 0, sizeof(c->Q));
199 c->last_bits_used = 0;
200 }
201 init_get_bits(gb, buf, buf_size * 8);
202 skip_bits(gb, c->last_bits_used & 7);
203
204 if(keyframe)
205 maxband = mpc8_get_mod_golomb(gb, c->maxbands + 1);
206 else{
207 maxband = c->last_max_band + get_vlc2(gb, band_vlc.table, MPC8_BANDS_BITS, 2);
208 if(maxband > 32) maxband -= 33;
209 }
210 c->last_max_band = maxband;
211
212 /* read subband indexes */
213 if(maxband){
214 last[0] = last[1] = 0;
215 for(i = maxband - 1; i >= 0; i--){
216 for(ch = 0; ch < 2; ch++){
217 last[ch] = get_vlc2(gb, res_vlc[last[ch] > 2].table, MPC8_RES_BITS, 2) + last[ch];
218 if(last[ch] > 15) last[ch] -= 17;
219 bands[i].res[ch] = last[ch];
220 }
221 }
222 if(c->MSS){
223 int mask;
224
225 cnt = 0;
226 for(i = 0; i < maxband; i++)
227 if(bands[i].res[0] || bands[i].res[1])
228 cnt++;
229 t = mpc8_get_mod_golomb(gb, cnt);
230 mask = mpc8_get_mask(gb, cnt, t);
231 for(i = maxband - 1; i >= 0; i--)
232 if(bands[i].res[0] || bands[i].res[1]){
233 bands[i].msf = mask & 1;
234 mask >>= 1;
235 }
236 }
237 }
238 for(i = maxband; i < c->maxbands; i++)
239 bands[i].res[0] = bands[i].res[1] = 0;
240
241 if(keyframe){
242 for(i = 0; i < 32; i++)
243 c->oldDSCF[0][i] = c->oldDSCF[1][i] = 1;
244 }
245
246 for(i = 0; i < maxband; i++){
247 if(bands[i].res[0] || bands[i].res[1]){
248 cnt = !!bands[i].res[0] + !!bands[i].res[1] - 1;
249 if(cnt >= 0){
250 t = get_vlc2(gb, scfi_vlc[cnt].table, scfi_vlc[cnt].bits, 1);
251 if(bands[i].res[0]) bands[i].scfi[0] = t >> (2 * cnt);
252 if(bands[i].res[1]) bands[i].scfi[1] = t & 3;
253 }
254 }
255 }
256
257 for(i = 0; i < maxband; i++){
258 for(ch = 0; ch < 2; ch++){
259 if(!bands[i].res[ch]) continue;
260
261 if(c->oldDSCF[ch][i]){
262 bands[i].scf_idx[ch][0] = get_bits(gb, 7) - 6;
263 c->oldDSCF[ch][i] = 0;
264 }else{
265 t = get_vlc2(gb, dscf_vlc[1].table, MPC8_DSCF1_BITS, 2);
266 if(t == 64)
267 t += get_bits(gb, 6);
268 bands[i].scf_idx[ch][0] = ((bands[i].scf_idx[ch][2] + t - 25) & 0x7F) - 6;
269 }
270 for(j = 0; j < 2; j++){
271 if((bands[i].scfi[ch] << j) & 2)
272 bands[i].scf_idx[ch][j + 1] = bands[i].scf_idx[ch][j];
273 else{
274 t = get_vlc2(gb, dscf_vlc[0].table, MPC8_DSCF0_BITS, 2);
275 if(t == 31)
276 t = 64 + get_bits(gb, 6);
277 bands[i].scf_idx[ch][j + 1] = ((bands[i].scf_idx[ch][j] + t - 25) & 0x7F) - 6;
278 }
279 }
280 }
281 }
282
283 for(i = 0, off = 0; i < maxband; i++, off += SAMPLES_PER_BAND){
284 for(ch = 0; ch < 2; ch++){
285 res = bands[i].res[ch];
286 switch(res){
287 case -1:
288 for(j = 0; j < SAMPLES_PER_BAND; j++)
289 c->Q[ch][off + j] = (av_random(&c->rnd) & 0x3FC) - 510;
290 break;
291 case 0:
292 break;
293 case 1:
294 for(j = 0; j < SAMPLES_PER_BAND; j += SAMPLES_PER_BAND / 2){
295 cnt = get_vlc2(gb, q1_vlc.table, MPC8_Q1_BITS, 2);
296 t = mpc8_get_mask(gb, 18, cnt);
297 for(k = 0; k < SAMPLES_PER_BAND / 2; k++, t <<= 1)
298 c->Q[ch][off + j + k] = (t & 0x20000) ? (get_bits1(gb) << 1) - 1 : 0;
299 }
300 break;
301 case 2:
302 cnt = 6;//2*mpc8_thres[res]
303 for(j = 0; j < SAMPLES_PER_BAND; j += 3){
304 t = get_vlc2(gb, q2_vlc[cnt > 3].table, MPC8_Q2_BITS, 2);
305 c->Q[ch][off + j + 0] = mpc8_idx50[t];
306 c->Q[ch][off + j + 1] = mpc8_idx51[t];
307 c->Q[ch][off + j + 2] = mpc8_idx52[t];
308 cnt = (cnt >> 1) + mpc8_huffq2[t];
309 }
310 break;
311 case 3:
312 case 4:
313 for(j = 0; j < SAMPLES_PER_BAND; j += 2){
314 t = get_vlc2(gb, q3_vlc[res - 3].table, MPC8_Q3_BITS, 2) + q3_offsets[res - 3];
315 c->Q[ch][off + j + 1] = t >> 4;
316 c->Q[ch][off + j + 0] = (t & 8) ? (t & 0xF) - 16 : (t & 0xF);
317 }
318 break;
319 case 5:
320 case 6:
321 case 7:
322 case 8:
323 cnt = 2 * mpc8_thres[res];
324 for(j = 0; j < SAMPLES_PER_BAND; j++){
325 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];
326 c->Q[ch][off + j] = t;
327 cnt = (cnt >> 1) + FFABS(c->Q[ch][off + j]);
328 }
329 break;
330 default:
331 for(j = 0; j < SAMPLES_PER_BAND; j++){
332 c->Q[ch][off + j] = get_vlc2(gb, q9up_vlc.table, MPC8_Q9UP_BITS, 2);
333 if(res != 9){
334 c->Q[ch][off + j] <<= res - 9;
335 c->Q[ch][off + j] |= get_bits(gb, res - 9);
336 }
337 c->Q[ch][off + j] -= (1 << (res - 2)) - 1;
338 }
339 }
340 }
341 }
342
343 ff_mpc_dequantize_and_synth(c, maxband, data);
344
345 c->cur_frame++;
346
347 c->last_bits_used = get_bits_count(gb);
348 if(c->cur_frame >= c->frames)
349 c->cur_frame = 0;
350 *data_size = MPC_FRAME_SIZE * 4;
351
352 return c->cur_frame ? c->last_bits_used >> 3 : buf_size;
353 }
354
355 AVCodec mpc8_decoder = {
356 "mpc sv8",
357 CODEC_TYPE_AUDIO,
358 CODEC_ID_MUSEPACK8,
359 sizeof(MPCContext),
360 mpc8_decode_init,
361 NULL,
362 NULL,
363 mpc8_decode_frame,
364 };