static struct mp3_data *mp3_open_internal (const char *file,
const int buffered)
{
struct mp3_data *data;
data = (struct mp3_data *)xmalloc (sizeof(struct mp3_data));
data->ok = 0;
decoder_error_init (&data->error);
/* Reset information about the file */
data->freq = 0;
data->channels = 0;
data->skip_frames = 0;
data->bitrate = -1;
data->avg_bitrate = -1;
/* Open the file */
data->io_stream = io_open (file, buffered);
if (io_ok(data->io_stream)) {
data->ok = 1;
data->size = io_file_size (data->io_stream);
mad_stream_init (&data->stream);
mad_frame_init (&data->frame);
mad_synth_init (&data->synth);
if (options_get_int("Mp3IgnoreCRCErrors"))
mad_stream_options (&data->stream,
MAD_OPTION_IGNORECRC);
data->duration = count_time_internal (data);
mad_frame_mute (&data->frame);
data->stream.next_frame = NULL;
data->stream.sync = 0;
data->stream.error = MAD_ERROR_NONE;
if (io_seek(data->io_stream, SEEK_SET, 0) == (off_t)-1) {
decoder_error (&data->error, ERROR_FATAL, 0,
"seek failed");
io_close (data->io_stream);
mad_stream_finish (&data->stream);
mad_frame_finish (&data->frame);
mad_synth_finish (&data->synth);
data->ok = 0;
}
data->stream.error = MAD_ERROR_BUFLEN;
}
else {
decoder_error (&data->error, ERROR_FATAL, 0, "Can't open: %s",
io_strerror(data->io_stream));
io_close (data->io_stream);
}
return data;
}
off_t io_seek (struct io_stream *s, off_t offset, int whence)
{
off_t res;
off_t new_pos = 0;
assert (s != NULL);
assert (s->opened);
if (s->source == IO_SOURCE_CURL || !io_ok(s))
return -1;
LOCK (s->io_mutex);
switch (whence) {
case SEEK_SET:
if (offset >= 0 && (size_t)offset < s->size)
new_pos = offset;
break;
case SEEK_CUR:
if ((ssize_t)s->pos + offset >= 0
&& s->pos + offset < s->size)
new_pos = s->pos + offset;
break;
case SEEK_END:
new_pos = s->size + offset;
break;
default:
fatal ("Bad whence value: %d", whence);
}
if (s->buffered)
res = io_seek_buffered (s, new_pos);
else
res = io_seek_unbuffered (s, new_pos);
if (res != -1)
s->pos = res;
UNLOCK (s->io_mutex);
if (res != -1)
debug ("Seek to: %lu", (unsigned long)res);
else
logit ("Seek error");
return res;
}
/* Fill info structure with data from spx comments */
static void spx_info (const char *file_name, struct file_tags *tags,
const int tags_sel)
{
struct io_stream *s;
s = io_open (file_name, 0);
if (io_ok(s)) {
struct spx_data *data = spx_open_internal (s);
if (data->ok) {
if (tags_sel & TAGS_COMMENTS)
get_comments (data, tags);
if (tags_sel & TAGS_TIME)
tags->time = count_time (data);
}
spx_close (data);
}
}
static void *spx_open (const char *file)
{
struct io_stream *stream;
struct spx_data *data;
stream = io_open (file, 1);
if (io_ok(stream))
data = spx_open_internal (stream);
else {
data = (struct spx_data *)xmalloc (sizeof(struct spx_data));
decoder_error_init (&data->error);
decoder_error (&data->error, ERROR_STREAM, 0,
"Can't open file: %s",
io_strerror(data->stream));
data->ok = 0;
}
return data;
}
static void *aac_open_internal (struct io_stream *stream, const char *fname)
{
struct aac_data *data;
NeAACDecConfigurationPtr neaac_cfg;
unsigned char channels;
unsigned long sample_rate;
int n;
/* init private struct */
data = xcalloc (1, sizeof *data);
data->decoder = NeAACDecOpen();
/* set decoder config */
neaac_cfg = NeAACDecGetCurrentConfiguration(data->decoder);
neaac_cfg->outputFormat = FAAD_FMT_16BIT; /* force 16 bit audio */
neaac_cfg->downMatrix = 1; /* 5.1 -> stereo */
neaac_cfg->dontUpSampleImplicitSBR = 0; /* upsample, please! */
NeAACDecSetConfiguration(data->decoder, neaac_cfg);
if (stream)
data->stream = stream;
else {
data->stream = io_open (fname, 1);
if (!io_ok(data->stream)) {
decoder_error (&data->error, ERROR_FATAL, 0,
"Can't open AAC file: %s", io_strerror(data->stream));
return data;
}
}
/* find a frame */
if (buffer_fill_frame(data) <= 0) {
decoder_error (&data->error, ERROR_FATAL, 0,
"Not a valid (or unsupported) AAC file");
return data;
}
/* in case of a bug, make sure there is at least some data
* in the buffer for NeAACDecInit() to work with.
*/
if (buffer_fill_min(data, 256) <= 0) {
decoder_error (&data->error, ERROR_FATAL, 0,
"AAC file/stream too short");
return data;
}
/* init decoder, returns the length of the header (if any) */
channels = (unsigned char)data->channels;
sample_rate = data->sample_rate;
n = NeAACDecInit (data->decoder, buffer_data(data), buffer_length(data),
&sample_rate, &channels);
data->channels = channels;
data->sample_rate = (int)sample_rate;
if (n < 0) {
decoder_error (&data->error, ERROR_FATAL, 0,
"libfaad can't open this stream");
return data;
}
logit ("sample rate %dHz, channels %d", data->sample_rate, data->channels);
if (!data->sample_rate || !data->channels) {
decoder_error (&data->error, ERROR_FATAL, 0,
"Invalid AAC sound parameters");
return data;
}
/* skip the header */
logit ("skipping header (%d bytes)", n);
buffer_consume (data, n);
/*NeAACDecInitDRM(data->decoder, data->sample_rate, data->channels);*/
data->ok = 1;
return data;
}