/* GStreamer

 * Copyright (C) 2001 CodeFactory AB

 * Copyright (C) 2001 Thomas Nyberg <thomas@codefactory.se>

 * Copyright (C) 2001-2002 Andy Wingo <apwingo@eos.ncsu.edu>

 * Copyright (C) 2003 Benjamin Otte <in7y118@public.uni-hamburg.de>

 * Copyright (C) 2005 Wim Taymans <wim@fluendo.com>

 * Copyright (C) 2005, 2006 Tim-Philipp Müller <tim centricular net>

 * Copyright (C) 2008 Matthias Kretz <kretz@kde.org>

 *

 * gstalsasink2.c:

 *

 * 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 Lesser General Public 

 *  License along with this library.  If not, see <http://www.gnu.org/licenses/>.

 */

/**

 * SECTION:element-alsasink2

 * @short_description: play audio to an ALSA device

 * @see_also: alsasrc, alsamixer

 *

 * <refsect2>

 * <para>

 * This element renders raw audio samples using the ALSA api.

 * </para>

 * <title>Example pipelines</title>

 * <para>

 * Play an Ogg/Vorbis file.

 * </para>

 * <programlisting>

 * gst-launch -v filesrc location=sine.ogg ! oggdemux ! vorbisdec ! audioconvert ! audioresample ! alsasink2

 * </programlisting>

 * </refsect2>

 *

 * Last reviewed on 2006-03-01 (0.10.4)

 */

#define _XOPEN_SOURCE 600

#include <sys/ioctl.h>

#include <fcntl.h>

#include <errno.h>

#include <unistd.h>

#include <string.h>

#include <getopt.h>

#include <alsa/asoundlib.h>

#include "alsasink2.h"

#include <gst/interfaces/propertyprobe.h>

#include <gst/audio/multichannel.h>

#define _(text) (text)

#define GST_CHECK_ALSA_VERSION(major,minor,micro) \

    (SND_LIB_MAJOR > (major) || \

     (SND_LIB_MAJOR == (major) && SND_LIB_MINOR > (minor)) || \

     (SND_LIB_MAJOR == (major) && SND_LIB_MINOR == (minor) && \

      SND_LIB_SUBMINOR >= (micro)))

static const GList *

gst_alsa_device_property_probe_get_properties (GstPropertyProbe * probe)

{

  GObjectClass *klass = G_OBJECT_GET_CLASS (probe);

  static GList *list = NULL;

  /* well, not perfect, but better than no locking at all.

   * In the worst case we leak a list node, so who cares? */

  GST_CLASS_LOCK (GST_OBJECT_CLASS (klass));

  if (!list) {

    GParamSpec *pspec;

    pspec = g_object_class_find_property (klass, "device");

    list = g_list_append (NULL, pspec);

  }

  GST_CLASS_UNLOCK (GST_OBJECT_CLASS (klass));

  return list;

}

static GList *

gst_alsa_get_device_list (snd_pcm_stream_t stream)

{

  snd_ctl_t *handle;

  int card, err, dev;

  snd_ctl_card_info_t *info;

  snd_pcm_info_t *pcminfo;

  gboolean mixer = (stream == ~0u);

  GList *list = NULL;

  if (stream == ~0u)

    stream = 0;

  snd_ctl_card_info_malloc (&info);

  snd_pcm_info_malloc (&pcminfo);

  card = -1;

  if (snd_card_next (&card) < 0 || card < 0) {

    /* no soundcard found */

    return NULL;

  }

  while (card >= 0) {

    gchar name[32];

    g_snprintf (name, sizeof (name), "hw:%d", card);

    if ((err = snd_ctl_open (&handle, name, 0)) < 0) {

      goto next_card;

    }

    if ((err = snd_ctl_card_info (handle, info)) < 0) {

      snd_ctl_close (handle);

      goto next_card;

    }

    if (mixer) {

      list = g_list_append (list, g_strdup (name));

    } else {

      g_snprintf (name, sizeof (name), "default:CARD=%d", card);

      list = g_list_append (list, g_strdup (name));

      dev = -1;

      while (1) {

        gchar *gst_device;

        snd_ctl_pcm_next_device (handle, &dev);

        if (dev < 0)

          break;

        snd_pcm_info_set_device (pcminfo, dev);

        snd_pcm_info_set_subdevice (pcminfo, 0);

        snd_pcm_info_set_stream (pcminfo, stream);

        if ((err = snd_ctl_pcm_info (handle, pcminfo)) < 0) {

          continue;

        }

        gst_device = g_strdup_printf ("hw:%d,%d", card, dev);

        list = g_list_append (list, gst_device);

      }

    }

    snd_ctl_close (handle);

  next_card:

    if (snd_card_next (&card) < 0) {

      break;

    }

  }

  snd_ctl_card_info_free (info);

  snd_pcm_info_free (pcminfo);

  return list;

}

