1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (c) 2005 Jvo Studer
11 * Copyright (c) 2009 Yoshihisa Uchida
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.
18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 * KIND, either express or implied.
21 ****************************************************************************/
24 #include "codecs/libpcm/support_formats.h"
28 #define FOURCC(c1, c2, c3, c4) \
29 ((((uint32_t)c1)<<24)|(((uint32_t)c2)<<16)|(((uint32_t)c3)<<8)|((uint32_t)c4))
31 /* This codec supports the following AIFC compressionType formats */
33 AIFC_FORMAT_PCM
= FOURCC('N', 'O', 'N', 'E'), /* AIFC PCM Format (big endian) */
34 AIFC_FORMAT_ALAW
= FOURCC('a', 'l', 'a', 'w'), /* AIFC ALaw compressed */
35 AIFC_FORMAT_MULAW
= FOURCC('u', 'l', 'a', 'w'), /* AIFC uLaw compressed */
36 AIFC_FORMAT_IEEE_FLOAT32
= FOURCC('f', 'l', '3', '2'), /* AIFC IEEE float 32 bit */
37 AIFC_FORMAT_IEEE_FLOAT64
= FOURCC('f', 'l', '6', '4'), /* AIFC IEEE float 64 bit */
38 AIFC_FORMAT_QT_IMA_ADPCM
= FOURCC('i', 'm', 'a', '4'), /* AIFC QuickTime IMA ADPCM */
41 static const struct pcm_entry pcm_codecs
[] = {
42 { AIFC_FORMAT_PCM
, get_linear_pcm_codec
},
43 { AIFC_FORMAT_ALAW
, get_itut_g711_alaw_codec
},
44 { AIFC_FORMAT_MULAW
, get_itut_g711_mulaw_codec
},
45 { AIFC_FORMAT_IEEE_FLOAT32
, get_ieee_float_codec
},
46 { AIFC_FORMAT_IEEE_FLOAT64
, get_ieee_float_codec
},
47 { AIFC_FORMAT_QT_IMA_ADPCM
, get_qt_ima_adpcm_codec
},
50 #define PCM_SAMPLE_SIZE (1024*2)
52 static int32_t samples
[PCM_SAMPLE_SIZE
] IBSS_ATTR
;
54 static const struct pcm_codec
*get_codec(uint32_t formattag
)
57 for (i
= 0; i
< sizeof(pcm_codecs
)/sizeof(pcm_codecs
[0]); i
++)
58 if (pcm_codecs
[i
].format_tag
== formattag
)
59 return pcm_codecs
[i
].get_codec();
64 /* this is the codec entry point */
65 enum codec_status
codec_main(enum codec_entry_call_reason reason
)
67 if (reason
== CODEC_LOAD
) {
68 /* Generic codec initialisation */
69 ci
->configure(DSP_SET_SAMPLE_DEPTH
, PCM_OUTPUT_DEPTH
-1);
75 /* this is called for each file to process */
76 enum codec_status
codec_run(void)
78 struct pcm_format format
;
79 uint32_t bytesdone
, decodedsamples
;
80 /* rockbox: comment 'set but unused' variables
81 uint32_t num_sample_frames = 0;
88 uint32_t offset2snd
= 0;
89 off_t firstblockposn
; /* position of the first block in file */
91 const struct pcm_codec
*codec
;
99 codec_set_replaygain(ci
->id3
);
101 /* Need to save offset for later use (cleared indirectly by advance_buffer) */
102 bytesdone
= ci
->id3
->offset
;
104 /* assume the AIFF header is less than 1024 bytes */
106 buf
= ci
->request_buffer(&n
, 1024);
111 if (memcmp(buf
, "FORM", 4) != 0)
113 DEBUGF("CODEC_ERROR: does not aiff format %4.4s\n", (char*)&buf
[0]);
116 if (memcmp(&buf
[8], "AIFF", 4) == 0)
118 else if (memcmp(&buf
[8], "AIFC", 4) == 0)
122 DEBUGF("CODEC_ERROR: does not aiff format %4.4s\n", (char*)&buf
[8]);
129 ci
->memset(&format
, 0, sizeof(struct pcm_format
));
130 format
.is_signed
= true;
131 format
.is_little_endian
= false;
136 /* read until 'SSND' chunk, which typically is last */
137 while (format
.numbytes
== 0 && n
>= 8)
140 size
= ((buf
[4]<<24)|(buf
[5]<<16)|(buf
[6]<<8)|buf
[7]);
141 if (memcmp(buf
, "COMM", 4) == 0) {
142 if ((!is_aifc
&& size
< 18) || (is_aifc
&& size
< 22))
144 DEBUGF("CODEC_ERROR: 'COMM' chunk size=%lu < %d\n",
145 (unsigned long)size
, (is_aifc
)?22:18);
149 format
.channels
= ((buf
[8]<<8)|buf
[9]);
150 /* num_sample_frames */
152 num_sample_frames = ((buf[10]<<24)|(buf[11]<<16)|(buf[12]<<8)
157 format
.bitspersample
= ((buf
[14]<<8)|buf
[15]);
158 /* sample_rate (don't use last 4 bytes, only integer fs) */
159 if (buf
[16] != 0x40) {
160 DEBUGF("CODEC_ERROR: weird sampling rate (no @)\n");
163 format
.samplespersec
= ((buf
[18]<<24)|(buf
[19]<<16)|(buf
[20]<<8)|buf
[21])+1;
164 format
.samplespersec
>>= (16 + 14 - buf
[17]);
165 /* compressionType (AIFC only) */
168 format
.formattag
= (buf
[26]<<24)|(buf
[27]<<16)|(buf
[28]<<8)|buf
[29];
171 * aiff's sample_size is uncompressed sound data size.
172 * But format.bitspersample is compressed sound data size.
174 if (format
.formattag
== AIFC_FORMAT_ALAW
||
175 format
.formattag
== AIFC_FORMAT_MULAW
)
176 format
.bitspersample
= 8;
177 else if (format
.formattag
== AIFC_FORMAT_QT_IMA_ADPCM
)
178 format
.bitspersample
= 4;
181 format
.formattag
= AIFC_FORMAT_PCM
;
182 /* calc average bytes per second */
183 format
.avgbytespersec
= format
.samplespersec
*format
.channels
*format
.bitspersample
/8;
184 } else if (memcmp(buf
, "SSND", 4)==0) {
185 if (format
.bitspersample
== 0) {
186 DEBUGF("CODEC_ERROR: unsupported chunk order\n");
190 offset2snd
= (buf
[8]<<24)|(buf
[9]<<16)|(buf
[10]<<8)|buf
[11];
192 format
.blockalign
= ((buf
[12]<<24)|(buf
[13]<<16)|(buf
[14]<<8)|buf
[15]) >> 3;
193 if (format
.blockalign
== 0)
194 format
.blockalign
= format
.channels
* format
.bitspersample
>> 3;
195 format
.numbytes
= size
- 8 - offset2snd
;
196 size
= 8 + offset2snd
; /* advance to the beginning of data */
197 } else if (is_aifc
&& (memcmp(buf
, "FVER", 4)==0)) {
198 /* Format Version Chunk (AIFC only chunk) */
199 /* skip this chunk */
201 DEBUGF("unsupported AIFF chunk: '%c%c%c%c', size=%lu\n",
202 buf
[0], buf
[1], buf
[2], buf
[3], (unsigned long)size
);
205 size
+= 8 + (size
& 0x01); /* odd chunk sizes must be padded */
209 DEBUGF("CODEC_ERROR: AIFF header size > 1024\n");
215 if (format
.channels
== 0) {
216 DEBUGF("CODEC_ERROR: 'COMM' chunk not found or 0-channels file\n");
219 if (format
.numbytes
== 0) {
220 DEBUGF("CODEC_ERROR: 'SSND' chunk not found or has zero length\n");
224 codec
= get_codec(format
.formattag
);
227 DEBUGF("CODEC_ERROR: AIFC does not support compressionType: 0x%x\n",
228 (unsigned int)format
.formattag
);
232 if (!codec
->set_format(&format
))
237 ci
->configure(DSP_SWITCH_FREQUENCY
, ci
->id3
->frequency
);
239 if (format
.channels
== 2) {
240 ci
->configure(DSP_SET_STEREO_MODE
, STEREO_INTERLEAVED
);
241 } else if (format
.channels
== 1) {
242 ci
->configure(DSP_SET_STEREO_MODE
, STEREO_MONO
);
244 DEBUGF("CODEC_ERROR: more than 2 channels unsupported\n");
248 if (format
.samplesperblock
== 0)
250 DEBUGF("CODEC_ERROR: samplesperblock is 0\n");
253 if (format
.blockalign
== 0)
255 DEBUGF("CODEC_ERROR: blockalign is 0\n");
259 /* check chunksize */
260 if ((format
.chunksize
/ format
.blockalign
) * format
.samplesperblock
* format
.channels
262 format
.chunksize
= (PCM_SAMPLE_SIZE
/ format
.blockalign
) * format
.blockalign
;
263 if (format
.chunksize
== 0)
265 DEBUGF("CODEC_ERROR: chunksize is 0\n");
269 firstblockposn
= 1024 - n
;
270 ci
->advance_buffer(firstblockposn
);
272 /* make sure we're at the correct offset */
273 if (bytesdone
> (uint32_t) firstblockposn
) {
274 /* Round down to previous block */
275 struct pcm_pos
*newpos
= codec
->get_seek_pos(bytesdone
- firstblockposn
,
278 if (newpos
->pos
> format
.numbytes
)
281 if (ci
->seek_buffer(firstblockposn
+ newpos
->pos
))
283 bytesdone
= newpos
->pos
;
284 decodedsamples
= newpos
->samples
;
287 /* already where we need to be */
291 /* The main decoder loop */
294 while (!endofstream
) {
295 enum codec_command_action action
= ci
->get_command(¶m
);
297 if (action
== CODEC_ACTION_HALT
)
300 if (action
== CODEC_ACTION_SEEK_TIME
) {
301 /* 3rd args(read_buffer) is unnecessary in the format which AIFF supports. */
302 struct pcm_pos
*newpos
= codec
->get_seek_pos(param
, PCM_SEEK_TIME
, NULL
);
304 if (newpos
->pos
> format
.numbytes
)
306 ci
->set_elapsed(ci
->id3
->length
);
311 if (ci
->seek_buffer(firstblockposn
+ newpos
->pos
))
313 bytesdone
= newpos
->pos
;
314 decodedsamples
= newpos
->samples
;
317 ci
->set_elapsed(decodedsamples
*1000LL/ci
->id3
->frequency
);
320 aifbuf
= (uint8_t *)ci
->request_buffer(&n
, format
.chunksize
);
323 break; /* End of stream */
325 if (bytesdone
+ n
> format
.numbytes
) {
326 n
= format
.numbytes
- bytesdone
;
330 if (codec
->decode(aifbuf
, n
, samples
, &bufcount
) == CODEC_ERROR
)
332 DEBUGF("codec error\n");
336 ci
->pcmbuf_insert(samples
, NULL
, bufcount
);
338 ci
->advance_buffer(n
);
340 decodedsamples
+= bufcount
;
341 if (bytesdone
>= format
.numbytes
)
344 ci
->set_elapsed(decodedsamples
*1000LL/ci
->id3
->frequency
);