Nyaaori/rockbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Update software recording engine to latest codec interface.

Browse source 
Basically, just give it a good rewrite.

Software codec recording can be implemented in a more straightforward
and simple manner and made more robust through the better codec
control now available.

Encoded audio buffer uses a packed format instead of fixed-size
chunks and uses smaller data headers leading to more efficient usage.
The greatest benefit is with a VBR format like wavpack which needs
to request a maximum size but only actually ends up committing part
of that request.

No guard buffers are used for either PCM or encoded audio. PCM is
read into the codec's provided buffer and mono conversion done at
that time in the core if required. Any highly-specialized sample
conversion is still done within the codec itself, such as 32-bit
(wavpack) or interleaved mono (mp3).

There is no longer a separate filename array. All metadata goes
onto the main encoded audio buffer, eliminating any predermined
file limit on the buffer as well as not wasting the space for
unused path queue slots.

The core and codec interface is less awkward and a bit more sensible.
Some less useful interface features were removed. Threads are kept
on narrow code paths ie. the audio thread never calls encoding
functions and the codec thread never calls file functions as before.

Codecs no longer call file functions directly. Writes are buffered
in the core and data written to storage in larger chunks to speed up
flushing of data. In fact, codecs are no longer aware of the stream
being a file at all and have no access to the fd.

SPDIF frequency detection no longer requires a restart of recording
or plugging the source before entering the screen. It will poll
for changes and update when stopped or prerecording (which does
discard now-invalid prerecorded data).

I've seen to it that writing a proper header on full disk works
when the format makes it reasonably practical to do so. Other cases
may have incorrect data sizes but sample info will be in tact. File
left that way may play anyway.

mp3_enc.codec acquires the ability to write 'Info' headers with LAME
tags to make it gapless (bonus).

Change-Id: I670685166d5eb32ef58ef317f50b8af766ceb653
Reviewed-on: http://gerrit.rockbox.org/493
Reviewed-by: Michael Sevakis <jethead71@rockbox.org>
Tested-by: Michael Sevakis <jethead71@rockbox.org>
This commit is contained in:
Michael Sevakis 2013-06-22 16:41:16 -04:00
parent a9ea1a4269
commit 4888131972
16 changed files with 2821 additions and 2949 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
apps/audio_thread.c
View file

@ -108,6 +108,16 @@ static void NORETURN_ATTR audio_thread(void)
}
}
void audio_queue_post(long id, intptr_t data)
{
queue_post(&audio_queue, id, data);
}
intptr_t audio_queue_send(long id, intptr_t data)
{
return queue_send(&audio_queue, id, data);
}
/* Return the playback and recording status */
int audio_status(void)
{
@ -156,7 +166,9 @@ void audio_init(void)
audio_thread_id);
playback_init();
/* Recording doesn't need init call */
#ifdef AUDIO_HAVE_RECORDING
recording_init();
#endif
/* ...now...audio_reset_buffer must know the size of voicefile buffer so
init talk first which will init the buffers */

9
apps/audio_thread.h
View file

@ -74,7 +74,10 @@ enum
Q_AUDIO_CLOSE_RECORDING,
Q_AUDIO_RECORDING_OPTIONS,
Q_AUDIO_RECORD,
Q_AUDIO_RESUME,
Q_AUDIO_RECORD_STOP,
Q_AUDIO_RECORD_PAUSE,
Q_AUDIO_RECORD_RESUME,
Q_AUDIO_RECORD_FLUSH,
#endif
/*- settings -*/
@ -99,4 +102,8 @@ void audio_playback_handler(struct queue_event *ev);
void audio_recording_handler(struct queue_event *ev);
#endif
/** --- audio_queue helpers --- **/
void audio_queue_post(long id, intptr_t data);
intptr_t audio_queue_send(long id, intptr_t data);
#endif /* AUDIO_THREAD_H */

53
apps/codec_thread.c
View file

