diff options
author | Sean Bartell <wingedtachikoma@gmail.com> | 2011-06-25 21:32:25 -0400 |
---|---|---|
committer | Nils Wallménius <nils@rockbox.org> | 2012-04-25 22:13:20 +0200 |
commit | f40bfc9267b13b54e6379dfe7539447662879d24 (patch) | |
tree | 9b20069d5e62809ff434061ad730096836f916f2 /lib/rbcodec/codecs/libpcm/linear_pcm.c | |
parent | a0009907de7a0107d49040d8a180f140e2eff299 (diff) | |
download | rockbox-f40bfc9267b13b54e6379dfe7539447662879d24.tar.gz rockbox-f40bfc9267b13b54e6379dfe7539447662879d24.zip |
Add codecs to librbcodec.
Change-Id: Id7f4717d51ed02d67cb9f9cb3c0ada4a81843f97
Reviewed-on: http://gerrit.rockbox.org/137
Reviewed-by: Nils Wallménius <nils@rockbox.org>
Tested-by: Nils Wallménius <nils@rockbox.org>
Diffstat (limited to 'lib/rbcodec/codecs/libpcm/linear_pcm.c')
-rw-r--r-- | lib/rbcodec/codecs/libpcm/linear_pcm.c | 294 |
1 files changed, 294 insertions, 0 deletions
diff --git a/lib/rbcodec/codecs/libpcm/linear_pcm.c b/lib/rbcodec/codecs/libpcm/linear_pcm.c new file mode 100644 index 0000000000..5c3c140b8c --- /dev/null +++ b/lib/rbcodec/codecs/libpcm/linear_pcm.c | |||
@@ -0,0 +1,294 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) 2005 Dave Chapman | ||
11 | * Copyright (C) 2009 Yoshihisa Uchida | ||
12 | * | ||
13 | * This program is free software; you can redistribute it and/or | ||
14 | * modify it under the terms of the GNU General Public License | ||
15 | * as published by the Free Software Foundation; either version 2 | ||
16 | * of the License, or (at your option) any later version. | ||
17 | * | ||
18 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
19 | * KIND, either express or implied. | ||
20 | * | ||
21 | ****************************************************************************/ | ||
22 | #include "codeclib.h" | ||
23 | #include "support_formats.h" | ||
24 | |||
25 | /* | ||
26 | * Linear PCM | ||
27 | */ | ||
28 | |||
29 | #define INC_DEPTH_8 (PCM_OUTPUT_DEPTH - 8) | ||
30 | #define INC_DEPTH_16 (PCM_OUTPUT_DEPTH - 16) | ||
31 | #define INC_DEPTH_24 (PCM_OUTPUT_DEPTH - 24) | ||
32 | #define DEC_DEPTH_32 (32 - PCM_OUTPUT_DEPTH) | ||
33 | |||
34 | |||
35 | static struct pcm_format *fmt; | ||
36 | |||
37 | static bool set_format(struct pcm_format *format) | ||
38 | { | ||
39 | fmt = format; | ||
40 | |||
41 | if (fmt->channels == 0) | ||
42 | { | ||
43 | DEBUGF("CODEC_ERROR: channels is 0\n"); | ||
44 | return false; | ||
45 | } | ||
46 | |||
47 | if (fmt->bitspersample == 0) | ||
48 | { | ||
49 | DEBUGF("CODEC_ERROR: bitspersample is 0\n"); | ||
50 | return false; | ||
51 | } | ||
52 | |||
53 | if (fmt->bitspersample > 32) | ||
54 | { | ||
55 | DEBUGF("CODEC_ERROR: pcm with more than 32 bitspersample " | ||
56 | "is unsupported\n"); | ||
57 | return false; | ||
58 | } | ||
59 | |||
60 | fmt->bytespersample = fmt->bitspersample >> 3; | ||
61 | |||
62 | if (fmt->blockalign == 0) | ||
63 | fmt->blockalign = fmt->bytespersample * fmt->channels; | ||
64 | |||
65 | fmt->samplesperblock = fmt->blockalign / (fmt->bytespersample * fmt->channels); | ||
66 | |||
67 | /* chunksize = about 1/50[sec] data */ | ||
68 | fmt->chunksize = (ci->id3->frequency / (50 * fmt->samplesperblock)) | ||
69 | * fmt->blockalign; | ||
70 | |||
71 | return true; | ||
72 | } | ||
73 | |||
74 | static struct pcm_pos *get_seek_pos(uint32_t seek_val, int seek_mode, | ||
75 | uint8_t *(*read_buffer)(size_t *realsize)) | ||
76 | { | ||
77 | static struct pcm_pos newpos; | ||
78 | uint32_t newblock = (seek_mode == PCM_SEEK_TIME) ? | ||
79 | ((uint64_t)seek_val * ci->id3->frequency / 1000LL) | ||
80 | / fmt->samplesperblock : | ||
81 | seek_val / fmt->blockalign; | ||
82 | |||
83 | (void)read_buffer; | ||
84 | newpos.pos = newblock * fmt->blockalign; | ||
85 | newpos.samples = newblock * fmt->samplesperblock; | ||
86 | return &newpos; | ||
87 | } | ||
88 | |||
89 | /* 8bit decode functions */ | ||
90 | static inline void decode_s8(const uint8_t *inbuf, size_t inbufsize, int32_t *outbuf) | ||
91 | { | ||
92 | size_t i = 0; | ||
93 | |||
94 | for ( ; i < inbufsize; i++) | ||
95 | outbuf[i] = SE(inbuf[i]) << INC_DEPTH_8; | ||
96 | } | ||
97 | |||
98 | static inline void decode_u8(const uint8_t *inbuf, size_t inbufsize, int32_t *outbuf) | ||
99 | { | ||
100 | size_t i = 0; | ||
101 | |||
102 | for ( ; i < inbufsize; i++) | ||
103 | outbuf[i] = SFT(inbuf[i]) << INC_DEPTH_8; | ||
104 | } | ||
105 | |||
106 | /* 16bit decode functions */ | ||
107 | static inline void decode_s16le(const uint8_t *inbuf, size_t inbufsize, int32_t *outbuf) | ||
108 | { | ||
109 | size_t i = 0; | ||
110 | |||
111 | for ( ; i < inbufsize; i += 2) | ||
112 | outbuf[i/2] = (inbuf[i] << INC_DEPTH_16)|(SE(inbuf[i+1]) << INC_DEPTH_8); | ||
113 | } | ||
114 | |||
115 | static inline void decode_u16le(const uint8_t *inbuf, size_t inbufsize, int32_t *outbuf) | ||
116 | { | ||
117 | size_t i = 0; | ||
118 | |||
119 | for ( ; i < inbufsize; i += 2) | ||
120 | outbuf[i/2] = (inbuf[i] << INC_DEPTH_16)|(SFT(inbuf[i+1]) << INC_DEPTH_8); | ||
121 | } | ||
122 | |||
123 | static inline void decode_s16be(const uint8_t *inbuf, size_t inbufsize, int32_t *outbuf) | ||
124 | { | ||
125 | size_t i = 0; | ||
126 | |||
127 | for ( ; i < inbufsize; i += 2) | ||
128 | outbuf[i/2] = (inbuf[i+1] << INC_DEPTH_16)|(SE(inbuf[i]) << INC_DEPTH_8); | ||
129 | } | ||
130 | |||
131 | static inline void decode_u16be(const uint8_t *inbuf, size_t inbufsize, int32_t *outbuf) | ||
132 | { | ||
133 | size_t i = 0; | ||
134 | |||
135 | for ( ; i < inbufsize; i += 2) | ||
136 | outbuf[i/2] = (inbuf[i+1] << INC_DEPTH_16)|(SFT(inbuf[i]) << INC_DEPTH_8); | ||
137 | } | ||
138 | |||
139 | /* 24bit decode functions */ | ||
140 | static inline void decode_s24le(const uint8_t *inbuf, size_t inbufsize, int32_t *outbuf) | ||
141 | { | ||
142 | size_t i = 0; | ||
143 | |||
144 | for ( ; i < inbufsize; i += 3) | ||
145 | outbuf[i/3] = (inbuf[i] << INC_DEPTH_24)|(inbuf[i+1] << INC_DEPTH_16)| | ||
146 | (SE(inbuf[i+2]) << INC_DEPTH_8); | ||
147 | } | ||
148 | |||
149 | static inline void decode_u24le(const uint8_t *inbuf, size_t inbufsize, int32_t *outbuf) | ||
150 | { | ||
151 | size_t i = 0; | ||
152 | |||
153 | for ( ; i < inbufsize; i += 3) | ||
154 | outbuf[i/3] = (inbuf[i] << INC_DEPTH_24)|(inbuf[i+1] << INC_DEPTH_16)| | ||
155 | (SFT(inbuf[i+2]) << INC_DEPTH_8); | ||
156 | } | ||
157 | |||
158 | static inline void decode_s24be(const uint8_t *inbuf, size_t inbufsize, int32_t *outbuf) | ||
159 | { | ||
160 | size_t i = 0; | ||
161 | |||
162 | for ( ; i < inbufsize; i += 3) | ||
163 | outbuf[i/3] = (inbuf[i+2] << INC_DEPTH_24)|(inbuf[i+1] << INC_DEPTH_16)| | ||
164 | (SE(inbuf[i]) << INC_DEPTH_8); | ||
165 | } | ||
166 | |||
167 | static inline void decode_u24be(const uint8_t *inbuf, size_t inbufsize, int32_t *outbuf) | ||
168 | { | ||
169 | size_t i = 0; | ||
170 | |||
171 | for ( ; i < inbufsize; i += 3) | ||
172 | outbuf[i/3] = (inbuf[i+2] << INC_DEPTH_24)|(inbuf[i+1] << INC_DEPTH_16)| | ||
173 | (SFT(inbuf[i]) << INC_DEPTH_8); | ||
174 | } | ||
175 | |||
176 | /* 32bit decode functions */ | ||
177 | static inline void decode_s32le(const uint8_t *inbuf, size_t inbufsize, int32_t *outbuf) | ||
178 | { | ||
179 | size_t i = 0; | ||
180 | |||
181 | for ( ; i < inbufsize; i += 4) | ||
182 | outbuf[i/4] = (inbuf[i] >> DEC_DEPTH_32)|(inbuf[i+1] << INC_DEPTH_24)| | ||
183 | (inbuf[i+2] << INC_DEPTH_16)|(SE(inbuf[i+3]) << INC_DEPTH_8); | ||
184 | } | ||
185 | |||
186 | static inline void decode_u32le(const uint8_t *inbuf, size_t inbufsize, int32_t *outbuf) | ||
187 | { | ||
188 | size_t i = 0; | ||
189 | |||
190 | for ( ; i < inbufsize; i += 4) | ||
191 | outbuf[i/4] = (inbuf[i] >> DEC_DEPTH_32)|(inbuf[i+1] << INC_DEPTH_24)| | ||
192 | (inbuf[i+2] << INC_DEPTH_16)|(SFT(inbuf[i+3]) << INC_DEPTH_8); | ||
193 | } | ||
194 | |||
195 | static inline void decode_s32be(const uint8_t *inbuf, size_t inbufsize, int32_t *outbuf) | ||
196 | { | ||
197 | size_t i = 0; | ||
198 | |||
199 | for ( ; i < inbufsize; i += 4) | ||
200 | outbuf[i/4] = (inbuf[i+3] >> DEC_DEPTH_32)|(inbuf[i+2] << INC_DEPTH_24)| | ||
201 | (inbuf[i+1] << INC_DEPTH_16)|(SE(inbuf[i]) << INC_DEPTH_8); | ||
202 | } | ||
203 | |||
204 | static inline void decode_u32be(const uint8_t *inbuf, size_t inbufsize, int32_t *outbuf) | ||
205 | { | ||
206 | size_t i = 0; | ||
207 | |||
208 | for ( ; i < inbufsize; i += 4) | ||
209 | outbuf[i/4] = (inbuf[i+3] >> DEC_DEPTH_32)|(inbuf[i+2] << INC_DEPTH_24)| | ||
210 | (inbuf[i+1] << INC_DEPTH_16)|(SFT(inbuf[i]) << INC_DEPTH_8); | ||
211 | } | ||
212 | |||
213 | static int decode(const uint8_t *inbuf, size_t inbufsize, int32_t *outbuf, int *outbufcount) | ||
214 | { | ||
215 | if (fmt->bitspersample > 24) | ||
216 | { | ||
217 | if (fmt->is_little_endian) | ||
218 | { | ||
219 | if (fmt->is_signed) | ||
220 | decode_s32le(inbuf, inbufsize, outbuf); | ||
221 | else | ||
222 | decode_u32le(inbuf, inbufsize, outbuf); | ||
223 | } | ||
224 | else | ||
225 | { | ||
226 | if (fmt->is_signed) | ||
227 | decode_s32be(inbuf, inbufsize, outbuf); | ||
228 | else | ||
229 | decode_u32be(inbuf, inbufsize, outbuf); | ||
230 | } | ||
231 | *outbufcount = inbufsize >> 2; | ||
232 | } | ||
233 | else if (fmt->bitspersample > 16) | ||
234 | { | ||
235 | if (fmt->is_little_endian) | ||
236 | { | ||
237 | if (fmt->is_signed) | ||
238 | decode_s24le(inbuf, inbufsize, outbuf); | ||
239 | else | ||
240 | decode_u24le(inbuf, inbufsize, outbuf); | ||
241 | } | ||
242 | else | ||
243 | { | ||
244 | if (fmt->is_signed) | ||
245 | decode_s24be(inbuf, inbufsize, outbuf); | ||
246 | else | ||
247 | decode_u24be(inbuf, inbufsize, outbuf); | ||
248 | } | ||
249 | *outbufcount = inbufsize / 3; | ||
250 | } | ||
251 | else if (fmt->bitspersample > 8) | ||
252 | { | ||
253 | if (fmt->is_little_endian) | ||
254 | { | ||
255 | if (fmt->is_signed) | ||
256 | decode_s16le(inbuf, inbufsize, outbuf); | ||
257 | else | ||
258 | decode_u16le(inbuf, inbufsize, outbuf); | ||
259 | } | ||
260 | else | ||
261 | { | ||
262 | if (fmt->is_signed) | ||
263 | decode_s16be(inbuf, inbufsize, outbuf); | ||
264 | else | ||
265 | decode_u16be(inbuf, inbufsize, outbuf); | ||
266 | } | ||
267 | *outbufcount = inbufsize >> 1; | ||
268 | } | ||
269 | else | ||
270 | { | ||
271 | if (fmt->is_signed) | ||
272 | decode_s8(inbuf, inbufsize, outbuf); | ||
273 | else | ||
274 | decode_u8(inbuf, inbufsize, outbuf); | ||
275 | |||
276 | *outbufcount = inbufsize; | ||
277 | } | ||
278 | |||
279 | if (fmt->channels == 2) | ||
280 | *outbufcount >>= 1; | ||
281 | |||
282 | return CODEC_OK; | ||
283 | } | ||
284 | |||
285 | static const struct pcm_codec codec = { | ||
286 | set_format, | ||
287 | get_seek_pos, | ||
288 | decode, | ||
289 | }; | ||
290 | |||
291 | const struct pcm_codec *get_linear_pcm_codec(void) | ||
292 | { | ||
293 | return &codec; | ||
294 | } | ||