sys/osxaudio/Makefile.am: New OS X audio plugin by Zaheer Merali

Original commit message from CVS:
* sys/osxaudio/Makefile.am:  New OS X audio plugin by Zaheer Merali
* sys/osxaudio/gstosxaudio.c:
* sys/osxaudio/gstosxaudioelement.c:
* sys/osxaudio/gstosxaudioelement.h:
* sys/osxaudio/gstosxaudiosink.c:
* sys/osxaudio/gstosxaudiosink.h:
* sys/osxaudio/gstosxaudiosrc.c:
* sys/osxaudio/gstosxaudiosrc.h:

1 files changed, 450 insertions, 0 deletions

diff --git a/sys/osxaudio/gstosxaudioelement.c b/sys/osxaudio/gstosxaudioelement.c
new file mode 100644
index 00000000..5a25eb0f
--- /dev/null
+++ b/sys/osxaudio/gstosxaudioelement.c
@@ -0,0 +1,450 @@
+/* GStreamer
+ * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
+ *                    2000 Wim Taymans <wim.taymans@chello.be>
+ *
+ * gstosxaudioelement.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 Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <CoreAudio/CoreAudio.h>
+#include <pthread.h>
+
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+
+#include "gstosxaudioelement.h"
+
+enum
+{
+  ARG_0,
+  ARG_DEVICE,
+};
+
+/* elementfactory information */
+static GstElementDetails gst_osxaudioelement_details =
+GST_ELEMENT_DETAILS ("Audio Mixer (OSX)",
+    "Generic/Audio",
+    "Mac OS X audio mixer element",
+    "Zaheer Abbas Merali <zaheerabbas at merali.org>");
+
+static void gst_osxaudioelement_base_init (GstOsxAudioElementClass * klass);
+static void gst_osxaudioelement_class_init (GstOsxAudioElementClass * klass);
+
+static void gst_osxaudioelement_init (GstOsxAudioElement * osxaudio);
+static void gst_osxaudioelement_dispose (GObject * object);
+
+static void gst_osxaudioelement_set_property (GObject * object,
+    guint prop_id, const GValue * value, GParamSpec * pspec);
+static void gst_osxaudioelement_get_property (GObject * object,
+    guint prop_id, GValue * value, GParamSpec * pspec);
+static GstElementStateReturn gst_osxaudioelement_change_state (GstElement *
+    element);
+
+static GstElementClass *parent_class = NULL;
+
+
+GType
+gst_osxaudioelement_get_type (void)
+{
+  static GType osxaudioelement_type = 0;
+
+  if (!osxaudioelement_type) {
+    static const GTypeInfo osxaudioelement_info = {
+      sizeof (GstOsxAudioElementClass),
+      (GBaseInitFunc) gst_osxaudioelement_base_init,
+      NULL,
+      (GClassInitFunc) gst_osxaudioelement_class_init,
+      NULL,
+      NULL,
+      sizeof (GstOsxAudioElement),
+      0,
+      (GInstanceInitFunc) gst_osxaudioelement_init
+    };
+
+    osxaudioelement_type = g_type_register_static (GST_TYPE_ELEMENT,
+        "GstOsxAudioElement", &osxaudioelement_info, 0);
+  }
+
+  return osxaudioelement_type;
+}
+
+static void
+gst_osxaudioelement_base_init (GstOsxAudioElementClass * klass)
+{
+  GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
+
+  klass->device_combinations = NULL;
+
+  gst_element_class_set_details (element_class, &gst_osxaudioelement_details);
+}
+
+static void
+gst_osxaudioelement_class_init (GstOsxAudioElementClass * klass)
+{
+  GObjectClass *gobject_class;
+  GstElementClass *gstelement_class;
+
+  gobject_class = (GObjectClass *) klass;
+  gstelement_class = (GstElementClass *) klass;
+
+  parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
+
+  g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_DEVICE,
+      g_param_spec_int ("device", "Device index",
+          "Mac OS X CoreAudio Device Index (0 usually)", 0, G_MAXINT, 0,
+          G_PARAM_READWRITE));
+  gobject_class->set_property = gst_osxaudioelement_set_property;
+  gobject_class->get_property = gst_osxaudioelement_get_property;
+  gobject_class->dispose = gst_osxaudioelement_dispose;
+
+  gstelement_class->change_state = gst_osxaudioelement_change_state;
+}
+
+static void
+gst_osxaudioelement_init (GstOsxAudioElement * osxaudio)
+{
+  OSStatus status;
+  UInt32 propertySize;
+
+  pthread_mutex_init (&osxaudio->buffer_mutex, NULL);
+  pthread_mutex_unlock (&osxaudio->buffer_mutex);
+  propertySize = sizeof (osxaudio->device_id);
+  status =
+      AudioHardwareGetProperty (kAudioHardwarePropertyDefaultOutputDevice,
+      &propertySize, &(osxaudio->device_id));
+
+  if (status) {
+    GST_DEBUG ("AudioHardwareGetProperty returned %d\n", (int) status);
+  }
+  if (osxaudio->device_id == kAudioDeviceUnknown) {
+    GST_DEBUG ("AudioHardwareGetProperty: device_id is kAudioDeviceUnknown\n");
+  }
+  /* get requested buffer length */
+  propertySize = sizeof (osxaudio->buffer_len);
+  status =
+      AudioDeviceGetProperty (osxaudio->device_id, 0, false,
+      kAudioDevicePropertyBufferSize, &propertySize, &osxaudio->buffer_len);
+  if (status) {
+    GST_DEBUG
+        ("AudioDeviceGetProperty returned %d when getting kAudioDevicePropertyBufferSize\n",
+        (int) status);
+  }
+  GST_DEBUG ("%5d osxaudio->buffer_len\n", (int) osxaudio->buffer_len);
+
+}
+
+static void
+gst_osxaudioelement_dispose (GObject * object)
+{
+  GstOsxAudioElement *osxaudio = (GstOsxAudioElement *) object;
+
+  G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+/* General purpose Ring-buffering routines */
+int
+write_buffer (GstOsxAudioElement * osxaudio, unsigned char *data, int len)
+{
+  int len2 = 0;
+  int x;
+
+  while (len > 0) {
+    if (osxaudio->full_buffers == NUM_BUFS) {
+      GST_DEBUG ("Buffer overrun\n");
+      break;
+    }
+
+    x = osxaudio->buffer_len - osxaudio->buf_write_pos;
+    if (x > len)
+      x = len;
+    memcpy (osxaudio->buffer[osxaudio->buf_write] + osxaudio->buf_write_pos,
+        data + len2, x);
+
+    /* accessing common variables, locking mutex */
+    pthread_mutex_lock (&osxaudio->buffer_mutex);
+    len2 += x;
+    len -= x;
+    osxaudio->buffered_bytes += x;
+    osxaudio->buf_write_pos += x;
+    if (osxaudio->buf_write_pos >= osxaudio->buffer_len) {
+      /* block is full, find next! */
+      osxaudio->buf_write = (osxaudio->buf_write + 1) % NUM_BUFS;
+      ++osxaudio->full_buffers;
+      osxaudio->buf_write_pos = 0;
+    }
+    pthread_mutex_unlock (&osxaudio->buffer_mutex);
+  }
+
+  return len2;
+}
+
+int
+read_buffer (GstOsxAudioElement * osxaudio, unsigned char *data)
+{
+  int len2 = 0;
+  int len = osxaudio->buffer_len;
+  int x;
+
+  while (len > 0) {
+    if (osxaudio->full_buffers == 0) {
+      GST_DEBUG ("Buffer underrun\n");
+      break;
+    }
+
+    x = osxaudio->buffer_len - osxaudio->buf_read_pos;
+    if (x > len)
+      x = len;
+    memcpy (data + len2,
+        osxaudio->buffer[osxaudio->buf_read] + osxaudio->buf_read_pos, x);
+    len2 += x;
+    len -= x;
+
+    /* accessing common variables, locking mutex */
+    pthread_mutex_lock (&osxaudio->buffer_mutex);
+    osxaudio->buffered_bytes -= x;
+    osxaudio->buf_read_pos += x;
+    if (osxaudio->buf_read_pos >= osxaudio->buffer_len) {
+      /* block is empty, find next! */
+      osxaudio->buf_read = (osxaudio->buf_read + 1) % NUM_BUFS;
+      --osxaudio->full_buffers;
+      osxaudio->buf_read_pos = 0;
+    }
+    pthread_mutex_unlock (&osxaudio->buffer_mutex);
+  }
+
+
+  return len2;
+}
+
+/* The function that the CoreAudio thread calls when it has data */
+OSStatus
+inputAudioDeviceIOProc (AudioDeviceID inDevice, const AudioTimeStamp * inNow,
+    const AudioBufferList * inInputData, const AudioTimeStamp * inInputTime,
+    AudioBufferList * outOutputData, const AudioTimeStamp * inOutputTime,
+    void *inClientData)
+{
+  GstOsxAudioElement *osxaudio = GST_OSXAUDIOELEMENT (inClientData);
+
+  write_buffer (GST_OSXAUDIOELEMENT (osxaudio),
+      (char *) inInputData->mBuffers[0].mData, osxaudio->buffer_len);
+
+  return 0;
+}
+
+/* The function that the CoreAudio thread calls when it wants more data */
+
+OSStatus
+outputAudioDeviceIOProc (AudioDeviceID inDevice, const AudioTimeStamp * inNow,
+    const AudioBufferList * inInputData, const AudioTimeStamp * inInputTime,
+    AudioBufferList * outOutputData, const AudioTimeStamp * inOutputTime,
+    void *inClientData)
+{
+  GstOsxAudioElement *osxaudio = GST_OSXAUDIOELEMENT (inClientData);
+
+  outOutputData->mBuffers[0].mDataByteSize =
+      read_buffer (osxaudio, (char *) outOutputData->mBuffers[0].mData);
+
+  return 0;
+}
+
+static gboolean
+gst_osxaudioelement_open_audio (GstOsxAudioElement * osxaudio, gboolean input)
+{
+  gint caps;
+  int i;
+  OSErr status;
+
+  GST_INFO ("osxaudioelement: attempting to open sound device");
+
+  /* Allocate ring-buffer memory */
+  for (i = 0; i < NUM_BUFS; i++)
+    osxaudio->buffer[i] = (unsigned char *) malloc (osxaudio->buffer_len);
+  if (input) {
+    status =
+        AudioDeviceAddIOProc (osxaudio->device_id, inputAudioDeviceIOProc,
+        osxaudio);
+  } else {
+    /* Set the IO proc that CoreAudio will call when it needs data */
+    status =
+        AudioDeviceAddIOProc (osxaudio->device_id, outputAudioDeviceIOProc,
+        osxaudio);
+  }
+  if (status) {
+    GST_DEBUG ("AudioDeviceAddIOProc returned %d\n", (int) status);
+    return FALSE;
+  }
+
+  pthread_mutex_lock (&osxaudio->buffer_mutex);
+
+  /* reset ring-buffer state */
+  osxaudio->buf_read = 0;
+  osxaudio->buf_write = 0;
+  osxaudio->buf_read_pos = 0;
+  osxaudio->buf_write_pos = 0;
+
+  osxaudio->full_buffers = 0;
+  osxaudio->buffered_bytes = 0;
+
+  /* zero buffer */
+  for (i = 0; i < NUM_BUFS; i++)
+    bzero (osxaudio->buffer[i], osxaudio->buffer_len);
+
+  pthread_mutex_unlock (&osxaudio->buffer_mutex);
+
+  return TRUE;
+}
+
+static void
+gst_osxaudioelement_close_audio (GstOsxAudioElement * osxaudio, gboolean input)
+{
+  OSErr status;
+  int i;
+
+  /* stop callback */
+  if (input) {
+    status = AudioDeviceStop (osxaudio->device_id, inputAudioDeviceIOProc);
+  } else {
+    status = AudioDeviceStop (osxaudio->device_id, outputAudioDeviceIOProc);
+  }
+  if (status)
+    GST_DEBUG ("AudioDeviceStop returned %d\n", (int) status);
+
+  if (input) {
+    status =
+        AudioDeviceRemoveIOProc (osxaudio->device_id, inputAudioDeviceIOProc);
+  } else {
+    status =
+        AudioDeviceRemoveIOProc (osxaudio->device_id, outputAudioDeviceIOProc);
+  }
+  if (status)
+    GST_DEBUG ("AudioDeviceRemoveIOProc " "returned %d\n", (int) status);
+
+  for (i = 0; i < NUM_BUFS; i++)
+    free (osxaudio->buffer[i]);
+
+}
+
+static void
+gst_osxaudioelement_set_property (GObject * object,
+    guint prop_id, const GValue * value, GParamSpec * pspec)
+{
+  GstOsxAudioElement *osxaudio = GST_OSXAUDIOELEMENT (object);
+  OSStatus status;
+  int nDevices;
+  UInt32 propertySize;
+  int deviceid;
+  AudioDeviceID *devids;
+
+  switch (prop_id) {
+    case ARG_DEVICE:
+      /* check index given is in bounds, if not use default device */
+      status = AudioHardwareGetPropertyInfo (kAudioHardwarePropertyDevices,
+          &propertySize, NULL);
+      nDevices = propertySize / sizeof (AudioDeviceID);
+      deviceid = g_value_get_int (value);
+      if (deviceid < nDevices) {
+        devids = malloc (propertySize);
+        status =
+            AudioHardwareGetProperty (kAudioHardwarePropertyDevices,
+            &propertySize, devids);
+        osxaudio->device_id = devids[deviceid];
+        free (devids);
+      } else {
+        GST_DEBUG ("device index %d out of range.  Max index is currently %d\n",
+            deviceid, nDevices);
+      }
+      break;
+    default:
+      break;
+  }
+}
+
+static void
+gst_osxaudioelement_get_property (GObject * object,
+    guint prop_id, GValue * value, GParamSpec * pspec)
+{
+  GstOsxAudioElement *osxaudio = GST_OSXAUDIOELEMENT (object);
+  OSStatus status;
+  int nDevices;
+  UInt32 propertySize;
+  int deviceid;
+  AudioDeviceID *devids;
+  int i;
+
+  switch (prop_id) {
+    case ARG_DEVICE:
+      /* figure out what index the current one is */
+      status = AudioHardwareGetPropertyInfo (kAudioHardwarePropertyDevices,
+          &propertySize, NULL);
+      nDevices = propertySize / sizeof (AudioDeviceID);
+      devids = malloc (propertySize);
+      status =
+          AudioHardwareGetProperty (kAudioHardwarePropertyDevices,
+          &propertySize, devids);
+      for (i = 0; i < nDevices; i++) {
+        if (osxaudio->device_id == devids[i])
+          break;
+      }
+      g_value_set_int (value, i);
+      free (devids);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+}
+
+static GstElementStateReturn
+gst_osxaudioelement_change_state (GstElement * element)
+{
+  GstOsxAudioElement *osxaudio = GST_OSXAUDIOELEMENT (element);
+  const GList *padlist;
+  gboolean input = TRUE;
+
+  padlist = gst_element_get_pad_list (element);
+  if (padlist != NULL) {
+    GstPad *firstpad = padlist->data;
+
+    if (GST_PAD_IS_SINK (firstpad)) {
+      input = FALSE;
+    }
+  }
+  switch (GST_STATE_TRANSITION (element)) {
+    case GST_STATE_NULL_TO_READY:
+      if (!gst_osxaudioelement_open_audio (osxaudio, input)) {
+        return GST_STATE_FAILURE;
+      }
+      GST_INFO ("osxaudioelement: opened sound device");
+      break;
+    case GST_STATE_READY_TO_NULL:
+      gst_osxaudioelement_close_audio (osxaudio, input);
+      GST_INFO ("osxaudioelement: closed sound device");
+      break;
+    default:
+      break;
+  }
+
+  if (GST_ELEMENT_CLASS (parent_class)->change_state)
+    return GST_ELEMENT_CLASS (parent_class)->change_state (element);
+
+  return GST_STATE_SUCCESS;
+}