@ -365,10 +365,14 @@ static enum codec_command_action
queue_peek(&codec_queue, &ev); /* Find out what it is */
long id = ev.id;
intptr_t id = ev.id;
switch (id)
{
case Q_NULL:
LOGFQUEUE("codec < Q_NULL");
break;
case Q_CODEC_RUN: /* Already running */
LOGFQUEUE("codec < Q_CODEC_RUN");
break;
@ -388,8 +392,25 @@ static enum codec_command_action
break;
case Q_CODEC_STOP: /* Must only return 0 in main loop */
LOGFQUEUE("codec < Q_CODEC_STOP");
LOGFQUEUE("codec < Q_CODEC_STOP: %ld", ev.data);
#ifdef HAVE_RECORDING
if (type_is_encoder(codec_type))
{
/* Stream finish request (soft stop)? */
if (ev.data && param)
{
/* ev.data is pointer to size */
*param = ev.data;
action = CODEC_ACTION_STREAM_FINISH;
break;
}
}
else
#endif /* HAVE_RECORDING */
{
dsp_configure(ci.dsp, DSP_FLUSH, 0); /* Discontinuity */
}
return CODEC_ACTION_HALT; /* Leave in queue */
default: /* This is in error in this context. */
@ -459,7 +480,8 @@ static void load_codec(const struct codec_load_info *ev_data)
}
}
if (status >= 0)
/* Types must agree */
if (status >= 0 && encoder == !!codec_get_enc_callback())
{
codec_type = data.afmt;
codec_queue_ack(Q_CODEC_LOAD);
@ -685,10 +707,33 @@ bool codec_pause(void)
void codec_stop(void)
{
/* Wait until it's in the main loop */
LOGFQUEUE("audio >| codec Q_CODEC_STOP");
LOGFQUEUE("audio >| codec Q_CODEC_STOP: 0");
while (codec_queue_send(Q_CODEC_STOP, 0) != Q_NULL);
}
#ifdef HAVE_RECORDING
/* Tells codec to take final encoding step and then exit -
Returns minimum buffer size required or 0 if complete */
size_t codec_finish_stream(void)
{
size_t size = 0;
LOGFQUEUE("audio >| codec Q_CODEC_STOP: &size");
if (codec_queue_send(Q_CODEC_STOP, (intptr_t)&size) != Q_NULL)
{
/* Sync to keep size in scope and get response */
LOGFQUEUE("audio >| codec Q_NULL");
codec_queue_send(Q_NULL, 0);
if (size == 0)
codec_stop(); /* Replied with 0 size */
}
/* else thread running in the main loop */
return size;
}
#endif /* HAVE_RECORDING */
/* Call the codec's exit routine and close all references */
void codec_unload(void)
{

3
apps/codec_thread.h
View file

@ -46,6 +46,9 @@ void codec_go(void);
bool codec_pause(void);
void codec_seek(long time);
void codec_stop(void);
#ifdef HAVE_RECORDING
size_t codec_finish_stream(void);
#endif
void codec_unload(void);
int codec_loaded(void);

41
apps/codecs.c
View file

@ -73,13 +73,6 @@ static size_t codec_size;
extern void* plugin_get_audio_buffer(size_t *buffer_size);
#if (CONFIG_PLATFORM & PLATFORM_NATIVE) && defined(HAVE_RECORDING)
#undef open
static int open(const char* pathname, int flags, ...)
{
return file_open(pathname, flags);
}
#endif
struct codec_api ci = {
0, /* filesize */
@ -147,21 +140,14 @@ struct codec_api ci = {
#endif
#ifdef HAVE_RECORDING
enc_get_inputs,
enc_set_parameters,
enc_get_chunk,
enc_finish_chunk,
enc_get_pcm_data,
enc_unget_pcm_data,
/* file */
(open_func)PREFIX(open),
PREFIX(close),
(read_func)PREFIX(read),
PREFIX(lseek),
(write_func)PREFIX(write),
NULL, /* enc_pcmbuf_read */
NULL, /* enc_pcmbuf_advance */
NULL, /* enc_encbuf_get_buffer */
NULL, /* enc_encbuf_finish_buffer */
NULL, /* enc_stream_read */
NULL, /* enc_stream_lseek */
NULL, /* enc_stream_write */
round_value_to_list32,
#endif /* HAVE_RECORDING */
/* new stuff at the end, sort into place next time
@ -299,3 +285,16 @@ int codec_close(void)
return status;
}
#ifdef HAVE_RECORDING
enc_callback_t codec_get_enc_callback(void)
{
if (curr_handle == NULL ||
c_hdr->lc_hdr.magic != CODEC_ENC_MAGIC) {
logf("Codec: not an encoder");
return NULL;
}
return c_hdr->rec_extension[0];
}
#endif /* HAVE_RECORDING */

12
apps/playback.c
View file

@ -351,18 +351,6 @@ void playback_voice_event(void *data)
pcmbuf_soft_mode(*(bool *)data);
}
/** --- audio_queue helpers --- **/
static void audio_queue_post(long id, intptr_t data)
{
queue_post(&audio_queue, id, data);
}
static intptr_t audio_queue_send(long id, intptr_t data)
{
return queue_send(&audio_queue, id, data);
}
/** --- MP3Entry --- **/
/* Does the mp3entry have enough info for us to use it? */

3132
apps/recorder/pcm_record.c
View file

File diff suppressed because it is too large Load diff

80
apps/recorder/pcm_record.h
View file

@ -8,6 +8,7 @@
* $Id$
*
* Copyright (C) 2005 by Linus Nielsen Feltzing
* Copyright (C) 2006-2013 by Michael Sevakis
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
@ -18,47 +19,64 @@
* KIND, either express or implied.
*
****************************************************************************/
#ifndef PCM_RECORD_H
#define PCM_RECORD_H
#include "config.h"
/** Warnings (recording may continue with possible data loss)
** Reset of recording clears, otherwise see notes below
*/
/** Warnings **/
/* pcm (dma) buffer has overflowed */
/* PCM buffer has overflowed; PCM samples were dropped */
/* persists until: stop, new file, clear */
#define PCMREC_W_PCM_BUFFER_OVF 0x00000001
/* encoder output buffer has overflowed */
/* encoder output buffer has overflowed; encoded data was dropped */
/* persists until: stop, new file, clear */
#define PCMREC_W_ENC_BUFFER_OVF 0x00000002
/** Errors **/
/* failed to load encoder */
#define PCMREC_E_LOAD_ENCODER 0x80001000
/* error originating in encoder */
#define PCMREC_E_ENCODER 0x80002000
/* filename queue has desynced from stream markers */
#define PCMREC_E_FNQ_DESYNC 0x80004000
/* I/O error has occurred */
#define PCMREC_E_IO 0x80008000
#ifdef DEBUG
/* encoder has written past end of allocated space */
#define PCMREC_E_CHUNK_OVF 0x80010000
#endif /* DEBUG */
/* DMA callback has reported an error */
#define PCMREC_E_DMA 0x80020000
/* encoder and set/detected sample rates do not match */
/* persists until: rates match, clear */
#define PCMREC_W_SAMPR_MISMATCH 0x00000004
/* PCM frame skipped because of recoverable DMA error */
/* persists until: clear */
#define PCMREC_W_DMA 0x00000008
/* internal file size limit was reached; encoded data was dropped */
/* persists until: stop, new file, clear */
#define PCMREC_W_FILE_SIZE 0x00000010
/** General functions for high level codec recording **/
/* pcm_rec_error_clear is deprecated for general use. audio_error_clear
should be used */
/* all warning flags */
#define PCMREC_W_ALL 0x0000001f
/** Errors (recording should be reset)
**
** Stopping recording if recording clears internally and externally visible
** status must be cleared with audio_error_clear()
** reset of recording clears
*/
/* DMA callback has reported an error */
#define PCMREC_E_DMA 0x80010000
/* failed to load encoder */
#define PCMREC_E_LOAD_ENCODER 0x80020000
/* error originating in encoder */
#define PCMREC_E_ENCODER 0x80040000
/* error from encoder setup of stream parameters */
#define PCMREC_E_ENC_SETUP 0x80080000
/* error writing to output stream */
#define PCMREC_E_ENCODER_STREAM 0x80100000
/* I/O error has occurred */
#define PCMREC_E_IO 0x80200000
/* all error flags */
#define PCMREC_E_ALL 0x803f0000
/* Functions called by audio_thread.c */
void pcm_rec_error_clear(void);
/* pcm_rec_status is deprecated for general use. audio_status merges the
results for consistency with the hardware codec version */
unsigned int pcm_rec_status(void);
unsigned long pcm_rec_get_warnings(void);
void pcm_rec_init(void) INIT_ATTR;
int pcm_rec_current_bitrate(void);
int pcm_rec_encoder_afmt(void); /* AFMT_* value, AFMT_UNKNOWN if none */
int pcm_rec_rec_format(void); /* Format index or -1 otherwise */
uint32_t pcm_rec_get_warnings(void);
#ifdef HAVE_SPDIF_IN
unsigned long pcm_rec_sample_rate(void);
int pcm_get_num_unprocessed(void);
#endif
void recording_init(void);
/* audio.h contains audio_* recording functions */

13
apps/recorder/recording.c
View file

@ -1730,7 +1730,7 @@ bool recording_screen(bool no_source)
/* Don't use language string unless agreed upon to make this
method permanent - could do something in the statusbar */
snprintf(buf, sizeof(buf), "Warning: %08lX",
pcm_rec_get_warnings());
(unsigned long)pcm_rec_get_warnings());
}
else
#endif /* CONFIG_CODEC == SWCODEC */
@ -1755,8 +1755,16 @@ bool recording_screen(bool no_source)
if(audio_stat & AUDIO_STATUS_PRERECORD)
{
#if CONFIG_CODEC == SWCODEC
/* Tracks amount of prerecorded data in buffer */
snprintf(buf, sizeof(buf), "%s (%lu/%ds)...",
str(LANG_RECORD_PRERECORD),
audio_prerecorded_time() / HZ,
global_settings.rec_prerecord_time);
#else /* !SWCODEC */
snprintf(buf, sizeof(buf), "%s...",
str(LANG_RECORD_PRERECORD));
#endif /* CONFIG_CODEC == SWCODEC */
}
else
{
@ -1915,8 +1923,7 @@ bool recording_screen(bool no_source)
screens[i].update();
#if CONFIG_CODEC == SWCODEC
/* stop recording - some players like H10 freeze otherwise
TO DO: find out why it freezes and fix properly */
/* stop recording first and try to finish saving whatever it can */
rec_command(RECORDING_CMD_STOP);
audio_close_recording();
#endif

5
firmware/export/audio.h
View file

@ -212,10 +212,7 @@ unsigned long audio_num_recorded_bytes(void);
#if CONFIG_CODEC == SWCODEC
/* SWCODEC recording functions */
/* playback.c */
bool audio_load_encoder(int afmt);
void audio_remove_encoder(void);
unsigned char *audio_get_recording_buffer(size_t *buffer_size);
unsigned long audio_prerecorded_time(void);
#endif /* CONFIG_CODEC == SWCODEC */
#endif /* HAVE_RECORDING */

202
firmware/export/enc_base.h
View file

@ -9,7 +9,7 @@
*
* Base declarations for working with software encoders
*
* Copyright (C) 2006 Michael Sevakis
* 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
@ -24,7 +24,9 @@
#ifndef ENC_BASE_H
#define ENC_BASE_H
/** encoder config structures **/
#include <sys/types.h>
/** Encoder config structures **/
/** aiff_enc.codec **/
struct aiff_enc_config
@ -57,18 +59,22 @@ struct aiff_enc_config
/* MPEG 1 */
#define MPEG1_SAMPR_CAPS (SAMPR_CAP_32 | SAMPR_CAP_48 | SAMPR_CAP_44)
#define MPEG1_BITR_CAPS (MP3_BITR_CAP_32 | MP3_BITR_CAP_40 | MP3_BITR_CAP_48 | \
MP3_BITR_CAP_56 | MP3_BITR_CAP_64 | MP3_BITR_CAP_80 | \
MP3_BITR_CAP_96 | MP3_BITR_CAP_112 | MP3_BITR_CAP_128 | \
MP3_BITR_CAP_160 | MP3_BITR_CAP_192 | MP3_BITR_CAP_224 | \
#define MPEG1_BITR_CAPS (MP3_BITR_CAP_32 | MP3_BITR_CAP_40 | \
MP3_BITR_CAP_48 | MP3_BITR_CAP_56 | \
MP3_BITR_CAP_64 | MP3_BITR_CAP_80 | \
MP3_BITR_CAP_96 | MP3_BITR_CAP_112 | \
MP3_BITR_CAP_128 | MP3_BITR_CAP_160 | \
MP3_BITR_CAP_192 | MP3_BITR_CAP_224 | \
MP3_BITR_CAP_256 | MP3_BITR_CAP_320)
/* MPEG 2 */
#define MPEG2_SAMPR_CAPS (SAMPR_CAP_22 | SAMPR_CAP_24 | SAMPR_CAP_16)
#define MPEG2_BITR_CAPS (MP3_BITR_CAP_8 | MP3_BITR_CAP_16 | MP3_BITR_CAP_24 | \
MP3_BITR_CAP_32 | MP3_BITR_CAP_40 | MP3_BITR_CAP_48 | \
MP3_BITR_CAP_56 | MP3_BITR_CAP_64 | MP3_BITR_CAP_80 | \
MP3_BITR_CAP_96 | MP3_BITR_CAP_112 | MP3_BITR_CAP_128 | \
#define MPEG2_BITR_CAPS (MP3_BITR_CAP_8 | MP3_BITR_CAP_16 | \
MP3_BITR_CAP_24 | MP3_BITR_CAP_32 | \
MP3_BITR_CAP_40 | MP3_BITR_CAP_48 | \
MP3_BITR_CAP_56 | MP3_BITR_CAP_64 | \
MP3_BITR_CAP_80 | MP3_BITR_CAP_96 | \
MP3_BITR_CAP_112 | MP3_BITR_CAP_128 | \
MP3_BITR_CAP_144 | MP3_BITR_CAP_160)
#if 0
@ -131,6 +137,7 @@ struct wavpack_enc_config
#endif
};
/* General config information about any encoder */
struct encoder_config
{
union
@ -149,144 +156,77 @@ struct encoder_config
};
/** Encoder chunk macros and definitions **/
#define CHUNKF_START_FILE 0x0001ul /* This chunk starts a new file */
#define CHUNKF_END_FILE 0x0002ul /* This chunk ends the current file */
#define CHUNKF_PRERECORD 0x0010ul /* This chunk is prerecord data,
a new file could start anytime */
#define CHUNKF_ABORT 0x0020ul /* Encoder should not finish this
chunk */
#define CHUNKF_ERROR (~0ul ^ (~0ul >> 1)) /* An error has occured
(passed to/from encoder). Use the
sign bit to check (long)flags < 0. */
#define CHUNKF_ALLFLAGS (0x0033ul | CHUNKF_ERROR)
/* Header at the beginning of every encoder chunk */
#ifdef DEBUG
#define H_TO_BE32 htobe32
#define ENC_CHUNK_MAGIC H_TO_BE32(('P' << 24) | ('T' << 16) | ('Y' << 8) | 'R')
#endif
struct enc_chunk_hdr
/* What sort of data does the header describe? */
enum CHUNK_T
{
#ifdef DEBUG
unsigned long id; /* overflow detection - 'PTYR' - acronym for
"PTYR Tells You Right" ;) */
#endif
unsigned long flags; /* in/out: flags used by encoder and file
writing */
size_t enc_size; /* out: amount of encoder data written to
chunk */
unsigned long num_pcm; /* out: number of PCM samples eaten during
processing
(<= size of allocated buffer) */
unsigned char *enc_data; /* out: pointer to enc_size_written bytes
of encoded audio data in chunk */
/* Encoder defined data follows header. Can be audio data + any other
stuff the encoder needs to handle on a per chunk basis */
CHUNK_T_DATA = 0x0, /* Encoded audio data */
CHUNK_T_STREAM_START = 0x1, /* Stream start marker */
CHUNK_T_STREAM_END = 0x2, /* Stream end marker */
CHUNK_T_WRAP = 0x3 /* Buffer early wrap marker */
};
/* Paranoia: be sure header size is 4-byte aligned */
#define ENC_CHUNK_HDR_SIZE \
ALIGN_UP_P2(sizeof (struct enc_chunk_hdr), 2)
/* Skip the chunk header and return data */
#define ENC_CHUNK_SKIP_HDR(t, hdr) \
((typeof (t))((char *)hdr + ENC_CHUNK_HDR_SIZE))
/* Cast p to struct enc_chunk_hdr * */
#define ENC_CHUNK_HDR(p) \
((struct enc_chunk_hdr *)(p))
enum enc_events
/* Header for every buffer slot and chunk */
union enc_chunk_hdr
{
/* File writing events - data points to enc_file_event_data */
ENC_START_FILE = 0, /* a new file has been opened and no data has yet
been written */
ENC_WRITE_CHUNK, /* write the current chunk to disk */
ENC_END_FILE, /* current file about to be closed and all valid
data has been written */
/* Encoder buffer events - data points to enc_buffer_event_data */
ENC_REC_NEW_STREAM, /* Take steps to finish current stream and start
new */
};
/**
* encoder can write extra data to the file such as headers or more encoded
* samples and must update sizes and samples accordingly.
*/
struct enc_file_event_data
struct
{
struct enc_chunk_hdr *chunk; /* Current chunk */
size_t new_enc_size; /* New size of chunk */
unsigned long new_num_pcm; /* New number of pcm in chunk */
const char *filename; /* filename to open if ENC_START_FILE */
int rec_file; /* Current file or < 0 if none */
unsigned long num_pcm_samples; /* Current pcm sample count written to
file so far. */
uint32_t type : 2; /* Chunk type (CHUNK_T_*) */
uint32_t err : 1; /* Encoder error */
uint32_t pre : 1; /* Chunk is prerecorded data */
uint32_t aux0 : 1; /* Aux flag 0 - for encoder */
uint32_t unused : 3; /* */
uint32_t size : 24; /* size of data */
};
uint32_t zero; /* Zero-out struct access */
intptr_t reserved1; /* Want it at least pointer-sized */
} __attribute__((__may_alias__));
/**
* encoder may add some data to the end of the last and start of the next
* but must never yield when called so any encoding done should be absolutely
* minimal.
*/
struct enc_buffer_event_data
#define ENC_HDR_SIZE (sizeof (union enc_chunk_hdr))
/* When hdr.type is CHUNK_T_STREAM_START */
struct enc_chunk_file
{
unsigned long flags; /* in: One or more of:
* CHUNKF_PRERECORD
* CHUNKF_END_FILE
* CHUNKF_START_FILE
*/
struct enc_chunk_hdr *pre_chunk; /* in: pointer to first prerecord
* chunk
*/
struct enc_chunk_hdr *chunk; /* in,out: chunk were split occurs -
* first chunk of start
*/
};
union enc_chunk_hdr hdr; /* This chunk's header */
/* hdr.size = slot count of chunk */
char path[]; /* NULL-terminated path of file */
} __attribute__((__may_alias__));
/** Callbacks called by encoder codec **/
/* If flags = CHUNK_T_STREAM_END, just the header exists */
/* parameters passed to encoder by enc_get_inputs */
/* When hdr.type is CHUNK_T_DATA */
struct enc_chunk_data
{
union enc_chunk_hdr hdr; /* IN,OUT: This chunk's header */
/* hdr.size = total size of data[] */
uint32_t pcm_count; /* OUT: number of PCM samples encoded */
uint8_t data[]; /* OUT: encoded audio data */
} __attribute__((__may_alias__));
/* CHUNK_T_STREAM_END and CHUNK_T_WRAP consist of only the header */
#define ENC_FILE_HDR(hdr) ((struct enc_chunk_file *)(hdr))
#define ENC_DATA_HDR(hdr) ((struct enc_chunk_data *)(hdr))
/* Audio and encoder stream parameters */
struct enc_inputs
{
unsigned long sample_rate; /* out - pcm frequency */
int num_channels; /* out - number of audio channels */
int rec_mono_mode; /* out - how to create mono */
struct encoder_config *config; /* out - encoder settings */
};
void enc_get_inputs(struct enc_inputs *inputs);
/* parameters pass from encoder to enc_set_parameters */
struct enc_parameters
{
/* IN parameters */
int afmt; /* AFMT_* id - sanity checker */
size_t chunk_size; /* max chunk size required */
unsigned long enc_sample_rate; /* actual sample rate used by encoder
unsigned long sample_rate; /* PCM samplerate setting */
int num_channels; /* Number of audio channels */
struct encoder_config *config; /* Encoder settings */
/* IN,OUT parameters */
unsigned long enc_sample_rate; /* Actual sample rate accepted by encoder
(for recorded time calculation) */
size_t reserve_bytes; /* number of bytes to reserve immediately
following chunks */
void (*events_callback)(enum enc_events event,
void *data); /* pointer to events callback */
/* OUT parameters */
unsigned char *enc_buffer; /* pointer to enc_buffer */
size_t buf_chunk_size; /* size of chunks in enc_buffer */
int num_chunks; /* number of chunks allotted to encoder */
unsigned char *reserve_buffer; /* pointer to reserve_bytes bytes */
};
/* set the encoder dimensions - called by encoder codec at initialization
and termination */
void enc_set_parameters(struct enc_parameters *params);
/* returns pointer to next write chunk in circular buffer */
struct enc_chunk_hdr * enc_get_chunk(void);
/* releases the current chunk into the available chunks */
void enc_finish_chunk(void);
enum enc_callback_reason
{
ENC_CB_INPUTS, /* 'params' is struct enc_inputs * */
ENC_CB_STREAM, /* 'params' is union enc_chunk_hdr * */
};
#define PCM_MAX_FEED_SIZE 20000 /* max pcm size passed to encoder */
/* passes a pointer to next chunk of unprocessed wav data */
unsigned char * enc_get_pcm_data(size_t size);
/* puts some pcm data back in the queue */
size_t enc_unget_pcm_data(size_t size);
typedef int (* enc_callback_t)(enum enc_callback_reason reason, void *params);
#endif /* ENC_BASE_H */

