nils/shairport-sync
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add an "active" mode that can time out after a period -- 10 seconds by default -- after play ends.

Browse Source
This commit is contained in:
Mike Brady
2019-01-21 21:43:55 +00:00
parent 604ca8dee4
commit 2e4428538d
18 changed files with 300 additions and 261 deletions
Download Patch File Download Diff File Expand all files Collapse all files
activity_monitor.c
+99 -90
View File
@@ -1,11 +1,11 @@
/*
* Activity Monitor
*
*
* Contains code to run an activity flag and associated timer
* A pthread implements a simple state machine with three states,
* A pthread implements a simple state machine with three states,
* "idle", "active" and "timing out".
*
*
*
*
* This file is part of Shairport Sync.
* Copyright (c) Mike Brady 2019
* All rights reserved.
@@ -31,41 +31,43 @@
* OTHER DEALINGS IN THE SOFTWARE.
*/
#include <stdlib.h>
#include <errno.h>
#include <inttypes.h>
#include <stdlib.h>
#include <sys/types.h>
#include "config.h"
#include "activity_monitor.h"
#include "common.h"
#include "rtsp.h"
#include "activity_monitor.h"
enum am_state {am_inactive, am_active, am_timing_out} state;
enum ps_state {ps_inactive, ps_active} player_state;
enum am_state { am_inactive, am_active, am_timing_out } state;
enum ps_state { ps_inactive, ps_active } player_state;
pthread_t activity_monitor_thread;
pthread_mutex_t activity_monitor_mutex;
pthread_cond_t activity_monitor_cv;
void going_active(int block) {
// debug(1, "activity_monitor: state transitioning to \"active\" with%s blocking", block ? "" : "out");
// debug(1, "activity_monitor: state transitioning to \"active\" with%s blocking", block ? "" :
// "out");
if (config.cmd_active_start)
command_execute(config.cmd_active_start, "", block);
#ifdef CONFIG_METADATA
debug(2, "abeg"); // active mode begin
send_ssnc_metadata('pend', NULL, 0, 1); // contains cancellation points
debug(2, "abeg"); // active mode begin
send_ssnc_metadata('pend', NULL, 0, 1); // contains cancellation points
#endif
}
void going_inactive(int block) {
// debug(1, "activity_monitor: state transitioning to \"inactive\" with%s blocking", block ? "" : "out");
// debug(1, "activity_monitor: state transitioning to \"inactive\" with%s blocking", block ? "" :
// "out");
if (config.cmd_active_stop)
command_execute(config.cmd_active_stop, "", block);
#ifdef CONFIG_METADATA
debug(2, "aend"); // active mode end
send_ssnc_metadata('pend', NULL, 0, 1); // contains cancellation points
debug(2, "aend"); // active mode end
send_ssnc_metadata('pend', NULL, 0, 1); // contains cancellation points
#endif
}
@@ -83,17 +85,20 @@ void activity_monitor_signify_activity(int active) {
// The reason for all this is that we might want to perform the attached scripts
// and wait for them to complete before continuing. If they were perfomed in the
// activity monitor thread, then we coldn't wait for them to complete.
// Thus, the only time the thread will execute a going_... function is when a non-zero
// timeout actually matures.
if ((state == am_inactive) && (player_state == ps_active)) {
going_active(config.cmd_blocking); // note -- will be executed with the mutex locked, but that's okay
} else if ((state == am_active) && (player_state == ps_inactive) && (config.active_mode_timeout == 0.0)) {
going_inactive(config.cmd_blocking); // note -- will be executed with the mutex locked, but that's okay
going_active(
config.cmd_blocking); // note -- will be executed with the mutex locked, but that's okay
} else if ((state == am_active) && (player_state == ps_inactive) &&
(config.active_mode_timeout == 0.0)) {
going_inactive(
config.cmd_blocking); // note -- will be executed with the mutex locked, but that's okay
}
pthread_cond_signal(&activity_monitor_cv);
pthread_cond_signal(&activity_monitor_cv);
pthread_mutex_unlock(&activity_monitor_mutex);
}
@@ -115,7 +120,7 @@ void *activity_monitor_thread_code(void *arg) {
pthread_condattr_setclock(&attr, CLOCK_MONOTONIC); // can't do this in OS X, and don't need it.
rc = pthread_cond_init(&activity_monitor_cv, &attr);
pthread_condattr_destroy(&attr);
#endif
#ifdef COMPILE_FOR_OSX
rc = pthread_cond_init(&activity_monitor_cv, NULL);
@@ -123,84 +128,89 @@ void *activity_monitor_thread_code(void *arg) {
if (rc)
die("activity_monitor: error %d initialising activity_monitor_cv.");
pthread_cleanup_push(activity_thread_cleanup_handler, arg);
uint64_t sec;
uint64_t nsec;
int rc;
struct timespec time_for_wait;
state = am_inactive;
player_state = ps_inactive;
pthread_mutex_lock(&activity_monitor_mutex);
do {
switch (state) {
case am_inactive:
// debug(1,"am_state: am_inactive");
while (player_state != ps_active)
pthread_cond_wait(&activity_monitor_cv, &activity_monitor_mutex);
state = am_active;
// going_active(); // this is done in activity_monitor_signify_activity
case am_inactive:
// debug(1,"am_state: am_inactive");
while (player_state != ps_active)
pthread_cond_wait(&activity_monitor_cv, &activity_monitor_mutex);
state = am_active;
// going_active(); // this is done in activity_monitor_signify_activity
break;
case am_active:
// debug(1,"am_state: am_active");
while (player_state != ps_inactive)
pthread_cond_wait(&activity_monitor_cv, &activity_monitor_mutex);
if (config.active_mode_timeout == 0.0) {
state = am_inactive;
// going_inactive(); // this is done in activity_monitor_signify_activity
} else {
state = am_timing_out;
uint64_t time_to_wait_for_wakeup_fp = (uint64_t)(config.active_mode_timeout *1000000); // resolution of microseconds
time_to_wait_for_wakeup_fp = time_to_wait_for_wakeup_fp << 32;
time_to_wait_for_wakeup_fp = time_to_wait_for_wakeup_fp / 1000000;
#ifdef COMPILE_FOR_LINUX_AND_FREEBSD_AND_CYGWIN_AND_OPENBSD
uint64_t time_of_wakeup_fp = get_absolute_time_in_fp() + time_to_wait_for_wakeup_fp;
sec = time_of_wakeup_fp >> 32;
nsec = ((time_of_wakeup_fp & 0xffffffff) * 1000000000) >> 32;
time_for_wait.tv_sec = sec;
time_for_wait.tv_nsec = nsec;
#endif
#ifdef COMPILE_FOR_OSX
sec = time_to_wait_for_wakeup_fp >> 32;
nsec = ((time_to_wait_for_wakeup_fp & 0xffffffff) * 1000000000) >> 32;
time_for_wait.tv_sec = sec;
time_for_wait.tv_nsec = nsec;
#endif
}
break;
case am_timing_out:
// debug(1,"am_state: am_timing_out");
rc = 0;
while ((player_state != ps_active) && (rc != ETIMEDOUT)) {
#ifdef COMPILE_FOR_LINUX_AND_FREEBSD_AND_CYGWIN_AND_OPENBSD
rc = pthread_cond_timedwait(&activity_monitor_cv, &activity_monitor_mutex, &time_for_wait); // this is a pthread cancellation point
#endif
#ifdef COMPILE_FOR_OSX
rc = pthread_cond_timedwait_relative_np(&activity_monitor_cv, &activity_monitor_mutex, &time_for_wait);
#endif
}
if (player_state == ps_active)
state = am_active; // player has gone active -- do nothing, because it's still active
else if (rc == ETIMEDOUT) {
state = am_inactive;
pthread_mutex_unlock(&activity_monitor_mutex);
going_inactive(0); // don't wait for completion -- it makes no sense
pthread_mutex_lock(&activity_monitor_mutex);
} else {
// activity monitor was woken up in the state am_timing_out, but not by a timeout and player is not in ps_active state
debug(1, "activity monitor was woken up in the state am_timing_out, but didn't change state");
}
break;
default:
debug(1,"activity monitor in an illegal state!");
case am_active:
// debug(1,"am_state: am_active");
while (player_state != ps_inactive)
pthread_cond_wait(&activity_monitor_cv, &activity_monitor_mutex);
if (config.active_mode_timeout == 0.0) {
state = am_inactive;
// going_inactive(); // this is done in activity_monitor_signify_activity
} else {
state = am_timing_out;
uint64_t time_to_wait_for_wakeup_fp =
(uint64_t)(config.active_mode_timeout * 1000000); // resolution of microseconds
time_to_wait_for_wakeup_fp = time_to_wait_for_wakeup_fp << 32;
time_to_wait_for_wakeup_fp = time_to_wait_for_wakeup_fp / 1000000;
#ifdef COMPILE_FOR_LINUX_AND_FREEBSD_AND_CYGWIN_AND_OPENBSD
uint64_t time_of_wakeup_fp = get_absolute_time_in_fp() + time_to_wait_for_wakeup_fp;
sec = time_of_wakeup_fp >> 32;
nsec = ((time_of_wakeup_fp & 0xffffffff) * 1000000000) >> 32;
time_for_wait.tv_sec = sec;
time_for_wait.tv_nsec = nsec;
#endif
#ifdef COMPILE_FOR_OSX
sec = time_to_wait_for_wakeup_fp >> 32;
nsec = ((time_to_wait_for_wakeup_fp & 0xffffffff) * 1000000000) >> 32;
time_for_wait.tv_sec = sec;
time_for_wait.tv_nsec = nsec;
#endif
}
break;
case am_timing_out:
// debug(1,"am_state: am_timing_out");
rc = 0;
while ((player_state != ps_active) && (rc != ETIMEDOUT)) {
#ifdef COMPILE_FOR_LINUX_AND_FREEBSD_AND_CYGWIN_AND_OPENBSD
rc = pthread_cond_timedwait(&activity_monitor_cv, &activity_monitor_mutex,
&time_for_wait); // this is a pthread cancellation point
#endif
#ifdef COMPILE_FOR_OSX
rc = pthread_cond_timedwait_relative_np(&activity_monitor_cv, &activity_monitor_mutex,
&time_for_wait);
#endif
}
if (player_state == ps_active)
state = am_active; // player has gone active -- do nothing, because it's still active
else if (rc == ETIMEDOUT) {
state = am_inactive;
pthread_mutex_unlock(&activity_monitor_mutex);
going_inactive(0); // don't wait for completion -- it makes no sense
pthread_mutex_lock(&activity_monitor_mutex);
} else {
// activity monitor was woken up in the state am_timing_out, but not by a timeout and player
// is not in ps_active state
debug(1,
"activity monitor was woken up in the state am_timing_out, but didn't change state");
}
break;
default:
debug(1, "activity monitor in an illegal state!");
state = am_inactive;
break;
}
} while (1);
pthread_mutex_unlock(&activity_monitor_mutex);
pthread_mutex_unlock(&activity_monitor_mutex);
pthread_cleanup_pop(0); // should never happen
pthread_exit(NULL);
}
@@ -211,9 +221,8 @@ void activity_monitor_start() {
}
void activity_monitor_stop() {
debug(1,"activity_monitor_stop start...");
debug(1, "activity_monitor_stop start...");
pthread_cancel(activity_monitor_thread);
pthread_join(activity_monitor_thread,NULL);
debug(1,"activity_monitor_stop complete");
pthread_join(activity_monitor_thread, NULL);
debug(1, "activity_monitor_stop complete");
}