--- /dev/null
+/*
+ * Activity Monitor
+ *
+ * Contains code to run an activity flag and associated timer
+ * 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.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <sys/types.h>
+
+#include "config.h"
+
+#include "common.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;
+
+pthread_t activity_monitor_thread;
+pthread_mutex_t activity_monitor_mutex;
+pthread_cond_t activity_monitor_cv;
+
+void activity_monitor_signify_activity(int active) {
+ pthread_mutex_lock(&activity_monitor_mutex);
+ player_state = active == 0 ? ps_inactive : ps_active;
+ pthread_cond_signal(&activity_monitor_cv);
+ pthread_mutex_unlock(&activity_monitor_mutex);
+}
+
+void going_active() {
+ pthread_mutex_unlock(&activity_monitor_mutex);
+ debug(1, "activity_monitor: state transitioning to \"active\"");
+ pthread_mutex_lock(&activity_monitor_mutex);
+}
+
+void going_inactive() {
+ pthread_mutex_unlock(&activity_monitor_mutex);
+ debug(1, "activity_monitor: state transitioning to \"inactive\"");
+ pthread_mutex_lock(&activity_monitor_mutex);
+}
+
+void activity_thread_cleanup_handler(__attribute__((unused)) void *arg) {
+ debug(3, "activity_monitor: thread exit.");
+ pthread_cond_destroy(&activity_monitor_cv);
+ pthread_mutex_destroy(&activity_monitor_mutex);
+}
+
+void *activity_monitor_thread_code(void *arg) {
+ int rc = pthread_mutex_init(&activity_monitor_mutex, NULL);
+ if (rc)
+ die("activity_monitor: error %d initialising activity_monitor_mutex.", rc);
+
+// set the flowcontrol condition variable to wait on a monotonic clock
+#ifdef COMPILE_FOR_LINUX_AND_FREEBSD_AND_CYGWIN_AND_OPENBSD
+ pthread_condattr_t attr;
+ pthread_condattr_init(&attr);
+ 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);
+#endif
+ 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();
+ 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_timeout == 0.0) {
+ state = am_inactive;
+ going_inactive();
+ } else {
+ state = am_timing_out;
+
+ uint64_t time_to_wait_for_wakeup_fp = (uint64_t)(config.active_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;
+ going_inactive();
+ } 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_cleanup_pop(0); // should never happen
+ pthread_exit(NULL);
+}
+
+void activity_monitor_start() {
+ debug(1,"activity_monitor_start");
+ config.active_timeout = 5.5; // hack
+ pthread_create(&activity_monitor_thread, NULL, activity_monitor_thread_code, NULL);
+}
+
+void activity_monitor_stop() {
+ debug(1,"activity_monitor_stop start...");
+ pthread_cancel(activity_monitor_thread);
+ pthread_join(activity_monitor_thread,NULL);
+ debug(1,"activity_monitor_stop complete");
+}
+
projects / thirdparty / shairport-sync.git / commitdiff
