1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2006 Antonius Hellmann
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.
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
20 ****************************************************************************/
31 uint8_t riff_id
[4]; /* 00h - "RIFF" */
32 uint32_t riff_size
; /* 04h - sz following headers + data_size */
34 uint8_t format
[4]; /* 08h - "WAVE" */
35 uint8_t format_id
[4]; /* 0Ch - "fmt " */
36 uint32_t format_size
; /* 10h - 16 for PCM (sz format data) */
38 uint16_t audio_format
; /* 14h - 1=PCM */
39 uint16_t num_channels
; /* 16h - 1=M, 2=S, etc. */
40 uint32_t sample_rate
; /* 18h - HZ */
41 uint32_t byte_rate
; /* 1Ch - num_channels*sample_rate*bits_per_sample/8 */
42 uint16_t block_align
; /* 20h - num_channels*bits_per_samples/8 */
43 uint16_t bits_per_sample
; /* 22h - 8=8 bits, 16=16 bits, etc. */
44 /* Not for audio_format=1 (PCM) */
45 /* unsigned short extra_param_size; 24h - size of extra data */
46 /* unsigned char *extra_params; */
48 uint8_t data_id
[4]; /* 24h - "data" */
49 uint32_t data_size
; /* 28h - num_samples*num_channels*bits_per_sample/8 */
50 /* unsigned char *data; 2ch - actual sound data */
51 } __attribute__((packed
));
53 #define RIFF_FMT_HEADER_SIZE 12 /* format -> format_size */
54 #define RIFF_FMT_DATA_SIZE 16 /* audio_format -> bits_per_sample */
55 #define RIFF_DATA_HEADER_SIZE 8 /* data_id -> data_size */
57 #define PCM_DEPTH_BYTES 2
58 #define PCM_DEPTH_BITS 16
59 #define PCM_SAMP_PER_CHUNK 2048
60 #define PCM_CHUNK_SIZE (PCM_SAMP_PER_CHUNK*4)
62 static int num_channels IBSS_ATTR
;
63 static uint32_t sample_rate
;
64 static uint32_t enc_size
;
65 static int32_t err IBSS_ATTR
;
67 static const struct riff_header riff_header
=
70 { 'R', 'I', 'F', 'F' }, /* riff_id */
71 0, /* riff_size (*) */
73 { 'W', 'A', 'V', 'E' }, /* format */
74 { 'f', 'm', 't', ' ' }, /* format_id */
75 H_TO_LE32(16), /* format_size */
77 H_TO_LE16(1), /* audio_format */
78 0, /* num_channels (*) */
79 0, /* sample_rate (*) */
80 0, /* byte_rate (*) */
81 0, /* block_align (*) */
82 H_TO_LE16(PCM_DEPTH_BITS
), /* bits_per_sample */
84 { 'd', 'a', 't', 'a' }, /* data_id */
86 /* (*) updated during ENC_END_FILE event */
89 /* called version often - inline */
90 static inline bool is_file_data_ok(struct enc_file_event_data
*data
) ICODE_ATTR
;
91 static inline bool is_file_data_ok(struct enc_file_event_data
*data
)
93 return data
->rec_file
>= 0 && (long)data
->chunk
->flags
>= 0;
94 } /* is_file_data_ok */
96 /* called version often - inline */
97 static inline bool on_write_chunk(struct enc_file_event_data
*data
) ICODE_ATTR
;
98 static inline bool on_write_chunk(struct enc_file_event_data
*data
)
100 if (!is_file_data_ok(data
))
103 if (data
->chunk
->enc_data
== NULL
)
105 #ifdef ROCKBOX_HAS_LOGF
106 ci
->logf("wav enc: NULL data");
111 if (ci
->write(data
->rec_file
, data
->chunk
->enc_data
,
112 data
->chunk
->enc_size
) != (ssize_t
)data
->chunk
->enc_size
)
115 data
->num_pcm_samples
+= data
->chunk
->num_pcm
;
117 } /* on_write_chunk */
119 static bool on_start_file(struct enc_file_event_data
*data
)
121 if ((data
->chunk
->flags
& CHUNKF_ERROR
) || *data
->filename
== '\0')
124 data
->rec_file
= ci
->open(data
->filename
, O_RDWR
|O_CREAT
|O_TRUNC
);
126 if (data
->rec_file
< 0)
129 /* reset sample count */
130 data
->num_pcm_samples
= 0;
132 /* write template header */
133 if (ci
->write(data
->rec_file
, &riff_header
, sizeof (riff_header
))
134 != sizeof (riff_header
))
139 data
->new_enc_size
+= sizeof (riff_header
);
141 } /* on_start_file */
143 static bool on_end_file(struct enc_file_event_data
*data
)
145 /* update template header */
146 struct riff_header hdr
;
149 if (data
->rec_file
< 0)
150 return false; /* file already closed, nothing more we can do */
152 /* always _try_ to write the file header, even on error */
153 if ((ci
->lseek(data
->rec_file
, 0, SEEK_SET
)) ||
154 (ci
->read(data
->rec_file
, &hdr
, sizeof (hdr
)) != sizeof (hdr
)))
159 data_size
= data
->num_pcm_samples
*num_channels
*PCM_DEPTH_BYTES
;
162 hdr
.riff_size
= htole32(RIFF_FMT_HEADER_SIZE
+ RIFF_FMT_DATA_SIZE
163 + RIFF_DATA_HEADER_SIZE
+ data_size
);
166 hdr
.num_channels
= htole16(num_channels
);
167 hdr
.sample_rate
= htole32(sample_rate
);
168 hdr
.byte_rate
= htole32(sample_rate
*num_channels
* PCM_DEPTH_BYTES
);
169 hdr
.block_align
= htole16(num_channels
*PCM_DEPTH_BYTES
);
172 hdr
.data_size
= htole32(data_size
);
174 if (ci
->lseek(data
->rec_file
, 0, SEEK_SET
) != 0 ||
175 ci
->write(data
->rec_file
, &hdr
, sizeof (hdr
)) != sizeof (hdr
) ||
176 ci
->close(data
->rec_file
) != 0)
186 STATICIRAM
void enc_events_callback(enum enc_events event
, void *data
)
188 STATICIRAM
void enc_events_callback(enum enc_events event
, void *data
)
190 if (event
== ENC_WRITE_CHUNK
)
192 if (on_write_chunk((struct enc_file_event_data
*)data
))
195 else if (event
== ENC_START_FILE
)
197 if (on_start_file((struct enc_file_event_data
*)data
))
200 else if (event
== ENC_END_FILE
)
202 if (on_end_file((struct enc_file_event_data
*)data
))
210 ((struct enc_file_event_data
*)data
)->chunk
->flags
|= CHUNKF_ERROR
;
211 } /* enc_events_callback */
213 /* convert native pcm samples to wav format samples */
214 static inline void sample_to_mono(uint32_t **src
, uint32_t **dst
)
219 lr1
= (int16_t)lr1
+ (lr1
>> 16) + err
;
224 lr2
= (int16_t)lr2
+ (lr2
>> 16) + err
;
227 *(*dst
)++ = swap_odd_even_be32((lr1
<< 16) | (uint16_t)lr2
);
228 } /* sample_to_mono */
230 STATICIRAM
void chunk_to_wav_format(uint32_t *src
, uint32_t *dst
) ICODE_ATTR
;
231 STATICIRAM
void chunk_to_wav_format(uint32_t *src
, uint32_t *dst
)
233 if (num_channels
== 1)
236 * |LLLLLLLLllllllll|RRRRRRRRrrrrrrrr|
237 * |LLLLLLLLllllllll|RRRRRRRRrrrrrrrr| =>
238 * |mmmmmmmmMMMMMMMM|mmmmmmmmMMMMMMMM|
241 * |llllllllLLLLLLLL|rrrrrrrrRRRRRRRR|
242 * |llllllllLLLLLLLL|rrrrrrrrRRRRRRRR| =>
243 * |mmmmmmmmMMMMMMMM|mmmmmmmmMMMMMMMM|
245 uint32_t *src_end
= src
+ PCM_SAMP_PER_CHUNK
;
249 sample_to_mono(&src
, &dst
);
250 sample_to_mono(&src
, &dst
);
251 sample_to_mono(&src
, &dst
);
252 sample_to_mono(&src
, &dst
);
253 sample_to_mono(&src
, &dst
);
254 sample_to_mono(&src
, &dst
);
255 sample_to_mono(&src
, &dst
);
256 sample_to_mono(&src
, &dst
);
258 while (src
< src_end
);
262 #ifdef ROCKBOX_BIG_ENDIAN
263 /* |LLLLLLLLllllllll|RRRRRRRRrrrrrrrr| =>
264 * |llllllllLLLLLLLL|rrrrrrrrRRRRRRRR|
266 uint32_t *src_end
= src
+ PCM_SAMP_PER_CHUNK
;
270 *dst
++ = swap_odd_even32(*src
++);
271 *dst
++ = swap_odd_even32(*src
++);
272 *dst
++ = swap_odd_even32(*src
++);
273 *dst
++ = swap_odd_even32(*src
++);
274 *dst
++ = swap_odd_even32(*src
++);
275 *dst
++ = swap_odd_even32(*src
++);
276 *dst
++ = swap_odd_even32(*src
++);
277 *dst
++ = swap_odd_even32(*src
++);
279 while (src
< src_end
);
281 /* |llllllllLLLLLLLL|rrrrrrrrRRRRRRRR| =>
282 * |llllllllLLLLLLLL|rrrrrrrrRRRRRRRR|
284 ci
->memcpy(dst
, src
, PCM_CHUNK_SIZE
);
287 } /* chunk_to_wav_format */
289 static bool init_encoder(void)
291 struct enc_inputs inputs
;
292 struct enc_parameters params
;
294 if (ci
->enc_get_inputs
== NULL
||
295 ci
->enc_set_parameters
== NULL
||
296 ci
->enc_get_chunk
== NULL
||
297 ci
->enc_finish_chunk
== NULL
||
298 ci
->enc_get_pcm_data
== NULL
)
301 ci
->enc_get_inputs(&inputs
);
303 if (inputs
.config
->afmt
!= AFMT_PCM_WAV
)
306 sample_rate
= inputs
.sample_rate
;
307 num_channels
= inputs
.num_channels
;
310 /* configure the buffer system */
311 params
.afmt
= AFMT_PCM_WAV
;
312 enc_size
= PCM_CHUNK_SIZE
*inputs
.num_channels
/ 2;
313 params
.chunk_size
= enc_size
;
314 params
.enc_sample_rate
= sample_rate
;
315 params
.reserve_bytes
= 0;
316 params
.events_callback
= enc_events_callback
;
317 ci
->enc_set_parameters(¶ms
);
322 /* main codec entry point */
323 enum codec_status
codec_main(void)
327 ci
->enc_codec_loaded
= -1;
331 /* main application waits for this flag during encoder loading */
332 ci
->enc_codec_loaded
= 1;
334 /* main encoding loop */
335 while(!ci
->stop_encoder
)
339 while ((src
= (uint32_t *)ci
->enc_get_pcm_data(PCM_CHUNK_SIZE
)) != NULL
)
341 struct enc_chunk_hdr
*chunk
;
343 if (ci
->stop_encoder
)
346 chunk
= ci
->enc_get_chunk();
347 chunk
->enc_size
= enc_size
;
348 chunk
->num_pcm
= PCM_SAMP_PER_CHUNK
;
349 chunk
->enc_data
= ENC_CHUNK_SKIP_HDR(chunk
->enc_data
, chunk
);
351 chunk_to_wav_format(src
, (uint32_t *)chunk
->enc_data
);
353 ci
->enc_finish_chunk();
360 /* reset parameters to initial state */
361 ci
->enc_set_parameters(NULL
);
363 /* main application waits for this flag during encoder removing */
364 ci
->enc_codec_loaded
= 0;
369 #endif /* ndef SIMULATOR */