void input_loop(void)
{
input_module_t *inmod=NULL;
instance_t *instance, *prev, *next;
queue_item *queued;
int shutdown = 0;
int current_module = 0;
int valid_stream = 1;
int inc_count;
int not_waiting_for_critical;
int foundmodule = 0;
thread_cond_create(&ices_config->queue_cond);
thread_cond_create(&ices_config->event_pending_cond);
thread_mutex_create(&ices_config->refcount_lock);
thread_mutex_create(&ices_config->flush_lock);
memset (&control, 0, sizeof (control));
while(ices_config->playlist_module && modules[current_module].open)
{
if(!strcmp(ices_config->playlist_module, modules[current_module].name))
{
foundmodule = 1;
inmod = modules[current_module].open(ices_config->module_params);
break;
}
current_module++;
}
if(!inmod)
{
if(foundmodule)
LOG_ERROR1("Couldn't initialise input module \"%s\"",
ices_config->playlist_module);
else
LOG_ERROR1("No input module named \"%s\" could be found",
ices_config->playlist_module);
return;
}
ices_config->inmod = inmod;
/* ok, basic config stuff done. Now, we want to start all our listening
* threads.
*/
instance = ices_config->instances;
while(instance)
{
stream_description *arg = calloc(1, sizeof(stream_description));
arg->stream = instance;
arg->input = inmod;
/*
if(instance->savefilename != NULL)
thread_create("savefile", savefile_stream, arg, 1);
*/
thread_create("stream", ices_instance_stream, arg, 1);
instance = instance->next;
}
/* treat as if a signal has arrived straight away */
signal_usr1_handler (0);
/* now we go into the main loop
* We shut down the main thread ONLY once all the instances
* have killed themselves.
*/
while(!shutdown)
{
ref_buffer *chunk = calloc(1, sizeof(ref_buffer));
buffer_queue *current;
int ret;
instance = ices_config->instances;
prev = NULL;
while(instance)
{
/* if an instance has died, get rid of it
** this should be replaced with something that tries to
** restart the instance, probably.
*/
if (instance->died)
{
LOG_DEBUG0("An instance died, removing it");
next = instance->next;
if (prev)
prev->next = next;
else
ices_config->instances = next;
/* Just in case, flush any existing buffers
* Locks shouldn't be needed, but lets be SURE */
thread_mutex_lock(&ices_config->flush_lock);
input_flush_queue(instance->queue, 0);
thread_mutex_unlock(&ices_config->flush_lock);
config_free_instance(instance);
free(instance);
instance = next;
continue;
}
prev = instance;
instance = instance->next;
}
instance = ices_config->instances;
if(!instance)
{
shutdown = 1;
free(chunk);
continue;
}
if(ices_config->shutdown) /* We've been signalled to shut down, but */
{ /* the instances haven't done so yet... */
timing_sleep(250); /* sleep for quarter of a second */
free(chunk);
continue;
}
/* If this is the first time through, set initial time. This should
* be done before the call to inmod->getdata() below, in order to
* properly keep time if this input module blocks.
*/
if (control.starttime == 0)
control.starttime = timing_get_time();
/* get a chunk of data from the input module */
ret = inmod->getdata(inmod->internal, chunk);
/* input module signalled non-fatal error. Skip this chunk */
if(ret==0)
{
free(chunk);
continue;
}
/* Input module signalled fatal error, shut down - nothing we can do
* from here */
if(ret < 0)
{
ices_config->shutdown = 1;
thread_cond_broadcast(&ices_config->queue_cond);
free(chunk);
continue;
}
if(chunk->critical)
valid_stream = 1;
if(ret < 0) {
/* Tell the input module to go to the next track, hopefully allowing
* resync. */
ices_config->inmod->handle_event(ices_config->inmod,
EVENT_NEXTTRACK,NULL);
valid_stream = 0;
}
inc_count = 0;
not_waiting_for_critical = 0;
if(valid_stream)
{
while(instance)
{
if(instance->wait_for_critical && !chunk->critical)
{
instance = instance->next;
continue;
}
not_waiting_for_critical = 1;
if(instance->skip)
{
instance = instance->next;
continue;
}
queued = malloc(sizeof(queue_item));
queued->buf = chunk;
current = instance->queue;
inc_count++;
thread_mutex_lock(¤t->lock);
if(current->head == NULL)
{
current->head = current->tail = queued;
current->head->next = current->tail->next = NULL;
}
else
{
current->tail->next = queued;
queued->next = NULL;
current->tail = queued;
}
current->length++;
thread_mutex_unlock(¤t->lock);
instance = instance->next;
}
}
/* If everything is waiting for a critical buffer, force one
* early. (This will take effect on the next pass through)
*/
if(valid_stream && !not_waiting_for_critical) {
ices_config->inmod->handle_event(ices_config->inmod,
EVENT_NEXTTRACK,NULL);
instance = ices_config->instances;
while(instance) {
thread_mutex_lock(&ices_config->flush_lock);
input_flush_queue(instance->queue, 0);
instance->wait_for_critical = 0;
thread_mutex_unlock(&ices_config->flush_lock);
instance = instance->next;
}
}
/* Make sure we don't end up with a 0-refcount buffer that
* will never hit any of the free points. (this happens
* if all threads are set to skip, for example).
*/
thread_mutex_lock(&ices_config->refcount_lock);
chunk->count += inc_count;
if(!chunk->count)
{
free(chunk->buf);
free(chunk);
}
thread_mutex_unlock(&ices_config->refcount_lock);
if(valid_stream) {
/* wake up the instances */
thread_cond_broadcast(&ices_config->queue_cond);
}
}
LOG_INFO0 ("All instances removed, shutting down...");
ices_config->shutdown = 1;
thread_cond_broadcast(&ices_config->event_pending_cond);
timing_sleep(250); /* sleep for quarter of a second */
thread_cond_destroy(&ices_config->queue_cond);
thread_cond_destroy(&ices_config->event_pending_cond);
thread_mutex_destroy(&ices_config->flush_lock);
thread_mutex_destroy(&ices_config->refcount_lock);
inmod->handle_event(inmod, EVENT_SHUTDOWN, NULL);
return;
}
/* The main loop for each instance. Gets data passed to it from the stream
* manager (which gets it from the input module), and streams it to the
* specified server
*/
void *ices_instance_stream(void *arg)
{
int ret, shouterr;
ref_buffer *buffer;
char *connip;
stream_description *sdsc = arg;
instance_t *stream = sdsc->stream;
input_module_t *inmod = sdsc->input;
int reencoding = (inmod->type == ICES_INPUT_VORBIS) && stream->encode;
int encoding = (inmod->type == ICES_INPUT_PCM) && stream->encode;
char *stream_name = NULL, *stream_genre = NULL, *stream_description = NULL;
char *user = NULL;
vorbis_comment_init(&sdsc->vc);
sdsc->shout = shout_new();
/* we only support the ice protocol and vorbis streams currently */
shout_set_format(sdsc->shout, SHOUT_FORMAT_VORBIS);
//shout_set_protocol(sdsc->shout, SHOUT_PROTOCOL_ICE);
shout_set_protocol(sdsc->shout, SHOUT_PROTOCOL_HTTP);
signal(SIGPIPE, signal_hup_handler);
connip = malloc(16);
if(!resolver_getip(stream->hostname, connip, 16))
{
LOG_ERROR1("Could not resolve hostname \"%s\"", stream->hostname);
free(connip);
stream->died = 1;
return NULL;
}
if (!(shout_set_host(sdsc->shout, connip)) == SHOUTERR_SUCCESS) {
LOG_ERROR1("libshout error: %s\n", shout_get_error(sdsc->shout));
free(connip);
stream->died = 1;
return NULL;
}
shout_set_port(sdsc->shout, stream->port);
if (!(shout_set_password(sdsc->shout, stream->password)) == SHOUTERR_SUCCESS) {
LOG_ERROR1("libshout error: %s\n", shout_get_error(sdsc->shout));
free(connip);
stream->died = 1;
return NULL;
}
if (stream->user)
user = stream->user;
else
user = "******";
if(shout_set_user(sdsc->shout, user) != SHOUTERR_SUCCESS) {
LOG_ERROR1("libshout error: %s\n", shout_get_error(sdsc->shout));
free(connip);
stream->died = 1;
return NULL;
}
if (!(shout_set_agent(sdsc->shout, VERSIONSTRING)) == SHOUTERR_SUCCESS) {
LOG_ERROR1("libshout error: %s\n", shout_get_error(sdsc->shout));
free(connip);
stream->died = 1;
return NULL;
}
if (!(shout_set_mount(sdsc->shout, stream->mount)) == SHOUTERR_SUCCESS) {
LOG_ERROR1("libshout error: %s\n", shout_get_error(sdsc->shout));
free(connip);
stream->died = 1;
return NULL;
}
/* set the metadata for the stream */
if(stream->stream_name)
stream_name = stream->stream_name;
else if (ices_config->stream_name)
stream_name = ices_config->stream_name;
if(stream->stream_description)
stream_description = stream->stream_description;
else if (ices_config->stream_description)
stream_description = ices_config->stream_description;
if(stream->stream_genre)
stream_genre = stream->stream_genre;
else if (ices_config->stream_genre)
stream_genre = ices_config->stream_genre;
if(stream_name)
if (!(shout_set_name(sdsc->shout, stream_name)) == SHOUTERR_SUCCESS) {
LOG_ERROR1("libshout error: %s\n", shout_get_error(sdsc->shout));
free(connip);
stream->died = 1;
return NULL;
}
if (stream_genre)
if (!(shout_set_genre(sdsc->shout, stream_genre)) == SHOUTERR_SUCCESS) {
LOG_ERROR1("libshout error: %s\n", shout_get_error(sdsc->shout));
free(connip);
stream->died = 1;
return NULL;
}
if (stream_description)
if (!(shout_set_description(sdsc->shout, stream_description)) == SHOUTERR_SUCCESS) {
LOG_ERROR1("libshout error: %s\n", shout_get_error(sdsc->shout));
free(connip);
stream->died = 1;
return NULL;
}
if(stream->downmix && encoding && stream->channels == 1) {
stream->channels = 1;
sdsc->downmix = downmix_initialise();
}
if(stream->resampleinrate && stream->resampleoutrate && encoding) {
stream->samplerate = stream->resampleoutrate;
sdsc->resamp = resample_initialise(stream->channels,
stream->resampleinrate, stream->resampleoutrate);
}
if(encoding)
{
if(inmod->metadata_update)
inmod->metadata_update(inmod->internal, &sdsc->vc);
sdsc->enc = encode_initialise(stream->channels, stream->samplerate,
stream->managed, stream->min_br, stream->nom_br, stream->max_br,
stream->quality, stream->serial++, &sdsc->vc);
if(!sdsc->enc) {
LOG_ERROR0("Failed to configure encoder");
stream->died = 1;
return NULL; /* FIXME: probably leaking some memory here */
}
}
else if(reencoding)
sdsc->reenc = reencode_init(stream);
if(stream->savefilename != NULL)
{
stream->savefile = fopen(stream->savefilename, "wb");
if(!stream->savefile)
LOG_ERROR2("Failed to open stream save file %s: %s",
stream->savefilename, strerror(errno));
else
LOG_INFO1("Saving stream to file %s", stream->savefilename);
}
if((shouterr = shout_open(sdsc->shout)) == SHOUTERR_SUCCESS)
{
LOG_INFO3("Connected to server: %s:%d%s",
shout_get_host(sdsc->shout), shout_get_port(sdsc->shout), shout_get_mount(sdsc->shout));
while(1)
{
if(stream->buffer_failures > MAX_ERRORS)
{
LOG_WARN0("Too many errors, shutting down");
break;
}
buffer = stream_wait_for_data(stream);
/* buffer being NULL means that either a fatal error occured,
* or we've been told to shut down
*/
if(!buffer)
break;
/* If data is NULL or length is 0, we should just skip this one.
* Probably, we've been signalled to shut down, and that'll be
* caught next iteration. Add to the error count just in case,
* so that we eventually break out anyway
*/
if(!buffer->buf || !buffer->len)
{
LOG_WARN0("Bad buffer dequeued!");
stream->buffer_failures++;
continue;
}
if(stream->wait_for_critical)
{
LOG_INFO0("Trying restart on new substream");
stream->wait_for_critical = 0;
}
ret = process_and_send_buffer(sdsc, buffer);
/* No data produced, do nothing */
if(ret == -1)
;
/* Fatal error */
else if(ret == -2)
{
LOG_ERROR0("Serious error, waiting to restart on "
"next substream. Stream temporarily suspended.");
/* Set to wait until a critical buffer comes through (start of
* a new substream, typically), and flush existing queue.
*/
thread_mutex_lock(&ices_config->flush_lock);
stream->wait_for_critical = 1;
input_flush_queue(stream->queue, 0);
thread_mutex_unlock(&ices_config->flush_lock);
}
/* Non-fatal shout error */
else if(ret == 0)
{
LOG_ERROR2("Send error: %s (%s)",
shout_get_error(sdsc->shout), strerror(errno));
if(shout_get_errno(sdsc->shout) == SHOUTERR_SOCKET)
{
int i=0;
/* While we're trying to reconnect, don't receive data
* to this instance, or we'll overflow once reconnect
* succeeds
*/
thread_mutex_lock(&ices_config->flush_lock);
stream->skip = 1;
/* Also, flush the current queue */
input_flush_queue(stream->queue, 1);
thread_mutex_unlock(&ices_config->flush_lock);
while((i < stream->reconnect_attempts ||
stream->reconnect_attempts==-1) &&
!ices_config->shutdown)
{
i++;
LOG_WARN0("Trying reconnect after server socket error");
shout_close(sdsc->shout);
if((shouterr = shout_open(sdsc->shout)) == SHOUTERR_SUCCESS)
{
LOG_INFO3("Connected to server: %s:%d%s",
shout_get_host(sdsc->shout), shout_get_port(sdsc->shout),
shout_get_mount(sdsc->shout));
/* This stream can't restart until the next
* logical stream comes along, since the
* server won't have any cached headers for
* this source/connection. So, don't continue
* yet.
*/
thread_mutex_lock(&ices_config->flush_lock);
stream->wait_for_critical = 1;
input_flush_queue(stream->queue, 0);
thread_mutex_unlock(&ices_config->flush_lock);
break;
}
else
{
LOG_ERROR3("Failed to reconnect to %s:%d (%s)",
shout_get_host(sdsc->shout),shout_get_port(sdsc->shout),
shout_get_error(sdsc->shout));
if(i==stream->reconnect_attempts)
{
LOG_ERROR0("Reconnect failed too many times, "
"giving up.");
/* We want to die now */
stream->buffer_failures = MAX_ERRORS+1;
}
else /* Don't try again too soon */
sleep(stream->reconnect_delay);
}
}
stream->skip = 0;
}
stream->buffer_failures++;
}
stream_release_buffer(buffer);
}
}
else
{
LOG_ERROR3("Failed initial connect to %s:%d (%s)",
shout_get_host(sdsc->shout),shout_get_port(sdsc->shout), shout_get_error(sdsc->shout));
}
shout_close(sdsc->shout);
if(stream->savefile != NULL)
fclose(stream->savefile);
shout_free(sdsc->shout);
encode_clear(sdsc->enc);
reencode_clear(sdsc->reenc);
downmix_clear(sdsc->downmix);
resample_clear(sdsc->resamp);
vorbis_comment_clear(&sdsc->vc);
stream->died = 1;
return NULL;
}
