res_stasis_playback.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 2013, Digium, Inc.
 *
 * David M. Lee, II <[email protected]>
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */

/*! \file
 *
 * \brief res_stasis playback support.
 *
 * \author David M. Lee, II <[email protected]>
 */

/*** MODULEINFO
   <depend type="module">res_stasis</depend>
   <depend type="module">res_stasis_recording</depend>
   <support_level>core</support_level>
 ***/

#include "asterisk.h"

#include "asterisk/app.h"
#include "asterisk/astobj2.h"
#include "asterisk/bridge.h"
#include "asterisk/bridge_internal.h"
#include "asterisk/file.h"
#include "asterisk/logger.h"
#include "asterisk/module.h"
#include "asterisk/paths.h"
#include "asterisk/stasis_app_impl.h"
#include "asterisk/stasis_app_playback.h"
#include "asterisk/stasis_app_recording.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/stringfields.h"
#include "asterisk/uuid.h"
#include "asterisk/say.h"
#include "asterisk/indications.h"

/*! Number of hash buckets for playback container. Keep it prime! */
#define PLAYBACK_BUCKETS 127

/*! Default number of milliseconds of media to skip */
#define PLAYBACK_DEFAULT_SKIPMS 3000

#define SOUND_URI_SCHEME "sound:"
#define RECORDING_URI_SCHEME "recording:"
#define NUMBER_URI_SCHEME "number:"
#define DIGITS_URI_SCHEME "digits:"
#define CHARACTERS_URI_SCHEME "characters:"
#define TONE_URI_SCHEME "tone:"

/*! Container of all current playbacks */
static struct ao2_container *playbacks;

/*! Playback control object for res_stasis */
struct stasis_app_playback {
   AST_DECLARE_STRING_FIELDS(
      AST_STRING_FIELD(id);   /*!< Playback unique id */
      AST_STRING_FIELD(media);   /*!< The current media playing */
      AST_STRING_FIELD(language);   /*!< Preferred language */
      AST_STRING_FIELD(target);       /*!< Playback device uri */
   );
   /*! The list of medias to play back */
   AST_VECTOR(, char *) medias;

   /*! The current index in \c medias we're playing */
   size_t media_index;

   /*! Control object for the channel we're playing back to */
   struct stasis_app_control *control;
   /*! Number of milliseconds to skip before playing */
   long offsetms;
   /*! Number of milliseconds to skip for forward/reverse operations */
   int skipms;
   /*! Number of milliseconds of media that has been played */
   long playedms;
   /*! Current playback state */
   enum stasis_app_playback_state state;
   /*! Set when the playback can be controlled */
   unsigned int controllable:1;
};

static struct ast_json *playback_to_json(struct stasis_message *message,
   const struct stasis_message_sanitizer *sanitize)
{
   struct ast_channel_blob *channel_blob = stasis_message_data(message);
   struct ast_json *blob = channel_blob->blob;
   const char *state =
      ast_json_string_get(ast_json_object_get(blob, "state"));
   const char *type;

   if (!strcmp(state, "playing")) {
      type = "PlaybackStarted";
   } else if (!strcmp(state, "continuing")) {
      type = "PlaybackContinuing";
   } else if (!strcmp(state, "done")) {
      type = "PlaybackFinished";
   } else {
      return NULL;
   }

   return ast_json_pack("{s: s, s: o?, s: O}",
      "type", type,
      "timestamp", ast_json_timeval(*stasis_message_timestamp(message), NULL),
      "playback", blob);
}

STASIS_MESSAGE_TYPE_DEFN(stasis_app_playback_snapshot_type,
   .to_json = playback_to_json,
);

static void playback_dtor(void *obj)
{
   struct stasis_app_playback *playback = obj;
   int i;

   for (i = 0; i < AST_VECTOR_SIZE(&playback->medias); i++) {
      char *media = AST_VECTOR_GET(&playback->medias, i);

      ast_free(media);
   }
   AST_VECTOR_FREE(&playback->medias);

   ao2_cleanup(playback->control);
   ast_string_field_free_memory(playback);
}

static struct stasis_app_playback *playback_create(
   struct stasis_app_control *control, const char *id)
{
   RAII_VAR(struct stasis_app_playback *, playback, NULL, ao2_cleanup);
   char uuid[AST_UUID_STR_LEN];

