gstreamer/ext/openmpt/gstopenmptdec.c

/* GStreamer
 * Copyright (C) <2017> Carlos Rafael Giani <dv at pseudoterminal dot org>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */


/**
 * SECTION:element-openmptdec
 * @see_also: #GstOpenMptDec
 *
 * openmpdec decodes module music formats, such as S3M, MOD, XM, IT.
 * It uses the <ulink url="https://lib.openmpt.org">OpenMPT library</ulink>
 * for this purpose. It can be autoplugged and therefore works with decodebin.
 *
 * ## Example launch line
 *
 * |[
 * gst-launch-1.0 filesrc location=media/example.it ! openmptdec ! audioconvert ! audioresample ! autoaudiosink
 * ]|
 */


#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <gst/gst.h>

#include "gstopenmptdec.h"

#ifndef OPENMPT_API_VERSION_AT_LEAST
#define OPENMPT_API_VERSION_AT_LEAST(x, y, z) (FALSE)
#endif

GST_DEBUG_CATEGORY_STATIC (openmptdec_debug);
#define GST_CAT_DEFAULT openmptdec_debug


enum
{
  PROP_0,
  PROP_MASTER_GAIN,
  PROP_STEREO_SEPARATION,
  PROP_FILTER_LENGTH,
  PROP_VOLUME_RAMPING,
  PROP_OUTPUT_BUFFER_SIZE
};


#define DEFAULT_MASTER_GAIN 0
#define DEFAULT_STEREO_SEPARATION 100
#define DEFAULT_FILTER_LENGTH 0
#define DEFAULT_VOLUME_RAMPING -1
#define DEFAULT_OUTPUT_BUFFER_SIZE 1024

#define DEFAULT_SAMPLE_FORMAT GST_AUDIO_FORMAT_F32
#define DEFAULT_SAMPLE_RATE 48000
#define DEFAULT_NUM_CHANNELS 2



static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
    GST_PAD_SINK,
    GST_PAD_ALWAYS,
    GST_STATIC_CAPS ("audio/x-mod, "
        "type = (string) { 669, asylum-amf, dsmi-amf, extreme-ams, velvet-ams, "
        "dbm, digi, dmf, dsm, far, gdm, imf, it, j2b, mdl, med, mod, mt2, mtm, "
        "okt, psm, ptm, s3m, stm, ult, xm }")
    );

static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",
    GST_PAD_SRC,
    GST_PAD_ALWAYS,
    GST_STATIC_CAPS ("audio/x-raw, "
        "format = (string) { " GST_AUDIO_NE (S16) ", " GST_AUDIO_NE (F32) " }, "
        "layout = (string) interleaved, "
        "rate = (int) [ 1, 192000 ], " "channels = (int) { 1, 2, 4 } ")
    );



G_DEFINE_TYPE (GstOpenMptDec, gst_openmpt_dec,
    GST_TYPE_NONSTREAM_AUDIO_DECODER);



static void gst_openmpt_dec_finalize (GObject * object);

static void gst_openmpt_dec_set_property (GObject * object, guint prop_id,
    const GValue * value, GParamSpec * pspec);
static void gst_openmpt_dec_get_property (GObject * object, guint prop_id,
    GValue * value, GParamSpec * pspec);

static gboolean gst_openmpt_dec_seek (GstNonstreamAudioDecoder * dec,
    GstClockTime * new_position);
static GstClockTime gst_openmpt_dec_tell (GstNonstreamAudioDecoder * dec);

static void gst_openmpt_dec_log_func (char const *message, void *user);
static void gst_openmpt_dec_add_metadata_to_tag_list (GstOpenMptDec *
    openmpt_dec, GstTagList * tags, char const *key, gchar const *tag);
static gboolean gst_openmpt_dec_load_from_buffer (GstNonstreamAudioDecoder *
    dec, GstBuffer * source_data, guint initial_subsong,
    GstNonstreamAudioSubsongMode initial_subsong_mode,
    GstClockTime * initial_position,
    GstNonstreamAudioOutputMode * initial_output_mode,
    gint * initial_num_loops);

static GstTagList *gst_openmpt_dec_get_main_tags (GstNonstreamAudioDecoder *
    dec);

static gboolean gst_openmpt_dec_set_current_subsong (GstNonstreamAudioDecoder *
    dec, guint subsong, GstClockTime * initial_position);
static guint gst_openmpt_dec_get_current_subsong (GstNonstreamAudioDecoder *
    dec);

static guint gst_openmpt_dec_get_num_subsongs (GstNonstreamAudioDecoder * dec);
static GstClockTime
gst_openmpt_dec_get_subsong_duration (GstNonstreamAudioDecoder * dec,
    guint subsong);
