summaryrefslogtreecommitdiff
path: root/apps/codecs/libcook/cookdata_fixpoint.h
blob: b58666031dff538e5f471bf59522e9acdf79a9be (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
/*
 * COOK compatible decoder fixed point data types and constants
 * Copyright (c) 2007 Ian Braithwaite
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 *
 */

/**
 * @file cookdata_fixpoint.h
 * Cook AKA RealAudio G2 compatible decoder
 * fixed point data types and constants
 */

#include <inttypes.h>
typedef int32_t FIXP;           /* Fixed point variable type */
typedef uint16_t FIXPU;         /* Fixed point fraction 0<=x<1 */

typedef FIXP REAL_T;


/* No additional variables in COOKContext
 * for fixed point routines
 */
typedef struct {
} realvars_t;

static const FIXPU pow128_tab[128] = {
    /* x_i = 2^(15+i/128) */
    0x8000, 0x80b2, 0x8165, 0x8219, 0x82ce, 0x8383, 0x843a, 0x84f2, 0x85ab,
    0x8665, 0x871f, 0x87db, 0x8898, 0x8956, 0x8a15, 0x8ad5, 0x8b96, 0x8c58,
    0x8d1b, 0x8ddf, 0x8ea4, 0x8f6b, 0x9032, 0x90fa, 0x91c4, 0x928e, 0x935a,
    0x9427, 0x94f5, 0x95c4, 0x9694, 0x9765, 0x9838, 0x990c, 0x99e0, 0x9ab6,
    0x9b8d, 0x9c65, 0x9d3f, 0x9e19, 0x9ef5, 0x9fd2, 0xa0b0, 0xa190, 0xa270,
    0xa352, 0xa435, 0xa519, 0xa5ff, 0xa6e6, 0xa7ce, 0xa8b7, 0xa9a1, 0xaa8d,
    0xab7a, 0xac69, 0xad58, 0xae49, 0xaf3b, 0xb02f, 0xb124, 0xb21a, 0xb312,
    0xb40b, 0xb505, 0xb601, 0xb6fe, 0xb7fc, 0xb8fc, 0xb9fd, 0xbaff, 0xbc03,
    0xbd09, 0xbe0f, 0xbf18, 0xc021, 0xc12c, 0xc239, 0xc347, 0xc456, 0xc567,
    0xc67a, 0xc78d, 0xc8a3, 0xc9ba, 0xcad2, 0xcbec, 0xcd08, 0xce25, 0xcf43,
    0xd063, 0xd185, 0xd2a8, 0xd3cd, 0xd4f3, 0xd61b, 0xd745, 0xd870, 0xd99d,
    0xdacc, 0xdbfc, 0xdd2e, 0xde61, 0xdf96, 0xe0cd, 0xe205, 0xe340, 0xe47b,
    0xe5b9, 0xe6f8, 0xe839, 0xe97c, 0xeac1, 0xec07, 0xed4f, 0xee99, 0xefe5,
    0xf132, 0xf281, 0xf3d3, 0xf525, 0xf67a, 0xf7d1, 0xf929, 0xfa84, 0xfbe0,
    0xfd3e, 0xfe9e
};



/* dither_table and quant_centroid_table.
 * Index 1: [0] - scaled by 2^13, [1] - scaled by 2^13 / sqrt(2)
 * Index 2: [0..7] - category
 * Index 3: [0] - dither_table, [1..13] - quant_centroid_table
 */
static const FIXP quant_tables[2][8][14] ICONST_ATTR = {{{
    0x00000000, 0x0645a1cb, 0x0c2d0e56, 0x11eb851f, 0x17a1cac1, 0x1d4fdf3b,
    0x22ed9168, 0x28a7ef9e, 0x2e49ba5e, 0x33eb851f, 0x39916873, 0x3f126e98,
    0x449ba5e3, 0x4b958106
},{
    0x00000000, 0x08b43958, 0x10f5c28f, 0x19020c4a, 0x2116872b, 0x2922d0e5,
    0x3126e979, 0x38fdf3b6, 0x411eb852, 0x49eb851f, 0x00000000, 0x00000000,
    0x00000000, 0x00000000
},{
    0x00000000, 0x0bef9db2, 0x176c8b44, 0x22e147ae, 0x2e1cac08, 0x39581062,
    0x450e5604, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
    0x00000000, 0x00000000
},{
    0x00000000, 0x10189375, 0x20000000, 0x2fe353f8, 0x3fc28f5c, 0x00000000,
    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
    0x00000000, 0x00000000
},{
    0x00000000, 0x1522d0e5, 0x2b3f7cee, 0x3fba5e35, 0x00000000, 0x00000000,
    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
    0x00000000, 0x00000000
},{
    0x02d413cd, 0x1a83126f, 0x37db22d1, 0x00000000, 0x00000000, 0x00000000,
    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
    0x00000000, 0x00000000
},{
    0x04000000, 0x1f6c8b44, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
    0x00000000, 0x00000000
},{
    0x0b504f33, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
    0x00000000, 0x00000000
}},{{
    0x00000000, 0x046f5a70, 0x089c1768, 0x0cabddd3, 0x10b5d955, 0x14ba09ed,
    0x18b2a4b4, 0x1cbf85aa, 0x20bb05e5, 0x24b68620, 0x28b4ebcf, 0x2c994066,
    0x30835fe6, 0x35722a5e
},{
    0x00000000, 0x062797a1, 0x0bfe1683, 0x11aeee7a, 0x1765915b, 0x1d166952,
    0x22c17660, 0x284ca76c, 0x2e0bfaaa, 0x3444f306, 0x00000000, 0x00000000,
    0x00000000, 0x00000000
},{
    0x00000000, 0x0870a594, 0x1090326a, 0x18a9f456, 0x209b29e3, 0x288c5f70,
    0x30d478a5, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
    0x00000000, 0x00000000
},{
    0x00000000, 0x0b61afee, 0x16a09e66, 0x21dca76a, 0x2d15caf9, 0x00000000,
    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
    0x00000000, 0x00000000
},{
    0x00000000, 0x0ef20652, 0x1e94b968, 0x2d100010, 0x00000000, 0x00000000,
    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
    0x00000000, 0x00000000
},{
    0x02000000, 0x12bf2f44, 0x277f041b, 0x00000000, 0x00000000, 0x00000000,
    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
    0x00000000, 0x00000000
},{
    0x02d413cd, 0x16385a03, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
    0x00000000, 0x00000000
},{
    0x08000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
    0x00000000, 0x00000000
}}};

static const FIXPU cplscale2[3] = {
    /* 2^16 C_ij */
    0xf3f9, 0xb505, 0x4d8b
};
static const FIXPU cplscale3[7] = {
    /* 2^16 C_ij */
    0xfb35, 0xefdf, 0xe03d, 0xb505, 0x7b81, 0x596e, 0x314d
};
static const FIXPU cplscale4[15] = {
    /* 2^16 C_ij */
    0xfdd2, 0xf927, 0xf3f9, 0xee1d, 0xe749, 0xdee9, 0xd381, 0xb505, 0x903b,
    0x7de2, 0x6dbe, 0x5e02, 0x4d8b, 0x3ad1, 0x2155
};
static const FIXPU cplscale5[31] = {
    /* 2^16 C_ij */
    0xfef5, 0xfcce, 0xfa8e, 0xf832, 0xf5b5, 0xf314, 0xf049, 0xed4c, 0xea12,
    0xe68e, 0xe2ab, 0xde4b, 0xd938, 0xd30b, 0xcab6, 0xb505, 0x9c59, 0x90e8,
    0x8778, 0x7ef9, 0x76fc, 0x6f45, 0x67ab, 0x600e, 0x5850, 0x504d, 0x47db,
    0x3ebd, 0x3486, 0x2853, 0x1715
};
static const FIXPU cplscale6[63] = {
    /* 2^16 C_ij */
    0xff7d, 0xfe74, 0xfd65, 0xfc50, 0xfb35, 0xfa14, 0xf8eb, 0xf7bb, 0xf683,
    0xf543, 0xf3f9, 0xf2a6, 0xf148, 0xefdf, 0xee6a, 0xece6, 0xeb54, 0xe9b2,
    0xe7fd, 0xe634, 0xe453, 0xe258, 0xe03d, 0xddff, 0xdb94, 0xd8f4, 0xd610,
    0xd2d2, 0xcf13, 0xca8c, 0xc47c, 0xb505, 0xa41a, 0x9c90, 0x9685, 0x913a,
    0x8c67, 0x87e5, 0x839c, 0x7f7e, 0x7b81, 0x779b, 0x73c7, 0x6fff, 0x6c3f,
    0x6883, 0x64c7, 0x6107, 0x5d40, 0x596e, 0x558d, 0x5198, 0x4d8b, 0x495f,
    0x450d, 0x408b, 0x3bcd, 0x36c1, 0x314d, 0x2b4a, 0x246e, 0x1c1a, 0x1029
};

buffer; ptr += 4; /* size */ ptr += 4; /* frma */ ptr += 4; /* alac */ ptr += 4; /* size */ ptr += 4; /* alac */ ptr += 4; /* 0 ? */ alac->setinfo_max_samples_per_frame = *(uint32_t*)ptr; /* buffer size / 2 ? */ #ifdef ROCKBOX_LITTLE_ENDIAN _Swap32(alac->setinfo_max_samples_per_frame); #endif ptr += 4; alac->setinfo_7a = *(uint8_t*)ptr; ptr += 1; alac->setinfo_sample_size = *(uint8_t*)ptr; ptr += 1; alac->setinfo_rice_historymult = *(uint8_t*)ptr; ptr += 1; alac->setinfo_rice_initialhistory = *(uint8_t*)ptr; ptr += 1; alac->setinfo_rice_kmodifier = *(uint8_t*)ptr; ptr += 1; alac->setinfo_7f = *(uint8_t*)ptr; ptr += 1; alac->setinfo_80 = *(uint16_t*)ptr; #ifdef ROCKBOX_LITTLE_ENDIAN _Swap16(alac->setinfo_80); #endif ptr += 2; alac->setinfo_82 = *(uint32_t*)ptr; #ifdef ROCKBOX_LITTLE_ENDIAN _Swap32(alac->setinfo_82); #endif ptr += 4; alac->setinfo_86 = *(uint32_t*)ptr; #ifdef ROCKBOX_LITTLE_ENDIAN _Swap32(alac->setinfo_86); #endif ptr += 4; alac->setinfo_8a_rate = *(uint32_t*)ptr; #ifdef ROCKBOX_LITTLE_ENDIAN _Swap32(alac->setinfo_8a_rate); #endif ptr += 4; } /* stream reading */ /* supports reading 1 to 16 bits, in big endian format */ static inline uint32_t readbits_16(alac_file *alac, int bits) { uint32_t result; int new_accumulator; result = (alac->input_buffer[0] << 16) | (alac->input_buffer[1] << 8) | (alac->input_buffer[2]); /* shift left by the number of bits we've already read, * so that the top 'n' bits of the 24 bits we read will * be the return bits */ result = result << alac->input_buffer_bitaccumulator; result = result & 0x00ffffff; /* and then only want the top 'n' bits from that, where * n is 'bits' */ result = result >> (24 - bits); new_accumulator = (alac->input_buffer_bitaccumulator + bits); /* increase the buffer pointer if we've read over n bytes. */ alac->input_buffer += (new_accumulator >> 3); /* and the remainder goes back into the bit accumulator */ alac->input_buffer_bitaccumulator = (new_accumulator & 7); return result; } /* supports reading 1 to 32 bits, in big endian format */ static inline uint32_t readbits(alac_file *alac, int bits) { int32_t result = 0; if (bits > 16) { bits -= 16; result = readbits_16(alac, 16) << bits; } result |= readbits_16(alac, bits); return result; } /* reads a single bit */ static inline int readbit(alac_file *alac) { int result; int new_accumulator; result = alac->input_buffer[0]; result = result << alac->input_buffer_bitaccumulator; result = result >> 7 & 1; new_accumulator = (alac->input_buffer_bitaccumulator + 1); alac->input_buffer += (new_accumulator / 8); alac->input_buffer_bitaccumulator = (new_accumulator % 8); return result; } static inline void unreadbits(alac_file *alac, int bits) { int new_accumulator = (alac->input_buffer_bitaccumulator - bits); alac->input_buffer += (new_accumulator >> 3); alac->input_buffer_bitaccumulator = (new_accumulator & 7); if (alac->input_buffer_bitaccumulator < 0) alac->input_buffer_bitaccumulator *= -1; } static const unsigned char bittab[16] ICONST_ATTR = { 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4 }; static inline int count_leading_zeros(int input) { int output = 32; #if 0 /* Experimentation has shown that the following test is always false, so we don't bother to perform it. */ if (input & 0xffff0000) { input >>= 16; output -= 16; } #endif if (input & 0xff00) { input >>= 8; output -= 8; } if (input & 0xf0) { input >>= 4; output -= 4; } output -= bittab[input]; return output; } void basterdised_rice_decompress(alac_file *alac, int32_t *output_buffer, int output_size, int readsamplesize, /* arg_10 */ int rice_initialhistory, /* arg424->b */ int rice_kmodifier, /* arg424->d */ int rice_historymult, /* arg424->c */ int rice_kmodifier_mask /* arg424->e */ ) ICODE_ATTR_ALAC; void basterdised_rice_decompress(alac_file *alac, int32_t *output_buffer, int output_size, int readsamplesize, /* arg_10 */ int rice_initialhistory, /* arg424->b */ int rice_kmodifier, /* arg424->d */ int rice_historymult, /* arg424->c */ int rice_kmodifier_mask /* arg424->e */ ) { int output_count; unsigned int history = rice_initialhistory; int sign_modifier = 0; for (output_count = 0; output_count < output_size; output_count++) { int32_t x = 0; int32_t x_modified; int32_t final_val; /* read x - number of 1s before 0 represent the rice */ while (x <= 8 && readbit(alac)) { x++; } if (x > 8) /* RICE THRESHOLD */ { /* use alternative encoding */ int32_t value; value = readbits(alac, readsamplesize); /* mask value to readsamplesize size */ if (readsamplesize != 32) value &= (0xffffffff >> (32 - readsamplesize)); x = value; } else { /* standard rice encoding */ int extrabits; int k; /* size of extra bits */ /* read k, that is bits as is */ k = 31 - rice_kmodifier - count_leading_zeros((history >> 9) + 3); if (k < 0) k += rice_kmodifier; else k = rice_kmodifier; if (k != 1) { extrabits = readbits(alac, k); /* multiply x by 2^k - 1, as part of their strange algorithm */ x = (x << k) - x; if (extrabits > 1) { x += extrabits - 1; } else unreadbits(alac, 1); } } x_modified = sign_modifier + x; final_val = (x_modified + 1) / 2; if (x_modified & 1) final_val *= -1; output_buffer[output_count] = final_val; sign_modifier = 0; /* now update the history */ history += (x_modified * rice_historymult) - ((history * rice_historymult) >> 9); if (x_modified > 0xffff) history = 0xffff; /* special case: there may be compressed blocks of 0 */ if ((history < 128) && (output_count+1 < output_size)) { int block_size; sign_modifier = 1; x = 0; while (x <= 8 && readbit(alac)) { x++; } if (x > 8) { block_size = readbits(alac, 16); block_size &= 0xffff; } else { int k; int extrabits; k = count_leading_zeros(history) + ((history + 16) >> 6 /* / 64 */) - 24; extrabits = readbits(alac, k); block_size = (((1 << k) - 1) & rice_kmodifier_mask) * x + extrabits - 1; if (extrabits < 2) { x = 1 - extrabits; block_size += x; unreadbits(alac, 1); } } if (block_size > 0) { memset(&output_buffer[output_count+1], 0, block_size * 4); output_count += block_size; } if (block_size > 0xffff) sign_modifier = 0; history = 0; } } } #define SIGN_EXTENDED32(val, bits) ((val << (32 - bits)) >> (32 - bits)) #define SIGN_ONLY(v) \ ((v < 0) ? (-1) : \ ((v > 0) ? (1) : \ (0))) static void predictor_decompress_fir_adapt(int32_t *error_buffer, int32_t *buffer_out, int output_size, int readsamplesize, int16_t *predictor_coef_table, int predictor_coef_num, int predictor_quantitization) ICODE_ATTR_ALAC; static void predictor_decompress_fir_adapt(int32_t *error_buffer, int32_t *buffer_out, int output_size, int readsamplesize, int16_t *predictor_coef_table, int predictor_coef_num, int predictor_quantitization) { int i; /* first sample always copies */ *buffer_out = *error_buffer; if (!predictor_coef_num) { if (output_size <= 1) return; memcpy(buffer_out+1, error_buffer+1, (output_size-1) * 4); return; } if (predictor_coef_num == 0x1f) /* 11111 - max value of predictor_coef_num */ { /* second-best case scenario for fir decompression, * error describes a small difference from the previous sample only */ if (output_size <= 1) return; for (i = 0; i < output_size - 1; i++) { int32_t prev_value; int32_t error_value; prev_value = buffer_out[i]; error_value = error_buffer[i+1]; buffer_out[i+1] = SIGN_EXTENDED32((prev_value + error_value), readsamplesize); } return; } /* read warm-up samples */ if (predictor_coef_num > 0) { int i; for (i = 0; i < predictor_coef_num; i++) { int32_t val; val = buffer_out[i] + error_buffer[i+1]; val = SIGN_EXTENDED32(val, readsamplesize); buffer_out[i+1] = val; } } /* 4 and 8 are very common cases (the only ones i've seen). The following code is an initial attempt to unroll and optimise these two cases by the Rockbox project. More work is needed. */ /* optimised case: 4 */ if (predictor_coef_num == 4) { for (i = 4 + 1; i < output_size; i++) { int sum = 0; int outval; int error_val = error_buffer[i]; sum = (buffer_out[4] - buffer_out[0]) * predictor_coef_table[0] + (buffer_out[3] - buffer_out[0]) * predictor_coef_table[1] + (buffer_out[2] - buffer_out[0]) * predictor_coef_table[2] + (buffer_out[1] - buffer_out[0]) * predictor_coef_table[3]; outval = (1 << (predictor_quantitization-1)) + sum; outval = outval >> predictor_quantitization; outval = outval + buffer_out[0] + error_val; outval = SIGN_EXTENDED32(outval, readsamplesize); buffer_out[4+1] = outval; if (error_val > 0) { int predictor_num = 4 - 1; while (predictor_num >= 0 && error_val > 0) { int val = buffer_out[0] - buffer_out[4 - predictor_num]; if (val!=0) { if (val < 0) { predictor_coef_table[predictor_num]++; val=-val; } else { predictor_coef_table[predictor_num]--;; } error_val -= ((val >> predictor_quantitization) * (4 - predictor_num)); } predictor_num--; } } else if (error_val < 0) { int predictor_num = 4 - 1; while (predictor_num >= 0 && error_val < 0) { int val = buffer_out[0] - buffer_out[4 - predictor_num]; if (val != 0) { if (val > 0) { predictor_coef_table[predictor_num]++; val=-val; /* neg value */ } else { predictor_coef_table[predictor_num]--; } error_val -= ((val >> predictor_quantitization) * (4 - predictor_num)); } predictor_num--; } } buffer_out++; } return; } /* optimised case: 8 */ if (predictor_coef_num == 8) { for (i = 8 + 1; i < output_size; i++) { int sum; int outval; int error_val = error_buffer[i]; sum = (buffer_out[8] - buffer_out[0]) * predictor_coef_table[0] + (buffer_out[7] - buffer_out[0]) * predictor_coef_table[1] + (buffer_out[6] - buffer_out[0]) * predictor_coef_table[2] + (buffer_out[5] - buffer_out[0]) * predictor_coef_table[3] + (buffer_out[4] - buffer_out[0]) * predictor_coef_table[4] + (buffer_out[3] - buffer_out[0]) * predictor_coef_table[5] + (buffer_out[2] - buffer_out[0]) * predictor_coef_table[6] + (buffer_out[1] - buffer_out[0]) * predictor_coef_table[7]; outval = (1 << (predictor_quantitization-1)) + sum; outval = outval >> predictor_quantitization; outval = outval + buffer_out[0] + error_val; outval = SIGN_EXTENDED32(outval, readsamplesize); buffer_out[8+1] = outval; if (error_val > 0) { int predictor_num = 8 - 1; while (predictor_num >= 0 && error_val > 0) { int val = buffer_out[0] - buffer_out[8 - predictor_num]; if (val!=0) { if (val < 0) { predictor_coef_table[predictor_num]++; val=-val; } else { predictor_coef_table[predictor_num]--;; } error_val -= ((val >> predictor_quantitization) * (8 - predictor_num)); } predictor_num--; } } else if (error_val < 0) { int predictor_num = 8 - 1; while (predictor_num >= 0 && error_val < 0) { int val = buffer_out[0] - buffer_out[8 - predictor_num]; if (val != 0) { if (val > 0) { predictor_coef_table[predictor_num]++; val=-val; /* neg value */ } else { predictor_coef_table[predictor_num]--; } error_val -= ((val >> predictor_quantitization) * (8 - predictor_num)); } predictor_num--; } } buffer_out++; } return; } /* general case */ if (predictor_coef_num > 0) { for (i = predictor_coef_num + 1; i < output_size; i++) { int j; int sum = 0; int outval; int error_val = error_buffer[i]; for (j = 0; j < predictor_coef_num; j++) { sum += (buffer_out[predictor_coef_num-j] - buffer_out[0]) * predictor_coef_table[j]; } outval = (1 << (predictor_quantitization-1)) + sum; outval = outval >> predictor_quantitization; outval = outval + buffer_out[0] + error_val; outval = SIGN_EXTENDED32(outval, readsamplesize); buffer_out[predictor_coef_num+1] = outval; if (error_val > 0) { int predictor_num = predictor_coef_num - 1; while (predictor_num >= 0 && error_val > 0) { int val = buffer_out[0] - buffer_out[predictor_coef_num - predictor_num]; int sign = SIGN_ONLY(val); predictor_coef_table[predictor_num] -= sign; val *= sign; /* absolute value */ error_val -= ((val >> predictor_quantitization) * (predictor_coef_num - predictor_num)); predictor_num--; } } else if (error_val < 0) { int predictor_num = predictor_coef_num - 1; while (predictor_num >= 0 && error_val < 0) { int val = buffer_out[0] - buffer_out[predictor_coef_num - predictor_num]; int sign = - SIGN_ONLY(val); predictor_coef_table[predictor_num] -= sign; val *= sign; /* neg value */ error_val -= ((val >> predictor_quantitization) * (predictor_coef_num - predictor_num)); predictor_num--; } } buffer_out++; } } } void deinterlace_16(int32_t* buffer0, int32_t* buffer1, int numsamples, uint8_t interlacing_shift, uint8_t interlacing_leftweight) ICODE_ATTR_ALAC; void deinterlace_16(int32_t* buffer0, int32_t* buffer1, int numsamples, uint8_t interlacing_shift, uint8_t interlacing_leftweight) { int i; if (numsamples <= 0) return; /* weighted interlacing */ if (interlacing_leftweight) { for (i = 0; i < numsamples; i++) { int32_t difference, midright; midright = buffer0[i]; difference = buffer1[i]; buffer0[i] = ((midright - ((difference * interlacing_leftweight) >> interlacing_shift)) + difference) << SCALE16; buffer1[i] = (midright - ((difference * interlacing_leftweight) >> interlacing_shift)) << SCALE16; } return; } /* otherwise basic interlacing took place */ for (i = 0; i < numsamples; i++) { buffer0[i] = buffer0[i] << SCALE16; buffer1[i] = buffer1[i] << SCALE16; } } static inline int decode_frame_mono( alac_file *alac, int32_t outputbuffer[ALAC_MAX_CHANNELS][ALAC_BLOCKSIZE], void (*yield)(void)) { int hassize; int isnotcompressed; int readsamplesize; int outputsamples = alac->setinfo_max_samples_per_frame; int wasted_bytes; int ricemodifier; /* 2^result = something to do with output waiting. * perhaps matters if we read > 1 frame in a pass? */ readbits(alac, 4); readbits(alac, 12); /* unknown, skip 12 bits */ hassize = readbits(alac, 1); /* the output sample size is stored soon */ wasted_bytes = readbits(alac, 2); /* unknown ? */ isnotcompressed = readbits(alac, 1); /* whether the frame is compressed */ if (hassize) { /* now read the number of samples, * as a 32bit integer */ outputsamples = readbits(alac, 32); } readsamplesize = alac->setinfo_sample_size - (wasted_bytes * 8); if (!isnotcompressed) { /* so it is compressed */ int predictor_coef_num; int prediction_type; int prediction_quantitization; int i; /* skip 16 bits, not sure what they are. seem to be used in * two channel case */ readbits(alac, 8); readbits(alac, 8); prediction_type = readbits(alac, 4); prediction_quantitization = readbits(alac, 4); ricemodifier = readbits(alac, 3); predictor_coef_num = readbits(alac, 5); /* read the predictor table */ for (i = 0; i < predictor_coef_num; i++) { predictor_coef_table[i] = (int16_t)readbits(alac, 16); } if (wasted_bytes) { /* these bytes seem to have something to do with * > 2 channel files. */ //fprintf(stderr, "FIXME: unimplemented, unhandling of wasted_bytes\n"); } yield(); basterdised_rice_decompress(alac, outputbuffer[0], outputsamples, readsamplesize, alac->setinfo_rice_initialhistory, alac->setinfo_rice_kmodifier, ricemodifier * alac->setinfo_rice_historymult / 4, (1 << alac->setinfo_rice_kmodifier) - 1); yield(); if (prediction_type == 0) { /* adaptive fir */ predictor_decompress_fir_adapt(outputbuffer[0], outputbuffer[0], outputsamples, readsamplesize, predictor_coef_table, predictor_coef_num, prediction_quantitization); } else { //fprintf(stderr, "FIXME: unhandled predicition type: %i\n", prediction_type); /* i think the only other prediction type (or perhaps this is just a * boolean?) runs adaptive fir twice.. like: * predictor_decompress_fir_adapt(predictor_error, tempout, ...) * predictor_decompress_fir_adapt(predictor_error, outputsamples ...) * little strange.. */ } } else { /* not compressed, easy case */ if (readsamplesize <= 16) { int i; for (i = 0; i < outputsamples; i++) { int32_t audiobits = readbits(alac, readsamplesize); audiobits = SIGN_EXTENDED32(audiobits, readsamplesize); outputbuffer[0][i] = audiobits; } } else { int i; for (i = 0; i < outputsamples; i++) { int32_t audiobits; audiobits = readbits(alac, 16); /* special case of sign extension.. * as we'll be ORing the low 16bits into this */ audiobits = audiobits << 16; audiobits = audiobits >> (32 - readsamplesize); audiobits |= readbits(alac, readsamplesize - 16); outputbuffer[0][i] = audiobits; } } /* wasted_bytes = 0; // unused */ } yield(); switch(alac->setinfo_sample_size) { case 16: { int i; for (i = 0; i < outputsamples; i++) { /* Output mono data as stereo */ outputbuffer[0][i] = outputbuffer[0][i] << SCALE16; outputbuffer[1][i] = outputbuffer[0][i]; } break; } case 20: case 24: case 32: //fprintf(stderr, "FIXME: unimplemented sample size %i\n", alac->setinfo_sample_size); break; default: break; } return outputsamples; } static inline int decode_frame_stereo( alac_file *alac, int32_t outputbuffer[ALAC_MAX_CHANNELS][ALAC_BLOCKSIZE], void (*yield)(void)) { int hassize; int isnotcompressed; int readsamplesize; int outputsamples = alac->setinfo_max_samples_per_frame; int wasted_bytes; uint8_t interlacing_shift; uint8_t interlacing_leftweight; /* 2^result = something to do with output waiting. * perhaps matters if we read > 1 frame in a pass? */ readbits(alac, 4); readbits(alac, 12); /* unknown, skip 12 bits */ hassize = readbits(alac, 1); /* the output sample size is stored soon */ wasted_bytes = readbits(alac, 2); /* unknown ? */ isnotcompressed = readbits(alac, 1); /* whether the frame is compressed */ if (hassize) { /* now read the number of samples, * as a 32bit integer */ outputsamples = readbits(alac, 32); } readsamplesize = alac->setinfo_sample_size - (wasted_bytes * 8) + 1; yield(); if (!isnotcompressed) { /* compressed */ int predictor_coef_num_a; int prediction_type_a; int prediction_quantitization_a; int ricemodifier_a; int predictor_coef_num_b; int prediction_type_b; int prediction_quantitization_b; int ricemodifier_b; int i; interlacing_shift = readbits(alac, 8); interlacing_leftweight = readbits(alac, 8); /******** channel 1 ***********/ prediction_type_a = readbits(alac, 4); prediction_quantitization_a = readbits(alac, 4); ricemodifier_a = readbits(alac, 3); predictor_coef_num_a = readbits(alac, 5); /* read the predictor table */ for (i = 0; i < predictor_coef_num_a; i++) { predictor_coef_table_a[i] = (int16_t)readbits(alac, 16); } /******** channel 2 *********/ prediction_type_b = readbits(alac, 4); prediction_quantitization_b = readbits(alac, 4); ricemodifier_b = readbits(alac, 3); predictor_coef_num_b = readbits(alac, 5); /* read the predictor table */ for (i = 0; i < predictor_coef_num_b; i++) { predictor_coef_table_b[i] = (int16_t)readbits(alac, 16); } /*********************/ if (wasted_bytes) { /* see mono case */ //fprintf(stderr, "FIXME: unimplemented, unhandling of wasted_bytes\n"); } yield(); /* channel 1 */ basterdised_rice_decompress(alac, outputbuffer[0], outputsamples, readsamplesize, alac->setinfo_rice_initialhistory, alac->setinfo_rice_kmodifier, ricemodifier_a * alac->setinfo_rice_historymult / 4, (1 << alac->setinfo_rice_kmodifier) - 1); yield(); if (prediction_type_a == 0) { /* adaptive fir */ predictor_decompress_fir_adapt(outputbuffer[0], outputbuffer[0], outputsamples, readsamplesize, predictor_coef_table_a, predictor_coef_num_a, prediction_quantitization_a); } else { /* see mono case */ //fprintf(stderr, "FIXME: unhandled predicition type: %i\n", prediction_type_a); } yield(); /* channel 2 */ basterdised_rice_decompress(alac, outputbuffer[1], outputsamples, readsamplesize, alac->setinfo_rice_initialhistory, alac->setinfo_rice_kmodifier, ricemodifier_b * alac->setinfo_rice_historymult / 4, (1 << alac->setinfo_rice_kmodifier) - 1); yield(); if (prediction_type_b == 0) { /* adaptive fir */ predictor_decompress_fir_adapt(outputbuffer[1], outputbuffer[1], outputsamples, readsamplesize, predictor_coef_table_b, predictor_coef_num_b, prediction_quantitization_b); } else { //fprintf(stderr, "FIXME: unhandled predicition type: %i\n", prediction_type_b); } } else { /* not compressed, easy case */ if (alac->setinfo_sample_size <= 16) { int i; for (i = 0; i < outputsamples; i++) { int32_t audiobits_a, audiobits_b; audiobits_a = readbits(alac, alac->setinfo_sample_size); audiobits_b = readbits(alac, alac->setinfo_sample_size); audiobits_a = SIGN_EXTENDED32(audiobits_a, alac->setinfo_sample_size); audiobits_b = SIGN_EXTENDED32(audiobits_b, alac->setinfo_sample_size); outputbuffer[0][i] = audiobits_a; outputbuffer[1][i] = audiobits_b; } } else { int i; for (i = 0; i < outputsamples; i++) { int32_t audiobits_a, audiobits_b; audiobits_a = readbits(alac, 16); audiobits_a = audiobits_a << 16; audiobits_a = audiobits_a >> (32 - alac->setinfo_sample_size); audiobits_a |= readbits(alac, alac->setinfo_sample_size - 16); audiobits_b = readbits(alac, 16); audiobits_b = audiobits_b << 16; audiobits_b = audiobits_b >> (32 - alac->setinfo_sample_size); audiobits_b |= readbits(alac, alac->setinfo_sample_size - 16); outputbuffer[0][i] = audiobits_a; outputbuffer[1][i] = audiobits_b; } } /* wasted_bytes = 0; */ interlacing_shift = 0; interlacing_leftweight = 0; } yield(); switch(alac->setinfo_sample_size) { case 16: { deinterlace_16(outputbuffer[0], outputbuffer[1], outputsamples, interlacing_shift, interlacing_leftweight); break; } case 20: case 24: case 32: //fprintf(stderr, "FIXME: unimplemented sample size %i\n", alac->setinfo_sample_size); break; default: break; } return outputsamples; } int alac_decode_frame(alac_file *alac, unsigned char *inbuffer, int32_t outputbuffer[ALAC_MAX_CHANNELS][ALAC_BLOCKSIZE], void (*yield)(void)) { int channels; int outputsamples; /* setup the stream */ alac->input_buffer = inbuffer; alac->input_buffer_bitaccumulator = 0; channels = readbits(alac, 3); /* TODO: The mono and stereo functions should be combined. */ switch(channels) { case 0: /* 1 channel */ outputsamples=decode_frame_mono(alac,outputbuffer,yield); break; case 1: /* 2 channels */ outputsamples=decode_frame_stereo(alac,outputbuffer,yield); break; default: /* Unsupported */ return -1; } return outputsamples; } void create_alac(int samplesize, int numchannels, alac_file* alac) { alac->samplesize = samplesize; alac->numchannels = numchannels; alac->bytespersample = (samplesize / 8) * numchannels; }