static void

gst_alsa_device_property_probe_probe_property (GstPropertyProbe * probe,

    guint prop_id, const GParamSpec * pspec)

{

  if (!g_str_equal (pspec->name, "device")) {

    G_OBJECT_WARN_INVALID_PROPERTY_ID (probe, prop_id, pspec);

  }

}

static gboolean

gst_alsa_device_property_probe_needs_probe (GstPropertyProbe * probe,

    guint prop_id, const GParamSpec * pspec)

{

  /* don't cache probed data */

  return TRUE;

}

static GValueArray *

gst_alsa_device_property_probe_get_values (GstPropertyProbe * probe,

    guint prop_id, const GParamSpec * pspec)

{

  GstElementClass *klass;

  const GList *templates;

  snd_pcm_stream_t mode = -1;

  GValueArray *array;

  GValue value = { 0, };

  GList *l, *list;

  if (!g_str_equal (pspec->name, "device")) {

    G_OBJECT_WARN_INVALID_PROPERTY_ID (probe, prop_id, pspec);

    return NULL;

  }

  klass = GST_ELEMENT_GET_CLASS (GST_ELEMENT (probe));

  /* I'm pretty sure ALSA has a good way to do this. However, their cool

   * auto-generated documentation is pretty much useless if you try to

   * do function-wise look-ups. */

  /* we assume one pad template at max [zero=mixer] */

  templates = gst_element_class_get_pad_template_list (klass);

  if (templates) {

    if (GST_PAD_TEMPLATE_DIRECTION (templates->data) == GST_PAD_SRC)

      mode = SND_PCM_STREAM_CAPTURE;

    else

      mode = SND_PCM_STREAM_PLAYBACK;

  }

  list = gst_alsa_get_device_list (mode);

  if (list == NULL) {

    GST_LOG_OBJECT (probe, "No devices found");

    return NULL;

  }

  array = g_value_array_new (g_list_length (list));

  g_value_init (&value, G_TYPE_STRING);

  for (l = list; l != NULL; l = l->next) {

    GST_LOG_OBJECT (probe, "Found device: %s", (gchar *) l->data);

    g_value_take_string (&value, (gchar *) l->data);

    l->data = NULL;

    g_value_array_append (array, &value);

  }

  g_value_unset (&value);

  g_list_free (list);

  return array;

}

static void

gst_alsa_property_probe_interface_init (GstPropertyProbeInterface * iface)

{

  iface->get_properties = gst_alsa_device_property_probe_get_properties;

  iface->probe_property = gst_alsa_device_property_probe_probe_property;

  iface->needs_probe = gst_alsa_device_property_probe_needs_probe;

  iface->get_values = gst_alsa_device_property_probe_get_values;

}

static void

gst_alsa_type_add_device_property_probe_interface (GType type)

{

  static const GInterfaceInfo probe_iface_info = {

    (GInterfaceInitFunc) gst_alsa_property_probe_interface_init,

    NULL,

    NULL,

  };

  g_type_add_interface_static (type, GST_TYPE_PROPERTY_PROBE,

      &probe_iface_info);

}

static GstCaps *

gst_alsa_detect_rates (GstObject * obj, snd_pcm_hw_params_t * hw_params,

    GstCaps * in_caps)

{

  GstCaps *caps;

  guint min, max;

  gint err, dir, min_rate, max_rate;

  guint i;

  GST_LOG_OBJECT (obj, "probing sample rates ...");

  if ((err = snd_pcm_hw_params_get_rate_min (hw_params, &min, &dir)) < 0)

    goto min_rate_err;

  if ((err = snd_pcm_hw_params_get_rate_max (hw_params, &max, &dir)) < 0)

    goto max_rate_err;

  min_rate = min;

  max_rate = max;

  if (min_rate < 4000)

    min_rate = 4000;            /* random 'sensible minimum' */

  if (max_rate <= 0)

    max_rate = G_MAXINT;        /* or maybe just use 192400 or so? */

  else if (max_rate > 0 && max_rate < 4000)

    max_rate = MAX (4000, min_rate);

  GST_DEBUG_OBJECT (obj, "Min. rate = %u (%d)", min_rate, min);

  GST_DEBUG_OBJECT (obj, "Max. rate = %u (%d)", max_rate, max);

  caps = gst_caps_make_writable (in_caps);

  for (i = 0; i < gst_caps_get_size (caps); ++i) {

    GstStructure *s;

    s = gst_caps_get_structure (caps, i);

    if (min_rate == max_rate) {

      gst_structure_set (s, "rate", G_TYPE_INT, min_rate, NULL);

    } else {

      gst_structure_set (s, "rate", GST_TYPE_INT_RANGE,

          min_rate, max_rate, NULL);

    }

  }

  return caps;

  /* ERRORS */

min_rate_err:

  {

    GST_ERROR_OBJECT (obj, "failed to query minimum sample rate: %s",

        snd_strerror (err));

    gst_caps_unref (in_caps);

    return NULL;

  }

max_rate_err:

  {

    GST_ERROR_OBJECT (obj, "failed to query maximum sample rate: %s",

        snd_strerror (err));

    gst_caps_unref (in_caps);

    return NULL;

  }

}