   if (!control) {
      return NULL;
   }

   playback = ao2_alloc(sizeof(*playback), playback_dtor);
   if (!playback || ast_string_field_init(playback, 128)) {
      return NULL;
   }

   if (AST_VECTOR_INIT(&playback->medias, 8)) {
      ao2_ref(playback, -1);
      return NULL;
   }

   if (!ast_strlen_zero(id)) {
      ast_string_field_set(playback, id, id);
   } else {
      ast_uuid_generate_str(uuid, sizeof(uuid));
      ast_string_field_set(playback, id, uuid);
   }

   ao2_ref(control, +1);
   playback->control = control;

   ao2_ref(playback, +1);
   return playback;
}

static int playback_hash(const void *obj, int flags)
{
   const struct stasis_app_playback *playback = obj;
   const char *id = flags & OBJ_KEY ? obj : playback->id;
   return ast_str_hash(id);
}

static int playback_cmp(void *obj, void *arg, int flags)
{
   struct stasis_app_playback *lhs = obj;
   struct stasis_app_playback *rhs = arg;
   const char *rhs_id = flags & OBJ_KEY ? arg : rhs->id;

   if (strcmp(lhs->id, rhs_id) == 0) {
      return CMP_MATCH | CMP_STOP;
   } else {
      return 0;
   }
}

static const char *state_to_string(enum stasis_app_playback_state state)
{
   switch (state) {
   case STASIS_PLAYBACK_STATE_QUEUED:
      return "queued";
   case STASIS_PLAYBACK_STATE_PLAYING:
      return "playing";
   case STASIS_PLAYBACK_STATE_PAUSED:
      return "paused";
   case STASIS_PLAYBACK_STATE_CONTINUING:
      return "continuing";
   case STASIS_PLAYBACK_STATE_STOPPED:
   case STASIS_PLAYBACK_STATE_COMPLETE:
   case STASIS_PLAYBACK_STATE_CANCELED:
      /* It doesn't really matter how we got here, but all of these
       * states really just mean 'done' */
      return "done";
   case STASIS_PLAYBACK_STATE_MAX:
      break;
   }

   return "?";
}

static void playback_publish(struct stasis_app_playback *playback)
{
   RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
   RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);

   ast_assert(playback != NULL);

   json = stasis_app_playback_to_json(playback);
   if (json == NULL) {
      return;
   }

   message = ast_channel_blob_create_from_cache(
      stasis_app_control_get_channel_id(playback->control),
      stasis_app_playback_snapshot_type(), json);
   if (message == NULL) {
      return;
   }

   stasis_app_control_publish(playback->control, message);
}

static int playback_first_update(struct stasis_app_playback *playback,
   const char *uniqueid)
{
   int res;
   SCOPED_AO2LOCK(lock, playback);

   if (playback->state == STASIS_PLAYBACK_STATE_CANCELED) {
      ast_log(LOG_NOTICE, "%s: Playback canceled for %s\n",
         uniqueid, playback->media);
      res = -1;
   } else {
      res = 0;
      playback->state = STASIS_PLAYBACK_STATE_PLAYING;
   }

   playback_publish(playback);
   return res;
}

static void playback_final_update(struct stasis_app_playback *playback,
   long playedms, int res, const char *uniqueid)
{
   SCOPED_AO2LOCK(lock, playback);

   playback->playedms = playedms;
   if (res == 0) {
      if (playback->media_index == AST_VECTOR_SIZE(&playback->medias) - 1) {
         playback->state = STASIS_PLAYBACK_STATE_COMPLETE;
      } else {
         playback->state = STASIS_PLAYBACK_STATE_CONTINUING;
      }
   } else {
      if (playback->state == STASIS_PLAYBACK_STATE_STOPPED) {
         ast_log(LOG_NOTICE, "%s: Playback stopped for %s\n",
            uniqueid, playback->media);
      } else {
         ast_log(LOG_WARNING, "%s: Playback failed for %s\n",
            uniqueid, playback->media);
         playback->state = STASIS_PLAYBACK_STATE_STOPPED;
      }
   }

   playback_publish(playback);
}

static void play_on_channel(struct stasis_app_playback *playback,
   struct ast_channel *chan)
{
   int res;
   long offsetms;
   size_t index;