407
lib/rbcodec/codecs/aiff_enc.c
View file

@ -8,6 +8,7 @@
* $Id$
*
* 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
@ -47,10 +48,15 @@ struct aiff_header
#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)
static int num_channels;
static uint32_t sample_rate;
static size_t frame_size;
static size_t pcm_size;
static uint32_t num_sample_frames;
/* Template headers */
struct aiff_header aiff_header =
static const struct aiff_header aiff_template_header =
{
{ 'F', 'O', 'R', 'M' }, /* form_id */
0, /* form_size (*) */
@ -65,336 +71,193 @@ struct aiff_header aiff_header =
0, /* ssnd_size (*) */
htobe32(0), /* offset */
htobe32(0), /* block_size */
/* (*) updated when finalizing stream */
};
/* (*) 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;
static inline void frame_htobe(uint32_t *p, size_t size)
{
#ifdef ROCKBOX_LITTLE_ENDIAN
/* Byte-swap samples, stereo or mono */
do
{
uint32_t t;
t = swap_odd_even32(*p); *p++ = t;
t = swap_odd_even32(*p); *p++ = t;
t = swap_odd_even32(*p); *p++ = t;
t = swap_odd_even32(*p); *p++ = t;
t = swap_odd_even32(*p); *p++ = t;
t = swap_odd_even32(*p); *p++ = t;
t = swap_odd_even32(*p); *p++ = t;
t = swap_odd_even32(*p); *p++ = t;
}
while (size -= 8 * 2 * PCM_DEPTH_BYTES);
#endif /* ROCKBOX_LITTLE_ENDIAN */
(void)p; (void)size;
}
/* convert unsigned 32 bit value to 80-bit floating point number */
static void uint32_h_to_ieee754_extended_be(uint8_t f[10], uint32_t l)
ICODE_ATTR;
static 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;
int shift = __builtin_clz(l);
/* sign always zero - bit 79 */
/* exponent is 0-31 (normalized: 31 - shift + 16383) - bits 64-78 */
/* exponent is 0-31 (normalized: 30 - shift + 16383) - bits 64-78 */
f[0] = 0x40;
f[1] = (uint8_t)exp;
f[1] = (uint8_t)(30 - shift);
/* mantissa is value left justified with most significant non-zero
bit stored in bit 63 - bits 0-63 */
l <<= shift;
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)
static int on_stream_data(struct enc_chunk_data *data)
{
if ((data->chunk->flags & CHUNKF_ERROR) || *data->filename == '\0')
return false;
size_t size = data->hdr.size;
data->rec_file = ci->open(data->filename, O_RDWR|O_CREAT|O_TRUNC, 0666);
if (ci->enc_stream_write(data->data, size) != (ssize_t)size)
return -1;
if (data->rec_file < 0)
return false;
pcm_size += size;
num_sample_frames += data->pcm_count;
return 0;
}
static int on_stream_start(void)
{
/* reset sample count */
data->num_pcm_samples = 0;
pcm_size = 0;
num_sample_frames = 0;
/* write template headers */
if (ci->write(data->rec_file, &aiff_header, sizeof (aiff_header))
!= sizeof (aiff_header))
{
return false;
/* write template header */
if (ci->enc_stream_write(&aiff_template_header,
sizeof (struct aiff_header))
!= sizeof (struct aiff_header))
return -1;
return 0;
}
data->new_enc_size += sizeof(aiff_header);
return true;
} /* on_start_file */
static bool on_end_file(struct enc_file_event_data *data)
static int on_stream_end(union enc_chunk_hdr *hdr)
{
/* update template headers */
struct aiff_header hdr;
uint32_t data_size;
/* update template header */
struct aiff_header aiff;
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))
if (hdr->err)
{
return false;
/* Called for stream error; get correct data size */
ssize_t size = ci->enc_stream_lseek(0, SEEK_END);
if (size > (ssize_t)sizeof (aiff))
{
pcm_size = size - sizeof (aiff);
num_sample_frames = pcm_size / (PCM_DEPTH_BYTES*num_channels);
}
}
data_size = data->num_pcm_samples*num_channels*PCM_DEPTH_BYTES;
if (ci->enc_stream_lseek(0, SEEK_SET) != 0)
return -1;
if (ci->enc_stream_read(&aiff, sizeof (aiff)) != sizeof (aiff))
return -2;
/* 'FORM' chunk */
hdr.form_size = htobe32(data_size + sizeof (hdr) - 8);
aiff.form_size = htobe32(pcm_size + sizeof (aiff) - 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);
aiff.num_channels = htobe16(num_channels);
aiff.num_sample_frames = htobe32(num_sample_frames);
uint32_h_to_ieee754_extended_be(aiff.sample_rate, sample_rate);
/* 'SSND' chunk */
hdr.ssnd_size = htobe32(data_size + 8);
aiff.ssnd_size = htobe32(pcm_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;
if (ci->enc_stream_lseek(0, SEEK_SET) != 0)
return -3;
if (ci->enc_stream_write(&aiff, sizeof (aiff)) != sizeof (aiff))
return -4;
return 0;
}
data->rec_file = -1;
return true;
} /* on_end_file */
static void enc_events_callback(enum enc_events event, void *data)
ICODE_ATTR;
static 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 */
static void chunk_to_aiff_format(uint32_t *src, uint32_t *dst) ICODE_ATTR;
static 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(&params);
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;
(void)reason;
}
/* this is called for each file to process */
enum codec_status codec_run(void)
enum codec_status ICODE_ATTR codec_run(void)
{
enum { GETBUF_ENC, GETBUF_PCM } getbuf = GETBUF_ENC;
struct enc_chunk_data *data = NULL;
/* main encoding loop */
while (ci->get_command(NULL) != CODEC_ACTION_HALT)
while (1)
{
uint32_t *src = (uint32_t *)ci->enc_get_pcm_data(PCM_CHUNK_SIZE);
struct enc_chunk_hdr *chunk;
enum codec_command_action action = ci->get_command(NULL);
if (src == 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(frame_size)))
continue;
getbuf = GETBUF_PCM;
case GETBUF_PCM:
if (!ci->enc_pcmbuf_read(data->data, PCM_SAMP_PER_CHUNK))
continue;
getbuf = GETBUF_ENC;
}
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);
data->hdr.size = frame_size;
data->pcm_count = PCM_SAMP_PER_CHUNK;
chunk_to_aiff_format(src, (uint32_t *)chunk->enc_data);
frame_htobe((uint32_t *)data->data, frame_size);
ci->enc_finish_chunk();
ci->enc_pcmbuf_advance(PCM_SAMP_PER_CHUNK);
ci->enc_encbuf_finish_buffer();
}
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(params);
}
}
else if (reason == ENC_CB_INPUTS)
{
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;
}
return 0;
}

45
lib/rbcodec/codecs/codecs.h
View file

