static void log_md5_sum (const char *file, struct sound_params sound_params,
const struct decoder *f, uint8_t *md5, long md5_len)
{
unsigned int ix, bps;
char md5sum[MD5_DIGEST_SIZE * 2 + 1], format;
const char *fn, *endian;
for (ix = 0; ix < MD5_DIGEST_SIZE; ix += 1)
sprintf (&md5sum[ix * 2], "%02x", md5[ix]);
md5sum[MD5_DIGEST_SIZE * 2] = 0x00;
switch (sound_params.fmt & SFMT_MASK_FORMAT) {
case SFMT_S8:
case SFMT_S16:
case SFMT_S32:
format = 's';
break;
case SFMT_U8:
case SFMT_U16:
case SFMT_U32:
format = 'u';
break;
case SFMT_FLOAT:
format = 'f';
break;
default:
debug ("Unknown sound format: 0x%04lx", sound_params.fmt);
return;
}
bps = sfmt_Bps (sound_params.fmt) * 8;
endian = "";
if (format != 'f' && bps != 8) {
if (sound_params.fmt & SFMT_LE)
endian = "le";
else if (sound_params.fmt & SFMT_BE)
endian = "be";
}
fn = strrchr (file, '/');
fn = fn ? fn + 1 : file;
debug ("MD5(%s) = %s %ld %s %c%u%s %d %d",
fn, md5sum, md5_len, get_decoder_name (f),
format, bps, endian,
sound_params.channels, sound_params.rate);
}
static void *precache_thread (void *data)
{
struct precache *precache = (struct precache *)data;
int decoded;
struct sound_params new_sound_params;
struct decoder_error err;
precache->buf_fill = 0;
precache->sound_params.channels = 0; /* mark that sound_params were not
yet filled. */
precache->decoded_time = 0.0;
precache->f = get_decoder (precache->file);
assert (precache->f != NULL);
precache->decoder_data = precache->f->open(precache->file);
precache->f->get_error(precache->decoder_data, &err);
if (err.type != ERROR_OK) {
logit ("Failed to open the file for precache: %s", err.err);
decoder_error_clear (&err);
precache->f->close (precache->decoder_data);
return NULL;
}
audio_plist_set_time (precache->file,
precache->f->get_duration(precache->decoder_data));
/* Stop at PCM_BUF_SIZE, because when we decode too much, there is no
* place where we can put the data that doesn't fit into the buffer. */
while (precache->buf_fill < PCM_BUF_SIZE) {
decoded = precache->f->decode (precache->decoder_data,
precache->buf + precache->buf_fill,
PCM_BUF_SIZE, &new_sound_params);
if (!decoded) {
/* EOF so fast? We can't pass this information
* in precache, so give up. */
logit ("EOF when precaching.");
precache->f->close (precache->decoder_data);
return NULL;
}
precache->f->get_error (precache->decoder_data, &err);
if (err.type == ERROR_FATAL) {
logit ("Error reading file for precache: %s", err.err);
decoder_error_clear (&err);
precache->f->close (precache->decoder_data);
return NULL;
}
if (!precache->sound_params.channels)
precache->sound_params = new_sound_params;
else if (!sound_params_eq(precache->sound_params,
new_sound_params)) {
/* There is no way to store sound with two different
* parameters in the buffer, give up with
* precaching. (this should never happen). */
logit ("Sound parameters have changed when precaching.");
decoder_error_clear (&err);
precache->f->close (precache->decoder_data);
return NULL;
}
bitrate_list_add (&precache->bitrate_list,
precache->decoded_time,
precache->f->get_bitrate(
precache->decoder_data));
precache->buf_fill += decoded;
precache->decoded_time += decoded / (float)(sfmt_Bps(
new_sound_params.fmt) *
new_sound_params.rate *
new_sound_params.channels);
if (err.type != ERROR_OK) {
decoder_error_clear (&err);
break; /* Don't lose the error message */
}
}
precache->ok = 1;
logit ("Successfully precached file (%d bytes)", precache->buf_fill);
return NULL;
}
/* Decoder loop for already opened and probably running for some time decoder.
* next_file will be precached at eof. */
static void decode_loop (const struct decoder *f, void *decoder_data,
const char *next_file, struct out_buf *out_buf,
struct sound_params *sound_params, struct md5_data *md5,
const float already_decoded_sec)
{
bool eof = false;
bool stopped = false;
char buf[PCM_BUF_SIZE];
int decoded = 0;
struct sound_params new_sound_params;
bool sound_params_change = false;
float decode_time = already_decoded_sec; /* the position of the decoder
(in seconds) */
out_buf_set_free_callback (out_buf, buf_free_callback);
LOCK (curr_tags_mut);
curr_tags = tags_new ();
UNLOCK (curr_tags_mut);
if (f->get_stream) {
LOCK (decoder_stream_mut);
decoder_stream = f->get_stream (decoder_data);
UNLOCK (decoder_stream_mut);
}
else
logit ("No get_stream() function");
status_msg ("Playing...");
while (1) {
debug ("loop...");
LOCK (request_cond_mutex);
if (!eof && !decoded) {
struct decoder_error err;
UNLOCK (request_cond_mutex);
if (decoder_stream && out_buf_get_fill(out_buf)
< PREBUFFER_THRESHOLD) {
prebuffering = 1;
io_prebuffer (decoder_stream,
options_get_int("Prebuffering")
* 1024);
prebuffering = 0;
status_msg ("Playing...");
}
decoded = f->decode (decoder_data, buf, sizeof(buf),
&new_sound_params);
if (decoded)
decode_time += decoded / (float)(sfmt_Bps(
new_sound_params.fmt) *
new_sound_params.rate *
new_sound_params.channels);
f->get_error (decoder_data, &err);
if (err.type != ERROR_OK) {
md5->okay = false;
if (err.type != ERROR_STREAM
|| options_get_int(
"ShowStreamErrors"))
error ("%s", err.err);
decoder_error_clear (&err);
}
if (!decoded) {
eof = true;
logit ("EOF from decoder");
}
else {
debug ("decoded %d bytes", decoded);
if (!sound_params_eq(new_sound_params, *sound_params))
sound_params_change = true;
bitrate_list_add (&bitrate_list, decode_time,
f->get_bitrate(decoder_data));
update_tags (f, decoder_data, decoder_stream);
}
}
/* Wait, if there is no space in the buffer to put the decoded
* data or EOF occurred and there is something in the buffer. */
else if (decoded > out_buf_get_free(out_buf)
|| (eof && out_buf_get_fill(out_buf))) {
debug ("waiting...");
if (eof && !precache.file && next_file
&& file_type(next_file) == F_SOUND
&& options_get_int("Precache")
&& options_get_bool("AutoNext"))
start_precache (&precache, next_file);
pthread_cond_wait (&request_cond, &request_cond_mutex);
UNLOCK (request_cond_mutex);
}
else
UNLOCK (request_cond_mutex);
/* When clearing request, we must make sure, that another
* request will not arrive at the moment, so we check if
* the request has changed. */
if (request == REQ_STOP) {
logit ("stop");
stopped = true;
md5->okay = false;
out_buf_stop (out_buf);
LOCK (request_cond_mutex);
if (request == REQ_STOP)
request = REQ_NOTHING;
UNLOCK (request_cond_mutex);
break;
}
else if (request == REQ_SEEK) {
int decoder_seek;
logit ("seeking");
md5->okay = false;
req_seek = MAX(0, req_seek);
if ((decoder_seek = f->seek(decoder_data, req_seek))
== -1)
logit ("error when seeking");
else {
out_buf_stop (out_buf);
out_buf_reset (out_buf);
out_buf_time_set (out_buf, decoder_seek);
bitrate_list_empty (&bitrate_list);
decode_time = decoder_seek;
eof = false;
decoded = 0;
}
LOCK (request_cond_mutex);
if (request == REQ_SEEK)
request = REQ_NOTHING;
UNLOCK (request_cond_mutex);
}
else if (!eof && decoded <= out_buf_get_free(out_buf)
&& !sound_params_change) {
debug ("putting into the buffer %d bytes", decoded);
#if !defined(NDEBUG) && defined(DEBUG)
if (md5->okay) {
md5->len += decoded;
md5_process_bytes (buf, decoded, &md5->ctx);
}
#endif
audio_send_buf (buf, decoded);
decoded = 0;
}
else if (!eof && sound_params_change
&& out_buf_get_fill(out_buf) == 0) {
logit ("Sound parameters have changed.");
*sound_params = new_sound_params;
sound_params_change = false;
set_info_channels (sound_params->channels);
set_info_rate (sound_params->rate / 1000);
out_buf_wait (out_buf);
if (!audio_open(sound_params)) {
md5->okay = false;
break;
}
}
else if (eof && out_buf_get_fill(out_buf) == 0) {
logit ("played everything");
break;
}
}
status_msg ("");
LOCK (decoder_stream_mut);
decoder_stream = NULL;
f->close (decoder_data);
UNLOCK (decoder_stream_mut);
bitrate_list_destroy (&bitrate_list);
LOCK (curr_tags_mut);
if (curr_tags) {
tags_free (curr_tags);
curr_tags = NULL;
}
UNLOCK (curr_tags_mut);
out_buf_wait (out_buf);
if (precache.ok && (stopped || !options_get_bool ("AutoNext"))) {
precache_wait (&precache);
precache.f->close (precache.decoder_data);
precache_reset (&precache);
}
}
static int alsa_open (struct sound_params *sound_params)
{
snd_pcm_hw_params_t *hw_params;
int err;
unsigned int period_time;
unsigned int buffer_time;
snd_pcm_uframes_t chunk_frames;
snd_pcm_uframes_t buffer_frames;
char fmt_name[128];
switch (sound_params->fmt & SFMT_MASK_FORMAT) {
case SFMT_S8:
params.format = SND_PCM_FORMAT_S8;
break;
case SFMT_U8:
params.format = SND_PCM_FORMAT_U8;
break;
case SFMT_S16:
params.format = SND_PCM_FORMAT_S16;
break;
case SFMT_U16:
params.format = SND_PCM_FORMAT_U16;
break;
case SFMT_S32:
params.format = SND_PCM_FORMAT_S32;
break;
case SFMT_U32:
params.format = SND_PCM_FORMAT_U32;
break;
default:
error ("Unknown sample format: %s",
sfmt_str(sound_params->fmt, fmt_name,
sizeof(fmt_name)));
params.format = SND_PCM_FORMAT_UNKNOWN;
return 0;
}
if ((err = snd_pcm_open(&handle, options_get_str("AlsaDevice"),
SND_PCM_STREAM_PLAYBACK,
SND_PCM_NONBLOCK)) < 0) {
error ("Can't open audio: %s", snd_strerror(err));
return 0;
}
if ((err = snd_pcm_hw_params_malloc(&hw_params)) < 0) {
error ("Can't allocate alsa hardware parameters structure: %s",
snd_strerror(err));
return 0;
}
if ((err = snd_pcm_hw_params_any (handle, hw_params)) < 0) {
error ("Can't initialize hardware parameters structure: %s",
snd_strerror(err));
snd_pcm_hw_params_free (hw_params);
return 0;
}
if ((err = snd_pcm_hw_params_set_access (handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
error ("Can't set alsa access type: %s", snd_strerror(err));
snd_pcm_hw_params_free (hw_params);
return 0;
}
if ((err = snd_pcm_hw_params_set_format (handle, hw_params,
params.format)) < 0) {
error ("Can't set sample format: %s", snd_strerror(err));
snd_pcm_hw_params_free (hw_params);
return 0;
}
params.rate = sound_params->rate;
if ((err = snd_pcm_hw_params_set_rate_near (handle, hw_params,
¶ms.rate, 0)) < 0) {
error ("Can't set sample rate: %s", snd_strerror(err));
snd_pcm_hw_params_free (hw_params);
return 0;
}
logit ("Set rate to %d", params.rate);
if ((err = snd_pcm_hw_params_set_channels (handle, hw_params,
sound_params->channels)) < 0) {
error ("Can't set number of channels: %s", snd_strerror(err));
snd_pcm_hw_params_free (hw_params);
return 0;
}
if ((err = snd_pcm_hw_params_get_buffer_time_max(hw_params,
&buffer_time, 0)) < 0) {
error ("Can't get maximum buffer time: %s", snd_strerror(err));
snd_pcm_hw_params_free (hw_params);
return 0;
}
if (buffer_time > BUFFER_MAX_USEC)
buffer_time = BUFFER_MAX_USEC;
period_time = buffer_time / 4;
if ((err = snd_pcm_hw_params_set_period_time_near(handle, hw_params,
&period_time, 0)) < 0) {
error ("Can't set period time: %s", snd_strerror(err));
snd_pcm_hw_params_free (hw_params);
return 0;
}
if ((err = snd_pcm_hw_params_set_buffer_time_near(handle, hw_params,
&buffer_time, 0)) < 0) {
error ("Can't set buffer time: %s", snd_strerror(err));
snd_pcm_hw_params_free (hw_params);
return 0;
}
if ((err = snd_pcm_hw_params (handle, hw_params)) < 0) {
error ("Can't set audio parameters: %s", snd_strerror(err));
snd_pcm_hw_params_free (hw_params);
return 0;
}
snd_pcm_hw_params_get_period_size (hw_params, &chunk_frames, 0);
snd_pcm_hw_params_get_buffer_size (hw_params, &buffer_frames);
bytes_per_frame = sound_params->channels
* sfmt_Bps(sound_params->fmt);
logit ("Buffer time: %ldus", buffer_frames * bytes_per_frame);
if (chunk_frames == buffer_frames) {
error ("Can't use period equal to buffer size (%lu == %lu)",
chunk_frames, buffer_frames);
snd_pcm_hw_params_free (hw_params);
return 0;
}
chunk_size = chunk_frames * bytes_per_frame;
debug ("Chunk size: %d", chunk_size);
snd_pcm_hw_params_free (hw_params);
if ((err = snd_pcm_prepare(handle)) < 0) {
error ("Can't prepare audio interface for use: %s",
snd_strerror(err));
return 0;
}
debug ("ALSA device initialized");
params.channels = sound_params->channels;
alsa_buf_fill = 0;
return 1;
}
