sys/osxaudio/gstosxaudioelement.c

   1 /* GStreamer
   2  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
   3  *                    2000 Wim Taymans <wim.taymans@chello.be>
   4  *
   5  * gstosxaudioelement.c:
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include <CoreAudio/CoreAudio.h>
  28 #include <pthread.h>
  29
  30 #include <unistd.h>
  31 #include <errno.h>
  32 #include <string.h>
  33
  34 #include "gstosxaudioelement.h"
  35
  36 enum
  37 {
  38   ARG_0,
  39   ARG_DEVICE
  40 };
  41
  42 /* elementfactory information */
  43 static GstElementDetails gst_osxaudioelement_details =
  44 GST_ELEMENT_DETAILS ("Audio Mixer (OSX)",
  45     "Generic/Audio",
  46     "Mac OS X audio mixer element",
  47     "Zaheer Abbas Merali <zaheerabbas at merali.org>");
  48
  49 static void gst_osxaudioelement_base_init (GstOsxAudioElementClass * klass);
  50 static void gst_osxaudioelement_class_init (GstOsxAudioElementClass * klass);
  51
  52 static void gst_osxaudioelement_init (GstOsxAudioElement * osxaudio);
  53 static void gst_osxaudioelement_dispose (GObject * object);
  54
  55 static void gst_osxaudioelement_set_property (GObject * object,
  56     guint prop_id, const GValue * value, GParamSpec * pspec);
  57 static void gst_osxaudioelement_get_property (GObject * object,
  58     guint prop_id, GValue * value, GParamSpec * pspec);
  59 static GstElementStateReturn gst_osxaudioelement_change_state (GstElement *
  60     element);
  61
  62 static GstElementClass *parent_class = NULL;
  63
  64
  65 GType
  66 gst_osxaudioelement_get_type (void)
  67 {
  68   static GType osxaudioelement_type = 0;
  69
  70   if (!osxaudioelement_type) {
  71     static const GTypeInfo osxaudioelement_info = {
  72       sizeof (GstOsxAudioElementClass),
  73       (GBaseInitFunc) gst_osxaudioelement_base_init,
  74       NULL,
  75       (GClassInitFunc) gst_osxaudioelement_class_init,
  76       NULL,
  77       NULL,
  78       sizeof (GstOsxAudioElement),
  79       0,
  80       (GInstanceInitFunc) gst_osxaudioelement_init
  81     };
  82
  83     osxaudioelement_type = g_type_register_static (GST_TYPE_ELEMENT,
  84         "GstOsxAudioElement", &osxaudioelement_info, 0);
  85   }
  86
  87   return osxaudioelement_type;
  88 }
  89
  90 static void
  91 gst_osxaudioelement_base_init (GstOsxAudioElementClass * klass)
  92 {
  93   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
  94
  95   klass->device_combinations = NULL;
  96
  97   gst_element_class_set_details (element_class, &gst_osxaudioelement_details);
  98 }
  99
 100 static void
 101 gst_osxaudioelement_class_init (GstOsxAudioElementClass * klass)
 102 {
 103   GObjectClass *gobject_class;
 104   GstElementClass *gstelement_class;
 105
 106   gobject_class = (GObjectClass *) klass;
 107   gstelement_class = (GstElementClass *) klass;
 108
 109   parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
 110
 111   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_DEVICE,
 112       g_param_spec_int ("device", "Device index",
 113           "Mac OS X CoreAudio Device Index (0 usually)", 0, G_MAXINT, 0,
 114           G_PARAM_READWRITE));
 115   gobject_class->set_property = gst_osxaudioelement_set_property;
 116   gobject_class->get_property = gst_osxaudioelement_get_property;
 117   gobject_class->dispose = gst_osxaudioelement_dispose;
 118
 119   gstelement_class->change_state = gst_osxaudioelement_change_state;
 120 }
 121
 122 static void
 123 gst_osxaudioelement_init (GstOsxAudioElement * osxaudio)
 124 {
 125   OSStatus status;
 126   UInt32 propertySize;
 127
 128   pthread_mutex_init (&osxaudio->buffer_mutex, NULL);
 129   pthread_mutex_unlock (&osxaudio->buffer_mutex);
 130   propertySize = sizeof (osxaudio->device_id);
 131   status =
 132       AudioHardwareGetProperty (kAudioHardwarePropertyDefaultOutputDevice,
 133       &propertySize, &(osxaudio->device_id));
 134
 135   if (status) {
 136     GST_DEBUG ("AudioHardwareGetProperty returned %d\n", (int) status);
 137   }
 138   if (osxaudio->device_id == kAudioDeviceUnknown) {
 139     GST_DEBUG ("AudioHardwareGetProperty: device_id is kAudioDeviceUnknown\n");
 140   }
 141   /* get requested buffer length */
 142   propertySize = sizeof (osxaudio->buffer_len);
 143   status =
 144       AudioDeviceGetProperty (osxaudio->device_id, 0, false,
 145       kAudioDevicePropertyBufferSize, &propertySize, &osxaudio->buffer_len);
 146   if (status) {
 147     GST_DEBUG
 148         ("AudioDeviceGetProperty returned %d when getting kAudioDevicePropertyBufferSize\n",
 149         (int) status);
 150   }
 151   GST_DEBUG ("%5d osxaudio->buffer_len\n", (int) osxaudio->buffer_len);
 152
 153 }
 154
 155 static void
 156 gst_osxaudioelement_dispose (GObject * object)
 157 {
 158   GstOsxAudioElement *osxaudio = (GstOsxAudioElement *) object;
 159
 160   G_OBJECT_CLASS (parent_class)->dispose (object);
 161 }
 162
 163 /* General purpose Ring-buffering routines */
 164 int
 165 write_buffer (GstOsxAudioElement * osxaudio, unsigned char *data, int len)
 166 {
 167   int len2 = 0;
 168   int x;
 169
 170   while (len > 0) {
 171     if (osxaudio->full_buffers == NUM_BUFS) {
 172       GST_DEBUG ("Buffer overrun\n");
 173       break;
 174     }
 175
 176     x = osxaudio->buffer_len - osxaudio->buf_write_pos;
 177     if (x > len)
 178       x = len;
 179     memcpy (osxaudio->buffer[osxaudio->buf_write] + osxaudio->buf_write_pos,
 180         data + len2, x);
 181
 182     /* accessing common variables, locking mutex */
 183     pthread_mutex_lock (&osxaudio->buffer_mutex);
 184     len2 += x;
 185     len -= x;
 186     osxaudio->buffered_bytes += x;
 187     osxaudio->buf_write_pos += x;
 188     if (osxaudio->buf_write_pos >= osxaudio->buffer_len) {
 189       /* block is full, find next! */
 190       osxaudio->buf_write = (osxaudio->buf_write + 1) % NUM_BUFS;
 191       ++osxaudio->full_buffers;
 192       osxaudio->buf_write_pos = 0;
 193     }
 194     pthread_mutex_unlock (&osxaudio->buffer_mutex);
 195   }
 196
 197   return len2;
 198 }
 199
 200 int
 201 read_buffer (GstOsxAudioElement * osxaudio, unsigned char *data)
 202 {
 203   int len2 = 0;
 204   int len = osxaudio->buffer_len;
 205   int x;
 206
 207   while (len > 0) {
 208     if (osxaudio->full_buffers == 0) {
 209       GST_DEBUG ("Buffer underrun\n");
 210       break;
 211     }
 212
 213     x = osxaudio->buffer_len - osxaudio->buf_read_pos;
 214     if (x > len)
 215       x = len;
 216     memcpy (data + len2,
 217         osxaudio->buffer[osxaudio->buf_read] + osxaudio->buf_read_pos, x);
 218     len2 += x;
 219     len -= x;
 220
 221     /* accessing common variables, locking mutex */
 222     pthread_mutex_lock (&osxaudio->buffer_mutex);
 223     osxaudio->buffered_bytes -= x;
 224     osxaudio->buf_read_pos += x;
 225     if (osxaudio->buf_read_pos >= osxaudio->buffer_len) {
 226       /* block is empty, find next! */
 227       osxaudio->buf_read = (osxaudio->buf_read + 1) % NUM_BUFS;
 228       --osxaudio->full_buffers;
 229       osxaudio->buf_read_pos = 0;
 230     }
 231     pthread_mutex_unlock (&osxaudio->buffer_mutex);
 232   }
 233
 234
 235   return len2;
 236 }
 237
 238 /* The function that the CoreAudio thread calls when it has data */
 239 OSStatus
 240 inputAudioDeviceIOProc (AudioDeviceID inDevice, const AudioTimeStamp * inNow,
 241     const AudioBufferList * inInputData, const AudioTimeStamp * inInputTime,
 242     AudioBufferList * outOutputData, const AudioTimeStamp * inOutputTime,
 243     void *inClientData)
 244 {
 245   GstOsxAudioElement *osxaudio = GST_OSXAUDIOELEMENT (inClientData);
 246
 247   write_buffer (GST_OSXAUDIOELEMENT (osxaudio),
 248       (char *) inInputData->mBuffers[0].mData, osxaudio->buffer_len);
 249
 250   return 0;
 251 }
 252
 253 /* The function that the CoreAudio thread calls when it wants more data */
 254
 255 OSStatus
 256 outputAudioDeviceIOProc (AudioDeviceID inDevice, const AudioTimeStamp * inNow,
 257     const AudioBufferList * inInputData, const AudioTimeStamp * inInputTime,
 258     AudioBufferList * outOutputData, const AudioTimeStamp * inOutputTime,
 259     void *inClientData)
 260 {
 261   GstOsxAudioElement *osxaudio = GST_OSXAUDIOELEMENT (inClientData);
 262
 263   outOutputData->mBuffers[0].mDataByteSize =
 264       read_buffer (osxaudio, (char *) outOutputData->mBuffers[0].mData);
 265
 266   return 0;
 267 }
 268
 269 static gboolean
 270 gst_osxaudioelement_open_audio (GstOsxAudioElement * osxaudio, gboolean input)
 271 {
 272   gint caps;
 273   int i;
 274   OSErr status;
 275
 276   GST_INFO ("osxaudioelement: attempting to open sound device");
 277
 278   /* Allocate ring-buffer memory */
 279   for (i = 0; i < NUM_BUFS; i++)
 280     osxaudio->buffer[i] = (unsigned char *) malloc (osxaudio->buffer_len);
 281   if (input) {
 282     status =
 283         AudioDeviceAddIOProc (osxaudio->device_id, inputAudioDeviceIOProc,
 284         osxaudio);
 285   } else {
 286     /* Set the IO proc that CoreAudio will call when it needs data */
 287     status =
 288         AudioDeviceAddIOProc (osxaudio->device_id, outputAudioDeviceIOProc,
 289         osxaudio);
 290   }
 291   if (status) {
 292     GST_DEBUG ("AudioDeviceAddIOProc returned %d\n", (int) status);
 293     return FALSE;
 294   }
 295
 296   pthread_mutex_lock (&osxaudio->buffer_mutex);
 297
 298   /* reset ring-buffer state */
 299   osxaudio->buf_read = 0;
 300   osxaudio->buf_write = 0;
 301   osxaudio->buf_read_pos = 0;
 302   osxaudio->buf_write_pos = 0;
 303
 304   osxaudio->full_buffers = 0;
 305   osxaudio->buffered_bytes = 0;
 306
 307   /* zero buffer */
 308   for (i = 0; i < NUM_BUFS; i++)
 309     bzero (osxaudio->buffer[i], osxaudio->buffer_len);
 310
 311   pthread_mutex_unlock (&osxaudio->buffer_mutex);
 312
 313   return TRUE;
 314 }
 315
 316 static void
 317 gst_osxaudioelement_close_audio (GstOsxAudioElement * osxaudio, gboolean input)
 318 {
 319   OSErr status;
 320   int i;
 321
 322   /* stop callback */
 323   if (input) {
 324     status = AudioDeviceStop (osxaudio->device_id, inputAudioDeviceIOProc);
 325   } else {
 326     status = AudioDeviceStop (osxaudio->device_id, outputAudioDeviceIOProc);
 327   }
 328   if (status)
 329     GST_DEBUG ("AudioDeviceStop returned %d\n", (int) status);
 330
 331   if (input) {
 332     status =
 333         AudioDeviceRemoveIOProc (osxaudio->device_id, inputAudioDeviceIOProc);
 334   } else {
 335     status =
 336         AudioDeviceRemoveIOProc (osxaudio->device_id, outputAudioDeviceIOProc);
 337   }
 338   if (status)
 339     GST_DEBUG ("AudioDeviceRemoveIOProc " "returned %d\n", (int) status);
 340
 341   for (i = 0; i < NUM_BUFS; i++)
 342     free (osxaudio->buffer[i]);
 343
 344 }
 345
 346 static void
 347 gst_osxaudioelement_set_property (GObject * object,
 348     guint prop_id, const GValue * value, GParamSpec * pspec)
 349 {
 350   GstOsxAudioElement *osxaudio = GST_OSXAUDIOELEMENT (object);
 351   OSStatus status;
 352   int nDevices;
 353   UInt32 propertySize;
 354   int deviceid;
 355   AudioDeviceID *devids;
 356
 357   switch (prop_id) {
 358     case ARG_DEVICE:
 359       /* check index given is in bounds, if not use default device */
 360       status = AudioHardwareGetPropertyInfo (kAudioHardwarePropertyDevices,
 361           &propertySize, NULL);
 362       nDevices = propertySize / sizeof (AudioDeviceID);
 363       deviceid = g_value_get_int (value);
 364       if (deviceid < nDevices) {
 365         devids = malloc (propertySize);
 366         status =
 367             AudioHardwareGetProperty (kAudioHardwarePropertyDevices,
 368             &propertySize, devids);
 369         osxaudio->device_id = devids[deviceid];
 370         free (devids);
 371       } else {
 372         GST_DEBUG ("device index %d out of range.  Max index is currently %d\n",
 373             deviceid, nDevices);
 374       }
 375       break;
 376     default:
 377       break;
 378   }
 379 }
 380
 381 static void
 382 gst_osxaudioelement_get_property (GObject * object,
 383     guint prop_id, GValue * value, GParamSpec * pspec)
 384 {
 385   GstOsxAudioElement *osxaudio = GST_OSXAUDIOELEMENT (object);
 386   OSStatus status;
 387   int nDevices;
 388   UInt32 propertySize;
 389   int deviceid;
 390   AudioDeviceID *devids;
 391   int i;
 392
 393   switch (prop_id) {
 394     case ARG_DEVICE:
 395       /* figure out what index the current one is */
 396       status = AudioHardwareGetPropertyInfo (kAudioHardwarePropertyDevices,
 397           &propertySize, NULL);
 398       nDevices = propertySize / sizeof (AudioDeviceID);
 399       devids = malloc (propertySize);
 400       status =
 401           AudioHardwareGetProperty (kAudioHardwarePropertyDevices,
 402           &propertySize, devids);
 403       for (i = 0; i < nDevices; i++) {
 404         if (osxaudio->device_id == devids[i])
 405           break;
 406       }
 407       g_value_set_int (value, i);
 408       free (devids);
 409       break;
 410     default:
 411       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 412       break;
 413   }
 414 }
 415
 416 static GstElementStateReturn
 417 gst_osxaudioelement_change_state (GstElement * element)
 418 {
 419   GstOsxAudioElement *osxaudio = GST_OSXAUDIOELEMENT (element);
 420   const GList *padlist;
 421   gboolean input = TRUE;
 422
 423   padlist = gst_element_get_pad_list (element);
 424   if (padlist != NULL) {
 425     GstPad *firstpad = padlist->data;
 426
 427     if (GST_PAD_IS_SINK (firstpad)) {
 428       input = FALSE;
 429     }
 430   }
 431   switch (GST_STATE_TRANSITION (element)) {
 432     case GST_STATE_NULL_TO_READY:
 433       if (!gst_osxaudioelement_open_audio (osxaudio, input)) {
 434         return GST_STATE_FAILURE;
 435       }
 436       GST_INFO ("osxaudioelement: opened sound device");
 437       break;
 438     case GST_STATE_READY_TO_NULL:
 439       gst_osxaudioelement_close_audio (osxaudio, input);
 440       GST_INFO ("osxaudioelement: closed sound device");
 441       break;
 442     default:
 443       break;
 444   }
 445
 446   if (GST_ELEMENT_CLASS (parent_class)->change_state)
 447     return GST_ELEMENT_CLASS (parent_class)->change_state (element);
 448
 449   return GST_STATE_SUCCESS;
 450 }