summaryrefslogtreecommitdiff
path: root/apps/codecs/smaf.c
diff options
context:
space:
mode:
Diffstat (limited to 'apps/codecs/smaf.c')
-rw-r--r--apps/codecs/smaf.c435
1 files changed, 435 insertions, 0 deletions
diff --git a/apps/codecs/smaf.c b/apps/codecs/smaf.c
new file mode 100644
index 0000000000..227227ada8
--- /dev/null
+++ b/apps/codecs/smaf.c
@@ -0,0 +1,435 @@
1/***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
9 *
10 * Copyright (c) 2010 Yoshihisa Uchida
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version 2
15 * of the License, or (at your option) any later version.
16 *
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
19 *
20 ****************************************************************************/
21
22#include "codeclib.h"
23#include "codecs/libpcm/support_formats.h"
24
25CODEC_HEADER
26
27/*
28 * SMAF (Synthetic music Mobile Application Format)
29 *
30 * References
31 * [1] YAMAHA Corporation, Synthetic music Mobile Application Format Ver.3.05, 2002
32 */
33
34enum {
35 SMAF_TRACK_CHUNK_SCORE = 0, /* Score Track */
36 SMAF_TRACK_CHUNK_AUDIO, /* PCM Audio Track */
37};
38
39/* SMAF supported codec formats */
40enum {
41 SMAF_FORMAT_UNSUPPORT = 0, /* unsupported format */
42 SMAF_FORMAT_SIGNED_PCM, /* 2's complement PCM */
43 SMAF_FORMAT_UNSIGNED_PCM, /* Offset Binary PCM */
44 SMAF_FORMAT_ADPCM, /* YAMAHA ADPCM */
45};
46
47static int support_formats[2][3] = {
48 {SMAF_FORMAT_SIGNED_PCM, SMAF_FORMAT_UNSIGNED_PCM, SMAF_FORMAT_ADPCM },
49 {SMAF_FORMAT_SIGNED_PCM, SMAF_FORMAT_ADPCM, SMAF_FORMAT_UNSUPPORT },
50};
51
52static const struct pcm_entry pcm_codecs[] = {
53 { SMAF_FORMAT_SIGNED_PCM, get_linear_pcm_codec },
54 { SMAF_FORMAT_UNSIGNED_PCM, get_linear_pcm_codec },
55 { SMAF_FORMAT_ADPCM, get_yamaha_adpcm_codec },
56};
57
58#define NUM_FORMATS 3
59
60static int basebits[4] = { 4, 8, 12, 16 };
61
62#define PCM_SAMPLE_SIZE (2048*2)
63
64static int32_t samples[PCM_SAMPLE_SIZE] IBSS_ATTR;
65
66static const struct pcm_codec *get_codec(uint32_t formattag)
67{
68 int i;
69
70 for (i = 0; i < NUM_FORMATS; i++)
71 {
72 if (pcm_codecs[i].format_tag == formattag)
73 {
74 if (pcm_codecs[i].get_codec)
75 return pcm_codecs[i].get_codec();
76 return 0;
77 }
78 }
79 return 0;
80}
81
82static unsigned int get_be32(uint8_t *buf)
83{
84 return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
85}
86
87static int convert_smaf_audio_format(int track_chunk, unsigned int audio_format)
88{
89 if (audio_format > 3)
90 return SMAF_FORMAT_UNSUPPORT;
91
92 return support_formats[track_chunk][audio_format];
93}
94
95static int convert_smaf_audio_basebit(unsigned int basebit)
96{
97 if (basebit > 4)
98 return 0;
99 return basebits[basebit];
100}
101
102static bool parse_audio_track(struct pcm_format *fmt,
103 unsigned char **stbuf, unsigned char *endbuf)
104{
105 unsigned char *buf = *stbuf;
106 int chunksize;
107
108 buf += 8;
109 fmt->channels = ((buf[2] & 0x80) >> 7) + 1;
110 fmt->formattag = convert_smaf_audio_format(SMAF_TRACK_CHUNK_AUDIO,
111 (buf[2] >> 4) & 0x07);
112 if (fmt->formattag == SMAF_FORMAT_UNSUPPORT)
113 {
114 DEBUGF("CODEC_ERROR: unsupport pcm data format : %d\n", (buf[2] >> 4) & 0x07);
115 return false;
116 }
117 fmt->bitspersample = convert_smaf_audio_basebit(buf[3] >> 4);
118 if (fmt->bitspersample == 0)
119 {
120 DEBUGF("CODEC_ERROR: unsupport pcm data basebit : %d\n", buf[3] >> 4);
121 return false;
122 }
123 buf += 6;
124 while (buf < endbuf)
125 {
126 chunksize = get_be32(buf + 4) + 8;
127 if (memcmp(buf, "Awa", 3) == 0)
128 {
129 fmt->numbytes = get_be32(buf + 4);
130 buf += 8;
131 return true;
132 }
133 buf += chunksize;
134 }
135 DEBUGF("CODEC_ERROR: smaf does not include stream pcm data\n");
136 return false;
137}
138
139static bool parse_score_track(struct pcm_format *fmt,
140 unsigned char **stbuf, unsigned char *endbuf)
141{
142 unsigned char *buf = *stbuf;
143 int chunksize;
144
145 if (buf[9] != 0x00)
146 {
147 DEBUGF("CODEC_ERROR: score track chunk unsupport sequence type %d\n", buf[9]);
148 return false;
149 }
150
151 /*
152 * skip to the next chunk.
153 * MA-2/MA-3/MA-5: padding 16 bytes
154 * MA-7: padding 32 bytes
155 */
156 if (buf[3] < 7)
157 buf += 28;
158 else
159 buf += 44;
160
161 while (buf < endbuf)
162 {
163 chunksize = get_be32(buf + 4) + 8;
164 if (memcmp(buf, "Mtsp", 4) == 0)
165 {
166 buf += 8;
167 if (memcmp(buf, "Mwa", 3) != 0)
168 {
169 DEBUGF("CODEC_ERROR: smaf does not include stream pcm data\n");
170 return false;
171 }
172 fmt->numbytes = get_be32(buf + 4) - 3;
173 fmt->channels = ((buf[8] & 0x80) >> 7) + 1;
174 fmt->formattag = convert_smaf_audio_format(SMAF_TRACK_CHUNK_SCORE,
175 (buf[8] >> 4) & 0x07);
176 if (fmt->formattag == SMAF_FORMAT_UNSUPPORT)
177 {
178 DEBUGF("CODEC_ERROR: unsupport pcm data format : %d\n",
179 (buf[8] >> 4) & 0x07);
180 return false;
181 }
182 fmt->bitspersample = convert_smaf_audio_basebit(buf[8] & 0x0f);
183 if (fmt->bitspersample == 0)
184 {
185 DEBUGF("CODEC_ERROR: unsupport pcm data basebit : %d\n",
186 buf[8] & 0x0f);
187 return false;
188 }
189 buf += 11;
190 return true;
191 }
192 buf += chunksize;
193 }
194
195 DEBUGF("CODEC_ERROR: smaf does not include stream pcm data\n");
196 return false;
197}
198
199static bool parse_header(struct pcm_format *fmt, size_t *pos)
200{
201 unsigned char *buf, *stbuf, *endbuf;
202 size_t chunksize;
203
204 ci->memset(fmt, 0, sizeof(struct pcm_format));
205
206 /* assume the SMAF pcm data position is less than 1024 bytes */
207 stbuf = ci->request_buffer(&chunksize, 1024);
208 if (chunksize < 1024)
209 return false;
210
211 buf = stbuf;
212 endbuf = stbuf + chunksize;
213
214 if (memcmp(buf, "MMMD", 4) != 0)
215 {
216 DEBUGF("CODEC_ERROR: does not smaf format %c%c%c%c\n",
217 buf[0], buf[1], buf[2], buf[3]);
218 return false;
219 }
220 buf += 8;
221
222 while (buf < endbuf)
223 {
224 chunksize = get_be32(buf + 4) + 8;
225 if (memcmp(buf, "ATR", 3) == 0)
226 {
227 if (!parse_audio_track(fmt, &buf, endbuf))
228 return false;
229 break;
230 }
231 if (memcmp(buf, "MTR", 3) == 0)
232 {
233 if (!parse_score_track(fmt, &buf, endbuf))
234 return false;
235 break;
236 }
237 buf += chunksize;
238 }
239
240 if (buf >= endbuf)
241 {
242 DEBUGF("CODEC_ERROR: unsupported smaf format\n");
243 return false;
244 }
245
246 /* blockalign */
247 if (fmt->formattag == SMAF_FORMAT_SIGNED_PCM ||
248 fmt->formattag == SMAF_FORMAT_UNSIGNED_PCM)
249 fmt->blockalign = fmt->channels * fmt->bitspersample >> 3;
250
251 /* data signess (default signed) */
252 fmt->is_signed = (fmt->formattag != SMAF_FORMAT_UNSIGNED_PCM);
253
254 fmt->is_little_endian = false;
255
256 /* sets pcm data position */
257 *pos = buf - stbuf;
258
259 return true;
260}
261
262static struct pcm_format format;
263static uint32_t bytesdone;
264
265static uint8_t *read_buffer(size_t *realsize)
266{
267 uint8_t *buffer = (uint8_t *)ci->request_buffer(realsize, format.chunksize);
268 if (bytesdone + (*realsize) > format.numbytes)
269 *realsize = format.numbytes - bytesdone;
270 bytesdone += *realsize;
271 ci->advance_buffer(*realsize);
272 return buffer;
273}
274
275enum codec_status codec_main(void)
276{
277 int status = CODEC_OK;
278 uint32_t decodedsamples;
279 uint32_t i = CODEC_OK;
280 size_t n;
281 int bufcount;
282 int endofstream;
283 uint8_t *smafbuf;
284 off_t firstblockposn; /* position of the first block in file */
285 const struct pcm_codec *codec;
286
287 /* Generic codec initialisation */
288 ci->configure(DSP_SET_SAMPLE_DEPTH, 28);
289
290next_track:
291 if (codec_init()) {
292 i = CODEC_ERROR;
293 goto exit;
294 }
295
296 while (!*ci->taginfo_ready && !ci->stop_codec)
297 ci->sleep(1);
298
299 codec_set_replaygain(ci->id3);
300
301 ci->memset(&format, 0, sizeof(struct pcm_format));
302 format.is_signed = true;
303 format.is_little_endian = false;
304
305 decodedsamples = 0;
306 codec = 0;
307
308 if (!parse_header(&format, &n))
309 {
310 i = CODEC_ERROR;
311 goto done;
312 }
313
314 codec = get_codec(format.formattag);
315 if (codec == 0)
316 {
317 DEBUGF("CODEC_ERROR: unsupport audio format: 0x%lx\n", format.formattag);
318 i = CODEC_ERROR;
319 goto done;
320 }
321
322 if (!codec->set_format(&format))
323 {
324 i = CODEC_ERROR;
325 goto done;
326 }
327
328 /* common format check */
329 if (format.channels == 0) {
330 DEBUGF("CODEC_ERROR: 'fmt ' chunk not found or 0-channels file\n");
331 status = CODEC_ERROR;
332 goto done;
333 }
334 if (format.samplesperblock == 0) {
335 DEBUGF("CODEC_ERROR: 'fmt ' chunk not found or 0-wSamplesPerBlock file\n");
336 status = CODEC_ERROR;
337 goto done;
338 }
339 if (format.blockalign == 0)
340 {
341 DEBUGF("CODEC_ERROR: 'fmt ' chunk not found or 0-blockalign file\n");
342 i = CODEC_ERROR;
343 goto done;
344 }
345 if (format.numbytes == 0) {
346 DEBUGF("CODEC_ERROR: 'data' chunk not found or has zero-length\n");
347 status = CODEC_ERROR;
348 goto done;
349 }
350
351 /* check chunksize */
352 if ((format.chunksize / format.blockalign) * format.samplesperblock * format.channels
353 > PCM_SAMPLE_SIZE)
354 format.chunksize = (PCM_SAMPLE_SIZE / format.blockalign) * format.blockalign;
355 if (format.chunksize == 0)
356 {
357 DEBUGF("CODEC_ERROR: chunksize is 0\n");
358 i = CODEC_ERROR;
359 goto done;
360 }
361
362 ci->configure(DSP_SWITCH_FREQUENCY, ci->id3->frequency);
363
364 if (format.channels == 2) {
365 ci->configure(DSP_SET_STEREO_MODE, STEREO_INTERLEAVED);
366 } else if (format.channels == 1) {
367 ci->configure(DSP_SET_STEREO_MODE, STEREO_MONO);
368 } else {
369 DEBUGF("CODEC_ERROR: more than 2 channels unsupported\n");
370 i = CODEC_ERROR;
371 goto done;
372 }
373
374 firstblockposn = 1024 - n;
375 ci->advance_buffer(firstblockposn);
376
377 /* The main decoder loop */
378 bytesdone = 0;
379 ci->set_elapsed(0);
380 endofstream = 0;
381
382 while (!endofstream) {
383 ci->yield();
384 if (ci->stop_codec || ci->new_track)
385 break;
386
387 if (ci->seek_time) {
388 struct pcm_pos *newpos = codec->get_seek_pos(ci->seek_time, &read_buffer);
389
390 decodedsamples = newpos->samples;
391 if (newpos->pos > format.numbytes)
392 break;
393 if (ci->seek_buffer(firstblockposn + newpos->pos))
394 {
395 bytesdone = newpos->pos;
396 }
397 ci->seek_complete();
398 }
399 smafbuf = (uint8_t *)ci->request_buffer(&n, format.chunksize);
400
401 if (n == 0)
402 break; /* End of stream */
403
404 if (bytesdone + n > format.numbytes) {
405 n = format.numbytes - bytesdone;
406 endofstream = 1;
407 }
408
409 status = codec->decode(smafbuf, n, samples, &bufcount);
410 if (status == CODEC_ERROR)
411 {
412 DEBUGF("codec error\n");
413 goto done;
414 }
415
416 ci->pcmbuf_insert(samples, NULL, bufcount);
417
418 ci->advance_buffer(n);
419 bytesdone += n;
420 decodedsamples += bufcount;
421 if (bytesdone >= format.numbytes)
422 endofstream = 1;
423
424 ci->set_elapsed(decodedsamples*1000LL/ci->id3->frequency);
425 }
426 i = CODEC_OK;
427
428done:
429 if (ci->request_next_track())
430 goto next_track;
431
432exit:
433 return i;
434}
435
generated by cgit v1.2.3 (git 2.39.1) at 2024-08-22 21:27:57 +0000