@ -36,7 +36,7 @@
#endif
#if (CONFIG_CODEC == SWCODEC)
#ifdef HAVE_RECORDING
#include "pcm_record.h"
#include "enc_base.h"
#endif
#include "dsp_core.h"
#include "dsp_misc.h"
@ -72,12 +72,12 @@
#define CODEC_ENC_MAGIC 0x52454E43 /* RENC */
/* increase this every time the api struct changes */
#define CODEC_API_VERSION 45
#define CODEC_API_VERSION 46
/* update this to latest version if a change to the api struct breaks
backwards compatibility (and please take the opportunity to sort in any
new function which are "waiting" at the end of the function table) */
#define CODEC_MIN_API_VERSION 45
#define CODEC_MIN_API_VERSION 46
/* reasons for calling codec main entrypoint */
enum codec_entry_call_reason {
@ -96,6 +96,9 @@ enum codec_command_action {
CODEC_ACTION_HALT = -1,
CODEC_ACTION_NULL = 0,
CODEC_ACTION_SEEK_TIME = 1,
#ifdef HAVE_RECORDING
CODEC_ACTION_STREAM_FINISH = 2,
#endif
};
/* NOTE: To support backwards compatibility, only add new functions at
@ -200,24 +203,18 @@ struct codec_api {
#endif
#ifdef HAVE_RECORDING
void (*enc_get_inputs)(struct enc_inputs *inputs);
void (*enc_set_parameters)(struct enc_parameters *params);
struct enc_chunk_hdr * (*enc_get_chunk)(void);
void (*enc_finish_chunk)(void);
unsigned char * (*enc_get_pcm_data)(size_t size);
size_t (*enc_unget_pcm_data)(size_t size);
/* file */
int (*open)(const char* pathname, int flags, ...);
int (*close)(int fd);
ssize_t (*read)(int fd, void* buf, size_t count);
off_t (*lseek)(int fd, off_t offset, int whence);
ssize_t (*write)(int fd, const void* buf, size_t count);
int (*enc_pcmbuf_read)(void *buf, int count);
int (*enc_pcmbuf_advance)(int count);
struct enc_chunk_data * (*enc_encbuf_get_buffer)(size_t need);
void (*enc_encbuf_finish_buffer)(void);
ssize_t (*enc_stream_read)(void *buf, size_t count);
off_t (*enc_stream_lseek)(off_t offset, int whence);
ssize_t (*enc_stream_write)(const void *buf, size_t count);
int (*round_value_to_list32)(unsigned long value,
const unsigned long list[],
int count,
bool signd);
#endif
#endif /* HAVE_RECORDING */
/* new stuff at the end, sort into place next time
the API gets incompatible */
@ -229,6 +226,7 @@ struct codec_header {
enum codec_status(*entry_point)(enum codec_entry_call_reason reason);
enum codec_status(*run_proc)(void);
struct codec_api **api;
void * rec_extension[]; /* extension for encoders */
};
#ifdef CODEC
@ -249,7 +247,7 @@ extern unsigned char plugin_end_addr[];
__attribute__ ((section (".header")))= { \
{ CODEC_ENC_MAGIC, TARGET_ID, CODEC_API_VERSION, \
plugin_start_addr, plugin_end_addr }, codec_start, \
codec_run, &ci };
codec_run, &ci, { enc_callback } };
#else /* def SIMULATOR */
/* decoders */
@ -262,7 +260,7 @@ extern unsigned char plugin_end_addr[];
#define CODEC_ENC_HEADER \
const struct codec_header __header = { \
{ CODEC_ENC_MAGIC, TARGET_ID, CODEC_API_VERSION, NULL, NULL }, \
codec_start, codec_run, &ci };
codec_start, codec_run, &ci, { enc_callback } };
#endif /* SIMULATOR */
#endif /* CODEC */
@ -277,12 +275,19 @@ void *codec_get_buffer_callback(size_t *size);
int codec_load_buf(int hid, struct codec_api *api);
int codec_load_file(const char* codec, struct codec_api *api);
int codec_run_proc(void);
int codec_halt(void);
int codec_close(void);
#if CONFIG_CODEC == SWCODEC && defined(HAVE_RECORDING)
enc_callback_t codec_get_enc_callback(void);
#else
#define codec_get_enc_callback() NULL
#endif
/* defined by the codec */
enum codec_status codec_start(enum codec_entry_call_reason reason);
enum codec_status codec_main(enum codec_entry_call_reason reason);
enum codec_status codec_run(void);
#if CONFIG_CODEC == SWCODEC && defined(HAVE_RECORDING)
int enc_callback(enum enc_callback_reason reason, void *params);
#endif
#endif /* _CODECS_H_ */

805
lib/rbcodec/codecs/mp3_enc.c
View file

