static void
track_changed(XmrWindow *window,
SongInfo *new_track,
XmrMprisPlugin *plugin)
{
song_info_free(plugin->current_song);
plugin->current_song = song_info_copy(new_track);
metadata_changed(plugin);
}
static void
bookmark_file_changed_callback (NemoFile *file,
NemoBookmark *bookmark)
{
GFile *location;
g_assert (file == bookmark->details->file);
DEBUG ("%s: file changed", nemo_bookmark_get_name (bookmark));
location = nemo_file_get_location (file);
if (!g_file_equal (bookmark->details->location, location) &&
!nemo_file_is_in_trash (file)) {
DEBUG ("%s: file got moved", nemo_bookmark_get_name (bookmark));
g_object_unref (bookmark->details->location);
bookmark->details->location = g_object_ref (location);
g_object_notify_by_pspec (G_OBJECT (bookmark), properties[PROP_LOCATION]);
g_signal_emit (bookmark, signals[CONTENTS_CHANGED], 0);
}
g_object_unref (location);
if (nemo_file_is_gone (file) ||
nemo_file_is_in_trash (file)) {
/* The file we were monitoring has been trashed, deleted,
* or moved in a way that we didn't notice. We should make
* a spanking new NemoFile object for this
* location so if a new file appears in this place
* we will notice. However, we can't immediately do so
* because creating a new NemoFile directly as a result
* of noticing a file goes away may trigger i/o on that file
* again, noticeing it is gone, leading to a loop.
* So, the new NemoFile is created when the bookmark
* is used again. However, this is not really a problem, as
* we don't want to change the icon or anything about the
* bookmark just because its not there anymore.
*/
DEBUG ("%s: trashed", nemo_bookmark_get_name (bookmark));
nemo_bookmark_disconnect_file (bookmark);
nemo_bookmark_set_icon_to_default (bookmark);
} else {
nemo_bookmark_update_icon (bookmark);
bookmark_set_name_from_ready_file (bookmark, file);
if (metadata_changed (bookmark)) {
g_signal_emit (bookmark, signals[CONTENTS_CHANGED], 0);
}
}
}
static void __prebuffer(void)
{
int limit_chunks;
BUG_ON(producer_status != PS_PLAYING);
if (ip_is_remote(ip)) {
limit_chunks = buffer_nr_chunks;
} else {
int limit_ms, limit_size;
limit_ms = 250;
limit_size = limit_ms * buffer_second_size() / 1000;
limit_chunks = limit_size / CHUNK_SIZE;
if (limit_chunks < 1)
limit_chunks = 1;
}
while (1) {
int nr_read, size, filled;
char *wpos;
filled = buffer_get_filled_chunks();
/* d_print("PREBUF: %2d / %2d\n", filled, limit_chunks); */
/* not fatal */
//BUG_ON(filled > limit_chunks);
if (filled >= limit_chunks)
break;
size = buffer_get_wpos(&wpos);
nr_read = ip_read(ip, wpos, size);
if (nr_read < 0) {
if (nr_read == -1 && errno == EAGAIN)
continue;
player_ip_error(nr_read, "reading file %s", ip_get_filename(ip));
/* ip_read sets eof */
nr_read = 0;
}
if (ip_metadata_changed(ip))
metadata_changed();
/* buffer_fill with 0 count marks current chunk filled */
buffer_fill(nr_read);
__producer_buffer_fill_update();
if (nr_read == 0) {
/* EOF */
break;
}
}
}
static void *producer_loop(void *arg)
{
while (1) {
/* number of chunks to fill
* too big => seeking is slow
* too small => underruns?
*/
const int chunks = 1;
int size, nr_read, i;
char *wpos;
producer_lock();
if (!producer_running)
break;
if (producer_status == PS_UNLOADED ||
producer_status == PS_PAUSED ||
producer_status == PS_STOPPED || ip_eof(ip)) {
pthread_cond_wait(&producer_playing, &producer_mutex);
producer_unlock();
continue;
}
for (i = 0; ; i++) {
size = buffer_get_wpos(&wpos);
if (size == 0) {
/* buffer is full */
producer_unlock();
ms_sleep(50);
break;
}
nr_read = ip_read(ip, wpos, size);
if (nr_read < 0) {
if (nr_read != -1 || errno != EAGAIN) {
player_ip_error(nr_read, "reading file %s",
ip_get_filename(ip));
/* ip_read sets eof */
nr_read = 0;
} else {
producer_unlock();
ms_sleep(50);
break;
}
}
if (ip_metadata_changed(ip))
metadata_changed();
/* buffer_fill with 0 count marks current chunk filled */
buffer_fill(nr_read);
if (nr_read == 0) {
/* consumer handles EOF */
producer_unlock();
ms_sleep(50);
break;
}
if (i == chunks) {
producer_unlock();
/* don't sleep! */
break;
}
}
__producer_buffer_fill_update();
}
__producer_unload();
producer_unlock();
return NULL;
}