   /* Even though these local variables look fairly pointless, they avoid
    * having a bunch of NULL's passed directly into
    * ast_control_streamfile() */
   const char *fwd = NULL;
   const char *rev = NULL;
   const char *stop = NULL;
   const char *pause = NULL;
   const char *restart = NULL;

   ast_assert(playback != NULL);

   if (ast_channel_state(chan) != AST_STATE_UP) {
      ast_indicate(chan, AST_CONTROL_PROGRESS);
   }

   offsetms = playback->offsetms;

   for (index = 0; index < AST_VECTOR_SIZE(&playback->medias); index++) {
      playback->media_index = index;

      /* Set the current media to play */
      ast_string_field_set(playback, media, AST_VECTOR_GET(&playback->medias, playback->media_index));

      res = playback_first_update(playback, ast_channel_uniqueid(chan));
      if (res != 0) {
         return;
      }

      if (ast_begins_with(playback->media, SOUND_URI_SCHEME)) {
         playback->controllable = 1;

         /* Play sound */
         res = ast_control_streamfile_lang(chan, playback->media + strlen(SOUND_URI_SCHEME),
               fwd, rev, stop, pause, restart, playback->skipms, playback->language,
               &offsetms);
      } else if (ast_begins_with(playback->media, RECORDING_URI_SCHEME)) {
         /* Play recording */
         RAII_VAR(struct stasis_app_stored_recording *, recording, NULL,
            ao2_cleanup);
         const char *relname =
            playback->media + strlen(RECORDING_URI_SCHEME);
         recording = stasis_app_stored_recording_find_by_name(relname);

         if (!recording) {
            ast_log(LOG_ERROR, "Attempted to play recording '%s' on channel '%s' but recording does not exist",
               relname, ast_channel_name(chan));
            continue;
         }

         playback->controllable = 1;

         res = ast_control_streamfile_lang(chan,
            stasis_app_stored_recording_get_file(recording), fwd, rev, stop, pause,
            restart, playback->skipms, playback->language, &offsetms);
      } else if (ast_begins_with(playback->media, NUMBER_URI_SCHEME)) {
         int number;

         if (sscanf(playback->media + strlen(NUMBER_URI_SCHEME), "%30d", &number) != 1) {
            ast_log(LOG_ERROR, "Attempted to play number '%s' on channel '%s' but number is invalid",
               playback->media + strlen(NUMBER_URI_SCHEME), ast_channel_name(chan));
            continue;
         }

         res = ast_say_number(chan, number, stop, playback->language, NULL);
      } else if (ast_begins_with(playback->media, DIGITS_URI_SCHEME)) {
         res = ast_say_digit_str(chan, playback->media + strlen(DIGITS_URI_SCHEME),
            stop, playback->language);
      } else if (ast_begins_with(playback->media, CHARACTERS_URI_SCHEME)) {
         res = ast_say_character_str(chan, playback->media + strlen(CHARACTERS_URI_SCHEME),
            stop, playback->language, AST_SAY_CASE_NONE);
      } else if (ast_begins_with(playback->media, TONE_URI_SCHEME)) {
         playback->controllable = 1;
         res = ast_control_tone(chan, playback->media + strlen(TONE_URI_SCHEME));
      } else {
         /* Play URL */
         ast_log(LOG_ERROR, "Attempted to play URI '%s' on channel '%s' but scheme is unsupported\n",
            playback->media, ast_channel_name(chan));
         continue;
      }

      playback_final_update(playback, offsetms, res,
         ast_channel_uniqueid(chan));
      if (res == AST_CONTROL_STREAM_STOP) {
         break;
      }

      /* Reset offset for any subsequent media */
      offsetms = 0;
   }
   return;
}

/*!
 * \brief Special case code to play while a channel is in a bridge.
 *
 * \param bridge_channel The channel's bridge_channel.
 * \param playback_id Id of the playback to start.
 */
static void play_on_channel_in_bridge(struct ast_bridge_channel *bridge_channel,
   const char *playback_id)
{
   RAII_VAR(struct stasis_app_playback *, playback, NULL, ao2_cleanup);

   playback = stasis_app_playback_find_by_id(playback_id);
   if (!playback) {
      ast_log(LOG_ERROR, "Couldn't find playback %s\n",
         playback_id);
      return;
   }

   play_on_channel(playback, bridge_channel->chan);
}