@ -8,6 +8,7 @@
* $Id$
*
* 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
@ -37,14 +38,6 @@
CODEC_ENC_HEADER
#define ENC_PADDING_FRAMES1 2
#define ENC_PADDING_FRAMES2 4
#define ENC_DELAY_SAMP 576
#define ENC_DELAY_SIZE (ENC_DELAY_SAMP*4)
#define SAMP_PER_FRAME1 1152
#define SAMP_PER_FRAME2 576
#define PCM_CHUNK_SIZE1 (SAMP_PER_FRAME1*4)
#define PCM_CHUNK_SIZE2 (SAMP_PER_FRAME2*4)
#define SAMPL2 576
#define SBLIMIT 32
#define HTN 16
@ -83,14 +76,20 @@ typedef struct {
mpeg_t mpg;
long frac_per_frame;
long byte_per_frame;
long req_byte_per_frame;
long slot_lag;
int sideinfo_len;
int mean_bits;
int ResvSize;
int channels;
int rec_mono_mode;
int granules;
long src_samplerate;
long samplerate;
short *samp_buffer;
unsigned samp_per_frame;
int flush_frames;
int delay;
int padding;
} config_t;
typedef struct {
@ -118,7 +117,8 @@ struct huffcodebig {
#define shft_n(x,n) ((x) >> n)
#define SQRT 724 /* sqrt(2) * 512 */
static short mfbuf [2*(1152+512)] IBSS_ATTR; /* 3328 Bytes */
static short mfbuf [2*(1152+512)] IBSS_ATTR
/* for memcpy and 32-bit access */ MEM_ALIGN_ATTR; /* 3328 Bytes */
static int sb_data [2][2][18][SBLIMIT] IBSS_ATTR; /* 13824 Bytes */
static int mdct_freq [SAMPL2] IBSS_ATTR; /* 2304 Bytes */
static char mdct_sign [SAMPL2] IBSS_ATTR; /* 576 Bytes */
@ -171,12 +171,7 @@ static uint8_t t16l [256] IBSS_ATTR;
static uint8_t t24l [256] IBSS_ATTR;
static struct huffcodetab ht [HTN] IBSS_ATTR;
static unsigned pcm_chunk_size IBSS_ATTR;
static unsigned samp_per_frame IBSS_ATTR;
static config_t cfg IBSS_ATTR;
static char *res_buffer;
static int32_t err IBSS_ATTR;
static uint8_t band_scale_f[22];
static const uint8_t ht_count_const[2][2][16] =
@ -848,12 +843,8 @@ static int count_bit1 ( short *ix, uint32_t start, uint32_t end, int *bits );
static int count_bigv ( short *ix, uint32_t start, uint32_t end, int table0, int table1,
int *bits);
static void encodeSideInfo( side_info_t si[2][2] )
static inline uint32_t encodeHeader( int padding, long bitr_id )
{
int gr, ch, header;
uint32_t cc=0, sz=0;
/*
* MPEG header layout:
* AAAAAAAA AAABBCCD EEEEFFGH IIJJKLMM
@ -871,19 +862,37 @@ static void encodeSideInfo( side_info_t si[2][2] )
* L (2) = original
* M (1-0) = emphasis
*/
header = (0xfff00000) | /* frame sync (AAAAAAAAA AAA)
mp3 type (upper): 1 (B) */
(0x01 << 17) | /* mp3 layer: 01 (CC) */
( 0x1 << 16) | /* mp3 crc: 1 (D) */
( 0x1 << 2); /* mp3 org: 1 (L) */
header |= cfg.mpg.type << 19;
header |= cfg.mpg.bitr_id << 12;
header |= cfg.mpg.smpl_id << 10;
header |= cfg.mpg.padding << 9;
header |= cfg.mpg.mode << 6;
return (0xffe00000 ) /* frame sync (AAAAAAAAA AAA) */
| (0x2 << 19) /* mp3 type (upper): 1 (BB) */
| (cfg.mpg.type << 19)
| (0x1 << 17) /* mp3 layer: 01 (CC) */
| (0x1 << 16) /* mp3 crc: 1 (D) */
| (bitr_id << 12)
| (cfg.mpg.smpl_id << 10)
| (padding << 9)
| (cfg.mpg.mode << 6)
| (0x1 << 2); /* mp3 org: 1 (L) */
/* no emphasis (bits 0-1) */
putbits( header, 32 );
}
static long calcFrameSize(int bitr_id, long *frac)
{
unsigned long v = bitr_index[cfg.mpg.type][bitr_id];
v = SAMPL2 * 16000 * v / (2 - cfg.mpg.type);
v /= cfg.samplerate;
if (frac)
*frac = v % 64;
return v / 64;
}
static void encodeSideInfo( side_info_t si[2][2] )
{
int gr, ch;
uint32_t cc=0, sz=0;
putbits( encodeHeader( cfg.mpg.padding, cfg.mpg.bitr_id ), 32 );
if(cfg.mpg.type == 1)
{ /* MPEG1 */
@ -1501,8 +1510,8 @@ static void iteration_loop(int *xr, side_info_t *si, int gr_cnt)
/* returns sum_j=0^31 a[j]*cos(PI*j*(k+1/2)/32), 0<=k<32 */
void window_subband1(short *wk, int sb0[SBLIMIT], int sb1[SBLIMIT]) ICODE_ATTR;
void window_subband1(short *wk, int sb0[SBLIMIT], int sb1[SBLIMIT])
static void ICODE_ATTR window_subband1(short *wk, int sb0[SBLIMIT],
int sb1[SBLIMIT])
{
int k, i, u, v;
short *wp, *x1, *x2;
@ -1761,8 +1770,7 @@ void window_subband1(short *wk, int sb0[SBLIMIT], int sb1[SBLIMIT])
#endif
}
void window_subband2(short *x1, int a[SBLIMIT]) ICODE_ATTR;
void window_subband2(short *x1, int a[SBLIMIT])
static void ICODE_ATTR window_subband2(short *x1, int a[SBLIMIT])
{
int xr;
short *wp = enwindow;
@ -1879,8 +1887,7 @@ void window_subband2(short *x1, int a[SBLIMIT])
xr = a[29]; a[29] += a[ 2]; a[ 2] -= xr;
}
void mdct_long(int *out, int *in) ICODE_ATTR;
void mdct_long(int *out, int *in)
static void ICODE_ATTR mdct_long(int *out, int *in)
{
int ct,st;
int tc1, tc2, tc3, tc4, ts5, ts6, ts7, ts8;
@ -1969,44 +1976,51 @@ static int find_samplerate_index(long freq, int *mp3_type)
return i;
}
static bool init_mp3_encoder_engine(int sample_rate,
int num_channels,
int rec_mono_mode,
struct encoder_config *enc_cfg)
static void mp3_encoder_reset(void)
{
const bool stereo = num_channels > 1;
uint32_t avg_byte_per_frame;
memset(&cfg.cod_info, 0, sizeof(cfg.cod_info));
memset(mfbuf , 0, sizeof(mfbuf ));
memset(mdct_freq , 0, sizeof(mdct_freq ));
memset(enc_data , 0, sizeof(enc_data ));
memset(sb_data , 0, sizeof(sb_data ));
memset(&CodedData , 0, sizeof(CodedData ));
cfg.slot_lag = 0;
}
static void mp3_encoder_init(unsigned long sample_rate, int num_channels,
unsigned long bitrate)
{
mp3_encoder_reset();
const bool stereo = num_channels > 1;
cfg.channels = stereo ? 2 : 1;
cfg.rec_mono_mode = rec_mono_mode;
cfg.mpg.mode = stereo ? 0 : 3; /* 0=stereo, 3=mono */
cfg.mpg.smpl_id = find_samplerate_index(sample_rate, &cfg.mpg.type);
cfg.samplerate = sampr_index[cfg.mpg.type][cfg.mpg.smpl_id];
cfg.mpg.bitr_id = find_bitrate_index(cfg.mpg.type,
enc_cfg->mp3_enc.bitrate,
stereo);
cfg.src_samplerate = sample_rate;
cfg.mpg.bitr_id = find_bitrate_index(cfg.mpg.type, bitrate, stereo);
cfg.mpg.bitrate = bitr_index[cfg.mpg.type][cfg.mpg.bitr_id];
cfg.mpg.num_bands = num_bands[stereo ? cfg.mpg.type : 2][cfg.mpg.bitr_id];
if (cfg.mpg.type == 1)
{
cfg.granules = 2;
pcm_chunk_size = PCM_CHUNK_SIZE1;
samp_per_frame = SAMP_PER_FRAME1;
cfg.samp_per_frame = 1152;
cfg.flush_frames = 2;
}
else
{
cfg.granules = 1;
pcm_chunk_size = PCM_CHUNK_SIZE2;
samp_per_frame = SAMP_PER_FRAME2;
cfg.samp_per_frame = 576;
cfg.flush_frames = 3;
}
cfg.delay = 576-16;
cfg.padding = 3*576+16;
cfg.samp_buffer = mfbuf + 2*512;
memcpy(scalefac, sfBand[cfg.mpg.smpl_id + 3*cfg.mpg.type], sizeof(scalefac));
memset(mfbuf , 0 , sizeof(mfbuf ));
memset(mdct_freq , 0 , sizeof(mdct_freq ));
memset(enc_data , 0 , sizeof(enc_data ));
memset(sb_data , 0 , sizeof(sb_data ));
memset(&CodedData, 0 , sizeof(CodedData ));
memcpy(ca , ca_const , sizeof(ca ));
memcpy(cs , cs_const , sizeof(cs ));
memcpy(cx , cx_const , sizeof(cx ));
@ -2052,6 +2066,7 @@ static bool init_mp3_encoder_engine(int sample_rate,
memcpy(t16l , t16l_const , sizeof(t16l ));
memcpy(t24l , t24l_const , sizeof(t24l ));
memcpy(ht , ht_const , sizeof(ht ));
memset(band_scale_f, 0 , sizeof(band_scale_f));
ht[ 0].table = NULL; ht[ 0].hlen = NULL; /* Apparently not used */
ht[ 1].table = t1HB; ht[ 1].hlen = t1l;
@ -2071,90 +2086,14 @@ static bool init_mp3_encoder_engine(int sample_rate,
ht[15].table = t15HB; ht[15].hlen = t15l;
/* Figure average number of 'bytes' per frame */
avg_byte_per_frame = SAMPL2 * 16000 * cfg.mpg.bitrate / (2 - cfg.mpg.type);
avg_byte_per_frame = avg_byte_per_frame / cfg.samplerate;
cfg.byte_per_frame = avg_byte_per_frame / 64;
cfg.frac_per_frame = avg_byte_per_frame & 63;
cfg.slot_lag = 0;
cfg.byte_per_frame = calcFrameSize(cfg.mpg.bitr_id, &cfg.frac_per_frame);
cfg.sideinfo_len = 32 + (cfg.mpg.type ? (cfg.channels == 1 ? 136 : 256)
: (cfg.channels == 1 ? 72 : 136));
return true;
cfg.req_byte_per_frame = ALIGN_UP(cfg.byte_per_frame + 1,
sizeof (uint32_t));
}
static inline void to_mono(uint16_t **samp)
{
int16_t l = **samp;
int16_t r = *(*samp+1);
int32_t m;
switch(cfg.rec_mono_mode)
{
case 1:
/* mono = L */
m = l;
break;
case 2:
/* mono = R */
m = r;
break;
case 0:
default:
/* mono = (L+R)/2 */
m = l + r + err;
err = m & 1;
m >>= 1;
break;
}
*(*samp)++ = (uint16_t)m;
*(*samp)++ = (uint16_t)m;
} /* to_mono */
static void to_mono_mm(void) ICODE_ATTR;
static void to_mono_mm(void)
{
/* |llllllllllllllll|rrrrrrrrrrrrrrrr| =>
* |mmmmmmmmmmmmmmmm|mmmmmmmmmmmmmmmm|
*/
uint16_t *samp = &mfbuf[2*512];
uint16_t *samp_end = samp + 2*samp_per_frame;
do
{
to_mono(&samp);
to_mono(&samp);
to_mono(&samp);
to_mono(&samp);
to_mono(&samp);
to_mono(&samp);
to_mono(&samp);
to_mono(&samp);
}
while (samp < samp_end);
} /* to_mono_mm */
#ifdef ROCKBOX_LITTLE_ENDIAN
/* Swaps a frame to big endian */
static inline void byte_swap_frame32(uint32_t *dst, uint32_t *src,
size_t size)
{
uint32_t *src_end = SKIPBYTES(src, size);
do
{
*dst++ = swap32(*src++);
*dst++ = swap32(*src++);
*dst++ = swap32(*src++);
*dst++ = swap32(*src++);
*dst++ = swap32(*src++);
*dst++ = swap32(*src++);
*dst++ = swap32(*src++);
*dst++ = swap32(*src++);
}
while(src < src_end);
} /* byte_swap_frame32 */
#endif /* ROCKBOX_LITTLE_ENDIAN */
static void set_scale_facs(int *mdct_freq)
{
unsigned int i, is, ie, k, s;
@ -2188,9 +2127,7 @@ static void set_scale_facs(int *mdct_freq)
}
}
static void encode_frame(char *buffer, struct enc_chunk_hdr *chunk)
ICODE_ATTR;
static void encode_frame(char *buffer, struct enc_chunk_hdr *chunk)
static size_t ICODE_ATTR mp3_encoder_encode_frame(uint8_t *outbuf)
{
int gr, gr_cnt;
uint32_t max;
@ -2211,28 +2148,6 @@ static void encode_frame(char *buffer, struct enc_chunk_hdr *chunk)
- cfg.sideinfo_len) / cfg.granules / cfg.channels
- 42; // reserved for scale_facs
/* shift out old samples */
memcpy(mfbuf, mfbuf + 2*cfg.granules*576, 4*512);
if (chunk->flags & CHUNKF_START_FILE)
{
/* prefix silent samples for encoder delay */
memset(mfbuf + 2*512, 0, ENC_DELAY_SIZE);
/* read new samples to iram for further processing */
memcpy(mfbuf + 2*512 + ENC_DELAY_SIZE/2,
buffer, pcm_chunk_size - ENC_DELAY_SIZE);
chunk->num_pcm = samp_per_frame - ENC_DELAY_SAMP;
}
else
{
/* read new samples to iram for further processing */
memcpy(mfbuf + 2*512, buffer, pcm_chunk_size);
chunk->num_pcm = samp_per_frame;
}
if (cfg.channels == 1)
to_mono_mm();
cfg.ResvSize = 0;
gr_cnt = cfg.granules * cfg.channels;
CodedData.bitpos = cfg.sideinfo_len; /* leave space for mp3 header */
@ -2366,264 +2281,398 @@ static void encode_frame(char *buffer, struct enc_chunk_hdr *chunk)
}
}
chunk->enc_size = cfg.byte_per_frame + cfg.mpg.padding;
/* shift out old samples */
memmove(mfbuf, mfbuf + 2*cfg.granules*576, 4*512);
/* finish this chunk by adding sideinfo header data */
CodedData.bitpos = 0;
encodeSideInfo( cfg.cod_info );
#ifdef ROCKBOX_BIG_ENDIAN
/* copy chunk to enc_buffer */
memcpy(chunk->enc_data, CodedData.bbuf, chunk->enc_size);
long size = cfg.byte_per_frame + cfg.mpg.padding;
#ifdef ROCKBOX_LITTLE_ENDIAN
/* convert frame to big endian */
const uint32_t *src = CodedData.bbuf;
uint32_t *dst = (uint32_t *)outbuf;
for(long i = 0; i < size; i += sizeof(uint32_t))
*dst++ = swap32(*src++);
#else
/* swap frame to big endian */
byte_swap_frame32((uint32_t *)chunk->enc_data, CodedData.bbuf, chunk->enc_size);
#endif
} /* encode_frame */
memcpy(outbuf, CodedData.bbuf, size);
#endif /* ROCKBOX_LITTLE_ENDIAN */
/* called very often - inline */
static inline bool is_file_data_ok(struct enc_file_event_data *filed)
{
return filed->rec_file >= 0 && (long)filed->chunk->flags >= 0;
} /* is_event_ok */
static unsigned char mp3_data[16384] __attribute__((aligned(4)));
static unsigned int mp3_data_len; /* current data size in buffer */
/* called very often - inline */
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("mp3 enc: NULL data");
#endif
return true;
return size;
}
/* if current chunk doesn't fit => write collected data */
if (mp3_data_len + data->chunk->enc_size > sizeof(mp3_data))
{
if (ci->write(data->rec_file, mp3_data,
mp3_data_len) != (ssize_t)mp3_data_len)
return false;
mp3_data_len = 0;
/*======== Codec section ========*/
/* CRC code lovingly ripped from:
* github.com/CFR-maniac/lame/blob/master/libmp3lame/VbrTag.c */
/* Lookup table for fast CRC computation
* See 'crc_update_lookup'
* Uses the polynomial x^16+x^15+x^2+1 */
static const uint16_t crc16_lookup[256] ICONST_ATTR =
{
0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440,
0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40,
0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841,
0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40,
0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41,
0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641,
0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040,
0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240,
0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441,
0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41,
0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840,
0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41,
0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40,
0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640,
0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041,
0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240,
0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441,
0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41,
0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840,
0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41,
0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40,
0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640,
0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041,
0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241,
0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440,
0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40,
0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841,
0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40,
0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41,
0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641,
0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040
};
static ssize_t header_size;
static unsigned int mp3_crc16;
/* fast CRC-16 computation - uses table crc16_lookup 8*/
static inline unsigned int crc_update_lookup(unsigned int value,
unsigned int crc)
{
unsigned int tmp = crc ^ value;
crc = (crc >> 8) ^ crc16_lookup[tmp & 0xff];
return crc & 0xffff;
}
memcpy(mp3_data+mp3_data_len, data->chunk->enc_data,
data->chunk->enc_size);
mp3_data_len += data->chunk->enc_size;
data->num_pcm_samples += data->chunk->num_pcm;
return true;
} /* on_write_chunk */
static bool on_start_file(struct enc_file_event_data *data)
/* Calculate position of 'Info' header */
static int get_info_offset(uint32_t header)
{
if ((data->chunk->flags & CHUNKF_ERROR) || *data->filename == '\0')
return false;
uint32_t type = (header & (0x3 << 19)) >> 19;
uint32_t mode = (header & (0x3 << 6)) >> 6;
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;
/* reset buffer write position */
mp3_data_len = 0;
return true;
} /* on_start_file */
static bool on_end_file(struct enc_file_event_data *data)
{
if (data->rec_file < 0)
return false; /* file already closed, nothing more we can do */
/* write the remaining mp3_data */
if (ci->write(data->rec_file, mp3_data, mp3_data_len)
!= (ssize_t)mp3_data_len)
return false;
/* reset buffer write position */
mp3_data_len = 0;
/* always _try_ to write the file header, even on error */
if (ci->close(data->rec_file) != 0)
return false;
data->rec_file = -1;
return true;
} /* on_end_file */
static void on_rec_new_stream(struct enc_buffer_event_data *data)
{
int num_frames = cfg.mpg.type == 1 ?
ENC_PADDING_FRAMES1 : ENC_PADDING_FRAMES2;
if (data->flags & CHUNKF_END_FILE)
{
/* add silent frames to end - encoder will also be flushed for start
of next file if any */
memset(res_buffer, 0, pcm_chunk_size);
/* the initial chunk given for the end is at enc_wr_index */
while (num_frames-- > 0)
{
data->chunk->enc_data = ENC_CHUNK_SKIP_HDR(data->chunk->enc_data,
data->chunk);
encode_frame(res_buffer, data->chunk);
data->chunk->num_pcm = samp_per_frame;
ci->enc_finish_chunk();
data->chunk = ci->enc_get_chunk();
return type == 3 ? (mode == 3 ? 21 : 36) : (mode == 3 ? 13 : 21);
}
}
else if (data->flags & CHUNKF_PRERECORD)
{
/* nothing to add and we cannot change prerecorded data */
}
else if (data->flags & CHUNKF_START_FILE)
{
/* starting fresh ... be sure to flush encoder first */
struct enc_chunk_hdr *chunk = ENC_CHUNK_HDR(res_buffer);
chunk->flags = 0;
chunk->enc_data = ENC_CHUNK_SKIP_HDR(chunk->enc_data, chunk);
while (num_frames-- > 0)
/* Write very basic 'Info' header with delay, padding and a bit of
* miscellaneous info. */
static bool write_info_header(bool first_encode)
{
memset(chunk->enc_data, 0, pcm_chunk_size);
encode_frame(chunk->enc_data, chunk);
}
}
} /* on_rec_new_stream */
ssize_t size = cfg.byte_per_frame;
static 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;
/* By default the MP3 frame header for the info frame is the same as
unpadded audio frames */
uint32_t header = encodeHeader(0, cfg.mpg.bitr_id);
int i = get_info_offset(header);
if (i + 8 + 36 > size)
{
/* The default frame size too small so find the smallest one that
may accomodate it by increasing the bit rate for this empty
MP3 frame */
int j;
for (j = cfg.mpg.bitr_id + 1; j < 15; j++)
{
size = calcFrameSize(j, NULL);
if (size >= i + 8 + 36)
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;
case ENC_REC_NEW_STREAM:
on_rec_new_stream((struct enc_buffer_event_data *)data);
return;
default:
return;
}
/* Something failed above. Signal error back to core. */
((struct enc_file_event_data *)data)->chunk->flags |= CHUNKF_ERROR;
} /* enc_events_callback */
static bool enc_init(void)
if (j >= 15)
{
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 ||
ci->enc_unget_pcm_data == NULL )
return false;
ci->enc_get_inputs(&inputs);
if (inputs.config->afmt != AFMT_MPA_L3)
return false;
init_mp3_encoder_engine(inputs.sample_rate, inputs.num_channels,
inputs.rec_mono_mode, inputs.config);
err = 0;
/* configure the buffer system */
params.afmt = AFMT_MPA_L3;
params.chunk_size = cfg.byte_per_frame + 1;
params.enc_sample_rate = cfg.samplerate;
/* need enough reserved bytes to hold one frame of pcm samples + hdr
for padding and flushing */
params.reserve_bytes = ENC_CHUNK_HDR_SIZE + pcm_chunk_size;
params.events_callback = enc_events_callback;
ci->enc_set_parameters(&params);
res_buffer = params.reserve_buffer;
#ifdef CPU_COLDFIRE
asm volatile ("move.l #0, %macsr"); /* integer mode */
#endif
/* Shouldn't really happen but... */
header_size = -1;
return true;
} /* enc_init */
}
header = encodeHeader(0, j);
/* Info offset won't change */
}
uint8_t frame[size];
memset(frame, 0, size);
frame[0] = header >> 24;
frame[1] = header >> 16;
frame[2] = header >> 8;
frame[3] = header >> 0;
/* 'Info' header (CBR 'Xing') */
memcpy(&frame[i], "Info", 4);
/* flags = 0; Info contains no other sections and is 8 bytes */
/* Just mark the LAMEness to indicate header presence; we're not
actually _the_ LAME so 'rbshn' is the version we give */
memcpy(&frame[i + 8], "LAMErbshn", 9);
/* Fill-in some info about us
* reference: http://gabriel.mp3-tech.org/mp3infotag.html
*/
/* Revision + VBR method:
* [7:4] = Revision (0 ??)
* [3:0] = VBR method (CBR)
*/
frame[i + 17] = (0 << 4) | (1 << 0);
/* If first frame since encoder reset is long gone (not unlikely in
prerecording), then the delay is long passed and no trimming done
at the start */
unsigned int delay = first_encode ? cfg.delay : 0;
unsigned int padding = cfg.padding;
/* Delay and padding:
* [23:12] = delay
* [11: 0] = padding
*/
frame[i + 29] = delay >> 4;
frame[i + 30] = (delay << 4) | (padding >> 8);
frame[i + 31] = padding;
/* Misc:
* [7:6] = source frequency
* [ 5] = unwise settings (of course not :)
* [4:2] = stereo mode (mono or stereo)
* [1:0] = noise shaping (who knows, 0)
*/
uint8_t misc;
if (cfg.src_samplerate <= 32000)
misc = (0 << 6);
else if (cfg.src_samplerate <= 44100)
misc = (1 << 6);
else if (cfg.src_samplerate <= 48000)
misc = (2 << 6);
else /* > 48000 */
misc = (3 << 6);
if (cfg.channels > 1)
misc |= (1 << 2); /* Stereo */
frame[i + 32] = misc;
if (ci->enc_stream_write(frame, size) != size)
{
ci->enc_stream_lseek(0, SEEK_SET);
header_size = -1;
return false;
}
header_size = size;
return true;
}
static inline int on_stream_data(struct enc_chunk_data *data)
{
ssize_t size = data->hdr.size;
if (header_size > 0)
{
/* Header is layed-down; keep running CRC of audio data */
uint8_t *p = data->data;
uint8_t *p_end = p + size;
while (p < p_end)
mp3_crc16 = crc_update_lookup(*p++, mp3_crc16);
}
if (ci->enc_stream_write(data->data, size) != size)
return -1;
return 0;
}
static int on_stream_start(struct enc_chunk_file *file)
{
mp3_crc16 = 0x0000;
if (!write_info_header(file->hdr.aux0))
return -1;
return 0;
}
static int on_stream_end(union enc_chunk_hdr *hdr)
{
ssize_t size = header_size;
if (size <= 0)
return 0; /* No header possible/none yet written */
/* Update audio CRC and header CRC */
uint8_t frame[size];
/* Won't fail this since it could still be useable if some decoder
plays loose with the CRC info (like Rockbox :) */
if (ci->enc_stream_lseek(0, SEEK_SET) != 0 ||
ci->enc_stream_read(frame, size) != size)
return 0;
uint32_t header = (frame[0] << 24) | (frame[1] << 16) |
(frame[2] << 8) | (frame[3] << 0);
int i = get_info_offset(header); /* Get 'Info' header */
/* 'Info' header = 8 bytes */
/* Fill-in audio data CRC16 */
/* On error, fixing data CRC would require scanning file since it
has probably dropped something we tried to write and the likely
reason is that the disk filled; just leave it 0 in that case. */
if (!hdr->err)
{
frame[i + 40] = mp3_crc16 >> 8;
frame[i + 41] = mp3_crc16;
}
/* Fill-in header CRC16 */
unsigned int hdr_crc16 = 0x0000;
for (int j = 0; j < i + 42; j++)
hdr_crc16 = crc_update_lookup(frame[j], hdr_crc16);
frame[i + 42] = hdr_crc16 >> 8;
frame[i + 43] = hdr_crc16;
/* Update file */
if (ci->enc_stream_lseek(0, SEEK_SET) == 0)
ci->enc_stream_write(frame, size);
return 0;
}
/* this is the codec entry point */
enum codec_status codec_main(enum codec_entry_call_reason reason)
{
if (reason == CODEC_LOAD) {
if (!enc_init())
return CODEC_ERROR;
}
else if (reason == CODEC_UNLOAD) {
/* reset parameters to initial state */
ci->enc_set_parameters(NULL);
}
#ifdef CPU_COLDFIRE
if (reason == CODEC_LOAD)
asm volatile ("move.l #0, %macsr"); /* integer mode */
#endif
return CODEC_OK;
(void)reason;
}
/* this is called for each file to process */
enum codec_status codec_run(void)
{
mp3_encoder_reset();
uint32_t first = 1;
/* Needs to do stream finishing steps to flush-out all samples */
int frames_rem = -1; /* -1 = indeterminate */
enum { GETBUF_ENC, GETBUF_PCM } getbuf = GETBUF_ENC;
struct enc_chunk_data *data = NULL;
/* main encoding loop */
while(ci->get_command(NULL) != CODEC_ACTION_HALT)
while (frames_rem)
{
char *buffer = buffer = ci->enc_get_pcm_data(pcm_chunk_size);
struct enc_chunk_hdr *chunk;
intptr_t param;
enum codec_command_action action = ci->get_command(&param);
if(buffer == NULL)
continue;
chunk = ci->enc_get_chunk();
chunk->enc_data = ENC_CHUNK_SKIP_HDR(chunk->enc_data, chunk);
encode_frame(buffer, chunk);
if (chunk->num_pcm < samp_per_frame)
if (action != CODEC_ACTION_NULL)
{
ci->enc_unget_pcm_data(pcm_chunk_size - chunk->num_pcm*4);
chunk->num_pcm = samp_per_frame;
if (action != CODEC_ACTION_STREAM_FINISH)
break;
if (frames_rem < 0)
frames_rem = cfg.flush_frames;
/* Reply with required space */
*(size_t *)param = cfg.req_byte_per_frame*frames_rem;
}
ci->enc_finish_chunk();
/* First obtain output buffer; when available, get PCM data */
switch (getbuf)
{
case GETBUF_ENC:
if (!(data = ci->enc_encbuf_get_buffer(cfg.req_byte_per_frame)))
continue;
getbuf = GETBUF_PCM;
case GETBUF_PCM:
if (LIKELY(frames_rem < 0))
{
/* Encoding audio */
int count = cfg.samp_per_frame;
if (!ci->enc_pcmbuf_read(cfg.samp_buffer, count))
continue;
ci->enc_pcmbuf_advance(cfg.samp_per_frame);
if (cfg.channels == 1)
{
/* Interleave the mono samples to stereo as required by
encoder */
uint16_t *src = cfg.samp_buffer + count;
uint32_t *dst = (uint32_t *)(src + count);
for (int i = count; i > 0; i--)
{ uint32_t s = *--src; *--dst = s | (s << 16); }
}
}
else
{
/* Flushing encoder */
memset(cfg.samp_buffer, 0, cfg.samp_per_frame*4);
frames_rem--;
}
getbuf = GETBUF_ENC;
}
data->hdr.aux0 = first;
first = 0;
data->hdr.size = mp3_encoder_encode_frame(data->data);
data->pcm_count = cfg.samp_per_frame;
ci->enc_encbuf_finish_buffer();
}
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(params);
case CHUNK_T_STREAM_END:
return on_stream_end(params);
}
}
else if (reason == ENC_CB_INPUTS)
{
struct enc_inputs *inputs = params;
mp3_encoder_init(inputs->sample_rate, inputs->num_channels,
inputs->config->mp3_enc.bitrate);
/* Return the actual configuration */
inputs->enc_sample_rate = cfg.samplerate;
}
return 0;
}

