ffmpeg / libavcodec / mpc8.c @ 9106a698
History  View  Annotate  Download (12.1 KB)
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 021101301 USA

20 
*/

21  
22 
/**

23 
* @file libavcodec/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 "libavutil/lfg.h" 
29 
#include "avcodec.h" 
30 
#include "get_bits.h" 
31 
#include "dsputil.h" 
32 
#include "mpegaudio.h" 
33  
34 
#include "mpc.h" 
35 
#include "mpcdata.h" 
36 
#include "mpc8data.h" 
37 
#include "mpc8huff.h" 
38  
39 
static VLC band_vlc, scfi_vlc[2], dscf_vlc[2], res_vlc[2]; 
40 
static VLC q1_vlc, q2_vlc[2], q3_vlc[2], quant_vlc[4][2], q9up_vlc; 
41  
42 
static const int q3_offsets[2] = { MPC8_Q3_OFFSET, MPC8_Q4_OFFSET }; 
43 
static const int quant_offsets[6] = { MPC8_Q5_OFFSET, MPC8_Q6_OFFSET, MPC8_Q7_OFFSET, MPC8_Q8_OFFSET }; 
44  
45 
static inline int mpc8_dec_base(GetBitContext *gb, int k, int n) 
46 
{ 
47 
int code = get_bits(gb, mpc8_cnk_len[k1][n1]  1); 
48  
49 
if (code >= mpc8_cnk_lost[k1][n1]) 
50 
code = ((code << 1)  get_bits1(gb))  mpc8_cnk_lost[k1][n1]; 
51  
52 
return code;

53 
} 
54  
55 
static inline int mpc8_dec_enum(GetBitContext *gb, int k, int n) 
56 
{ 
57 
int bits = 0; 
58 
const uint32_t * C = mpc8_cnk[k1]; 
59 
int code = mpc8_dec_base(gb, k, n);

60  
61 
do {

62 
n; 
63 
if (code >= C[n]) {

64 
bits = 1 << n;

65 
code = C[n]; 
66 
C = 32;

67 
k; 
68 
} 
69 
} while(k > 0); 
70  
71 
return bits;

72 
} 
73  
74 
static inline int mpc8_get_mod_golomb(GetBitContext *gb, int m) 
75 
{ 
76 
if(mpc8_cnk_len[0][m] < 1) return 0; 
77 
return mpc8_dec_base(gb, 1, m+1); 
78 
} 
79  
80 
static int mpc8_get_mask(GetBitContext *gb, int size, int t) 
81 
{ 
82 
int mask = 0; 
83  
84 
if(t && t != size)

85 
mask = mpc8_dec_enum(gb, FFMIN(t, size  t), size); 
86 
if((t << 1) > size) mask = ~mask; 
87  
88 
return mask;

89 
} 
90  
91 
static av_cold int mpc8_decode_init(AVCodecContext * avctx) 
92 
{ 
93 
int i;

94 
MPCContext *c = avctx>priv_data; 
95 
GetBitContext gb; 
96 
static int vlc_initialized = 0; 
97  
98 
if(avctx>extradata_size < 2){ 
99 
av_log(avctx, AV_LOG_ERROR, "Too small extradata size (%i)!\n", avctx>extradata_size);

100 
return 1; 
101 
} 
102 
memset(c>oldDSCF, 0, sizeof(c>oldDSCF)); 
103 
av_lfg_init(&c>rnd, 0xDEADBEEF);

104 
dsputil_init(&c>dsp, avctx); 
105  
106 
ff_mpc_init(); 
107  
108 
init_get_bits(&gb, avctx>extradata, 16);

109  
110 
skip_bits(&gb, 3);//sample rate 
111 
c>maxbands = get_bits(&gb, 5) + 1; 
112 
skip_bits(&gb, 4);//channels 
113 
c>MSS = get_bits1(&gb); 
114 
c>frames = 1 << (get_bits(&gb, 3) * 2); 
115  
116 
if(vlc_initialized) return 0; 
117 
av_log(avctx, AV_LOG_DEBUG, "Initing VLC\n");

118  
119 
init_vlc(&band_vlc, MPC8_BANDS_BITS, MPC8_BANDS_SIZE, 
120 
mpc8_bands_bits, 1, 1, 
121 
mpc8_bands_codes, 1, 1, INIT_VLC_USE_STATIC); 
122  
123 
init_vlc(&q1_vlc, MPC8_Q1_BITS, MPC8_Q1_SIZE, 
124 
mpc8_q1_bits, 1, 1, 
125 
mpc8_q1_codes, 1, 1, INIT_VLC_USE_STATIC); 
126 
init_vlc(&q9up_vlc, MPC8_Q9UP_BITS, MPC8_Q9UP_SIZE, 
127 
mpc8_q9up_bits, 1, 1, 
128 
mpc8_q9up_codes, 1, 1, INIT_VLC_USE_STATIC); 
129  
130 
init_vlc(&scfi_vlc[0], MPC8_SCFI0_BITS, MPC8_SCFI0_SIZE,

131 
mpc8_scfi0_bits, 1, 1, 
132 
mpc8_scfi0_codes, 1, 1, INIT_VLC_USE_STATIC); 
133 
init_vlc(&scfi_vlc[1], MPC8_SCFI1_BITS, MPC8_SCFI1_SIZE,

134 
mpc8_scfi1_bits, 1, 1, 
135 
mpc8_scfi1_codes, 1, 1, INIT_VLC_USE_STATIC); 
136  
137 
init_vlc(&dscf_vlc[0], MPC8_DSCF0_BITS, MPC8_DSCF0_SIZE,

138 
mpc8_dscf0_bits, 1, 1, 
139 
mpc8_dscf0_codes, 1, 1, INIT_VLC_USE_STATIC); 
140 
init_vlc(&dscf_vlc[1], MPC8_DSCF1_BITS, MPC8_DSCF1_SIZE,

141 
mpc8_dscf1_bits, 1, 1, 
142 
mpc8_dscf1_codes, 1, 1, INIT_VLC_USE_STATIC); 
143  
144 
init_vlc_sparse(&q3_vlc[0], MPC8_Q3_BITS, MPC8_Q3_SIZE,

145 
mpc8_q3_bits, 1, 1, 
146 
mpc8_q3_codes, 1, 1, 
147 
mpc8_q3_syms, 1, 1, INIT_VLC_USE_STATIC); 
148 
init_vlc_sparse(&q3_vlc[1], MPC8_Q4_BITS, MPC8_Q4_SIZE,

149 
mpc8_q4_bits, 1, 1, 
150 
mpc8_q4_codes, 1, 1, 
151 
mpc8_q4_syms, 1, 1, INIT_VLC_USE_STATIC); 
152  
153 
for(i = 0; i < 2; i++){ 
154 
init_vlc(&res_vlc[i], MPC8_RES_BITS, MPC8_RES_SIZE, 
155 
&mpc8_res_bits[i], 1, 1, 
156 
&mpc8_res_codes[i], 1, 1, INIT_VLC_USE_STATIC); 
157  
158 
init_vlc(&q2_vlc[i], MPC8_Q2_BITS, MPC8_Q2_SIZE, 
159 
&mpc8_q2_bits[i], 1, 1, 
160 
&mpc8_q2_codes[i], 1, 1, INIT_VLC_USE_STATIC); 
161  
162 
init_vlc(&quant_vlc[0][i], MPC8_Q5_BITS, MPC8_Q5_SIZE,

163 
&mpc8_q5_bits[i], 1, 1, 
164 
&mpc8_q5_codes[i], 1, 1, INIT_VLC_USE_STATIC); 
165 
init_vlc(&quant_vlc[1][i], MPC8_Q6_BITS, MPC8_Q6_SIZE,

166 
&mpc8_q6_bits[i], 1, 1, 
167 
&mpc8_q6_codes[i], 1, 1, INIT_VLC_USE_STATIC); 
168 
init_vlc(&quant_vlc[2][i], MPC8_Q7_BITS, MPC8_Q7_SIZE,

169 
&mpc8_q7_bits[i], 1, 1, 
170 
&mpc8_q7_codes[i], 1, 1, INIT_VLC_USE_STATIC); 
171 
init_vlc(&quant_vlc[3][i], MPC8_Q8_BITS, MPC8_Q8_SIZE,

172 
&mpc8_q8_bits[i], 1, 1, 
173 
&mpc8_q8_codes[i], 1, 1, INIT_VLC_USE_STATIC); 
174 
} 
175 
vlc_initialized = 1;

176 
avctx>sample_fmt = SAMPLE_FMT_S16; 
177 
avctx>channel_layout = (avctx>channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO;

178 
return 0; 
179 
} 
180  
181 
static int mpc8_decode_frame(AVCodecContext * avctx, 
182 
void *data, int *data_size, 
183 
AVPacket *avpkt) 
184 
{ 
185 
const uint8_t *buf = avpkt>data;

186 
int buf_size = avpkt>size;

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_lfg_get(&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 
"mpc8",

357 
CODEC_TYPE_AUDIO, 
358 
CODEC_ID_MUSEPACK8, 
359 
sizeof(MPCContext),

360 
mpc8_decode_init, 
361 
NULL,

362 
NULL,

363 
mpc8_decode_frame, 
364 
.long_name = NULL_IF_CONFIG_SMALL("Musepack SV8"),

365 
}; 