sys/oss4/oss4-source.c - mtk-gst-plugins-good - Git at Google

 /* GStreamer OSS4 audio source
  * Copyright (C) 2007-2008 Tim-Philipp Müller <tim centricular net>
  *
  * 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-oss4src
  *
  * This element lets you record sound using the Open Sound System (OSS)
  * version 4.
  *
  * <refsect2>
  * <title>Example pipelines</title>
  * |[
  * gst-launch-1.0 -v oss4src ! queue ! audioconvert ! vorbisenc ! oggmux ! filesink location=mymusic.ogg
  * ]| will record sound from your sound card using OSS4 and encode it to an
  * Ogg/Vorbis file (this will only work if your mixer settings are right
  * and the right inputs areenabled etc.)
  * </refsect2>
  */

 /* FIXME: make sure we're not doing ioctls from the app thread (e.g. via the
  * mixer interface) while recording */

 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif

 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/ioctl.h>
 #include <fcntl.h>
 #include <errno.h>
 #include <unistd.h>
 #include <string.h>

 #include <gst/gst-i18n-plugin.h>

 #define NO_LEGACY_MIXER
 #include "oss4-audio.h"
 #include "oss4-source.h"
 #include "oss4-property-probe.h"
 #include "oss4-soundcard.h"

 #define GST_OSS4_SOURCE_IS_OPEN(src)  (GST_OSS4_SOURCE(src)->fd != -1)

 GST_DEBUG_CATEGORY_EXTERN (oss4src_debug);
 #define GST_CAT_DEFAULT oss4src_debug

 #define DEFAULT_DEVICE       NULL
 #define DEFAULT_DEVICE_NAME  NULL

 enum
 {
   PROP_0,
   PROP_DEVICE,
   PROP_DEVICE_NAME
 };

 #define gst_oss4_source_parent_class parent_class
 G_DEFINE_TYPE (GstOss4Source, gst_oss4_source, GST_TYPE_AUDIO_SRC);

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

 static void gst_oss4_source_dispose (GObject * object);
 static void gst_oss4_source_finalize (GstOss4Source * osssrc);

 static GstCaps *gst_oss4_source_getcaps (GstBaseSrc * bsrc, GstCaps * filter);

 static gboolean gst_oss4_source_open (GstAudioSrc * asrc,
     gboolean silent_errors);
 static gboolean gst_oss4_source_open_func (GstAudioSrc * asrc);
 static gboolean gst_oss4_source_close (GstAudioSrc * asrc);
 static gboolean gst_oss4_source_prepare (GstAudioSrc * asrc,
     GstAudioRingBufferSpec * spec);
 static gboolean gst_oss4_source_unprepare (GstAudioSrc * asrc);
 static guint gst_oss4_source_read (GstAudioSrc * asrc, gpointer data,
     guint length, GstClockTime * timestamp);
 static guint gst_oss4_source_delay (GstAudioSrc * asrc);
 static void gst_oss4_source_reset (GstAudioSrc * asrc);

 static void
 gst_oss4_source_class_init (GstOss4SourceClass * klass)
 {
   GObjectClass *gobject_class;
   GstElementClass *gstelement_class;
   GstBaseSrcClass *gstbasesrc_class;
   GstAudioSrcClass *gstaudiosrc_class;
   GstPadTemplate *templ;

   gobject_class = (GObjectClass *) klass;
   gstelement_class = (GstElementClass *) klass;
   gstbasesrc_class = (GstBaseSrcClass *) klass;
   gstaudiosrc_class = (GstAudioSrcClass *) klass;

   gobject_class->dispose = gst_oss4_source_dispose;
   gobject_class->finalize = (GObjectFinalizeFunc) gst_oss4_source_finalize;
   gobject_class->get_property = gst_oss4_source_get_property;
   gobject_class->set_property = gst_oss4_source_set_property;

   gstbasesrc_class->get_caps = GST_DEBUG_FUNCPTR (gst_oss4_source_getcaps);

   gstaudiosrc_class->open = GST_DEBUG_FUNCPTR (gst_oss4_source_open_func);
   gstaudiosrc_class->prepare = GST_DEBUG_FUNCPTR (gst_oss4_source_prepare);
   gstaudiosrc_class->unprepare = GST_DEBUG_FUNCPTR (gst_oss4_source_unprepare);
   gstaudiosrc_class->close = GST_DEBUG_FUNCPTR (gst_oss4_source_close);
   gstaudiosrc_class->read = GST_DEBUG_FUNCPTR (gst_oss4_source_read);
   gstaudiosrc_class->delay = GST_DEBUG_FUNCPTR (gst_oss4_source_delay);
   gstaudiosrc_class->reset = GST_DEBUG_FUNCPTR (gst_oss4_source_reset);

   g_object_class_install_property (gobject_class, PROP_DEVICE,
       g_param_spec_string ("device", "Device",
           "OSS4 device (e.g. /dev/oss/hdaudio0/pcm0 or /dev/dspN) "
           "(NULL = use first available device)",
           DEFAULT_DEVICE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

   g_object_class_install_property (gobject_class, PROP_DEVICE_NAME,
       g_param_spec_string ("device-name", "Device name",
           "Human-readable name of the sound device", DEFAULT_DEVICE_NAME,
           G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));

   gst_element_class_set_static_metadata (gstelement_class,
       "OSS v4 Audio Source", "Source/Audio",
       "Capture from a sound card via OSS version 4",
       "Tim-Philipp Müller <tim centricular net>");

   templ = gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
       gst_oss4_audio_get_template_caps ());
   gst_element_class_add_pad_template (gstelement_class, templ);
 }

 static void
 gst_oss4_source_init (GstOss4Source * osssrc)
 {
   const gchar *device;

   device = g_getenv ("AUDIODEV");
   if (device == NULL)
     device = DEFAULT_DEVICE;

   osssrc->fd = -1;
   osssrc->device = g_strdup (device);
   osssrc->device_name = g_strdup (DEFAULT_DEVICE_NAME);
   osssrc->device_name = NULL;
 }

 static void
 gst_oss4_source_finalize (GstOss4Source * oss)
 {
   g_free (oss->device);
   oss->device = NULL;

   G_OBJECT_CLASS (parent_class)->finalize ((GObject *) (oss));
 }

 static void
 gst_oss4_source_dispose (GObject * object)
 {
   GstOss4Source *oss = GST_OSS4_SOURCE (object);

   if (oss->probed_caps) {
     gst_caps_unref (oss->probed_caps);
     oss->probed_caps = NULL;
   }

   G_OBJECT_CLASS (parent_class)->dispose (object);
 }

 static void
 gst_oss4_source_set_property (GObject * object, guint prop_id,
     const GValue * value, GParamSpec * pspec)
 {
   GstOss4Source *oss;

   oss = GST_OSS4_SOURCE (object);

   switch (prop_id) {
     case PROP_DEVICE:
       GST_OBJECT_LOCK (oss);
       if (oss->fd == -1) {
         g_free (oss->device);
         oss->device = g_value_dup_string (value);
         g_free (oss->device_name);
         oss->device_name = NULL;
       } else {
         g_warning ("%s: can't change \"device\" property while audio source "
             "is open", GST_OBJECT_NAME (oss));
       }
       GST_OBJECT_UNLOCK (oss);
       break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
   }
 }

 static void
 gst_oss4_source_get_property (GObject * object, guint prop_id,
     GValue * value, GParamSpec * pspec)
 {
   GstOss4Source *oss;

   oss = GST_OSS4_SOURCE (object);

   switch (prop_id) {
     case PROP_DEVICE:
       GST_OBJECT_LOCK (oss);
       g_value_set_string (value, oss->device);
       GST_OBJECT_UNLOCK (oss);
       break;
     case PROP_DEVICE_NAME:
       GST_OBJECT_LOCK (oss);
       /* If device is set, try to retrieve the name even if we're not open */
       if (oss->fd == -1 && oss->device != NULL) {
         if (gst_oss4_source_open (GST_AUDIO_SRC (oss), TRUE)) {
           g_value_set_string (value, oss->device_name);
           gst_oss4_source_close (GST_AUDIO_SRC (oss));
         } else {
           gchar *name = NULL;

           gst_oss4_property_probe_find_device_name_nofd (GST_OBJECT (oss),
               oss->device, &name);
           g_value_set_string (value, name);
           g_free (name);
         }
       } else {
         g_value_set_string (value, oss->device_name);
       }

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

 static GstCaps *
 gst_oss4_source_getcaps (GstBaseSrc * bsrc, GstCaps * filter)
 {
   GstOss4Source *oss;
   GstCaps *caps;

   oss = GST_OSS4_SOURCE (bsrc);

   if (oss->fd == -1) {
     caps = gst_oss4_audio_get_template_caps ();
   } else if (oss->probed_caps) {
     caps = gst_caps_copy (oss->probed_caps);
   } else {
     caps = gst_oss4_audio_probe_caps (GST_OBJECT (oss), oss->fd);
     if (caps != NULL && !gst_caps_is_empty (caps)) {
       oss->probed_caps = gst_caps_copy (caps);
     }
   }

   if (filter && caps) {
     GstCaps *intersection;

     intersection =
         gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
     gst_caps_unref (caps);
     return intersection;
   } else {
     return caps;
   }
 }

 /* note: we must not take the object lock here unless we fix up get_property */
 static gboolean
 gst_oss4_source_open (GstAudioSrc * asrc, gboolean silent_errors)
 {
   GstOss4Source *oss;
   gchar *device;
   int mode;

   oss = GST_OSS4_SOURCE (asrc);

   if (oss->device)
     device = g_strdup (oss->device);
   else
     device = gst_oss4_audio_find_device (GST_OBJECT_CAST (oss));

   /* desperate times, desperate measures */
   if (device == NULL)
     device = g_strdup ("/dev/dsp0");

   GST_INFO_OBJECT (oss, "Trying to open OSS4 device '%s'", device);

   /* we open in non-blocking mode even if we don't really want to do writes
    * non-blocking because we can't be sure that this is really a genuine
    * OSS4 device with well-behaved drivers etc. We really don't want to
    * hang forever under any circumstances. */
   oss->fd = open (device, O_RDONLY | O_NONBLOCK, 0);
   if (oss->fd == -1) {
     switch (errno) {
       case EBUSY:
         goto busy;
       case EACCES:
         goto no_permission;
       default:
         goto open_failed;
     }
   }

   GST_INFO_OBJECT (oss, "Opened device");

   /* Make sure it's OSS4. If it's old OSS, let osssink handle it */
   if (!gst_oss4_audio_check_version (GST_OBJECT_CAST (oss), oss->fd))
     goto legacy_oss;

   /* now remove the non-blocking flag. */
   mode = fcntl (oss->fd, F_GETFL);
   mode &= ~O_NONBLOCK;
   if (fcntl (oss->fd, F_SETFL, mode) < 0) {
     /* some drivers do no support unsetting the non-blocking flag, try to
      * close/open the device then. This is racy but we error out properly. */
     GST_WARNING_OBJECT (oss, "failed to unset O_NONBLOCK (buggy driver?), "
         "will try to re-open device now");
     gst_oss4_source_close (asrc);
     if ((oss->fd = open (device, O_RDONLY, 0)) == -1)
       goto non_block;
   }

   oss->open_device = device;

   /* not using ENGINEINFO here because it sometimes returns a different and
    * less useful name than AUDIOINFO for the same device */
   if (!gst_oss4_property_probe_find_device_name (GST_OBJECT (oss), oss->fd,
           oss->open_device, &oss->device_name)) {
     oss->device_name = NULL;
   }

   return TRUE;

   /* ERRORS */
 busy:
   {
     if (!silent_errors) {
       GST_ELEMENT_ERROR (oss, RESOURCE, BUSY,
           (_("Could not open audio device for playback. "
                   "Device is being used by another application.")), (NULL));
     }
     g_free (device);
     return FALSE;
   }
 no_permission:
   {
     if (!silent_errors) {
       GST_ELEMENT_ERROR (oss, RESOURCE, OPEN_READ,
           (_("Could not open audio device for playback. "
                   "You don't have permission to open the device.")),
           GST_ERROR_SYSTEM);
     }
     g_free (device);
     return FALSE;
   }
 open_failed:
   {
     if (!silent_errors) {
       GST_ELEMENT_ERROR (oss, RESOURCE, OPEN_READ,
           (_("Could not open audio device for playback.")), GST_ERROR_SYSTEM);
     }
     g_free (device);
     return FALSE;
   }
 legacy_oss:
   {
     gst_oss4_source_close (asrc);
     if (!silent_errors) {
       GST_ELEMENT_ERROR (oss, RESOURCE, OPEN_READ,
           (_("Could not open audio device for playback. "
                   "This version of the Open Sound System is not supported by this "
                   "element.")), ("Try the 'osssink' element instead"));
     }
     g_free (device);
     return FALSE;
   }
 non_block:
   {
     if (!silent_errors) {
       GST_ELEMENT_ERROR (oss, RESOURCE, SETTINGS, (NULL),
           ("Unable to set device %s into non-blocking mode: %s",
               oss->device, g_strerror (errno)));
     }
     g_free (device);
     return FALSE;
   }
 }

 static gboolean
 gst_oss4_source_open_func (GstAudioSrc * asrc)
 {
   return gst_oss4_source_open (asrc, FALSE);
 }

 static gboolean
 gst_oss4_source_close (GstAudioSrc * asrc)
 {
   GstOss4Source *oss;

   oss = GST_OSS4_SOURCE (asrc);

   if (oss->fd != -1) {
     GST_DEBUG_OBJECT (oss, "closing device");
     close (oss->fd);
     oss->fd = -1;
   }

   oss->bytes_per_sample = 0;

   gst_caps_replace (&oss->probed_caps, NULL);

   g_free (oss->open_device);
   oss->open_device = NULL;

   g_free (oss->device_name);
   oss->device_name = NULL;

   return TRUE;
 }

 static gboolean
 gst_oss4_source_prepare (GstAudioSrc * asrc, GstAudioRingBufferSpec * spec)
 {
   GstOss4Source *oss;

   oss = GST_OSS4_SOURCE (asrc);

   if (!gst_oss4_audio_set_format (GST_OBJECT_CAST (oss), oss->fd, spec)) {
     GST_WARNING_OBJECT (oss, "Couldn't set requested format %" GST_PTR_FORMAT,
         spec->caps);
     return FALSE;
   }

   oss->bytes_per_sample = GST_AUDIO_INFO_BPF (&spec->info);

   return TRUE;
 }

 static gboolean
 gst_oss4_source_unprepare (GstAudioSrc * asrc)
 {
   /* could do a SNDCTL_DSP_HALT, but the OSS manual recommends a close/open,
    * since HALT won't properly reset some devices, apparently */

   if (!gst_oss4_source_close (asrc))
     goto couldnt_close;

   if (!gst_oss4_source_open_func (asrc))
     goto couldnt_reopen;

   return TRUE;

   /* ERRORS */
 couldnt_close:
   {
     GST_DEBUG_OBJECT (asrc, "Couldn't close the audio device");
     return FALSE;
   }
 couldnt_reopen:
   {
     GST_DEBUG_OBJECT (asrc, "Couldn't reopen the audio device");
     return FALSE;
   }
 }

 static guint
 gst_oss4_source_read (GstAudioSrc * asrc, gpointer data, guint length,
     GstClockTime * timestamp)
 {
   GstOss4Source *oss;
   int n;

   oss = GST_OSS4_SOURCE_CAST (asrc);

   n = read (oss->fd, data, length);
   GST_LOG_OBJECT (asrc, "%u bytes, %u samples", n, n / oss->bytes_per_sample);

   if (G_UNLIKELY (n < 0)) {
     switch (errno) {
       case ENOTSUP:
       case EACCES:{
         /* This is the most likely cause, I think */
         GST_ELEMENT_ERROR (asrc, RESOURCE, READ,
             (_("Recording is not supported by this audio device.")),
             ("read: %s (device: %s) (maybe this is an output-only device?)",
                 g_strerror (errno), oss->open_device));
         break;
       }
       default:{
         GST_ELEMENT_ERROR (asrc, RESOURCE, READ,
             (_("Error recording from audio device.")),
             ("read: %s (device: %s)", g_strerror (errno), oss->open_device));
         break;
       }
     }
   }

   return (guint) n;
 }

 static guint
 gst_oss4_source_delay (GstAudioSrc * asrc)
 {
   audio_buf_info info = { 0, };
   GstOss4Source *oss;
   guint delay;

   oss = GST_OSS4_SOURCE_CAST (asrc);

   if (ioctl (oss->fd, SNDCTL_DSP_GETISPACE, &info) == -1) {
     GST_LOG_OBJECT (oss, "GETISPACE failed: %s", g_strerror (errno));
     return 0;
   }

   delay = (info.fragstotal * info.fragsize) - info.bytes;
   GST_LOG_OBJECT (oss, "fragstotal:%d, fragsize:%d, bytes:%d, delay:%d",
       info.fragstotal, info.fragsize, info.bytes, delay);
   return delay;
 }

 static void
 gst_oss4_source_reset (GstAudioSrc * asrc)
 {
   /* There's nothing we can do here really: OSS can't handle access to the
    * same device/fd from multiple threads and might deadlock or blow up in
    * other ways if we try an ioctl SNDCTL_DSP_HALT or similar */
 }
	/* GStreamer OSS4 audio source
	* Copyright (C) 2007-2008 Tim-Philipp Müller <tim centricular net>
	*
	* 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-oss4src
	*
	* This element lets you record sound using the Open Sound System (OSS)
	* version 4.
	*
	* <refsect2>
	* <title>Example pipelines</title>
	* \|[
	* gst-launch-1.0 -v oss4src ! queue ! audioconvert ! vorbisenc ! oggmux ! filesink location=mymusic.ogg
	* ]\| will record sound from your sound card using OSS4 and encode it to an
	* Ogg/Vorbis file (this will only work if your mixer settings are right
	* and the right inputs areenabled etc.)
	* </refsect2>
	*/

	/* FIXME: make sure we're not doing ioctls from the app thread (e.g. via the
	* mixer interface) while recording */

	#ifdef HAVE_CONFIG_H
	#include "config.h"
	#endif

	#include <sys/types.h>
	#include <sys/stat.h>
	#include <sys/ioctl.h>
	#include <fcntl.h>
	#include <errno.h>
	#include <unistd.h>
	#include <string.h>

	#include <gst/gst-i18n-plugin.h>

	#define NO_LEGACY_MIXER
	#include "oss4-audio.h"
	#include "oss4-source.h"
	#include "oss4-property-probe.h"
	#include "oss4-soundcard.h"

	#define GST_OSS4_SOURCE_IS_OPEN(src) (GST_OSS4_SOURCE(src)->fd != -1)

	GST_DEBUG_CATEGORY_EXTERN (oss4src_debug);
	#define GST_CAT_DEFAULT oss4src_debug

	#define DEFAULT_DEVICE NULL
	#define DEFAULT_DEVICE_NAME NULL

	enum
	{
	PROP_0,
	PROP_DEVICE,
	PROP_DEVICE_NAME
	};

	#define gst_oss4_source_parent_class parent_class
	G_DEFINE_TYPE (GstOss4Source, gst_oss4_source, GST_TYPE_AUDIO_SRC);

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

	static void gst_oss4_source_dispose (GObject * object);
	static void gst_oss4_source_finalize (GstOss4Source * osssrc);

	static GstCaps gst_oss4_source_getcaps (GstBaseSrc bsrc, GstCaps * filter);

	static gboolean gst_oss4_source_open (GstAudioSrc * asrc,
	gboolean silent_errors);
	static gboolean gst_oss4_source_open_func (GstAudioSrc * asrc);
	static gboolean gst_oss4_source_close (GstAudioSrc * asrc);
	static gboolean gst_oss4_source_prepare (GstAudioSrc * asrc,
	GstAudioRingBufferSpec * spec);
	static gboolean gst_oss4_source_unprepare (GstAudioSrc * asrc);
	static guint gst_oss4_source_read (GstAudioSrc * asrc, gpointer data,
	guint length, GstClockTime * timestamp);
	static guint gst_oss4_source_delay (GstAudioSrc * asrc);
	static void gst_oss4_source_reset (GstAudioSrc * asrc);

	static void
	gst_oss4_source_class_init (GstOss4SourceClass * klass)
	{
	GObjectClass *gobject_class;
	GstElementClass *gstelement_class;
	GstBaseSrcClass *gstbasesrc_class;
	GstAudioSrcClass *gstaudiosrc_class;
	GstPadTemplate *templ;

	gobject_class = (GObjectClass *) klass;
	gstelement_class = (GstElementClass *) klass;
	gstbasesrc_class = (GstBaseSrcClass *) klass;
	gstaudiosrc_class = (GstAudioSrcClass *) klass;

	gobject_class->dispose = gst_oss4_source_dispose;
	gobject_class->finalize = (GObjectFinalizeFunc) gst_oss4_source_finalize;
	gobject_class->get_property = gst_oss4_source_get_property;
	gobject_class->set_property = gst_oss4_source_set_property;

	gstbasesrc_class->get_caps = GST_DEBUG_FUNCPTR (gst_oss4_source_getcaps);

	gstaudiosrc_class->open = GST_DEBUG_FUNCPTR (gst_oss4_source_open_func);
	gstaudiosrc_class->prepare = GST_DEBUG_FUNCPTR (gst_oss4_source_prepare);
	gstaudiosrc_class->unprepare = GST_DEBUG_FUNCPTR (gst_oss4_source_unprepare);
	gstaudiosrc_class->close = GST_DEBUG_FUNCPTR (gst_oss4_source_close);
	gstaudiosrc_class->read = GST_DEBUG_FUNCPTR (gst_oss4_source_read);
	gstaudiosrc_class->delay = GST_DEBUG_FUNCPTR (gst_oss4_source_delay);
	gstaudiosrc_class->reset = GST_DEBUG_FUNCPTR (gst_oss4_source_reset);

	g_object_class_install_property (gobject_class, PROP_DEVICE,
	g_param_spec_string ("device", "Device",
	"OSS4 device (e.g. /dev/oss/hdaudio0/pcm0 or /dev/dspN) "
	"(NULL = use first available device)",
	DEFAULT_DEVICE, G_PARAM_READWRITE \| G_PARAM_STATIC_STRINGS));

	g_object_class_install_property (gobject_class, PROP_DEVICE_NAME,
	g_param_spec_string ("device-name", "Device name",
	"Human-readable name of the sound device", DEFAULT_DEVICE_NAME,
	G_PARAM_READABLE \| G_PARAM_STATIC_STRINGS));

	gst_element_class_set_static_metadata (gstelement_class,
	"OSS v4 Audio Source", "Source/Audio",
	"Capture from a sound card via OSS version 4",
	"Tim-Philipp Müller <tim centricular net>");

	templ = gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
	gst_oss4_audio_get_template_caps ());
	gst_element_class_add_pad_template (gstelement_class, templ);
	}

	static void
	gst_oss4_source_init (GstOss4Source * osssrc)
	{
	const gchar *device;

	device = g_getenv ("AUDIODEV");
	if (device == NULL)
	device = DEFAULT_DEVICE;

	osssrc->fd = -1;
	osssrc->device = g_strdup (device);
	osssrc->device_name = g_strdup (DEFAULT_DEVICE_NAME);
	osssrc->device_name = NULL;
	}

	static void
	gst_oss4_source_finalize (GstOss4Source * oss)
	{
	g_free (oss->device);
	oss->device = NULL;

	G_OBJECT_CLASS (parent_class)->finalize ((GObject *) (oss));
	}

	static void
	gst_oss4_source_dispose (GObject * object)
	{
	GstOss4Source *oss = GST_OSS4_SOURCE (object);

	if (oss->probed_caps) {
	gst_caps_unref (oss->probed_caps);
	oss->probed_caps = NULL;
	}

	G_OBJECT_CLASS (parent_class)->dispose (object);
	}

	static void
	gst_oss4_source_set_property (GObject * object, guint prop_id,
	const GValue * value, GParamSpec * pspec)
	{
	GstOss4Source *oss;

	oss = GST_OSS4_SOURCE (object);

	switch (prop_id) {
	case PROP_DEVICE:
	GST_OBJECT_LOCK (oss);
	if (oss->fd == -1) {
	g_free (oss->device);
	oss->device = g_value_dup_string (value);
	g_free (oss->device_name);
	oss->device_name = NULL;
	} else {
	g_warning ("%s: can't change \"device\" property while audio source "
	"is open", GST_OBJECT_NAME (oss));
	}
	GST_OBJECT_UNLOCK (oss);
	break;
	default:
	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
	break;
	}
	}

	static void
	gst_oss4_source_get_property (GObject * object, guint prop_id,
	GValue * value, GParamSpec * pspec)
	{
	GstOss4Source *oss;

	oss = GST_OSS4_SOURCE (object);

	switch (prop_id) {
	case PROP_DEVICE:
	GST_OBJECT_LOCK (oss);
	g_value_set_string (value, oss->device);
	GST_OBJECT_UNLOCK (oss);
	break;
	case PROP_DEVICE_NAME:
	GST_OBJECT_LOCK (oss);
	/* If device is set, try to retrieve the name even if we're not open */
	if (oss->fd == -1 && oss->device != NULL) {
	if (gst_oss4_source_open (GST_AUDIO_SRC (oss), TRUE)) {
	g_value_set_string (value, oss->device_name);
	gst_oss4_source_close (GST_AUDIO_SRC (oss));
	} else {
	gchar *name = NULL;

	gst_oss4_property_probe_find_device_name_nofd (GST_OBJECT (oss),
	oss->device, &name);
	g_value_set_string (value, name);
	g_free (name);
	}
	} else {
	g_value_set_string (value, oss->device_name);
	}

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

	static GstCaps *
	gst_oss4_source_getcaps (GstBaseSrc * bsrc, GstCaps * filter)
	{
	GstOss4Source *oss;
	GstCaps *caps;

	oss = GST_OSS4_SOURCE (bsrc);

	if (oss->fd == -1) {
	caps = gst_oss4_audio_get_template_caps ();
	} else if (oss->probed_caps) {
	caps = gst_caps_copy (oss->probed_caps);
	} else {
	caps = gst_oss4_audio_probe_caps (GST_OBJECT (oss), oss->fd);
	if (caps != NULL && !gst_caps_is_empty (caps)) {
	oss->probed_caps = gst_caps_copy (caps);
	}
	}

	if (filter && caps) {
	GstCaps *intersection;

	intersection =
	gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
	gst_caps_unref (caps);
	return intersection;
	} else {
	return caps;
	}
	}

	/* note: we must not take the object lock here unless we fix up get_property */
	static gboolean
	gst_oss4_source_open (GstAudioSrc * asrc, gboolean silent_errors)
	{
	GstOss4Source *oss;
	gchar *device;
	int mode;

	oss = GST_OSS4_SOURCE (asrc);

	if (oss->device)
	device = g_strdup (oss->device);
	else
	device = gst_oss4_audio_find_device (GST_OBJECT_CAST (oss));

	/* desperate times, desperate measures */
	if (device == NULL)
	device = g_strdup ("/dev/dsp0");

	GST_INFO_OBJECT (oss, "Trying to open OSS4 device '%s'", device);

	/* we open in non-blocking mode even if we don't really want to do writes
	* non-blocking because we can't be sure that this is really a genuine
	* OSS4 device with well-behaved drivers etc. We really don't want to
	* hang forever under any circumstances. */
	oss->fd = open (device, O_RDONLY \| O_NONBLOCK, 0);
	if (oss->fd == -1) {
	switch (errno) {
	case EBUSY:
	goto busy;
	case EACCES:
	goto no_permission;
	default:
	goto open_failed;
	}
	}

	GST_INFO_OBJECT (oss, "Opened device");

	/* Make sure it's OSS4. If it's old OSS, let osssink handle it */
	if (!gst_oss4_audio_check_version (GST_OBJECT_CAST (oss), oss->fd))
	goto legacy_oss;

	/* now remove the non-blocking flag. */
	mode = fcntl (oss->fd, F_GETFL);
	mode &= ~O_NONBLOCK;
	if (fcntl (oss->fd, F_SETFL, mode) < 0) {
	/* some drivers do no support unsetting the non-blocking flag, try to
	* close/open the device then. This is racy but we error out properly. */
	GST_WARNING_OBJECT (oss, "failed to unset O_NONBLOCK (buggy driver?), "
	"will try to re-open device now");
	gst_oss4_source_close (asrc);
	if ((oss->fd = open (device, O_RDONLY, 0)) == -1)
	goto non_block;
	}

	oss->open_device = device;

	/* not using ENGINEINFO here because it sometimes returns a different and
	* less useful name than AUDIOINFO for the same device */
	if (!gst_oss4_property_probe_find_device_name (GST_OBJECT (oss), oss->fd,
	oss->open_device, &oss->device_name)) {
	oss->device_name = NULL;
	}

	return TRUE;

	/* ERRORS */
	busy:
	{
	if (!silent_errors) {
	GST_ELEMENT_ERROR (oss, RESOURCE, BUSY,
	(_("Could not open audio device for playback. "
	"Device is being used by another application.")), (NULL));
	}
	g_free (device);
	return FALSE;
	}
	no_permission:
	{
	if (!silent_errors) {
	GST_ELEMENT_ERROR (oss, RESOURCE, OPEN_READ,
	(_("Could not open audio device for playback. "
	"You don't have permission to open the device.")),
	GST_ERROR_SYSTEM);
	}
	g_free (device);
	return FALSE;
	}
	open_failed:
	{
	if (!silent_errors) {
	GST_ELEMENT_ERROR (oss, RESOURCE, OPEN_READ,
	(_("Could not open audio device for playback.")), GST_ERROR_SYSTEM);
	}
	g_free (device);
	return FALSE;
	}
	legacy_oss:
	{
	gst_oss4_source_close (asrc);
	if (!silent_errors) {
	GST_ELEMENT_ERROR (oss, RESOURCE, OPEN_READ,
	(_("Could not open audio device for playback. "
	"This version of the Open Sound System is not supported by this "
	"element.")), ("Try the 'osssink' element instead"));
	}
	g_free (device);
	return FALSE;
	}
	non_block:
	{
	if (!silent_errors) {
	GST_ELEMENT_ERROR (oss, RESOURCE, SETTINGS, (NULL),
	("Unable to set device %s into non-blocking mode: %s",
	oss->device, g_strerror (errno)));
	}
	g_free (device);
	return FALSE;
	}
	}

	static gboolean
	gst_oss4_source_open_func (GstAudioSrc * asrc)
	{
	return gst_oss4_source_open (asrc, FALSE);
	}

	static gboolean
	gst_oss4_source_close (GstAudioSrc * asrc)
	{
	GstOss4Source *oss;

	oss = GST_OSS4_SOURCE (asrc);

	if (oss->fd != -1) {
	GST_DEBUG_OBJECT (oss, "closing device");
	close (oss->fd);
	oss->fd = -1;
	}

	oss->bytes_per_sample = 0;

	gst_caps_replace (&oss->probed_caps, NULL);

	g_free (oss->open_device);
	oss->open_device = NULL;

	g_free (oss->device_name);
	oss->device_name = NULL;

	return TRUE;
	}

	static gboolean
	gst_oss4_source_prepare (GstAudioSrc * asrc, GstAudioRingBufferSpec * spec)
	{
	GstOss4Source *oss;

	oss = GST_OSS4_SOURCE (asrc);

	if (!gst_oss4_audio_set_format (GST_OBJECT_CAST (oss), oss->fd, spec)) {
	GST_WARNING_OBJECT (oss, "Couldn't set requested format %" GST_PTR_FORMAT,
	spec->caps);
	return FALSE;
	}

	oss->bytes_per_sample = GST_AUDIO_INFO_BPF (&spec->info);

	return TRUE;
	}

	static gboolean
	gst_oss4_source_unprepare (GstAudioSrc * asrc)
	{
	/* could do a SNDCTL_DSP_HALT, but the OSS manual recommends a close/open,
	* since HALT won't properly reset some devices, apparently */

	if (!gst_oss4_source_close (asrc))
	goto couldnt_close;

	if (!gst_oss4_source_open_func (asrc))
	goto couldnt_reopen;

	return TRUE;

	/* ERRORS */
	couldnt_close:
	{
	GST_DEBUG_OBJECT (asrc, "Couldn't close the audio device");
	return FALSE;
	}
	couldnt_reopen:
	{
	GST_DEBUG_OBJECT (asrc, "Couldn't reopen the audio device");
	return FALSE;
	}
	}

	static guint
	gst_oss4_source_read (GstAudioSrc * asrc, gpointer data, guint length,
	GstClockTime * timestamp)
	{
	GstOss4Source *oss;
	int n;

	oss = GST_OSS4_SOURCE_CAST (asrc);

	n = read (oss->fd, data, length);
	GST_LOG_OBJECT (asrc, "%u bytes, %u samples", n, n / oss->bytes_per_sample);

	if (G_UNLIKELY (n < 0)) {
	switch (errno) {
	case ENOTSUP:
	case EACCES:{
	/* This is the most likely cause, I think */
	GST_ELEMENT_ERROR (asrc, RESOURCE, READ,
	(_("Recording is not supported by this audio device.")),
	("read: %s (device: %s) (maybe this is an output-only device?)",
	g_strerror (errno), oss->open_device));
	break;
	}
	default:{
	GST_ELEMENT_ERROR (asrc, RESOURCE, READ,
	(_("Error recording from audio device.")),
	("read: %s (device: %s)", g_strerror (errno), oss->open_device));
	break;
	}
	}
	}

	return (guint) n;
	}

	static guint
	gst_oss4_source_delay (GstAudioSrc * asrc)
	{
	audio_buf_info info = { 0, };
	GstOss4Source *oss;
	guint delay;

	oss = GST_OSS4_SOURCE_CAST (asrc);

	if (ioctl (oss->fd, SNDCTL_DSP_GETISPACE, &info) == -1) {
	GST_LOG_OBJECT (oss, "GETISPACE failed: %s", g_strerror (errno));
	return 0;
	}

	delay = (info.fragstotal * info.fragsize) - info.bytes;
	GST_LOG_OBJECT (oss, "fragstotal:%d, fragsize:%d, bytes:%d, delay:%d",
	info.fragstotal, info.fragsize, info.bytes, delay);
	return delay;
	}

	static void
	gst_oss4_source_reset (GstAudioSrc * asrc)
	{
	/* There's nothing we can do here really: OSS can't handle access to the
	* same device/fd from multiple threads and might deadlock or blow up in
	* other ways if we try an ioctl SNDCTL_DSP_HALT or similar */
	}