380
lib/rbcodec/codecs/wav_enc.c
View file

@ -8,6 +8,7 @@
* $Id$
*
* 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
@ -40,12 +41,12 @@ struct riff_header
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) */
/* unsigned short extra_param_size; 24h - size of extra data */
/* unsigned char *extra_params; */
/* 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 */
/* unsigned char *data; 2ch - actual sound data */
/* uint8_t data[data_size]; 2Ch - actual sound data */
} __attribute__((packed));
#define RIFF_FMT_HEADER_SIZE 12 /* format -> format_size */
@ -55,15 +56,13 @@ struct riff_header
#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)
static int num_channels IBSS_ATTR;
static int rec_mono_mode IBSS_ATTR;
static int num_channels;
static uint32_t sample_rate;
static uint32_t enc_size;
static int32_t err IBSS_ATTR;
static size_t frame_size;
static size_t data_size;
static const struct riff_header riff_header =
static const struct riff_header riff_template_header =
{
/* "RIFF" header */
{ 'R', 'I', 'F', 'F' }, /* riff_id */
@ -82,305 +81,164 @@ static const struct riff_header riff_header =
/* data header */
{ 'd', 'a', 't', 'a' }, /* data_id */
0 /* data_size (*) */
/* (*) updated during ENC_END_FILE event */
/* (*) updated when finalizing stream */
};
/* 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)
static inline void frame_htole(uint32_t *p, size_t size)
{
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)
#ifdef ROCKBOX_BIG_ENDIAN
/* Byte-swap samples, stereo or mono */
do
{
if (!is_file_data_ok(data))
return false;
if (data->chunk->enc_data == NULL)
{
#ifdef ROCKBOX_HAS_LOGF
ci->logf("wav enc: NULL data");
#endif
return true;
uint32_t t;
t = swap_odd_even32(*p); *p++ = t;
t = swap_odd_even32(*p); *p++ = t;
t = swap_odd_even32(*p); *p++ = t;
t = swap_odd_even32(*p); *p++ = t;
t = swap_odd_even32(*p); *p++ = t;
t = swap_odd_even32(*p); *p++ = t;
t = swap_odd_even32(*p); *p++ = t;
t = swap_odd_even32(*p); *p++ = t;
}
while (size -= 8 * 2 * PCM_DEPTH_BYTES);
#endif /* ROCKBOX_BIG_ENDIAN */
(void)p; (void)size;
}
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)
static int on_stream_data(struct enc_chunk_data *data)
{
if ((data->chunk->flags & CHUNKF_ERROR) || *data->filename == '\0')
return false;
size_t size = data->hdr.size;
data->rec_file = ci->open(data->filename, O_RDWR|O_CREAT|O_TRUNC, 0666);
if (ci->enc_stream_write(data->data, size) != (ssize_t)size)
return -1;
if (data->rec_file < 0)
return false;
data_size += size;
return 0;
}
static int on_stream_start(void)
{
/* reset sample count */
data->num_pcm_samples = 0;
data_size = 0;
/* write template header */
if (ci->write(data->rec_file, &riff_header, sizeof (riff_header))
!= sizeof (riff_header))
{
return false;
if (ci->enc_stream_write(&riff_template_header, sizeof (struct riff_header))
!= sizeof (struct riff_header))
return -1;
return 0;
}
data->new_enc_size += sizeof (riff_header);
return true;
} /* on_start_file */
static bool on_end_file(struct enc_file_event_data *data)
static int on_stream_end(union enc_chunk_hdr *hdr)
{
/* update template header */
struct riff_header hdr;
uint32_t data_size;
struct riff_header riff;
if (data->rec_file < 0)
return false; /* file already closed, nothing more we can do */
/* always _try_ to write the file header, even on error */
if ((ci->lseek(data->rec_file, 0, SEEK_SET)) ||
(ci->read(data->rec_file, &hdr, sizeof (hdr)) != sizeof (hdr)))
if (hdr->err)
{
return false;
/* Called for stream error; get correct data size */
ssize_t size = ci->enc_stream_lseek(0, SEEK_END);
if (size > (ssize_t)sizeof (riff))
data_size = size - sizeof (riff);
}
data_size = data->num_pcm_samples*num_channels*PCM_DEPTH_BYTES;
if (ci->enc_stream_lseek(0, SEEK_SET) ||
ci->enc_stream_read(&riff, sizeof (riff)) != sizeof (riff))
return -1;
/* "RIFF" header */
hdr.riff_size = htole32(RIFF_FMT_HEADER_SIZE + RIFF_FMT_DATA_SIZE
riff.riff_size = htole32(RIFF_FMT_HEADER_SIZE + RIFF_FMT_DATA_SIZE
+ RIFF_DATA_HEADER_SIZE + data_size);
/* format data */
hdr.num_channels = htole16(num_channels);
hdr.sample_rate = htole32(sample_rate);
hdr.byte_rate = htole32(sample_rate*num_channels* PCM_DEPTH_BYTES);
hdr.block_align = htole16(num_channels*PCM_DEPTH_BYTES);
riff.num_channels = htole16(num_channels);
riff.sample_rate = htole32(sample_rate);
riff.byte_rate = htole32(sample_rate*num_channels*PCM_DEPTH_BYTES);
riff.block_align = htole16(num_channels*PCM_DEPTH_BYTES);
/* data header */
hdr.data_size = htole32(data_size);
riff.data_size = htole32(data_size);
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;
if (ci->enc_stream_lseek(0, SEEK_SET) != 0)
return -2;
if (ci->enc_stream_write(&riff, sizeof (riff)) != sizeof (riff))
return -3;
return 0;
}
data->rec_file = -1;
return true;
} /* on_end_file */
static void enc_events_callback(enum enc_events event, void *data)
ICODE_ATTR;
static 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 wav 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 = (uint16_t)lr1;
lr2 = *(*src)++;
lr2 = (uint16_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)++ = htole32((lr2 << 16) | (uint16_t)lr1);
} /* sample_to_mono */
static void chunk_to_wav_format(uint32_t *src, uint32_t *dst) ICODE_ATTR;
static void chunk_to_wav_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|
*/
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);
#else
/* |llllllllLLLLLLLL|rrrrrrrrRRRRRRRR| =>
* |llllllllLLLLLLLL|rrrrrrrrRRRRRRRR|
*/
ci->memcpy(dst, src, PCM_CHUNK_SIZE);
#endif
}
} /* chunk_to_wav_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_PCM_WAV)
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_PCM_WAV;
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(&params);
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;
(void)reason;
}
/* this is called for each file to process */
enum codec_status codec_run(void)
enum codec_status ICODE_ATTR codec_run(void)
{
enum { GETBUF_ENC, GETBUF_PCM } getbuf = GETBUF_ENC;
struct enc_chunk_data *data = NULL;
/* main encoding loop */
while(ci->get_command(NULL) != CODEC_ACTION_HALT)
while (1)
{
uint32_t *src = (uint32_t *)ci->enc_get_pcm_data(PCM_CHUNK_SIZE);
struct enc_chunk_hdr *chunk;
enum codec_command_action action = ci->get_command(NULL);
if(src == 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(frame_size)))
continue;
getbuf = GETBUF_PCM;
case GETBUF_PCM:
if (!ci->enc_pcmbuf_read(data->data, PCM_SAMP_PER_CHUNK))
continue;
getbuf = GETBUF_ENC;
}
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);
data->hdr.size = frame_size;
data->pcm_count = PCM_SAMP_PER_CHUNK;
chunk_to_wav_format(src, (uint32_t *)chunk->enc_data);
frame_htole((uint32_t *)data->data, frame_size);
ci->enc_finish_chunk();
ci->enc_pcmbuf_advance(PCM_SAMP_PER_CHUNK);
ci->enc_encbuf_finish_buffer();
}
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(params);
}
}
else if (reason == ENC_CB_INPUTS)
{
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;
}
return 0;
}