/*!
 * \brief \ref RAII_VAR function to remove a playback from the global list when
 * leaving scope.
 */
static void remove_from_playbacks(void *data)
{
   struct stasis_app_playback *playback = data;

   ao2_unlink_flags(playbacks, playback,
      OBJ_POINTER | OBJ_UNLINK | OBJ_NODATA);
   ao2_ref(playback, -1);
}

static int play_uri(struct stasis_app_control *control,
   struct ast_channel *chan, void *data)
{
   struct stasis_app_playback *playback = data;
   struct ast_bridge *bridge;

   if (!control) {
      return -1;
   }

   bridge = stasis_app_get_bridge(control);
   if (bridge) {
      struct ast_bridge_channel *bridge_chan;

      /* Queue up playback on the bridge */
      ast_bridge_lock(bridge);
      bridge_chan = ao2_bump(bridge_find_channel(bridge, chan));
      ast_bridge_unlock(bridge);
      if (bridge_chan) {
         ast_bridge_channel_queue_playfile_sync(
            bridge_chan,
            play_on_channel_in_bridge,
            playback->id,
            NULL); /* moh_class */
      }
      ao2_cleanup(bridge_chan);
   } else {
      play_on_channel(playback, chan);
   }

   return 0;
}

static void set_target_uri(
   struct stasis_app_playback *playback,
   enum stasis_app_playback_target_type target_type,
   const char *target_id)
{
   const char *type = NULL;
   switch (target_type) {
   case STASIS_PLAYBACK_TARGET_CHANNEL:
      type = "channel";
      break;
   case STASIS_PLAYBACK_TARGET_BRIDGE:
      type = "bridge";
      break;
   }

   ast_assert(type != NULL);

   ast_string_field_build(playback, target, "%s:%s", type, target_id);
}

struct stasis_app_playback *stasis_app_control_play_uri(
   struct stasis_app_control *control, const char **media,
   size_t media_count, const char *language, const char *target_id,
   enum stasis_app_playback_target_type target_type,
   int skipms, long offsetms, const char *id)
{
   struct stasis_app_playback *playback;
   size_t i;

   if (skipms < 0 || offsetms < 0 || media_count == 0) {
      return NULL;
   }

   playback = playback_create(control, id);
   if (!playback) {
      return NULL;
   }

   for (i = 0; i < media_count; i++) {
      char *media_uri;

      if (ast_strlen_zero(media[i])) {
         ast_log(LOG_ERROR, "Attempted to play media on channel '%s' but no media URI was provided.\n",
            stasis_app_control_get_channel_id(control));
         ao2_ref(playback, -1);
         return NULL;
      }

      media_uri = ast_malloc(strlen(media[i]) + 1);
      if (!media_uri) {
         ao2_ref(playback, -1);
         return NULL;
      }

      ast_debug(3, "%s: Sending play(%s) command\n",
         stasis_app_control_get_channel_id(control), media[i]);

       /* safe */
      strcpy(media_uri, media[i]);
      if (AST_VECTOR_APPEND(&playback->medias, media_uri)) {
         ao2_ref(playback, -1);
         ast_free(media_uri);
         return NULL;
      }
   }

   if (skipms == 0) {
      skipms = PLAYBACK_DEFAULT_SKIPMS;
   }

   ast_string_field_set(playback, media, AST_VECTOR_GET(&playback->medias, 0));
   ast_string_field_set(playback, language, language);
   set_target_uri(playback, target_type, target_id);
   playback->skipms = skipms;
   playback->offsetms = offsetms;
   ao2_link(playbacks, playback);

   playback->state = STASIS_PLAYBACK_STATE_QUEUED;
   playback_publish(playback);

   stasis_app_send_command_async(control, play_uri, ao2_bump(playback), remove_from_playbacks);

   return playback;
}

enum stasis_app_playback_state stasis_app_playback_get_state(
   struct stasis_app_playback *control)
{
   SCOPED_AO2LOCK(lock, control);
   return control->state;
}

const char *stasis_app_playback_get_id(
   struct stasis_app_playback *control)
{
   /* id is immutable; no lock needed */
   return control->id;
}

