activity_monitor.c

/*
 * 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");
}