455
lib/rbcodec/codecs/wavpack_enc.c
View file

@ -8,6 +8,7 @@
* $Id$
*
* 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
@ -47,29 +48,39 @@ struct riff_header
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) */
/* unsigned short extra_param_size; 24h - size of extra data */
/* unsigned char *extra_params; */
/* 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 */
/* unsigned char *data; 2ch - actual sound data */
/* 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
#define PCM_CHUNK_SIZE (4*PCM_SAMP_PER_CHUNK)
/** Data **/
static int8_t input_buffer[PCM_CHUNK_SIZE*2] IBSS_ATTR;
static int32_t input_buffer[PCM_SAMP_PER_CHUNK*2] IBSS_ATTR;
static WavpackConfig config IBSS_ATTR;
static WavpackContext *wpc;
static int32_t data_size, input_size, input_step IBSS_ATTR;
static int32_t err IBSS_ATTR;
static uint32_t sample_rate;
static int num_channels;
static uint32_t total_samples;
static size_t out_reqsize;
static size_t frame_size;
static const WavpackMetadataHeader wvpk_mdh =
{
@ -77,7 +88,7 @@ static const WavpackMetadataHeader wvpk_mdh =
sizeof (struct riff_header) / sizeof (uint16_t),
};
static const struct riff_header riff_header =
static const struct riff_header riff_template_header =
{
/* "RIFF" header */
{ 'R', 'I', 'F', 'F' }, /* riff_id */
@ -96,157 +107,75 @@ static const struct riff_header riff_header =
/* data header */
{ 'd', 'a', 't', 'a' }, /* data_id */
0 /* data_size (*) */
/* (*) updated during ENC_END_FILE event */
/* (*) updated when finalizing stream */
};
static inline void sample_to_int32_mono(int32_t **src, int32_t **dst)
static inline void sample_to_int32(int32_t **dst, int32_t **src)
{
int32_t t = *(*src)++;
/* endianness irrelevant */
t = (int16_t)t + (t >> 16) + err;
err = t & 1;
*(*dst)++ = t >> 1;
} /* sample_to_int32_mono */
static inline void sample_to_int32_stereo(int32_t **src, int32_t **dst)
{
int32_t t = *(*src)++;
uint32_t t = *(*src)++;
#ifdef ROCKBOX_BIG_ENDIAN
*(*dst)++ = t >> 16, *(*dst)++ = (int16_t)t;
*(*dst)++ = (int32_t)t >> 16;
*(*dst)++ = (int16_t)t;
#else
*(*dst)++ = (int16_t)t, *(*dst)++ = t >> 16;
*(*dst)++ = (int16_t)t;
*(*dst)++ = (int32_t)t >> 16;
#endif
} /* sample_to_int32_stereo */
}
static void chunk_to_int32(int32_t *src) ICODE_ATTR;
static void chunk_to_int32(int32_t *src)
static void ICODE_ATTR input_buffer_to_int32(size_t size)
{
int32_t *src_end, *dst;
#ifdef USE_IRAM
/* copy to IRAM before converting data */
dst = (int32_t *)input_buffer + PCM_SAMP_PER_CHUNK;
src_end = dst + PCM_SAMP_PER_CHUNK;
int32_t *dst = input_buffer;
int32_t *src = input_buffer + PCM_SAMP_PER_CHUNK;
memcpy(dst, src, PCM_CHUNK_SIZE);
src = dst;
#else
src_end = src + PCM_SAMP_PER_CHUNK;
#endif
dst = (int32_t *)input_buffer;
if (config.num_channels == 1)
{
/*
* |llllllllllllllll|rrrrrrrrrrrrrrrr| =>
* |mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm|
*/
do
{
/* read 10 longs and write 10 longs */
sample_to_int32_mono(&src, &dst);
sample_to_int32_mono(&src, &dst);
sample_to_int32_mono(&src, &dst);
sample_to_int32_mono(&src, &dst);
sample_to_int32_mono(&src, &dst);
sample_to_int32_mono(&src, &dst);
sample_to_int32_mono(&src, &dst);
sample_to_int32_mono(&src, &dst);
sample_to_int32_mono(&src, &dst);
sample_to_int32_mono(&src, &dst);
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(src < src_end);
return;
}
else
{
/*
* |llllllllllllllll|rrrrrrrrrrrrrrrr| =>
* |llllllllllllllllllllllllllllllll|rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr|
*/
do
{
/* read 10 longs and write 20 longs */
sample_to_int32_stereo(&src, &dst);
sample_to_int32_stereo(&src, &dst);
sample_to_int32_stereo(&src, &dst);
sample_to_int32_stereo(&src, &dst);
sample_to_int32_stereo(&src, &dst);
sample_to_int32_stereo(&src, &dst);
sample_to_int32_stereo(&src, &dst);
sample_to_int32_stereo(&src, &dst);
sample_to_int32_stereo(&src, &dst);
sample_to_int32_stereo(&src, &dst);
}
while (src < src_end);
return;
}
} /* chunk_to_int32 */
/* called very 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 very 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("wvpk enc: NULL data");
#endif
return true;
while (size -= 10 * 2 * PCM_DEPTH_BYTES);
}
static int on_stream_data(struct wvpk_chunk_data *wpdata)
{
/* update timestamp (block_index) */
((WavpackHeader *)data->chunk->enc_data)->block_index =
htole32(data->num_pcm_samples);
wpdata->wphdr.block_index = htole32(total_samples);
if (ci->write(data->rec_file, data->chunk->enc_data,
data->chunk->enc_size) != (ssize_t)data->chunk->enc_size)
return false;
size_t size = wpdata->ckhdr.hdr.size;
if (ci->enc_stream_write(wpdata->ckhdr.data, size) != (ssize_t)size)
return -1;
data->num_pcm_samples += data->chunk->num_pcm;
return true;
} /* on_write_chunk */
total_samples += wpdata->ckhdr.pcm_count;
static bool on_start_file(struct enc_file_event_data *data)
return 0;
}
static int on_stream_start(void)
{
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;
total_samples = 0;
/* write template headers */
if (ci->write(data->rec_file, &wvpk_mdh, sizeof (wvpk_mdh))
!= sizeof (wvpk_mdh) ||
ci->write(data->rec_file, &riff_header, sizeof (riff_header))
!= sizeof (riff_header))
{
return false;
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;
}
data->new_enc_size += sizeof(wvpk_mdh) + sizeof(riff_header);
return true;
} /* on_start_file */
static bool on_end_file(struct enc_file_event_data *data)
static int on_stream_end(void)
{
struct
{
@ -255,19 +184,16 @@ static bool on_end_file(struct enc_file_event_data *data)
WavpackHeader wph;
} __attribute__ ((packed)) h;
uint32_t data_size;
if (data->rec_file < 0)
return false; /* file already closed, nothing more we can do */
/* always _try_ to write the file header, even on error */
/* Correcting sizes on error is a bit of a pain */
/* read template headers at start */
if (ci->lseek(data->rec_file, 0, SEEK_SET) != 0 ||
ci->read(data->rec_file, &h, sizeof (h)) != sizeof (h))
return false;
if (ci->enc_stream_lseek(0, SEEK_SET) != 0)
return -1;
data_size = data->num_pcm_samples*config.num_channels*PCM_DEPTH_BYTES;
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 +
@ -286,121 +212,29 @@ static bool on_end_file(struct enc_file_event_data *data)
/** Wavpack header **/
h.wph.ckSize = htole32(letoh32(h.wph.ckSize) + sizeof (h.wpmdh)
+ sizeof (h.rhdr));
h.wph.total_samples = htole32(data->num_pcm_samples);
h.wph.total_samples = htole32(total_samples);
/* MDH|RIFF|WVPK => WVPK|MDH|RIFF */
if (ci->lseek(data->rec_file, 0, SEEK_SET)
!= 0 ||
ci->write(data->rec_file, &h.wph, sizeof (h.wph))
!= sizeof (h.wph) ||
ci->write(data->rec_file, &h.wpmdh, sizeof (h.wpmdh))
!= sizeof (h.wpmdh) ||
ci->write(data->rec_file, &h.rhdr, sizeof (h.rhdr))
!= sizeof (h.rhdr) ||
ci->close(data->rec_file) != 0 )
{
return false;
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;
}
data->rec_file = -1;
return true;
} /* on_end_file */
static void enc_events_callback(enum enc_events event, void *data)
ICODE_ATTR;
static 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:
/* write metadata header and RIFF header */
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 */
static bool init_encoder(void)
{
struct enc_inputs inputs;
struct enc_parameters params;
codec_init();
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 ||
ci->enc_unget_pcm_data == NULL )
return false;
ci->enc_get_inputs(&inputs);
if (inputs.config->afmt != AFMT_WAVPACK)
return false;
memset(&config, 0, sizeof (config));
config.bits_per_sample = PCM_DEPTH_BITS;
config.bytes_per_sample = PCM_DEPTH_BYTES;
config.sample_rate = inputs.sample_rate;
config.num_channels = inputs.num_channels;
wpc = WavpackOpenFileOutput ();
if (!WavpackSetConfiguration(wpc, &config, -1))
return false;
err = 0;
/* configure the buffer system */
params.afmt = AFMT_WAVPACK;
input_size = PCM_CHUNK_SIZE*inputs.num_channels / 2;
data_size = 105*input_size / 100;
input_size *= 2;
input_step = input_size / 4;
params.chunk_size = data_size;
params.enc_sample_rate = inputs.sample_rate;
params.reserve_bytes = 0;
params.events_callback = enc_events_callback;
ci->enc_set_parameters(&params);
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) {
/* initialize params and config */
if (!init_encoder())
return CODEC_ERROR;
}
else if (reason == CODEC_UNLOAD) {
/* reset parameters to initial state */
ci->enc_set_parameters(NULL);
}
if (reason == CODEC_LOAD)
codec_init();
return CODEC_OK;
}
@ -408,60 +242,89 @@ enum codec_status codec_main(enum codec_entry_call_reason reason)
/* this is called for each file to process */
enum codec_status codec_run(void)
{
enum { GETBUF_ENC, GETBUF_PCM } getbuf = GETBUF_ENC;
struct enc_chunk_data *data = NULL;
/* main encoding loop */
while(ci->get_command(NULL) != CODEC_ACTION_HALT)
while (1)
{
uint8_t *src = (uint8_t *)ci->enc_get_pcm_data(PCM_CHUNK_SIZE);
struct enc_chunk_hdr *chunk;
bool abort_chunk;
uint8_t *dst;
uint8_t *src_end;
enum codec_command_action action = ci->get_command(NULL);
if(src == 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;
chunk = ci->enc_get_chunk();
/* reset counts and pointer */
chunk->enc_size = 0;
chunk->num_pcm = 0;
chunk->enc_data = NULL;
dst = ENC_CHUNK_SKIP_HDR(dst, chunk);
WavpackStartBlock(wpc, dst, dst + data_size);
chunk_to_int32((uint32_t*)src);
src = input_buffer;
src_end = src + input_size;
/* encode chunk in four steps yielding between each */
do
{
abort_chunk = true;
if (WavpackPackSamples(wpc, (int32_t *)src,
PCM_SAMP_PER_CHUNK/4))
{
chunk->num_pcm += PCM_SAMP_PER_CHUNK/4;
ci->yield();
/* could've been stopped in some way */
abort_chunk = chunk->flags & CHUNKF_ABORT;
getbuf = GETBUF_PCM;
case GETBUF_PCM:
if (!ci->enc_pcmbuf_read(input_buffer + PCM_SAMP_PER_CHUNK,
PCM_SAMP_PER_CHUNK))
continue;
getbuf = GETBUF_ENC;
}
src += input_step;
}
while (!abort_chunk && src < src_end);
input_buffer_to_int32(frame_size);
if (!abort_chunk)
if (WavpackStartBlock(wpc, data->data, data->data + out_reqsize) &&
WavpackPackSamples(wpc, input_buffer, PCM_SAMP_PER_CHUNK))
{
chunk->enc_data = dst;
if (chunk->num_pcm < PCM_SAMP_PER_CHUNK)
ci->enc_unget_pcm_data(PCM_CHUNK_SIZE - chunk->num_pcm*4);
/* finish the chunk and store chunk size info */
chunk->enc_size = WavpackFinishBlock(wpc);
ci->enc_finish_chunk();
data->hdr.size = WavpackFinishBlock(wpc);
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();
}
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;
}