/*************************************************************************** * __________ __ ___. * Open \______ \ ____ ____ | | _\_ |__ _______ ___ * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ * \/ \/ \/ \/ \/ * * Copyright (C) 2006 Antonius Hellmann * Copyright (C) 2006-2013 Michael Sevakis * * 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 "codeclib.h" #include "libwavpack/wavpack.h" CODEC_ENC_HEADER #if NUM_CORES > 1 #define WAVPACK_ENC_COP #endif /** Types **/ typedef struct { uint8_t type; /* Type of metadata */ uint8_t word_size; /* Size of metadata in words */ } __attribute__((packed)) WavpackMetadataHeader; struct riff_header { uint8_t riff_id[4]; /* 00h - "RIFF" */ uint32_t riff_size; /* 04h - sz following headers + data_size */ /* format header */ uint8_t format[4]; /* 08h - "WAVE" */ uint8_t format_id[4]; /* 0Ch - "fmt " */ uint32_t format_size; /* 10h - 16 for PCM (sz format data) */ /* format data */ uint16_t audio_format; /* 14h - 1=PCM */ uint16_t num_channels; /* 16h - 1=M, 2=S, etc. */ uint32_t sample_rate; /* 18h - HZ */ uint32_t byte_rate; /* 1Ch - num_channels*sample_rate*bits_per_sample/8 */ uint16_t block_align; /* 20h - num_channels*bits_per_samples/8 */ uint16_t bits_per_sample; /* 22h - 8=8 bits, 16=16 bits, etc. */ /* Not for audio_format=1 (PCM) */ /* uint16_t extra_param_size; 24h - size of extra data */ /* uint8_t extra_params[extra_param_size]; */ /* data header */ uint8_t data_id[4]; /* 24h - "data" */ uint32_t data_size; /* 28h - num_samples*num_channels*bits_per_sample/8 */ /* uint8_t data[data_size]; 2Ch - actual sound data */ } __attribute__((packed)); #define RIFF_FMT_HEADER_SIZE 12 /* format -> format_size */ #define RIFF_FMT_DATA_SIZE 16 /* audio_format -> bits_per_sample */ #define RIFF_DATA_HEADER_SIZE 8 /* data_id -> data_size */ struct wvpk_chunk_data { struct enc_chunk_data ckhdr; /* The base data chunk header */ WavpackHeader wphdr; /* The block wavpack info */ uint8_t data[]; /* Encoded audio data */ }; #define PCM_DEPTH_BITS 16 #define PCM_DEPTH_BYTES 2 #define PCM_SAMP_PER_CHUNK 5000 /** Data **/ static int32_t input_buffer[PCM_SAMP_PER_CHUNK*2] IBSS_ATTR; #ifdef WAVPACK_ENC_COP #if CONFIG_CPU == PP5020 || CONFIG_CPU == PP5002 /* Not enough for IRAM */ static uint8_t output_buffer[PCM_SAMP_PER_CHUNK*PCM_DEPTH_BYTES*2*110/100] SHAREDBSS_ATTR MEM_ALIGN_ATTR; #else static uint8_t output_buffer[PCM_SAMP_PER_CHUNK*PCM_DEPTH_BYTES*2*110/100] IBSS_ATTR MEM_ALIGN_ATTR; #endif #endif /* WAVPACK_ENC_COP */ static WavpackConfig config IBSS_ATTR; static WavpackContext *wpc IBSS_ATTR; static uint32_t sample_rate IBSS_ATTR; static int num_channels IBSS_ATTR; static uint32_t total_samples IBSS_ATTR; static size_t out_reqsize IBSS_ATTR; static size_t frame_size IBSS_ATTR; static const WavpackMetadataHeader wvpk_mdh = { ID_RIFF_HEADER, sizeof (struct riff_header) / sizeof (uint16_t), }; static const struct riff_header riff_template_header = { /* "RIFF" header */ { 'R', 'I', 'F', 'F' }, /* riff_id */ 0, /* riff_size (*) */ /* format header */ { 'W', 'A', 'V', 'E' }, /* format */ { 'f', 'm', 't', ' ' }, /* format_id */ htole32(16), /* format_size */ /* format data */ htole16(1), /* audio_format */ 0, /* num_channels (*) */ 0, /* sample_rate (*) */ 0, /* byte_rate (*) */ 0, /* block_align (*) */ htole16(PCM_DEPTH_BITS), /* bits_per_sample */ /* data header */ { 'd', 'a', 't', 'a' }, /* data_id */ 0 /* data_size (*) */ /* (*) updated when finalizing stream */ }; static inline void sample_to_int32(int32_t **dst, int32_t **src) { uint32_t t = *(*src)++; #ifdef ROCKBOX_BIG_ENDIAN *(*dst)++ = (int32_t)t >> 16; *(*dst)++ = (int16_t)t; #else *(*dst)++ = (int16_t)t; *(*dst)++ = (int32_t)t >> 16; #endif } static void ICODE_ATTR input_buffer_to_int32(size_t size) { int32_t *dst = input_buffer; int32_t *src = input_buffer + PCM_SAMP_PER_CHUNK; do { sample_to_int32(&dst, &src); sample_to_int32(&dst, &src); sample_to_int32(&dst, &src); sample_to_int32(&dst, &src); sample_to_int32(&dst, &src); sample_to_int32(&dst, &src); sample_to_int32(&dst, &src); sample_to_int32(&dst, &src); sample_to_int32(&dst, &src); sample_to_int32(&dst, &src); } while (size -= 10 * 2 * PCM_DEPTH_BYTES); } static int on_stream_data(struct wvpk_chunk_data *wpdata) { /* update timestamp (block_index) */ wpdata->wphdr.block_index = htole32(total_samples); size_t size = wpdata->ckhdr.hdr.size; if (ci->enc_stream_write(wpdata->ckhdr.data, size) != (ssize_t)size) return -1; total_samples += wpdata->ckhdr.pcm_count; return 0; } static int on_stream_start(void) { /* reset sample count */ total_samples = 0; /* write template headers */ if (ci->enc_stream_write(&wvpk_mdh, sizeof (wvpk_mdh)) != sizeof (wvpk_mdh)) return -1; if (ci->enc_stream_write(&riff_template_header, sizeof (riff_template_header)) != sizeof (riff_template_header)) return -2; return 0; } static int on_stream_end(void) { struct { WavpackMetadataHeader wpmdh; struct riff_header rhdr; WavpackHeader wph; } __attribute__ ((packed)) h; /* Correcting sizes on error is a bit of a pain */ /* read template headers at start */ if (ci->enc_stream_lseek(0, SEEK_SET) != 0) return -1; if (ci->enc_stream_read(&h, sizeof (h)) != sizeof (h)) return -2; size_t data_size = total_samples*config.num_channels*PCM_DEPTH_BYTES; /** "RIFF" header **/ h.rhdr.riff_size = htole32(RIFF_FMT_HEADER_SIZE + RIFF_FMT_DATA_SIZE + RIFF_DATA_HEADER_SIZE + data_size); /* format data */ h.rhdr.num_channels = htole16(config.num_channels); h.rhdr.sample_rate = htole32(config.sample_rate); h.rhdr.byte_rate = htole32(config.sample_rate*config.num_channels* PCM_DEPTH_BYTES); h.rhdr.block_align = htole16(config.num_channels*PCM_DEPTH_BYTES); /* data header */ h.rhdr.data_size = htole32(data_size); /** Wavpack header **/ h.wph.ckSize = htole32(letoh32(h.wph.ckSize) + sizeof (h.wpmdh) + sizeof (h.rhdr)); h.wph.total_samples = htole32(total_samples); /* MDH|RIFF|WVPK => WVPK|MDH|RIFF */ if (ci->enc_stream_lseek(0, SEEK_SET) != 0) return -3; if (ci->enc_stream_write(&h.wph, sizeof (h.wph)) != sizeof (h.wph)) return -4; if (ci->enc_stream_write(&h.wpmdh, sizeof (h.wpmdh)) != sizeof (h.wpmdh)) return -5; if (ci->enc_stream_write(&h.rhdr, sizeof (h.rhdr)) != sizeof (h.rhdr)) return -6; return 0; } static inline uint32_t encode_block_(uint8_t *outbuf) { if (WavpackStartBlock(wpc, outbuf, outbuf + out_reqsize) && WavpackPackSamples(wpc, input_buffer, PCM_SAMP_PER_CHUNK)) return WavpackFinishBlock(wpc); return 0; } #ifdef WAVPACK_ENC_COP /* This is to relieve CPU of encoder load since it has other significant tasks to perform when recording. It is not written to provide parallelism within the codec. */ static const char enc_thread_name[] = { "Wavpack enc" }; static bool quit IBSS_ATTR; static uint32_t out_size IBSS_ATTR; static struct semaphore enc_sema IBSS_ATTR; static struct semaphore cod_sema IBSS_ATTR; static unsigned int enc_thread_id; static void ICODE_ATTR enc_thread(void) { while (1) { ci->semaphore_wait(&enc_sema, TIMEOUT_BLOCK); if (quit) break; out_size = encode_block_(output_buffer); ci->semaphore_release(&cod_sema); } } static inline bool enc_thread_init(void *stack, size_t stack_size) { quit = false; ci->semaphore_init(&enc_sema, 1, 0); ci->semaphore_init(&cod_sema, 1, 0); enc_thread_id = ci->create_thread(enc_thread, stack, stack_size, 0, enc_thread_name IF_PRIO(, PRIORITY_PLAYBACK) IF_COP(, COP)); return enc_thread_id != 0; } static inline void enc_thread_stop(void) { quit = true; ci->semaphore_release(&enc_sema); ci->thread_wait(enc_thread_id); } static inline uint32_t encode_block(uint8_t *outbuf) { ci->semaphore_release(&enc_sema); ci->semaphore_wait(&cod_sema, TIMEOUT_BLOCK); ci->memcpy(outbuf, output_buffer, out_size); return out_size; } #else /* !WAVPACK_ENC_COP */ static inline uint32_t encode_block(uint8_t *outbuf) { return encode_block_(outbuf); } static inline bool enc_thread_init(void *stack, size_t stack_size) { return true; (void)stack; (void)stack_size; } static inline void enc_thread_stop(void) { } #endif /* WAVPACK_ENC_COP */ /* this is the codec entry point */ enum codec_status codec_main(enum codec_entry_call_reason reason) { if (reason == CODEC_LOAD) codec_init(); return CODEC_OK; } /* this is called for each file to process */ enum codec_status codec_run(void) { /* Encoder thread stack goes on our stack - leave 4k for us Will be optimized away when single-threaded */ uint32_t enc_stack[(DEFAULT_STACK_SIZE+0x1000) / sizeof(uint32_t)]; if (!enc_thread_init(enc_stack, sizeof (enc_stack))) return CODEC_ERROR; enum { GETBUF_ENC, GETBUF_PCM } getbuf = GETBUF_ENC; struct enc_chunk_data *data = NULL; /* main encoding loop */ while (1) { long action = ci->get_command(NULL); if (action != CODEC_ACTION_NULL) break; /* First obtain output buffer; when available, get PCM data */ switch (getbuf) { case GETBUF_ENC: if (!(data = ci->enc_encbuf_get_buffer(out_reqsize))) continue; getbuf = GETBUF_PCM; /*fallthrough*/ case GETBUF_PCM: if (!ci->enc_pcmbuf_read(input_buffer + PCM_SAMP_PER_CHUNK, PCM_SAMP_PER_CHUNK)) continue; getbuf = GETBUF_ENC; } input_buffer_to_int32(frame_size); uint32_t size = encode_block(data->data); if (size) { /* finish the chunk and store chunk size info */ data->hdr.size = size; data->pcm_count = PCM_SAMP_PER_CHUNK; } else { data->hdr.err = 1; } ci->enc_pcmbuf_advance(PCM_SAMP_PER_CHUNK); ci->enc_encbuf_finish_buffer(); } enc_thread_stop(); return CODEC_OK; } /* this is called by recording system */ int ICODE_ATTR enc_callback(enum enc_callback_reason reason, void *params) { if (LIKELY(reason == ENC_CB_STREAM)) { switch (((union enc_chunk_hdr *)params)->type) { case CHUNK_T_DATA: return on_stream_data(params); case CHUNK_T_STREAM_START: return on_stream_start(); case CHUNK_T_STREAM_END: return on_stream_end(); } } else if (reason == ENC_CB_INPUTS) { /* Save parameters */ struct enc_inputs *inputs = params; sample_rate = inputs->sample_rate; num_channels = inputs->num_channels; frame_size = PCM_SAMP_PER_CHUNK*PCM_DEPTH_BYTES*num_channels; out_reqsize = frame_size*110 / 100; /* Add 10% */ /* Setup Wavpack encoder */ memset(&config, 0, sizeof (config)); config.bits_per_sample = PCM_DEPTH_BITS; config.bytes_per_sample = PCM_DEPTH_BYTES; config.sample_rate = sample_rate; config.num_channels = num_channels; wpc = WavpackOpenFileOutput(); if (!WavpackSetConfiguration(wpc, &config, -1)) return -1; } return 0; }