static GstTagList *gst_openmpt_dec_get_subsong_tags (GstNonstreamAudioDecoder *
    dec, guint subsong);
static gboolean gst_openmpt_dec_set_subsong_mode (GstNonstreamAudioDecoder *
    dec, GstNonstreamAudioSubsongMode mode, GstClockTime * initial_position);

static gboolean gst_openmpt_dec_set_num_loops (GstNonstreamAudioDecoder * dec,
    gint num_loops);
static gint gst_openmpt_dec_get_num_loops (GstNonstreamAudioDecoder * dec);

static guint
gst_openmpt_dec_get_supported_output_modes (GstNonstreamAudioDecoder * dec);
static gboolean gst_openmpt_dec_decode (GstNonstreamAudioDecoder * dec,
    GstBuffer ** buffer, guint * num_samples);

static gboolean gst_openmpt_dec_select_subsong (GstOpenMptDec *
    openmpt_dec, GstNonstreamAudioSubsongMode subsong_mode,
    gint openmpt_subsong);


void
gst_openmpt_dec_class_init (GstOpenMptDecClass * klass)
{
  GObjectClass *object_class;
  GstElementClass *element_class;
  GstNonstreamAudioDecoderClass *dec_class;

  GST_DEBUG_CATEGORY_INIT (openmptdec_debug, "openmptdec", 0,
      "OpenMPT-based module music decoder");

  object_class = G_OBJECT_CLASS (klass);
  element_class = GST_ELEMENT_CLASS (klass);
  dec_class = GST_NONSTREAM_AUDIO_DECODER_CLASS (klass);

  gst_element_class_add_pad_template (element_class,
      gst_static_pad_template_get (&sink_template));
  gst_element_class_add_pad_template (element_class,
      gst_static_pad_template_get (&src_template));

  object_class->finalize = GST_DEBUG_FUNCPTR (gst_openmpt_dec_finalize);
  object_class->set_property = GST_DEBUG_FUNCPTR (gst_openmpt_dec_set_property);
  object_class->get_property = GST_DEBUG_FUNCPTR (gst_openmpt_dec_get_property);

  dec_class->seek = GST_DEBUG_FUNCPTR (gst_openmpt_dec_seek);
  dec_class->tell = GST_DEBUG_FUNCPTR (gst_openmpt_dec_tell);
  dec_class->load_from_buffer =
      GST_DEBUG_FUNCPTR (gst_openmpt_dec_load_from_buffer);
  dec_class->get_main_tags = GST_DEBUG_FUNCPTR (gst_openmpt_dec_get_main_tags);
  dec_class->set_num_loops = GST_DEBUG_FUNCPTR (gst_openmpt_dec_set_num_loops);
  dec_class->get_num_loops = GST_DEBUG_FUNCPTR (gst_openmpt_dec_get_num_loops);
  dec_class->get_supported_output_modes =
      GST_DEBUG_FUNCPTR (gst_openmpt_dec_get_supported_output_modes);
  dec_class->decode = GST_DEBUG_FUNCPTR (gst_openmpt_dec_decode);
  dec_class->set_current_subsong =
      GST_DEBUG_FUNCPTR (gst_openmpt_dec_set_current_subsong);
  dec_class->get_current_subsong =
      GST_DEBUG_FUNCPTR (gst_openmpt_dec_get_current_subsong);
  dec_class->get_num_subsongs =
      GST_DEBUG_FUNCPTR (gst_openmpt_dec_get_num_subsongs);
  dec_class->get_subsong_duration =
      GST_DEBUG_FUNCPTR (gst_openmpt_dec_get_subsong_duration);
  dec_class->get_subsong_tags =
      GST_DEBUG_FUNCPTR (gst_openmpt_dec_get_subsong_tags);
  dec_class->set_subsong_mode =
      GST_DEBUG_FUNCPTR (gst_openmpt_dec_set_subsong_mode);

  gst_element_class_set_static_metadata (element_class,
      "OpenMPT-based module music decoder",
      "Codec/Decoder/Audio",
      "Decoders module files (MOD/S3M/XM/IT/MTM/...) using OpenMPT",
      "Carlos Rafael Giani <dv@pseudoterminal.org>");

  g_object_class_install_property (object_class,
      PROP_MASTER_GAIN,
      g_param_spec_int ("master-gain",
          "Master gain",
          "Gain to apply to the playback, in millibel",
          -G_MAXINT, G_MAXINT,
          DEFAULT_MASTER_GAIN, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
      );
  g_object_class_install_property (object_class,
      PROP_STEREO_SEPARATION,
      g_param_spec_int ("stereo-separation",
          "Stereo separation",
          "Degree of separation for stereo channels, in percent",
          0, 400,
          DEFAULT_STEREO_SEPARATION, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
      );
  g_object_class_install_property (object_class,
      PROP_FILTER_LENGTH,
      g_param_spec_int ("filter-length",
          "Filter length",
          "Length of interpolation filter to use for the samples (0 = internal default)",
          0, 8,
          DEFAULT_FILTER_LENGTH, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
      );
  g_object_class_install_property (object_class,
      PROP_VOLUME_RAMPING,
      g_param_spec_int ("volume-ramping",
          "Volume ramping",
          "Volume ramping strength; higher value -> slower ramping (-1 = internal default)",
          -1, 10,
          DEFAULT_VOLUME_RAMPING, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
      );
  /* 4*4 => quad output with F32 samples; this ensures that no overflow can happen */
  g_object_class_install_property (object_class,
      PROP_OUTPUT_BUFFER_SIZE,
      g_param_spec_uint ("output-buffer-size",
          "Output buffer size",
          "Size of each output buffer, in samples (actual size can be smaller "
          "than this during flush or EOS)",
          1, G_MAXUINT / (4 * 4),
          DEFAULT_OUTPUT_BUFFER_SIZE,
          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
      );
}


void
gst_openmpt_dec_init (GstOpenMptDec * openmpt_dec)
{
  openmpt_dec->mod = NULL;

  openmpt_dec->cur_subsong = 0;
  openmpt_dec->num_subsongs = 0;
  openmpt_dec->subsong_durations = NULL;

  openmpt_dec->num_loops = 0;

  openmpt_dec->master_gain = DEFAULT_MASTER_GAIN;
  openmpt_dec->stereo_separation = DEFAULT_STEREO_SEPARATION;
  openmpt_dec->filter_length = DEFAULT_FILTER_LENGTH;
  openmpt_dec->volume_ramping = DEFAULT_VOLUME_RAMPING;

  openmpt_dec->output_buffer_size = DEFAULT_OUTPUT_BUFFER_SIZE;

  openmpt_dec->main_tags = NULL;

  openmpt_dec->sample_format = DEFAULT_SAMPLE_FORMAT;
  openmpt_dec->sample_rate = DEFAULT_SAMPLE_RATE;
  openmpt_dec->num_channels = DEFAULT_NUM_CHANNELS;
}


static void
gst_openmpt_dec_finalize (GObject * object)
{
  GstOpenMptDec *openmpt_dec;

  g_return_if_fail (GST_IS_OPENMPT_DEC (object));
  openmpt_dec = GST_OPENMPT_DEC (object);

  if (openmpt_dec->main_tags != NULL)
    gst_tag_list_unref (openmpt_dec->main_tags);

  if (openmpt_dec->mod != NULL)
    openmpt_module_destroy (openmpt_dec->mod);

  g_free (openmpt_dec->subsong_durations);

  G_OBJECT_CLASS (gst_openmpt_dec_parent_class)->finalize (object);
}


static void
gst_openmpt_dec_set_property (GObject * object, guint prop_id,
    const GValue * value, GParamSpec * pspec)
{
  GstNonstreamAudioDecoder *dec;
  GstOpenMptDec *openmpt_dec;

  dec = GST_NONSTREAM_AUDIO_DECODER (object);
  openmpt_dec = GST_OPENMPT_DEC (object);

  switch (prop_id) {
    case PROP_MASTER_GAIN:
    {
      GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (dec);
      openmpt_dec->master_gain = g_value_get_int (value);
      if (openmpt_dec->mod != NULL)
        openmpt_module_set_render_param (openmpt_dec->mod,
            OPENMPT_MODULE_RENDER_MASTERGAIN_MILLIBEL,
            openmpt_dec->master_gain);
      GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
      break;
    }

    case PROP_STEREO_SEPARATION:
    {
      GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (dec);
      openmpt_dec->stereo_separation = g_value_get_int (value);
      if (openmpt_dec->mod != NULL)
        openmpt_module_set_render_param (openmpt_dec->mod,
            OPENMPT_MODULE_RENDER_STEREOSEPARATION_PERCENT,
            openmpt_dec->stereo_separation);
      GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
      break;
    }

    case PROP_FILTER_LENGTH:
    {
      GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (dec);
      openmpt_dec->filter_length = g_value_get_int (value);
      if (openmpt_dec->mod != NULL)
        openmpt_module_set_render_param (openmpt_dec->mod,
            OPENMPT_MODULE_RENDER_INTERPOLATIONFILTER_LENGTH,
            openmpt_dec->filter_length);
      GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
      break;
    }

    case PROP_VOLUME_RAMPING:
    {
      GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (dec);
      openmpt_dec->volume_ramping = g_value_get_int (value);
      if (openmpt_dec->mod != NULL)
        openmpt_module_set_render_param (openmpt_dec->mod,
            OPENMPT_MODULE_RENDER_VOLUMERAMPING_STRENGTH,
            openmpt_dec->volume_ramping);
      GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
      break;
    }

    case PROP_OUTPUT_BUFFER_SIZE:
    {
      GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (dec);
      openmpt_dec->output_buffer_size = g_value_get_uint (value);
      GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
      break;
    }

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}


static void
gst_openmpt_dec_get_property (GObject * object, guint prop_id, GValue * value,
    GParamSpec * pspec)
{
  GstOpenMptDec *openmpt_dec = GST_OPENMPT_DEC (object);

  switch (prop_id) {
    case PROP_MASTER_GAIN:
    {
      GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (object);
      g_value_set_int (value, openmpt_dec->master_gain);
      GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (object);
      break;
    }

    case PROP_STEREO_SEPARATION:
    {
      GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (object);
      g_value_set_int (value, openmpt_dec->stereo_separation);
      GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (object);
      break;
    }

    case PROP_FILTER_LENGTH:
    {
      GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (object);
      g_value_set_int (value, openmpt_dec->filter_length);
      GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (object);
      break;
    }

    case PROP_VOLUME_RAMPING:
    {
      GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (object);
      g_value_set_int (value, openmpt_dec->volume_ramping);
      GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (object);
      break;
    }

    case PROP_OUTPUT_BUFFER_SIZE:
    {
      GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (object);
      g_value_set_uint (value, openmpt_dec->output_buffer_size);
      GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (object);
      break;
    }

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}


static gboolean
gst_openmpt_dec_seek (GstNonstreamAudioDecoder * dec,
    GstClockTime * new_position)
{
  GstOpenMptDec *openmpt_dec = GST_OPENMPT_DEC (dec);
  g_return_val_if_fail (openmpt_dec->mod != NULL, FALSE);

  openmpt_module_set_position_seconds (openmpt_dec->mod,
      (double) (*new_position) / GST_SECOND);
  *new_position = gst_openmpt_dec_tell (dec);

  return TRUE;
}


static GstClockTime
gst_openmpt_dec_tell (GstNonstreamAudioDecoder * dec)
{
  GstOpenMptDec *openmpt_dec = GST_OPENMPT_DEC (dec);
  g_return_val_if_fail (openmpt_dec->mod != NULL, GST_CLOCK_TIME_NONE);

  return (GstClockTime) (openmpt_module_get_position_seconds (openmpt_dec->mod)
      * GST_SECOND);
}


static void
gst_openmpt_dec_log_func (char const *message, void *user)
{
  GST_LOG_OBJECT (GST_OBJECT (user), "%s", message);
}


static void
gst_openmpt_dec_add_metadata_to_tag_list (GstOpenMptDec * openmpt_dec,
    GstTagList * tags, char const *key, gchar const *tag)
{
  char const *metadata = openmpt_module_get_metadata (openmpt_dec->mod, key);

  if (metadata && *metadata) {
    GST_DEBUG_OBJECT (openmpt_dec,
        "adding metadata \"%s\" with key \"%s\" to tag list as tag \"%s\"",
        metadata, key, tag);

    if (g_strcmp0 (tag, GST_TAG_DATE_TIME) == 0) {
      /* Special handling for date-time tags - interpret the
       * metadata string as an iso8601 string and convert it
       * to a GstDateTime value, since this is the data type
       * that GST_TAG_DATE_TIME expects. */

      GstDateTime *date_time = gst_date_time_new_from_iso8601_string (metadata);
      if (date_time) {
        GST_DEBUG_OBJECT (openmpt_dec,
            "successfully created date-time object out of iso8601 string");
        gst_tag_list_add (tags, GST_TAG_MERGE_REPLACE, tag, date_time, NULL);
        gst_date_time_unref (date_time);
      } else
        GST_WARNING_OBJECT (openmpt_dec,
            "could not create date-time object out of iso8601 string - not adding metadata to tags");
    } else {
      /* Default handling - just insert the metadata string as-is */
      gst_tag_list_add (tags, GST_TAG_MERGE_REPLACE, tag, metadata, NULL);
    }
  } else
    GST_DEBUG_OBJECT (openmpt_dec,
        "attempted to add metadata with key \"%s\" to tag list as tag \"%s\", but none exists",
        key, tag);

  if (metadata)
    openmpt_free_string (metadata);
}


static gboolean
gst_openmpt_dec_load_from_buffer (GstNonstreamAudioDecoder * dec,
    GstBuffer * source_data, guint initial_subsong,
    GstNonstreamAudioSubsongMode initial_subsong_mode,
    GstClockTime * initial_position,
    GstNonstreamAudioOutputMode * initial_output_mode, gint * initial_num_loops)
{
  GstMapInfo map;
  GstOpenMptDec *openmpt_dec;

  openmpt_dec = GST_OPENMPT_DEC (dec);

  /* First, determine the sample rate, channel count, and sample format to use */
  openmpt_dec->sample_format = DEFAULT_SAMPLE_FORMAT;
  openmpt_dec->sample_rate = DEFAULT_SAMPLE_RATE;
  openmpt_dec->num_channels = DEFAULT_NUM_CHANNELS;
  gst_nonstream_audio_decoder_get_downstream_info (dec,
      &(openmpt_dec->sample_format), &(openmpt_dec->sample_rate),
      &(openmpt_dec->num_channels));

  /* Set output format */
  if (!gst_nonstream_audio_decoder_set_output_format_simple (dec,
          openmpt_dec->sample_rate,
          openmpt_dec->sample_format, openmpt_dec->num_channels))
    return FALSE;

  /* Pass the module data to OpenMPT for loading */
  gst_buffer_map (source_data, &map, GST_MAP_READ);
#if OPENMPT_API_VERSION_AT_LEAST(0,3,0)
  openmpt_dec->mod =
      openmpt_module_create_from_memory2 (map.data, map.size,
      gst_openmpt_dec_log_func, dec, NULL, NULL, NULL, NULL, NULL);
#else
  openmpt_dec->mod =
      openmpt_module_create_from_memory (map.data, map.size,
      gst_openmpt_dec_log_func, dec, NULL);
#endif
  gst_buffer_unmap (source_data, &map);

  if (openmpt_dec->mod == NULL) {
    GST_ERROR_OBJECT (dec, "loading module failed");
    return FALSE;
  }

  /* Copy subsong states */
  openmpt_dec->cur_subsong = initial_subsong;
  openmpt_dec->cur_subsong_mode = initial_subsong_mode;

  /* Query the number of subsongs available for logging and for checking
   * the initial subsong index */
  openmpt_dec->num_subsongs =
      openmpt_module_get_num_subsongs (openmpt_dec->mod);
  if (G_UNLIKELY (initial_subsong >= openmpt_dec->num_subsongs)) {
    GST_WARNING_OBJECT (openmpt_dec,
        "initial subsong %u out of bounds (there are %u subsongs) - setting it to 0",
        initial_subsong, openmpt_dec->num_subsongs);
    initial_subsong = 0;
  }
  GST_INFO_OBJECT (openmpt_dec, "%d subsong(s) available",
      openmpt_dec->num_subsongs);

  /* Query the OpenMPT default subsong (can be -1)
   * The default subsong is the one that is initially selected, so we
   * need to query it here, *before* any openmpt_module_select_subsong()
   * calls are done */
  {
    gchar const *subsong_cstr =
        openmpt_module_ctl_get (openmpt_dec->mod, "subsong");
    gchar *endptr;

    if (subsong_cstr != NULL) {
      openmpt_dec->default_openmpt_subsong =
          g_ascii_strtoll (subsong_cstr, &endptr, 10);
      if (subsong_cstr == endptr) {
        GST_WARNING_OBJECT (openmpt_dec,
            "could not convert ctl string \"%s\" to subsong index - using default OpenMPT index -1 instead",
            subsong_cstr);
        openmpt_dec->default_openmpt_subsong = -1;
      } else
        GST_DEBUG_OBJECT (openmpt_dec, "default OpenMPT subsong index is %d",
            openmpt_dec->default_openmpt_subsong);

      openmpt_free_string (subsong_cstr);
    } else {
      GST_INFO_OBJECT (openmpt_dec,
          "could not get subsong ctl string - using default OpenMPT index -1 instead");
      openmpt_dec->default_openmpt_subsong = -1;
    }
  }

  /* Seek to initial position */
  if (*initial_position != 0) {
    openmpt_module_set_position_seconds (openmpt_dec->mod,
        (double) (*initial_position) / GST_SECOND);
    *initial_position =
        (GstClockTime) (openmpt_module_get_position_seconds (openmpt_dec->mod) *
        GST_SECOND);
  }

  /* LOOPING output mode is not supported */
  *initial_output_mode = GST_NONSTREAM_AUDIO_OUTPUT_MODE_STEADY;

  /* Query the durations of each subsong (if any exist) */
  if (openmpt_dec->num_subsongs > 0) {
    guint i;

    openmpt_dec->subsong_durations =
        g_try_malloc (openmpt_dec->num_subsongs * sizeof (double));
    if (openmpt_dec->subsong_durations == NULL) {
      GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
      GST_ELEMENT_ERROR (openmpt_dec, RESOURCE, NO_SPACE_LEFT,
          ("could not allocate memory for subsong duration array"), (NULL));
      GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (dec);
      return FALSE;
    }

    for (i = 0; i < openmpt_dec->num_subsongs; ++i) {
      openmpt_module_select_subsong (openmpt_dec->mod, i);
      openmpt_dec->subsong_durations[i] =
          openmpt_module_get_duration_seconds (openmpt_dec->mod);
    }
  }

  /* Select the initial subsong */
  gst_openmpt_dec_select_subsong (openmpt_dec, initial_subsong_mode,
      initial_subsong);

  /* Set the number of loops, and query the actual number
   * that was chosen by OpenMPT */
  {
    int32_t actual_repeat_count;
    openmpt_module_set_repeat_count (openmpt_dec->mod, *initial_num_loops);
    actual_repeat_count = openmpt_module_get_repeat_count (openmpt_dec->mod);

    if (actual_repeat_count != *initial_num_loops) {
      GST_DEBUG_OBJECT (openmpt_dec,
          "requested num-loops value %d differs from actual value %d",
          *initial_num_loops, actual_repeat_count);
      *initial_num_loops = actual_repeat_count;
    }
  }

  /* Set render parameters (adjustable via properties) */
  openmpt_module_set_render_param (openmpt_dec->mod,
      OPENMPT_MODULE_RENDER_MASTERGAIN_MILLIBEL, openmpt_dec->master_gain);
  openmpt_module_set_render_param (openmpt_dec->mod,
      OPENMPT_MODULE_RENDER_STEREOSEPARATION_PERCENT,
      openmpt_dec->stereo_separation);
  openmpt_module_set_render_param (openmpt_dec->mod,
      OPENMPT_MODULE_RENDER_INTERPOLATIONFILTER_LENGTH,
      openmpt_dec->filter_length);
  openmpt_module_set_render_param (openmpt_dec->mod,
      OPENMPT_MODULE_RENDER_VOLUMERAMPING_STRENGTH,
      openmpt_dec->volume_ramping);

  /* Log the available metadata keys, and produce a
   * tag list if any keys are available */
  {
    char const *metadata_keys =
        openmpt_module_get_metadata_keys (openmpt_dec->mod);
    if (metadata_keys != NULL) {
      GstTagList *tags = gst_tag_list_new_empty ();

      GST_DEBUG_OBJECT (dec, "metadata keys: [%s]", metadata_keys);
      openmpt_free_string (metadata_keys);

      gst_openmpt_dec_add_metadata_to_tag_list (openmpt_dec, tags, "title",
          GST_TAG_TITLE);
      gst_openmpt_dec_add_metadata_to_tag_list (openmpt_dec, tags, "artist",
          GST_TAG_ARTIST);
      gst_openmpt_dec_add_metadata_to_tag_list (openmpt_dec, tags, "message",
          GST_TAG_COMMENT);
      gst_openmpt_dec_add_metadata_to_tag_list (openmpt_dec, tags, "tracker",
          GST_TAG_APPLICATION_NAME);
      gst_openmpt_dec_add_metadata_to_tag_list (openmpt_dec, tags, "type_long",
          GST_TAG_CODEC);
      gst_openmpt_dec_add_metadata_to_tag_list (openmpt_dec, tags, "date",
          GST_TAG_DATE_TIME);
      gst_openmpt_dec_add_metadata_to_tag_list (openmpt_dec, tags,
          "container_long", GST_TAG_CONTAINER_FORMAT);

      openmpt_dec->main_tags = tags;
    } else {
      GST_DEBUG_OBJECT (dec,
          "no metadata keys found - not producing a tag list");
    }
  }

  /* Log any warnings that were produced by OpenMPT while loading */
  {
    char const *warnings =
        openmpt_module_get_metadata (openmpt_dec->mod, "warnings");
    if (warnings) {
      if (*warnings)
        GST_WARNING_OBJECT (openmpt_dec, "reported warnings during loading: %s",
            warnings);
      openmpt_free_string (warnings);
    }
  }

  return TRUE;
}


static GstTagList *
gst_openmpt_dec_get_main_tags (GstNonstreamAudioDecoder * dec)
{
  GstOpenMptDec *openmpt_dec = GST_OPENMPT_DEC (dec);
  return gst_tag_list_ref (openmpt_dec->main_tags);
}


static gboolean
gst_openmpt_dec_set_current_subsong (GstNonstreamAudioDecoder * dec,
    guint subsong, GstClockTime * initial_position)
{
  GstOpenMptDec *openmpt_dec = GST_OPENMPT_DEC (dec);
  g_return_val_if_fail (openmpt_dec->mod != NULL, FALSE);

  if (gst_openmpt_dec_select_subsong (openmpt_dec,
          openmpt_dec->cur_subsong_mode, subsong)) {
    GST_DEBUG_OBJECT (openmpt_dec,
        "selected subsong %u and switching subsong mode to SINGLE", subsong);
    openmpt_dec->cur_subsong_mode = GST_NONSTREAM_AUDIO_SUBSONG_MODE_SINGLE;
    openmpt_dec->cur_subsong = subsong;
    *initial_position = 0;
    return TRUE;
  } else {
    GST_ERROR_OBJECT (openmpt_dec, "could not select subsong %u", subsong);
    return FALSE;
  }
}


static guint
gst_openmpt_dec_get_current_subsong (GstNonstreamAudioDecoder * dec)
{
  GstOpenMptDec *openmpt_dec = GST_OPENMPT_DEC (dec);
  return openmpt_dec->cur_subsong;
}


static guint
gst_openmpt_dec_get_num_subsongs (GstNonstreamAudioDecoder * dec)
{
  GstOpenMptDec *openmpt_dec = GST_OPENMPT_DEC (dec);
  return openmpt_dec->num_subsongs;
}


static GstClockTime
gst_openmpt_dec_get_subsong_duration (GstNonstreamAudioDecoder * dec,
    guint subsong)
{
  GstOpenMptDec *openmpt_dec = GST_OPENMPT_DEC (dec);
  return (GstClockTime) (openmpt_dec->subsong_durations[subsong] * GST_SECOND);
}


static GstTagList *
gst_openmpt_dec_get_subsong_tags (GstNonstreamAudioDecoder * dec, guint subsong)
{
  GstOpenMptDec *openmpt_dec;
  char const *name;

  openmpt_dec = GST_OPENMPT_DEC (dec);

  name = openmpt_module_get_subsong_name (openmpt_dec->mod, subsong);
  if (name != NULL) {
    GstTagList *tags = NULL;

    if (*name) {
      tags = gst_tag_list_new_empty ();
      gst_tag_list_add (tags, GST_TAG_MERGE_REPLACE, "title", name, NULL);
    }

    openmpt_free_string (name);

    return tags;
  } else
    return NULL;
}


static gboolean
gst_openmpt_dec_set_subsong_mode (GstNonstreamAudioDecoder * dec,
    GstNonstreamAudioSubsongMode mode, GstClockTime * initial_position)
{
  GstOpenMptDec *openmpt_dec = GST_OPENMPT_DEC (dec);
  g_return_val_if_fail (openmpt_dec->mod != NULL, FALSE);

  if (gst_openmpt_dec_select_subsong (openmpt_dec, mode,
          openmpt_dec->cur_subsong)) {
    GST_DEBUG_OBJECT (openmpt_dec, "set subsong mode");
    openmpt_dec->cur_subsong_mode = mode;
    *initial_position = 0;
    return TRUE;
  } else {
    GST_ERROR_OBJECT (openmpt_dec, "could not set subsong mode");
    return FALSE;
  }
}


static gboolean
gst_openmpt_dec_set_num_loops (GstNonstreamAudioDecoder * dec, gint num_loops)
{
  GstOpenMptDec *openmpt_dec = GST_OPENMPT_DEC (dec);
  openmpt_dec->num_loops = num_loops;

  if (openmpt_dec->mod != NULL) {
    if (openmpt_module_set_repeat_count (openmpt_dec->mod, num_loops)) {
      GST_DEBUG_OBJECT (openmpt_dec, "successfully set repeat count %d",
          num_loops);
      return TRUE;
    } else {
      GST_ERROR_OBJECT (openmpt_dec, "could not set repeat count %d",
          num_loops);
      return FALSE;
    }
  } else
    return TRUE;
}


static gint
gst_openmpt_dec_get_num_loops (GstNonstreamAudioDecoder * dec)
{
  GstOpenMptDec *openmpt_dec = GST_OPENMPT_DEC (dec);
  return openmpt_dec->num_loops;
}


static guint
gst_openmpt_dec_get_supported_output_modes (G_GNUC_UNUSED
    GstNonstreamAudioDecoder * dec)
{
  return 1u << GST_NONSTREAM_AUDIO_OUTPUT_MODE_STEADY;
}


static gboolean
gst_openmpt_dec_decode (GstNonstreamAudioDecoder * dec, GstBuffer ** buffer,
    guint * num_samples)
{
  GstOpenMptDec *openmpt_dec;
  GstBuffer *outbuf;
  GstMapInfo map;
  size_t num_read_samples;
  gsize outbuf_size;
  GstAudioFormatInfo const *fmt_info;

  openmpt_dec = GST_OPENMPT_DEC (dec);

  fmt_info = gst_audio_format_get_info (openmpt_dec->sample_format);

  /* Allocate output buffer */
  outbuf_size =
      openmpt_dec->output_buffer_size * (fmt_info->width / 8) *
      openmpt_dec->num_channels;
  outbuf =
      gst_nonstream_audio_decoder_allocate_output_buffer (dec, outbuf_size);
  if (G_UNLIKELY (outbuf == NULL))
    return FALSE;

  /* Write samples into the output buffer */

  gst_buffer_map (outbuf, &map, GST_MAP_WRITE);

  switch (openmpt_dec->sample_format) {
    case GST_AUDIO_FORMAT_S16:
    {
      int16_t *out_samples = (int16_t *) (map.data);
      switch (openmpt_dec->num_channels) {
        case 1:
          num_read_samples =
              openmpt_module_read_mono (openmpt_dec->mod,
              openmpt_dec->sample_rate, openmpt_dec->output_buffer_size,
              out_samples);
          break;
        case 2:
          num_read_samples =
              openmpt_module_read_interleaved_stereo (openmpt_dec->mod,
              openmpt_dec->sample_rate, openmpt_dec->output_buffer_size,
              out_samples);
          break;
        case 4:
          num_read_samples =
              openmpt_module_read_interleaved_quad (openmpt_dec->mod,
              openmpt_dec->sample_rate, openmpt_dec->output_buffer_size,
              out_samples);
          break;
        default:
          g_assert_not_reached ();
      }
      break;
    }
    case GST_AUDIO_FORMAT_F32:
    {
      float *out_samples = (float *) (map.data);
      switch (openmpt_dec->num_channels) {
        case 1:
          num_read_samples =
              openmpt_module_read_float_mono (openmpt_dec->mod,
              openmpt_dec->sample_rate, openmpt_dec->output_buffer_size,
              out_samples);
          break;
        case 2:
          num_read_samples =
              openmpt_module_read_interleaved_float_stereo (openmpt_dec->mod,
              openmpt_dec->sample_rate, openmpt_dec->output_buffer_size,
              out_samples);
          break;
        case 4:
          num_read_samples =
              openmpt_module_read_interleaved_float_quad (openmpt_dec->mod,
              openmpt_dec->sample_rate, openmpt_dec->output_buffer_size,
              out_samples);
          break;
        default:
          g_assert_not_reached ();
      }
      break;
    }
    default:
    {
      GST_ERROR_OBJECT (dec, "using unsupported sample format %s",
          fmt_info->name);
      g_assert_not_reached ();
    }
  }

  gst_buffer_unmap (outbuf, &map);

  if (num_read_samples == 0)
    return FALSE;

  *buffer = outbuf;
  *num_samples = num_read_samples;

  return TRUE;
}


static gboolean
gst_openmpt_dec_select_subsong (GstOpenMptDec * openmpt_dec,
    GstNonstreamAudioSubsongMode subsong_mode, gint openmpt_subsong)
{
  switch (subsong_mode) {
    case GST_NONSTREAM_AUDIO_SUBSONG_MODE_SINGLE:
      GST_DEBUG_OBJECT (openmpt_dec, "setting subsong mode to SINGLE");
      return openmpt_module_select_subsong (openmpt_dec->mod, openmpt_subsong);

    case GST_NONSTREAM_AUDIO_SUBSONG_MODE_ALL:
      GST_DEBUG_OBJECT (openmpt_dec, "setting subsong mode to ALL");
      return openmpt_module_select_subsong (openmpt_dec->mod, -1);

    case GST_NONSTREAM_AUDIO_SUBSONG_MODE_DECODER_DEFAULT:
      /* NOTE: The OpenMPT documentation recommends to not bother
       * calling openmpt_module_select_subsong() if the decoder
       * default shall be used. However, the user might have switched
       * the subsong mode from SINGLE or ALL to DECODER_DEFAULT,
       * in which case we *do* have to set the default subsong index.
       * So, just set the default index here. */
      GST_DEBUG_OBJECT (openmpt_dec, "setting subsong mode to DECODER_DEFAULT");
      return openmpt_module_select_subsong (openmpt_dec->mod,
          openmpt_dec->default_openmpt_subsong);

    default:
      g_assert_not_reached ();
      return TRUE;
  }
}