From f40bfc9267b13b54e6379dfe7539447662879d24 Mon Sep 17 00:00:00 2001 From: Sean Bartell Date: Sat, 25 Jun 2011 21:32:25 -0400 Subject: Add codecs to librbcodec. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Change-Id: Id7f4717d51ed02d67cb9f9cb3c0ada4a81843f97 Reviewed-on: http://gerrit.rockbox.org/137 Reviewed-by: Nils Wallménius Tested-by: Nils Wallménius --- lib/rbcodec/codecs/aiff_enc.c | 400 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 400 insertions(+) create mode 100644 lib/rbcodec/codecs/aiff_enc.c (limited to 'lib/rbcodec/codecs/aiff_enc.c') diff --git a/lib/rbcodec/codecs/aiff_enc.c b/lib/rbcodec/codecs/aiff_enc.c new file mode 100644 index 0000000000..fc44196eb0 --- /dev/null +++ b/lib/rbcodec/codecs/aiff_enc.c @@ -0,0 +1,400 @@ +/*************************************************************************** + * __________ __ ___. + * Open \______ \ ____ ____ | | _\_ |__ _______ ___ + * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / + * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < + * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ + * \/ \/ \/ \/ \/ + * $Id$ + * + * Copyright (C) 2006 Antonius Hellmann + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ****************************************************************************/ + +#include +#include "codeclib.h" + +CODEC_ENC_HEADER + +struct aiff_header +{ + uint8_t form_id[4]; /* 00h - 'FORM' */ + uint32_t form_size; /* 04h - size of file - 8 */ + uint8_t aiff_id[4]; /* 08h - 'AIFF' */ + uint8_t comm_id[4]; /* 0Ch - 'COMM' */ + int32_t comm_size; /* 10h - num_channels through sample_rate + (18) */ + int16_t num_channels; /* 14h - 1=M, 2=S, etc. */ + uint32_t num_sample_frames; /* 16h - num samples for each channel */ + int16_t sample_size; /* 1ah - 1-32 bits per sample */ + uint8_t sample_rate[10]; /* 1ch - IEEE 754 80-bit floating point */ + uint8_t ssnd_id[4]; /* 26h - "SSND" */ + int32_t ssnd_size; /* 2ah - size of chunk from offset to + end of pcm data */ + uint32_t offset; /* 2eh - data offset from end of header */ + uint32_t block_size; /* 32h - pcm data alignment */ + /* 36h */ +} __attribute__((packed)); + +#define PCM_DEPTH_BYTES 2 +#define PCM_DEPTH_BITS 16 +#define PCM_SAMP_PER_CHUNK 2048 +#define PCM_CHUNK_SIZE (PCM_SAMP_PER_CHUNK*4) + +/* Template headers */ +struct aiff_header aiff_header = +{ + { 'F', 'O', 'R', 'M' }, /* form_id */ + 0, /* form_size (*) */ + { 'A', 'I', 'F', 'F' }, /* aiff_id */ + { 'C', 'O', 'M', 'M' }, /* comm_id */ + htobe32(18), /* comm_size */ + 0, /* num_channels (*) */ + 0, /* num_sample_frames (*) */ + htobe16(PCM_DEPTH_BITS), /* sample_size */ + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, /* sample_rate (*) */ + { 'S', 'S', 'N', 'D' }, /* ssnd_id */ + 0, /* ssnd_size (*) */ + htobe32(0), /* offset */ + htobe32(0), /* block_size */ +}; + +/* (*) updated when finalizing file */ + +static int num_channels IBSS_ATTR; +static int rec_mono_mode IBSS_ATTR; +static uint32_t sample_rate; +static uint32_t enc_size; +static int32_t err IBSS_ATTR; + +/* convert unsigned 32 bit value to 80-bit floating point number */ +STATICIRAM void uint32_h_to_ieee754_extended_be(uint8_t f[10], uint32_t l) + ICODE_ATTR; +STATICIRAM void uint32_h_to_ieee754_extended_be(uint8_t f[10], uint32_t l) +{ + int32_t exp; + + ci->memset(f, 0, 10); + + if (l == 0) + return; + + for (exp = 30; (l & (1ul << 31)) == 0; exp--) + l <<= 1; + + /* sign always zero - bit 79 */ + /* exponent is 0-31 (normalized: 31 - shift + 16383) - bits 64-78 */ + f[0] = 0x40; + f[1] = (uint8_t)exp; + /* mantissa is value left justified with most significant non-zero + bit stored in bit 63 - bits 0-63 */ + f[2] = (uint8_t)(l >> 24); + f[3] = (uint8_t)(l >> 16); + f[4] = (uint8_t)(l >> 8); + f[5] = (uint8_t)(l >> 0); +} /* uint32_h_to_ieee754_extended_be */ + +/* called version often - inline */ +static inline bool is_file_data_ok(struct enc_file_event_data *data) ICODE_ATTR; +static inline bool is_file_data_ok(struct enc_file_event_data *data) +{ + return data->rec_file >= 0 && (long)data->chunk->flags >= 0; +} /* is_file_data_ok */ + +/* called version often - inline */ +static inline bool on_write_chunk(struct enc_file_event_data *data) ICODE_ATTR; +static inline bool on_write_chunk(struct enc_file_event_data *data) +{ + if (!is_file_data_ok(data)) + return false; + + if (data->chunk->enc_data == NULL) + { +#ifdef ROCKBOX_HAS_LOGF + ci->logf("aiff enc: NULL data"); +#endif + return true; + } + + if (ci->write(data->rec_file, data->chunk->enc_data, + data->chunk->enc_size) != (ssize_t)data->chunk->enc_size) + return false; + + data->num_pcm_samples += data->chunk->num_pcm; + return true; +} /* on_write_chunk */ + +static bool on_start_file(struct enc_file_event_data *data) +{ + if ((data->chunk->flags & CHUNKF_ERROR) || *data->filename == '\0') + return false; + + data->rec_file = ci->open(data->filename, O_RDWR|O_CREAT|O_TRUNC, 0666); + + if (data->rec_file < 0) + return false; + + /* reset sample count */ + data->num_pcm_samples = 0; + + /* write template headers */ + if (ci->write(data->rec_file, &aiff_header, sizeof (aiff_header)) + != sizeof (aiff_header)) + { + return false; + } + + data->new_enc_size += sizeof(aiff_header); + return true; +} /* on_start_file */ + +static bool on_end_file(struct enc_file_event_data *data) +{ + /* update template headers */ + struct aiff_header hdr; + uint32_t data_size; + + if (!is_file_data_ok(data)) + return false; + + if (ci->lseek(data->rec_file, 0, SEEK_SET) != 0 || + ci->read(data->rec_file, &hdr, sizeof (hdr)) != sizeof (hdr)) + { + return false; + } + + data_size = data->num_pcm_samples*num_channels*PCM_DEPTH_BYTES; + + /* 'FORM' chunk */ + hdr.form_size = htobe32(data_size + sizeof (hdr) - 8); + + /* 'COMM' chunk */ + hdr.num_channels = htobe16(num_channels); + hdr.num_sample_frames = htobe32(data->num_pcm_samples); + uint32_h_to_ieee754_extended_be(hdr.sample_rate, sample_rate); + + /* 'SSND' chunk */ + hdr.ssnd_size = htobe32(data_size + 8); + + if (ci->lseek(data->rec_file, 0, SEEK_SET) != 0 || + ci->write(data->rec_file, &hdr, sizeof (hdr)) != sizeof (hdr) || + ci->close(data->rec_file) != 0) + { + return false; + } + + data->rec_file = -1; + + return true; +} /* on_end_file */ + +STATICIRAM void enc_events_callback(enum enc_events event, void *data) + ICODE_ATTR; +STATICIRAM void enc_events_callback(enum enc_events event, void *data) +{ + switch (event) + { + case ENC_WRITE_CHUNK: + if (on_write_chunk((struct enc_file_event_data *)data)) + return; + + break; + + case ENC_START_FILE: + if (on_start_file((struct enc_file_event_data *)data)) + return; + + break; + + case ENC_END_FILE: + if (on_end_file((struct enc_file_event_data *)data)) + return; + + break; + + default: + return; + } + + /* Something failed above. Signal error back to core. */ + ((struct enc_file_event_data *)data)->chunk->flags |= CHUNKF_ERROR; +} /* enc_events_callback */ + +/* convert native pcm samples to aiff format samples */ +static inline void sample_to_mono(uint32_t **src, uint32_t **dst) +{ + int32_t lr1, lr2; + + switch(rec_mono_mode) + { + case 1: + /* mono = L */ + lr1 = *(*src)++; + lr1 = lr1 >> 16; + lr2 = *(*src)++; + lr2 = lr2 >> 16; + break; + case 2: + /* mono = R */ + lr1 = *(*src)++; + lr1 = (int16_t)lr1; + lr2 = *(*src)++; + lr2 = (int16_t)lr2; + break; + case 0: + default: + /* mono = (L+R)/2 */ + lr1 = *(*src)++; + lr1 = (int16_t)lr1 + (lr1 >> 16) + err; + err = lr1 & 1; + lr1 >>= 1; + + lr2 = *(*src)++; + lr2 = (int16_t)lr2 + (lr2 >> 16) + err; + err = lr2 & 1; + lr2 >>= 1; + break; + } + *(*dst)++ = htobe32((lr1 << 16) | (uint16_t)lr2); +} /* sample_to_mono */ + +STATICIRAM void chunk_to_aiff_format(uint32_t *src, uint32_t *dst) ICODE_ATTR; +STATICIRAM void chunk_to_aiff_format(uint32_t *src, uint32_t *dst) +{ + if (num_channels == 1) + { + /* On big endian: + * |LLLLLLLLllllllll|RRRRRRRRrrrrrrrr| + * |LLLLLLLLllllllll|RRRRRRRRrrrrrrrr| => + * |MMMMMMMMmmmmmmmm|MMMMMMMMmmmmmmmm| + * + * On little endian: + * |llllllllLLLLLLLL|rrrrrrrrRRRRRRRR| + * |llllllllLLLLLLLL|rrrrrrrrRRRRRRRR| => + * |MMMMMMMMmmmmmmmm|MMMMMMMMmmmmmmmm| + */ + uint32_t *src_end = src + PCM_SAMP_PER_CHUNK; + + do + { + sample_to_mono(&src, &dst); + sample_to_mono(&src, &dst); + sample_to_mono(&src, &dst); + sample_to_mono(&src, &dst); + sample_to_mono(&src, &dst); + sample_to_mono(&src, &dst); + sample_to_mono(&src, &dst); + sample_to_mono(&src, &dst); + } + while (src < src_end); + } + else + { +#ifdef ROCKBOX_BIG_ENDIAN + /* |LLLLLLLLllllllll|RRRRRRRRrrrrrrrr| => + * |LLLLLLLLllllllll|RRRRRRRRrrrrrrrr| + */ + ci->memcpy(dst, src, PCM_CHUNK_SIZE); +#else + /* |llllllllLLLLLLLL|rrrrrrrrRRRRRRRR| => + * |LLLLLLLLllllllll|RRRRRRRRrrrrrrrr| + */ + uint32_t *src_end = src + PCM_SAMP_PER_CHUNK; + + do + { + *dst++ = swap_odd_even32(*src++); + *dst++ = swap_odd_even32(*src++); + *dst++ = swap_odd_even32(*src++); + *dst++ = swap_odd_even32(*src++); + *dst++ = swap_odd_even32(*src++); + *dst++ = swap_odd_even32(*src++); + *dst++ = swap_odd_even32(*src++); + *dst++ = swap_odd_even32(*src++); + } + while (src < src_end); +#endif + } +} /* chunk_to_aiff_format */ + +static bool init_encoder(void) +{ + struct enc_inputs inputs; + struct enc_parameters params; + + if (ci->enc_get_inputs == NULL || + ci->enc_set_parameters == NULL || + ci->enc_get_chunk == NULL || + ci->enc_finish_chunk == NULL || + ci->enc_get_pcm_data == NULL ) + return false; + + ci->enc_get_inputs(&inputs); + + if (inputs.config->afmt != AFMT_AIFF) + return false; + + sample_rate = inputs.sample_rate; + num_channels = inputs.num_channels; + rec_mono_mode = inputs.rec_mono_mode; + err = 0; + + /* configure the buffer system */ + params.afmt = AFMT_AIFF; + enc_size = PCM_CHUNK_SIZE*inputs.num_channels / 2; + params.chunk_size = enc_size; + params.enc_sample_rate = sample_rate; + params.reserve_bytes = 0; + params.events_callback = enc_events_callback; + ci->enc_set_parameters(¶ms); + + return true; +} /* init_encoder */ + +/* this is the codec entry point */ +enum codec_status codec_main(enum codec_entry_call_reason reason) +{ + if (reason == CODEC_LOAD) { + if (!init_encoder()) + return CODEC_ERROR; + } + else if (reason == CODEC_UNLOAD) { + /* reset parameters to initial state */ + ci->enc_set_parameters(NULL); + } + + return CODEC_OK; +} + +/* this is called for each file to process */ +enum codec_status codec_run(void) +{ + /* main encoding loop */ + while (ci->get_command(NULL) != CODEC_ACTION_HALT) + { + uint32_t *src = (uint32_t *)ci->enc_get_pcm_data(PCM_CHUNK_SIZE); + struct enc_chunk_hdr *chunk; + + if (src == NULL) + continue; + + chunk = ci->enc_get_chunk(); + chunk->enc_size = enc_size; + chunk->num_pcm = PCM_SAMP_PER_CHUNK; + chunk->enc_data = ENC_CHUNK_SKIP_HDR(chunk->enc_data, chunk); + + chunk_to_aiff_format(src, (uint32_t *)chunk->enc_data); + + ci->enc_finish_chunk(); + } + + return CODEC_OK; +} -- cgit v1.2.3