static const struct

{

  const int width;

  const int depth;

  const int sformat;

  const int uformat;

} pcmformats[] = {

  {

  8, 8, SND_PCM_FORMAT_S8, SND_PCM_FORMAT_U8}, {

  16, 16, SND_PCM_FORMAT_S16, SND_PCM_FORMAT_U16}, {

  32, 24, SND_PCM_FORMAT_S24, SND_PCM_FORMAT_U24}, {

#if (G_BYTE_ORDER == G_LITTLE_ENDIAN)   /* no endian-unspecific enum available */

  24, 24, SND_PCM_FORMAT_S24_3LE, SND_PCM_FORMAT_U24_3LE}, {

#else

  24, 24, SND_PCM_FORMAT_S24_3BE, SND_PCM_FORMAT_U24_3BE}, {

#endif

  32, 32, SND_PCM_FORMAT_S32, SND_PCM_FORMAT_U32}

};

static GstCaps *

gst_alsa_detect_formats (GstObject * obj, snd_pcm_hw_params_t * hw_params,

    GstCaps * in_caps)

{

  snd_pcm_format_mask_t *mask;

  GstStructure *s;

  GstCaps *caps;

  guint i;

  snd_pcm_format_mask_malloc (&mask);

  snd_pcm_hw_params_get_format_mask (hw_params, mask);

  caps = gst_caps_new_empty ();

  for (i = 0; i < gst_caps_get_size (in_caps); ++i) {

    GstStructure *scopy;

    guint w;

    gint width = 0, depth = 0;

    s = gst_caps_get_structure (in_caps, i);

    if (!gst_structure_has_name (s, "audio/x-raw-int")) {

      GST_WARNING_OBJECT (obj, "skipping non-int format");

      continue;

    }

    if (!gst_structure_get_int (s, "width", &width) ||

        !gst_structure_get_int (s, "depth", &depth))

      continue;

    if (width == 0 || (width % 8) != 0)

      continue;                 /* Only full byte widths are valid */

    for (w = 0; w < G_N_ELEMENTS (pcmformats); w++)

      if (pcmformats[w].width == width && pcmformats[w].depth == depth)

        break;

    if (w == G_N_ELEMENTS (pcmformats))

      continue;                 /* Unknown format */

    if (snd_pcm_format_mask_test (mask, pcmformats[w].sformat) &&

        snd_pcm_format_mask_test (mask, pcmformats[w].uformat)) {

      /* template contains { true, false } or just one, leave it as it is */

      scopy = gst_structure_copy (s);

    } else if (snd_pcm_format_mask_test (mask, pcmformats[w].sformat)) {

      scopy = gst_structure_copy (s);

      gst_structure_set (scopy, "signed", G_TYPE_BOOLEAN, TRUE, NULL);

    } else if (snd_pcm_format_mask_test (mask, pcmformats[w].uformat)) {

      scopy = gst_structure_copy (s);

      gst_structure_set (scopy, "signed", G_TYPE_BOOLEAN, FALSE, NULL);

    } else {

      scopy = NULL;

    }

    if (scopy) {

      if (width > 8) {

        /* TODO: proper endianness detection, for now it's CPU endianness only */

        gst_structure_set (scopy, "endianness", G_TYPE_INT, G_BYTE_ORDER, NULL);

      }

      gst_caps_append_structure (caps, scopy);

    }

  }

  snd_pcm_format_mask_free (mask);

  gst_caps_unref (in_caps);

  return caps;

}

/* we don't have channel mappings for more than this many channels */

#define GST_ALSA_MAX_CHANNELS 8

static GstStructure *