struct stasis_app_playback *stasis_app_playback_find_by_id(const char *id)
{
   return ao2_find(playbacks, id, OBJ_KEY);
}

struct ast_json *stasis_app_playback_to_json(
   const struct stasis_app_playback *playback)
{
   RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);

   if (playback == NULL) {
      return NULL;
   }

   if (playback->media_index == AST_VECTOR_SIZE(&playback->medias) - 1) {
      json = ast_json_pack("{s: s, s: s, s: s, s: s, s: s}",
         "id", playback->id,
         "media_uri", playback->media,
         "target_uri", playback->target,
         "language", playback->language,
         "state", state_to_string(playback->state));
   } else {
      json = ast_json_pack("{s: s, s: s, s: s, s: s, s: s, s: s}",
         "id", playback->id,
         "media_uri", playback->media,
         "next_media_uri", AST_VECTOR_GET(&playback->medias, playback->media_index + 1),
         "target_uri", playback->target,
         "language", playback->language,
         "state", state_to_string(playback->state));
   }

   return ast_json_ref(json);
}

typedef int (*playback_opreation_cb)(struct stasis_app_playback *playback);

static int playback_noop(struct stasis_app_playback *playback)
{
   return 0;
}

static int playback_cancel(struct stasis_app_playback *playback)
{
   SCOPED_AO2LOCK(lock, playback);
   playback->state = STASIS_PLAYBACK_STATE_CANCELED;
   return 0;
}

static int playback_stop(struct stasis_app_playback *playback)
{
   SCOPED_AO2LOCK(lock, playback);

   if (!playback->controllable) {
      return -1;
   }

   playback->state = STASIS_PLAYBACK_STATE_STOPPED;
   return stasis_app_control_queue_control(playback->control,
      AST_CONTROL_STREAM_STOP);
}

static int playback_restart(struct stasis_app_playback *playback)
{
   SCOPED_AO2LOCK(lock, playback);

   if (!playback->controllable) {
      return -1;
   }

   return stasis_app_control_queue_control(playback->control,
      AST_CONTROL_STREAM_RESTART);
}

static int playback_pause(struct stasis_app_playback *playback)
{
   SCOPED_AO2LOCK(lock, playback);

   if (!playback->controllable) {
      return -1;
   }

   playback->state = STASIS_PLAYBACK_STATE_PAUSED;
   playback_publish(playback);

   return stasis_app_control_queue_control(playback->control,
      AST_CONTROL_STREAM_SUSPEND);
}

static int playback_unpause(struct stasis_app_playback *playback)
{
   SCOPED_AO2LOCK(lock, playback);

   if (!playback->controllable) {
      return -1;
   }

   playback->state = STASIS_PLAYBACK_STATE_PLAYING;
   playback_publish(playback);

   return stasis_app_control_queue_control(playback->control,
      AST_CONTROL_STREAM_SUSPEND);
}

static int playback_reverse(struct stasis_app_playback *playback)
{
   SCOPED_AO2LOCK(lock, playback);

   if (!playback->controllable) {
      return -1;
   }

   return stasis_app_control_queue_control(playback->control,
      AST_CONTROL_STREAM_REVERSE);
}

static int playback_forward(struct stasis_app_playback *playback)
{
   SCOPED_AO2LOCK(lock, playback);

   if (!playback->controllable) {
      return -1;
   }

   return stasis_app_control_queue_control(playback->control,
      AST_CONTROL_STREAM_FORWARD);
}

/*!
 * \brief A sparse array detailing how commands should be handled in the
 * various playback states. Unset entries imply invalid operations.
 */
