?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Restor setting of EMAC mode on coldfire lost in r25056 fixes whitenoise when transiti...
[kugel-rb.git] / apps / codecs / libmusepack / mpc_decoder.c
blob7032049c7aaa85c01718909e0b684837be50bfcc
1 /*
2 Copyright (c) 2005-2009, The Musepack Development Team
3 All rights reserved.
4
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions are
7 met:
8
9 * Redistributions of source code must retain the above copyright
10 notice, this list of conditions and the following disclaimer.
11
12 * Redistributions in binary form must reproduce the above
13 copyright notice, this list of conditions and the following
14 disclaimer in the documentation and/or other materials provided
15 with the distribution.
16
17 * Neither the name of the The Musepack Development Team nor the
18 names of its contributors may be used to endorse or promote
19 products derived from this software without specific prior
20 written permission.
21
22 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 */
34 /// \file mpc_decoder.c
35 /// Core decoding routines and logic.
36
37 #include <string.h>
38 #include <codecs.h>
39 #include "mpcdec.h"
40 #include "minimax.h"
41 #include "decoder.h"
42 #include "huffman.h"
43 #include "internal.h"
44 #include "mpcdec_math.h"
45 #include "requant.h"
46 #include "mpc_bits_reader.h"
47
48 //SV7 tables
49 extern const mpc_lut_data mpc_HuffQ [7] [2];
50 extern const mpc_lut_data mpc_HuffHdr;
51 extern const mpc_huffman mpc_table_HuffSCFI [ 4];
52 extern const mpc_lut_data mpc_HuffDSCF;
53
54 //SV8 tables
55 extern const mpc_can_data mpc_can_Bands;
56 extern const mpc_can_data mpc_can_SCFI[2];
57 extern const mpc_can_data mpc_can_DSCF[2];
58 extern const mpc_can_data mpc_can_Res [2];
59 extern const mpc_can_data mpc_can_Q [8][2];
60 extern const mpc_can_data mpc_can_Q1;
61 extern const mpc_can_data mpc_can_Q9up;
62
63 //Decoder globals (g_Y_L and g_Y_R do not fit into iram for all targets)
64 static mpc_decoder g_mpc_decoder IBSS_ATTR;
65 static MPC_SAMPLE_FORMAT g_Y_L[MPC_FRAME_LENGTH] IBSS_ATTR_MPC_LARGE_IRAM;
66 static MPC_SAMPLE_FORMAT g_Y_R[MPC_FRAME_LENGTH] IBSS_ATTR_MPC_LARGE_IRAM;
67
68 //SV7 globals (decoding results for bundled quantizers (3- and 5-step))
69 static const mpc_int32_t g_sv7_idx30[] ICONST_ATTR =
70 {-1, 0, 1,-1, 0, 1,-1, 0, 1,-1, 0, 1,-1, 0, 1,-1, 0, 1,-1, 0, 1,-1, 0, 1,-1, 0, 1};
71 static const mpc_int32_t g_sv7_idx31[] ICONST_ATTR =
72 {-1,-1,-1, 0, 0, 0, 1, 1, 1,-1,-1,-1, 0, 0, 0, 1, 1, 1,-1,-1,-1, 0, 0, 0, 1, 1, 1};
73 static const mpc_int32_t g_sv7_idx32[] ICONST_ATTR =
74 {-1,-1,-1,-1,-1,-1,-1,-1,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1};
75 static const mpc_int32_t g_sv7_idx50[] ICONST_ATTR =
76 {-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2};
77 static const mpc_int32_t g_sv7_idx51[] ICONST_ATTR =
78 {-2,-2,-2,-2,-2,-1,-1,-1,-1,-1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2};
79
80 //SV8 globals (decoding results for bundled quantizers (3- and 5-step))
81 static const mpc_int8_t g_sv8_idx50[125] ICONST_ATTR =
82 {-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,
83 -2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,
84 -2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,
85 -2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,
86 -2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2};
87 static const mpc_int8_t g_sv8_idx51[125] ICONST_ATTR =
88 {-2,-2,-2,-2,-2,-1,-1,-1,-1,-1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
89 -2,-2,-2,-2,-2,-1,-1,-1,-1,-1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
90 -2,-2,-2,-2,-2,-1,-1,-1,-1,-1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
91 -2,-2,-2,-2,-2,-1,-1,-1,-1,-1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
92 -2,-2,-2,-2,-2,-1,-1,-1,-1,-1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2};
93 static const mpc_int8_t g_sv8_idx52[125] ICONST_ATTR =
94 {-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
95 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
96 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
97 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
98 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2};
99 static const mpc_int8_t g_sv8_HuffQ2_var[125] ICONST_ATTR =
100 { 6, 5, 4, 5, 6, 5, 4, 3, 4, 5, 4, 3, 2, 3, 4, 5, 4, 3, 4, 5, 6, 5, 4, 5, 6,
101 5, 4, 3, 4, 5, 4, 3, 2, 3, 4, 3, 2, 1, 2, 3, 4, 3, 2, 3, 4, 5, 4, 3, 4, 5,
102 4, 3, 2, 3, 4, 3, 2, 1, 2, 3, 2, 1, 0, 1, 2, 3, 2, 1, 2, 3, 4, 3, 2, 3, 4,
103 5, 4, 3, 4, 5, 4, 3, 2, 3, 4, 3, 2, 1, 2, 3, 4, 3, 2, 3, 4, 5, 4, 3, 4, 5,
104 6, 5, 4, 5, 6, 5, 4, 3, 4, 5, 4, 3, 2, 3, 4, 5, 4, 3, 4, 5, 6, 5, 4, 5, 6};
105
106 //------------------------------------------------------------------------------
107 // types
108 //------------------------------------------------------------------------------
109 enum
110 {
111 MEMSIZE = MPC_DECODER_MEMSIZE, // overall buffer size
112 MEMSIZE2 = (MEMSIZE/2), // size of one buffer
113 MEMMASK = (MEMSIZE-1)
114 };
115
116 //------------------------------------------------------------------------------
117 // forward declarations
118 //------------------------------------------------------------------------------
119 void mpc_decoder_requantisierung (mpc_decoder *d)
120 ICODE_ATTR_MPC_LARGE_IRAM;
121 void mpc_decoder_read_bitstream_sv7(mpc_decoder * d, mpc_bits_reader * r)
122 ICODE_ATTR_MPC_LARGE_IRAM;
123 void mpc_decoder_read_bitstream_sv8(mpc_decoder * d, mpc_bits_reader * r,
124 mpc_bool_t is_key_frame);
125
126 //------------------------------------------------------------------------------
127 // macros
128 //------------------------------------------------------------------------------
129 #define REQUANT_M1_S1_SAMPLES(IDX) \
130 *(YL+=IDX) = (templ = MPC_MULTIPLY_FLOAT_INT(facL,*L++))+(tempr = MPC_MULTIPLY_FLOAT_INT(facR,*R++)); \
131 *(YR+=IDX) = templ - tempr;
132
133 #define REQUANT_M1_S1(SUBFRAME) \
134 facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , d->SCF_Index_L[Band][SUBFRAME] & 0xFF); \
135 facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , d->SCF_Index_R[Band][SUBFRAME] & 0xFF); \
136 for (n = 0; n < 12; n+=4, YL += 32, YR += 32) { \
137 REQUANT_M1_S1_SAMPLES( 0); \
138 REQUANT_M1_S1_SAMPLES(32); \
139 REQUANT_M1_S1_SAMPLES(32); \
140 REQUANT_M1_S1_SAMPLES(32); \
141 }
142
143 #define REQUANT_M1_S0_SAMPLES(IDX) \
144 *(YR+=IDX) = *(YL+=IDX) = MPC_MULTIPLY_FLOAT_INT(facL,*L++);
145
146 #define REQUANT_M1_S0(SUBFRAME) \
147 facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , d->SCF_Index_L[Band][SUBFRAME] & 0xFF); \
148 for (n = 0; n < 12; n+=4, YL += 32, YR += 32) { \
149 REQUANT_M1_S0_SAMPLES( 0); \
150 REQUANT_M1_S0_SAMPLES(32); \
151 REQUANT_M1_S0_SAMPLES(32); \
152 REQUANT_M1_S0_SAMPLES(32); \
153 }
154
155 #define REQUANT_M0_S1_SAMPLES(IDX) \
156 *(YR+=IDX) = -(*(YL+=IDX) = MPC_MULTIPLY_FLOAT_INT(facR,*R++));
157
158 #define REQUANT_M0_S1(SUBFRAME) \
159 facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , d->SCF_Index_R[Band][SUBFRAME] & 0xFF); \
160 for (n = 0; n < 12; n+=4, YL += 32, YR += 32) { \
161 REQUANT_M0_S1_SAMPLES( 0); \
162 REQUANT_M0_S1_SAMPLES(32); \
163 REQUANT_M0_S1_SAMPLES(32); \
164 REQUANT_M0_S1_SAMPLES(32); \
165 }
166
167 #define REQUANT_L1_R1_SAMPLES(IDX) \
168 *(YL+=IDX) = MPC_MULTIPLY_FLOAT_INT(facL,*L++); \
169 *(YR+=IDX) = MPC_MULTIPLY_FLOAT_INT(facR,*R++);
170
171 #define REQUANT_L1_R1(SUBFRAME) \
172 facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , d->SCF_Index_L[Band][SUBFRAME] & 0xFF); \
173 facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , d->SCF_Index_R[Band][SUBFRAME] & 0xFF); \
174 for (n = 0; n < 12; n+=4, YL += 32, YR += 32) { \
175 REQUANT_L1_R1_SAMPLES( 0); \
176 REQUANT_L1_R1_SAMPLES(32); \
177 REQUANT_L1_R1_SAMPLES(32); \
178 REQUANT_L1_R1_SAMPLES(32); \
179 }
180
181 #define REQUANT_L1_R0_SAMPLES(IDX) \
182 *(YL+=IDX) = MPC_MULTIPLY_FLOAT_INT(facL,*L++); \
183 *(YR+=IDX) = 0;
184
185 #define REQUANT_L1_R0(SUBFRAME) \
186 facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , d->SCF_Index_L[Band][SUBFRAME] & 0xFF); \
187 for (n = 0; n < 12; n+=4, YL += 32, YR += 32) { \
188 REQUANT_L1_R0_SAMPLES( 0); \
189 REQUANT_L1_R0_SAMPLES(32); \
190 REQUANT_L1_R0_SAMPLES(32); \
191 REQUANT_L1_R0_SAMPLES(32); \
192 }
193
194 #define REQUANT_L0_R1_SAMPLES(IDX) \
195 *(YL+=IDX) = 0; \
196 *(YR+=IDX) = MPC_MULTIPLY_FLOAT_INT(facR,*R++);
197
198 #define REQUANT_L0_R1(SUBFRAME) \
199 facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , d->SCF_Index_R[Band][SUBFRAME] & 0xFF); \
200 for (n = 0; n < 12; n+=4, YL += 32, YR += 32) { \
201 REQUANT_L0_R1_SAMPLES( 0); \
202 REQUANT_L0_R1_SAMPLES(32); \
203 REQUANT_L0_R1_SAMPLES(32); \
204 REQUANT_L0_R1_SAMPLES(32); \
205 }
206
207 #define REQUANT_SILENCE_SAMPLES(IDX) \
208 *(YR+=IDX) = *(YL+=IDX) = 0;
209
210 #define REQUANT_SILENCE \
211 for (n = 0; n < 12; n+=4, YL += 32, YR += 32) { \
212 REQUANT_SILENCE_SAMPLES( 0); \
213 REQUANT_SILENCE_SAMPLES(32); \
214 REQUANT_SILENCE_SAMPLES(32); \
215 REQUANT_SILENCE_SAMPLES(32); \
216 }
217
218 /**
219 * set the scf indexes for seeking use
220 * needed only for sv7 seeking
221 * @param d
222 */
223 void mpc_decoder_reset_scf(mpc_decoder * d, int value)
224 {
225 memset(d->SCF_Index_L, value, sizeof d->SCF_Index_L );
226 memset(d->SCF_Index_R, value, sizeof d->SCF_Index_R );
227 }
228
229 static void mpc_decoder_setup(mpc_decoder *d)
230 {
231 #if defined(CPU_COLDFIRE)
232 coldfire_set_macsr(EMAC_FRACTIONAL | EMAC_SATURATE);
233 #endif
234
235 memset(d, 0, sizeof *d);
236
237 d->__r1 = 1;
238 d->__r2 = 1;
239 d->Y_L = g_Y_L;
240 d->Y_R = g_Y_R;
241
242 memset(d->Y_L, 0, sizeof(g_Y_L));
243 memset(d->Y_R, 0, sizeof(g_Y_R));
244
245 mpc_decoder_init_quant(d, 1.0f);
246 }
247
248 static void mpc_decoder_set_streaminfo(mpc_decoder *d, mpc_streaminfo *si)
249 {
250 d->stream_version = si->stream_version;
251 d->ms = si->ms;
252 d->max_band = si->max_band;
253 d->channels = si->channels;
254 d->samples_to_skip = MPC_DECODER_SYNTH_DELAY + si->beg_silence;
255
256 if (si->stream_version == 7 && si->is_true_gapless)
257 d->samples = ((si->samples + MPC_FRAME_LENGTH - 1) / MPC_FRAME_LENGTH) * MPC_FRAME_LENGTH;
258 else
259 d->samples = si->samples;
260 }
261
262 mpc_decoder * mpc_decoder_init(mpc_streaminfo *si)
263 {
264 mpc_decoder* p_tmp = &g_mpc_decoder;
265
266 if (p_tmp != 0) {
267 mpc_decoder_setup(p_tmp);
268 mpc_decoder_set_streaminfo(p_tmp, si);
269 huff_init_lut(LUT_DEPTH);
270 }
271
272 return p_tmp;
273 }
274
275 void mpc_decoder_exit(mpc_decoder *d)
276 {
277 (void)d;
278 }
279
280 void mpc_decoder_decode_frame(mpc_decoder * d,
281 mpc_bits_reader * r,
282 mpc_frame_info * i)
283 {
284 mpc_bits_reader r_sav = *r;
285 mpc_int64_t samples_left;
286
287 samples_left = d->samples - d->decoded_samples + MPC_DECODER_SYNTH_DELAY;
288
289 if (samples_left <= 0 && d->samples != 0) {
290 i->samples = 0;
291 i->bits = -1;
292 return;
293 }
294
295 if (d->stream_version == 8) {
296 mpc_decoder_read_bitstream_sv8(d, r, i->is_key_frame);
297 } else {
298 mpc_decoder_read_bitstream_sv7(d, r);
299 }
300
301 if (d->samples_to_skip < MPC_FRAME_LENGTH + MPC_DECODER_SYNTH_DELAY) {
302 mpc_decoder_requantisierung(d);
303 mpc_decoder_synthese_filter_float(d, i->buffer, d->channels);
304 }
305
306 d->decoded_samples += MPC_FRAME_LENGTH;
307
308 // reconstruct exact filelength
309 if (d->decoded_samples - d->samples < MPC_FRAME_LENGTH && d->stream_version == 7) {
310 int last_frame_samples = mpc_bits_read(r, 11);
311 if (d->decoded_samples == d->samples) {
312 if (last_frame_samples == 0) last_frame_samples = MPC_FRAME_LENGTH;
313 d->samples += last_frame_samples - MPC_FRAME_LENGTH;
314 samples_left += last_frame_samples - MPC_FRAME_LENGTH;
315 }
316 }
317
318 i->samples = samples_left > MPC_FRAME_LENGTH ? MPC_FRAME_LENGTH : samples_left < 0 ? 0 : (mpc_uint32_t) samples_left;
319 i->bits = (mpc_uint32_t) (((r->buff - r_sav.buff) << 3) + r_sav.count - r->count);
320
321 if (d->samples_to_skip) {
322 if (i->samples <= d->samples_to_skip) {
323 d->samples_to_skip -= i->samples;
324 i->samples = 0;
325 } else {
326 i->samples -= d->samples_to_skip;
327
328 /* move valid samples to beginning for channel 0. noninterleaved! */
329 memmove(i->buffer,
330 i->buffer + d->samples_to_skip,
331 i->samples * sizeof(MPC_SAMPLE_FORMAT));
332 /* move valid samples to beginning for channel 1. noninterleaved! */
333 memmove(i->buffer + MPC_FRAME_LENGTH,
334 i->buffer + MPC_FRAME_LENGTH + d->samples_to_skip,
335 i->samples * sizeof(MPC_SAMPLE_FORMAT));
336
337 d->samples_to_skip = 0;
338 }
339 }
340 }
341
342 void
343 mpc_decoder_requantisierung(mpc_decoder *d)
344 {
345 mpc_int32_t Band;
346 mpc_int32_t n;
347 MPC_SAMPLE_FORMAT facL;
348 MPC_SAMPLE_FORMAT facR;
349 MPC_SAMPLE_FORMAT templ;
350 MPC_SAMPLE_FORMAT tempr;
351 MPC_SAMPLE_FORMAT* YL;
352 MPC_SAMPLE_FORMAT* YR;
353 mpc_int16_t* L;
354 mpc_int16_t* R;
355 const mpc_int32_t Last_Band = d->max_band;
356
357 #ifdef MPC_FIXED_POINT
358 #if MPC_FIXED_POINT_FRACTPART == 14
359 #define MPC_MULTIPLY_SCF(CcVal, SCF_idx) \
360 MPC_MULTIPLY_EX(CcVal, d->SCF[SCF_idx], d->SCF_shift[SCF_idx])
361 #else
362
363 #error FIXME, Cc table is in 18.14 format
364
365 #endif
366 #else
367 #define MPC_MULTIPLY_SCF(CcVal, SCF_idx) \
368 MPC_MULTIPLY(CcVal, d->SCF[SCF_idx])
369 #endif
370 // requantization and scaling of subband-samples
371 for ( Band = 0; Band <= Last_Band; Band++ ) { // setting pointers
372 YL = d->Y_L + Band;
373 YR = d->Y_R + Band;
374 L = d->Q[Band].L;
375 R = d->Q[Band].R;
376 /************************** MS-coded **************************/
377 if ( d->MS_Flag [Band] ) {
378 if ( d->Res_L [Band] ) {
379 if ( d->Res_R [Band] ) { // M!=0, S!=0
380 REQUANT_M1_S1(0);
381 REQUANT_M1_S1(1);
382 REQUANT_M1_S1(2);
383 } else { // M!=0, S==0
384 REQUANT_M1_S0(0);
385 REQUANT_M1_S0(1);
386 REQUANT_M1_S0(2);
387 }
388 } else {
389 if ( d->Res_R[Band] ) // M==0, S!=0
390 {
391 REQUANT_M0_S1(0);
392 REQUANT_M0_S1(1);
393 REQUANT_M0_S1(2);
394 } else { // M==0, S==0
395 REQUANT_SILENCE;
396 }
397 }
398 }
399 /************************** LR-coded **************************/
400 else {
401 if ( d->Res_L [Band] ) {
402 if ( d->Res_R [Band] ) { // L!=0, R!=0
403 REQUANT_L1_R1(0);
404 REQUANT_L1_R1(1);
405 REQUANT_L1_R1(2);
406 } else { // L!=0, R==0
407 REQUANT_L1_R0(0);
408 REQUANT_L1_R0(1);
409 REQUANT_L1_R0(2);
410 }
411 }
412 else {
413 if ( d->Res_R [Band] ) { // L==0, R!=0
414 REQUANT_L0_R1(0);
415 REQUANT_L0_R1(1);
416 REQUANT_L0_R1(2);
417 } else { // L==0, R==0
418 REQUANT_SILENCE;
419 }
420 }
421 }
422 }
423 }
424
425 void mpc_decoder_read_bitstream_sv7(mpc_decoder * d, mpc_bits_reader * r)
426 {
427 mpc_int32_t n, idx, Max_used_Band = 0;
428
429 /***************************** Header *****************************/
430
431 // first subband
432 d->Res_L[0] = mpc_bits_read(r, 4);
433 d->Res_R[0] = mpc_bits_read(r, 4);
434 if (!(d->Res_L[0] == 0 && d->Res_R[0] == 0)) {
435 if (d->ms)
436 d->MS_Flag[0] = mpc_bits_read(r, 1);
437 Max_used_Band = 1;
438 }
439
440 // consecutive subbands
441 for ( n = 1; n <= d->max_band; n++ ) {
442 idx = mpc_bits_huff_lut(r, & mpc_HuffHdr);
443 d->Res_L[n] = (idx!=4) ? d->Res_L[n - 1] + idx : (int) mpc_bits_read(r, 4);
444
445 idx = mpc_bits_huff_lut(r, & mpc_HuffHdr);
446 d->Res_R[n] = (idx!=4) ? d->Res_R[n - 1] + idx : (int) mpc_bits_read(r, 4);
447
448 if (!(d->Res_L[n] == 0 && d->Res_R[n] == 0)) {
449 if (d->ms)
450 d->MS_Flag[n] = mpc_bits_read(r, 1);
451 Max_used_Band = n + 1;
452 }
453 }
454
455 /****************************** SCFI ******************************/
456 for ( n = 0; n < Max_used_Band; n++ ) {
457 if (d->Res_L[n])
458 d->SCFI_L[n] = mpc_bits_huff_dec(r, mpc_table_HuffSCFI);
459 if (d->Res_R[n])
460 d->SCFI_R[n] = mpc_bits_huff_dec(r, mpc_table_HuffSCFI);
461 }
462
463 /**************************** SCF/DSCF ****************************/
464 for ( n = 0; n < Max_used_Band; n++ ) {
465 mpc_int32_t * SCF = d->SCF_Index_L[n];
466 mpc_uint32_t Res = d->Res_L[n], SCFI = d->SCFI_L[n];
467 do {
468 if (Res) {
469 switch (SCFI) {
470 case 1:
471 idx = mpc_bits_huff_lut(r, & mpc_HuffDSCF);
472 SCF[0] = (idx!=8) ? SCF[2] + idx : (int) mpc_bits_read(r, 6);
473 idx = mpc_bits_huff_lut(r, & mpc_HuffDSCF);
474 SCF[1] = (idx!=8) ? SCF[0] + idx : (int) mpc_bits_read(r, 6);
475 SCF[2] = SCF[1];
476 break;
477 case 3:
478 idx = mpc_bits_huff_lut(r, & mpc_HuffDSCF);
479 SCF[0] = (idx!=8) ? SCF[2] + idx : (int) mpc_bits_read(r, 6);
480 SCF[1] = SCF[0];
481 SCF[2] = SCF[1];
482 break;
483 case 2:
484 idx = mpc_bits_huff_lut(r, & mpc_HuffDSCF);
485 SCF[0] = (idx!=8) ? SCF[2] + idx : (int) mpc_bits_read(r, 6);
486 SCF[1] = SCF[0];
487 idx = mpc_bits_huff_lut(r, & mpc_HuffDSCF);
488 SCF[2] = (idx!=8) ? SCF[1] + idx : (int) mpc_bits_read(r, 6);
489 break;
490 case 0:
491 idx = mpc_bits_huff_lut(r, & mpc_HuffDSCF);
492 SCF[0] = (idx!=8) ? SCF[2] + idx : (int) mpc_bits_read(r, 6);
493 idx = mpc_bits_huff_lut(r, & mpc_HuffDSCF);
494 SCF[1] = (idx!=8) ? SCF[0] + idx : (int) mpc_bits_read(r, 6);
495 idx = mpc_bits_huff_lut(r, & mpc_HuffDSCF);
496 SCF[2] = (idx!=8) ? SCF[1] + idx : (int) mpc_bits_read(r, 6);
497 break;
498 default:
499 return;
500 }
501 if (SCF[0] > 1024)
502 SCF[0] = 0x8080;
503 if (SCF[1] > 1024)
504 SCF[1] = 0x8080;
505 if (SCF[2] > 1024)
506 SCF[2] = 0x8080;
507 }
508 Res = d->Res_R[n];
509 SCFI = d->SCFI_R[n];
510 } while ( SCF == d->SCF_Index_L[n] && (SCF = d->SCF_Index_R[n]));
511 }
512
513 // if (d->seeking == TRUE)
514 // return;
515
516 /***************************** Samples ****************************/
517 for ( n = 0; n < Max_used_Band; n++ ) {
518 mpc_int16_t *q = d->Q[n].L, Res = d->Res_L[n];
519 do {
520 mpc_int32_t k;
521 const mpc_lut_data *Table;
522 switch (Res) {
523 case -2: case -3: case -4: case -5: case -6: case -7: case -8: case -9:
524 case -10: case -11: case -12: case -13: case -14: case -15: case -16: case -17: case 0:
525 break;
526 case -1:
527 for (k=0; k<36; k++ ) {
528 mpc_uint32_t tmp = mpc_random_int(d);
529 q[k] = ((tmp >> 24) & 0xFF) + ((tmp >> 16) & 0xFF) + ((tmp >> 8) & 0xFF) + ((tmp >> 0) & 0xFF) - 510;
530 }
531 break;
532 case 1:
533 Table = & mpc_HuffQ[0][mpc_bits_read(r, 1)];
534 for ( k = 0; k < 36; k += 3) {
535 idx = mpc_bits_huff_lut(r, Table);
536 q[k] = g_sv7_idx30[idx];
537 q[k + 1] = g_sv7_idx31[idx];
538 q[k + 2] = g_sv7_idx32[idx];
539 }
540 break;
541 case 2:
542 Table = & mpc_HuffQ[1][mpc_bits_read(r, 1)];
543 for ( k = 0; k < 36; k += 2) {
544 idx = mpc_bits_huff_lut(r, Table);
545 q[k] = g_sv7_idx50[idx];
546 q[k + 1] = g_sv7_idx51[idx];
547 }
548 break;
549 case 3:
550 case 4:
551 case 5:
552 case 6:
553 case 7:
554 Table = & mpc_HuffQ[Res - 1][mpc_bits_read(r, 1)];
555 for ( k = 0; k < 36; k++ )
556 q[k] = mpc_bits_huff_lut(r, Table);
557 break;
558 case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15: case 16: case 17:
559 for ( k = 0; k < 36; k++ )
560 q[k] = (mpc_int32_t)mpc_bits_read(r, Res_bit[Res]) - Dc[Res];
561 break;
562 default:
563 return;
564 }
565
566 Res = d->Res_R[n];
567 } while (q == d->Q[n].L && (q = d->Q[n].R));
568 }
569 }
570
571 void mpc_decoder_read_bitstream_sv8(mpc_decoder * d, mpc_bits_reader * r, mpc_bool_t is_key_frame)
572 {
573 mpc_int32_t n, Max_used_Band;
574 const mpc_can_data * Table, * Tables[2];
575
576 /***************************** Header *****************************/
577
578 if (is_key_frame == MPC_TRUE) {
579 Max_used_Band = mpc_bits_log_dec(r, d->max_band + 1);
580 } else {
581 Max_used_Band = d->last_max_band + mpc_bits_can_dec(r, & mpc_can_Bands);
582 if (Max_used_Band > 32) Max_used_Band -= 33;
583 }
584 d->last_max_band = Max_used_Band;
585
586 if (Max_used_Band) {
587 d->Res_L[Max_used_Band-1] = mpc_bits_can_dec(r, & mpc_can_Res[0]);
588 d->Res_R[Max_used_Band-1] = mpc_bits_can_dec(r, & mpc_can_Res[0]);
589 if (d->Res_L[Max_used_Band-1] > 15) d->Res_L[Max_used_Band-1] -= 17;
590 if (d->Res_R[Max_used_Band-1] > 15) d->Res_R[Max_used_Band-1] -= 17;
591 for ( n = Max_used_Band - 2; n >= 0; n--) {
592 d->Res_L[n] = mpc_bits_can_dec(r, & mpc_can_Res[d->Res_L[n + 1] > 2]) + d->Res_L[n + 1];
593 if (d->Res_L[n] > 15) d->Res_L[n] -= 17;
594 d->Res_R[n] = mpc_bits_can_dec(r, & mpc_can_Res[d->Res_R[n + 1] > 2]) + d->Res_R[n + 1];
595 if (d->Res_R[n] > 15) d->Res_R[n] -= 17;
596 }
597
598 if (d->ms) {
599 int cnt = 0, tot = 0;
600 mpc_uint32_t tmp = 0;
601 for( n = 0; n < Max_used_Band; n++)
602 if ( d->Res_L[n] != 0 || d->Res_R[n] != 0 )
603 tot++;
604 cnt = mpc_bits_log_dec(r, tot);
605 if (cnt != 0 && cnt != tot)
606 tmp = mpc_bits_enum_dec(r, mini(cnt, tot-cnt), tot);
607 if (cnt * 2 > tot) tmp = ~tmp;
608 for( n = Max_used_Band - 1; n >= 0; n--)
609 if ( d->Res_L[n] != 0 || d->Res_R[n] != 0 ) {
610 d->MS_Flag[n] = tmp & 1;
611 tmp >>= 1;
612 }
613 }
614 }
615
616 for( n = Max_used_Band; n <= d->max_band; n++)
617 d->Res_L[n] = d->Res_R[n] = 0;
618
619 /****************************** SCFI ******************************/
620 if (is_key_frame == MPC_TRUE){
621 for( n = 0; n < 32; n++)
622 d->DSCF_Flag_L[n] = d->DSCF_Flag_R[n] = 1; // new block -> force key frame
623 }
624
625 Tables[0] = & mpc_can_SCFI[0];
626 Tables[1] = & mpc_can_SCFI[1];
627 for ( n = 0; n < Max_used_Band; n++ ) {
628 int tmp = 0, cnt = -1;
629 if (d->Res_L[n]) cnt++;
630 if (d->Res_R[n]) cnt++;
631 if (cnt >= 0) {
632 tmp = mpc_bits_can_dec(r, Tables[cnt]);
633 if (d->Res_L[n]) d->SCFI_L[n] = tmp >> (2 * cnt);
634 if (d->Res_R[n]) d->SCFI_R[n] = tmp & 3;
635 }
636 }
637
638 /**************************** SCF/DSCF ****************************/
639
640 for ( n = 0; n < Max_used_Band; n++ ) {
641 mpc_int32_t * SCF = d->SCF_Index_L[n];
642 mpc_uint32_t Res = d->Res_L[n], SCFI = d->SCFI_L[n];
643 mpc_bool_t * DSCF_Flag = &d->DSCF_Flag_L[n];
644
645 do {
646 if ( Res ) {
647 int m;
648 if (*DSCF_Flag == 1) {
649 SCF[0] = (mpc_int32_t)mpc_bits_read(r, 7) - 6;
650 *DSCF_Flag = 0;
651 } else {
652 mpc_uint_t tmp = mpc_bits_can_dec(r, & mpc_can_DSCF[1]);
653 if (tmp == 64)
654 tmp += mpc_bits_read(r, 6);
655 SCF[0] = ((SCF[2] - 25 + tmp) & 127) - 6;
656 }
657 for( m = 0; m < 2; m++){
658 if (((SCFI << m) & 2) == 0) {
659 mpc_uint_t tmp = mpc_bits_can_dec(r, & mpc_can_DSCF[0]);
660 if (tmp == 31)
661 tmp = 64 + mpc_bits_read(r, 6);
662 SCF[m + 1] = ((SCF[m] - 25 + tmp) & 127) - 6;
663 } else
664 SCF[m + 1] = SCF[m];
665 }
666 }
667 Res = d->Res_R[n];
668 SCFI = d->SCFI_R[n];
669 DSCF_Flag = &d->DSCF_Flag_R[n];
670 } while ( SCF == d->SCF_Index_L[n] && (SCF = d->SCF_Index_R[n]));
671 }
672
673 /***************************** Samples ****************************/
674 for ( n = 0; n < Max_used_Band; n++ ) {
675 mpc_int16_t *q = d->Q[n].L, Res = d->Res_L[n];
676 static const int thres[] = {0, 0, 3, 0, 0, 1, 3, 4, 8};
677 do {
678 mpc_int32_t k = 0, idx = 1;
679 if (Res != 0) {
680 if (Res == 2) {
681 Tables[0] = & mpc_can_Q [0][0];
682 Tables[1] = & mpc_can_Q [0][1];
683 idx = 2 * thres[Res];
684 for ( ; k < 36; k += 3) {
685 int tmp = mpc_bits_can_dec(r, Tables[idx > thres[Res]]);
686 q[k] = g_sv8_idx50[tmp];
687 q[k + 1] = g_sv8_idx51[tmp];
688 q[k + 2] = g_sv8_idx52[tmp];
689 idx = (idx >> 1) + g_sv8_HuffQ2_var[tmp];
690 }
691 } else if (Res == 1) {
692 Table = & mpc_can_Q1;
693 for( ; k < 36; ){
694 int kmax = k + 18;
695 mpc_uint_t cnt = mpc_bits_can_dec(r, Table);
696 idx = 0;
697 if (cnt > 0 && cnt < 18)
698 idx = mpc_bits_enum_dec(r, cnt <= 9 ? cnt : 18 - cnt, 18);
699 if (cnt > 9) idx = ~idx;
700 for ( ; k < kmax; k++) {
701 q[k] = 0;
702 if ( idx & (1 << 17) )
703 q[k] = (mpc_bits_read(r, 1) << 1) - 1;
704 idx <<= 1;
705 }
706 }
707 } else if (Res == -1) {
708 for ( ; k<36; k++ ) {
709 mpc_uint32_t tmp = mpc_random_int(d);
710 q[k] = ((tmp >> 24) & 0xFF) + ((tmp >> 16) & 0xFF) + ((tmp >> 8) & 0xFF) + ((tmp >> 0) & 0xFF) - 510;
711 }
712 } else if (Res <= 4) {
713 Table = & mpc_can_Q[1][Res - 3];
714 for ( ; k < 36; k += 2 ) {
715 union {
716 mpc_int8_t sym;
717 struct { mpc_int8_t s1:4, s2:4; };
718 } tmp;
719 tmp.sym = mpc_bits_can_dec(r, Table);
720 q[k] = tmp.s1;
721 q[k + 1] = tmp.s2;
722 }
723 } else if (Res <= 8) {
724 Tables[0] = & mpc_can_Q [Res - 3][0];
725 Tables[1] = & mpc_can_Q [Res - 3][1];
726 idx = 2 * thres[Res];
727 for ( ; k < 36; k++ ) {
728 q[k] = mpc_bits_can_dec(r, Tables[idx > thres[Res]]);
729 idx = (idx >> 1) + absi(q[k]);
730 }
731 } else {
732 for ( ; k < 36; k++ ) {
733 q[k] = (unsigned char) mpc_bits_can_dec(r, & mpc_can_Q9up);
734 if (Res != 9)
735 q[k] = (q[k] << (Res - 9)) | mpc_bits_read(r, Res - 9);
736 q[k] -= Dc[Res];
737 }
738 }
739 }
740
741 Res = d->Res_R[n];
742 } while (q == d->Q[n].L && (q = d->Q[n].R));
743 }
744 }
745
My public Rockbox git repo