get_channel_free_structure (const GstStructure * in_structure)

{

  GstStructure *s = gst_structure_copy (in_structure);

  gst_structure_remove_field (s, "channels");

  return s;

}

static void

caps_add_channel_configuration (GstCaps * caps,

    const GstStructure * in_structure, gint min_chans, gint max_chans)

{

  GstAudioChannelPosition pos[8] = {

    GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,

    GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,

    GST_AUDIO_CHANNEL_POSITION_REAR_LEFT,

    GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT,

    GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER,

    GST_AUDIO_CHANNEL_POSITION_LFE,

    GST_AUDIO_CHANNEL_POSITION_SIDE_LEFT,

    GST_AUDIO_CHANNEL_POSITION_SIDE_RIGHT

  };

  GstStructure *s = NULL;

  gint c;

  if (min_chans == max_chans && max_chans <= 2) {

    s = get_channel_free_structure (in_structure);

    gst_structure_set (s, "channels", G_TYPE_INT, max_chans, NULL);

    gst_caps_append_structure (caps, s);

    return;

  }

  g_assert (min_chans >= 1);

  /* mono and stereo don't need channel configurations */

  if (min_chans == 2) {

    s = get_channel_free_structure (in_structure);

    gst_structure_set (s, "channels", G_TYPE_INT, 2, NULL);

    gst_caps_append_structure (caps, s);

  } else if (min_chans == 1 && max_chans >= 2) {

    s = get_channel_free_structure (in_structure);

    gst_structure_set (s, "channels", GST_TYPE_INT_RANGE, 1, 2, NULL);

    gst_caps_append_structure (caps, s);

  }

  /* don't know whether to use 2.1 or 3.0 here - but I suspect

   * alsa might work around that/fix it somehow. Can we tell alsa

   * what our channel layout is like? */

  if (max_chans >= 3 && min_chans <= 3) {

    GstAudioChannelPosition pos_21[3] = {

      GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,

      GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,

      GST_AUDIO_CHANNEL_POSITION_LFE

    };

    s = get_channel_free_structure (in_structure);

    gst_structure_set (s, "channels", G_TYPE_INT, 3, NULL);

    gst_audio_set_channel_positions (s, pos_21);

    gst_caps_append_structure (caps, s);

  }

  /* everything else (4, 6, 8 channels) needs a channel layout */

  for (c = MAX (4, min_chans); c <= 8; c += 2) {

    if (max_chans >= c) {

      s = get_channel_free_structure (in_structure);

      gst_structure_set (s, "channels", G_TYPE_INT, c, NULL);

      gst_audio_set_channel_positions (s, pos);

      gst_caps_append_structure (caps, s);

    }

  }

  for (c = MAX (9, min_chans); c <= max_chans; ++c) {

    GstAudioChannelPosition *ch_layout;

    gint i;

    ch_layout = g_new (GstAudioChannelPosition, c);

    for (i = 0; i < c; ++i) {

      ch_layout[i] = GST_AUDIO_CHANNEL_POSITION_NONE;

    }

    s = get_channel_free_structure (in_structure);

    gst_structure_set (s, "channels", G_TYPE_INT, c, NULL);

    gst_audio_set_channel_positions (s, ch_layout);

    gst_caps_append_structure (caps, s);

    g_free (ch_layout);

  }

}

static GstCaps *

gst_alsa_detect_channels (GstObject * obj, snd_pcm_hw_params_t * hw_params,

    GstCaps * in_caps)

{

  GstCaps *caps;

  guint min, max;

  gint min_chans, max_chans;

  gint err;

  guint i;

  GST_LOG_OBJECT (obj, "probing channels ...");

  if ((err = snd_pcm_hw_params_get_channels_min (hw_params, &min)) < 0)

    goto min_chan_error;

  if ((err = snd_pcm_hw_params_get_channels_max (hw_params, &max)) < 0)

    goto max_chan_error;

  /* note: the above functions may return (guint) -1 */

  min_chans = min;

  max_chans = max;

  if (min_chans < 0) {

    min_chans = 1;

    max_chans = GST_ALSA_MAX_CHANNELS;

  } else if (max_chans < 0) {

    max_chans = GST_ALSA_MAX_CHANNELS;

  }

  if (min_chans > max_chans) {

    gint temp;

    GST_WARNING_OBJECT (obj, "minimum channels > maximum channels (%d > %d), "

        "please fix your soundcard drivers", min, max);

    temp = min_chans;

    min_chans = max_chans;

    max_chans = temp;

  }

  /* pro cards seem to return large numbers for min_channels */