playback_opreation_cb operations[STASIS_PLAYBACK_STATE_MAX][STASIS_PLAYBACK_MEDIA_OP_MAX] = {
   [STASIS_PLAYBACK_STATE_QUEUED][STASIS_PLAYBACK_STOP] = playback_cancel,
   [STASIS_PLAYBACK_STATE_QUEUED][STASIS_PLAYBACK_RESTART] = playback_noop,

   [STASIS_PLAYBACK_STATE_PLAYING][STASIS_PLAYBACK_STOP] = playback_stop,
   [STASIS_PLAYBACK_STATE_PLAYING][STASIS_PLAYBACK_RESTART] = playback_restart,
   [STASIS_PLAYBACK_STATE_PLAYING][STASIS_PLAYBACK_PAUSE] = playback_pause,
   [STASIS_PLAYBACK_STATE_PLAYING][STASIS_PLAYBACK_UNPAUSE] = playback_noop,
   [STASIS_PLAYBACK_STATE_PLAYING][STASIS_PLAYBACK_REVERSE] = playback_reverse,
   [STASIS_PLAYBACK_STATE_PLAYING][STASIS_PLAYBACK_FORWARD] = playback_forward,

   [STASIS_PLAYBACK_STATE_CONTINUING][STASIS_PLAYBACK_STOP] = playback_stop,
   [STASIS_PLAYBACK_STATE_CONTINUING][STASIS_PLAYBACK_RESTART] = playback_restart,
   [STASIS_PLAYBACK_STATE_CONTINUING][STASIS_PLAYBACK_PAUSE] = playback_pause,
   [STASIS_PLAYBACK_STATE_CONTINUING][STASIS_PLAYBACK_UNPAUSE] = playback_noop,
   [STASIS_PLAYBACK_STATE_CONTINUING][STASIS_PLAYBACK_REVERSE] = playback_reverse,
   [STASIS_PLAYBACK_STATE_CONTINUING][STASIS_PLAYBACK_FORWARD] = playback_forward,

   [STASIS_PLAYBACK_STATE_PAUSED][STASIS_PLAYBACK_STOP] = playback_stop,
   [STASIS_PLAYBACK_STATE_PAUSED][STASIS_PLAYBACK_PAUSE] = playback_noop,
   [STASIS_PLAYBACK_STATE_PAUSED][STASIS_PLAYBACK_UNPAUSE] = playback_unpause,

   [STASIS_PLAYBACK_STATE_COMPLETE][STASIS_PLAYBACK_STOP] = playback_noop,
   [STASIS_PLAYBACK_STATE_CANCELED][STASIS_PLAYBACK_STOP] = playback_noop,
   [STASIS_PLAYBACK_STATE_STOPPED][STASIS_PLAYBACK_STOP] = playback_noop,
};

enum stasis_playback_oper_results stasis_app_playback_operation(
   struct stasis_app_playback *playback,
   enum stasis_app_playback_media_operation operation)
{
   playback_opreation_cb cb;
   SCOPED_AO2LOCK(lock, playback);

   ast_assert((unsigned int)playback->state < STASIS_PLAYBACK_STATE_MAX);

   if (operation >= STASIS_PLAYBACK_MEDIA_OP_MAX) {
      ast_log(LOG_ERROR, "Invalid playback operation %u\n", operation);
      return -1;
   }

   cb = operations[playback->state][operation];

   if (!cb) {
      if (playback->state != STASIS_PLAYBACK_STATE_PLAYING) {
         /* So we can be specific in our error message. */
         return STASIS_PLAYBACK_OPER_NOT_PLAYING;
      } else {
         /* And, really, all operations should be valid during
          * playback */
         ast_log(LOG_ERROR,
            "Unhandled operation during playback: %u\n",
            operation);
         return STASIS_PLAYBACK_OPER_FAILED;
      }
   }

   return cb(playback) ?
      STASIS_PLAYBACK_OPER_FAILED : STASIS_PLAYBACK_OPER_OK;
}

static int load_module(void)
{
   int r;

   r = STASIS_MESSAGE_TYPE_INIT(stasis_app_playback_snapshot_type);
   if (r != 0) {
      return AST_MODULE_LOAD_DECLINE;
   }

   playbacks = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, PLAYBACK_BUCKETS,
      playback_hash, NULL, playback_cmp);
   if (!playbacks) {
      STASIS_MESSAGE_TYPE_CLEANUP(stasis_app_playback_snapshot_type);
      return AST_MODULE_LOAD_DECLINE;
   }
   return AST_MODULE_LOAD_SUCCESS;
}

static int unload_module(void)
{
   ao2_cleanup(playbacks);
   playbacks = NULL;
   STASIS_MESSAGE_TYPE_CLEANUP(stasis_app_playback_snapshot_type);
   return 0;
}

AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS, "Stasis application playback support",
   .support_level = AST_MODULE_SUPPORT_CORE,
   .load = load_module,
   .unload = unload_module,
   .requires = "res_stasis,res_stasis_recording"
);