ext/alsa/gstalsasrc.c

   1 /* GStreamer
   2  * Copyright (C) 2005 Wim Taymans <wim@fluendo.com>
   3  *
   4  * gstalsasrc.c:
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 /**
  23  * SECTION:element-alsasrc
  24  * @see_also: alsasink, alsamixer
  25  *
  26  * This element reads data from an audio card using the ALSA API.
  27  *
  28  * <refsect2>
  29  * <title>Example pipelines</title>
  30  * |[
  31  * gst-launch -v alsasrc ! audioconvert ! vorbisenc ! oggmux ! filesink location=alsasrc.ogg
  32  * ]| Record from a sound card using ALSA and encode to Ogg/Vorbis.
  33  * </refsect2>
  34  *
  35  * Last reviewed on 2006-03-01 (0.10.4)
  36  */
  37
  38 #ifdef HAVE_CONFIG_H
  39 #include "config.h"
  40 #endif
  41 #include <sys/ioctl.h>
  42 #include <fcntl.h>
  43 #include <errno.h>
  44 #include <unistd.h>
  45 #include <string.h>
  46 #include <getopt.h>
  47 #include <alsa/asoundlib.h>
  48
  49 #include "gstalsasrc.h"
  50 #include "gstalsadeviceprobe.h"
  51
  52 #include <gst/gst-i18n-plugin.h>
  53
  54 #define DEFAULT_PROP_DEVICE             "default"
  55 #define DEFAULT_PROP_DEVICE_NAME        ""
  56 #define DEFAULT_PROP_CARD_NAME          ""
  57
  58 enum
  59 {
  60   PROP_0,
  61   PROP_DEVICE,
  62   PROP_DEVICE_NAME,
  63   PROP_CARD_NAME,
  64   PROP_LAST
  65 };
  66
  67 static void gst_alsasrc_init_interfaces (GType type);
  68 #define gst_alsasrc_parent_class parent_class
  69 G_DEFINE_TYPE_WITH_CODE (GstAlsaSrc, gst_alsasrc,
  70     GST_TYPE_AUDIO_SRC, gst_alsasrc_init_interfaces (g_define_type_id));
  71
  72 GST_IMPLEMENT_ALSA_MIXER_METHODS (GstAlsaSrc, gst_alsasrc_mixer);
  73
  74 static void gst_alsasrc_finalize (GObject * object);
  75 static void gst_alsasrc_set_property (GObject * object,
  76     guint prop_id, const GValue * value, GParamSpec * pspec);
  77 static void gst_alsasrc_get_property (GObject * object,
  78     guint prop_id, GValue * value, GParamSpec * pspec);
  79
  80 static GstCaps *gst_alsasrc_getcaps (GstBaseSrc * bsrc, GstCaps * filter);
  81
  82 static gboolean gst_alsasrc_open (GstAudioSrc * asrc);
  83 static gboolean gst_alsasrc_prepare (GstAudioSrc * asrc,
  84     GstRingBufferSpec * spec);
  85 static gboolean gst_alsasrc_unprepare (GstAudioSrc * asrc);
  86 static gboolean gst_alsasrc_close (GstAudioSrc * asrc);
  87 static guint gst_alsasrc_read (GstAudioSrc * asrc, gpointer data, guint length);
  88 static guint gst_alsasrc_delay (GstAudioSrc * asrc);
  89 static void gst_alsasrc_reset (GstAudioSrc * asrc);
  90 static GstStateChangeReturn gst_alsasrc_change_state (GstElement * element,
  91     GstStateChange transition);
  92 static GstFlowReturn gst_alsasrc_create (GstBaseSrc * bsrc, guint64 offset,
  93     guint length, GstBuffer ** outbuf);
  94 static GstClockTime gst_alsasrc_get_timestamp (GstAlsaSrc * src);
  95
  96
  97 /* AlsaSrc signals and args */
  98 enum
  99 {
 100   LAST_SIGNAL
 101 };
 102
 103 #if (G_BYTE_ORDER == G_LITTLE_ENDIAN)
 104 # define ALSA_SRC_FACTORY_ENDIANNESS   "LITTLE_ENDIAN, BIG_ENDIAN"
 105 #else
 106 # define ALSA_SRC_FACTORY_ENDIANNESS   "BIG_ENDIAN, LITTLE_ENDIAN"
 107 #endif
 108
 109 static GstStaticPadTemplate alsasrc_src_factory =
 110     GST_STATIC_PAD_TEMPLATE ("src",
 111     GST_PAD_SRC,
 112     GST_PAD_ALWAYS,
 113     GST_STATIC_CAPS ("audio/x-raw-int, "
 114         "endianness = (int) { " ALSA_SRC_FACTORY_ENDIANNESS " }, "
 115         "signed = (boolean) { TRUE, FALSE }, "
 116         "width = (int) 32, "
 117         "depth = (int) 32, "
 118         "rate = (int) [ 1, MAX ], " "channels = (int) [ 1, MAX ]; "
 119         "audio/x-raw-int, "
 120         "endianness = (int) { " ALSA_SRC_FACTORY_ENDIANNESS " }, "
 121         "signed = (boolean) { TRUE, FALSE }, "
 122         "width = (int) 32, "
 123         "depth = (int) 24, "
 124         "rate = (int) [ 1, MAX ], " "channels = (int) [ 1, MAX ]; "
 125         "audio/x-raw-int, "
 126         "endianness = (int) { " ALSA_SRC_FACTORY_ENDIANNESS " }, "
 127         "signed = (boolean) { TRUE, FALSE }, "
 128         "width = (int) 24, "
 129         "depth = (int) 24, "
 130         "rate = (int) [ 1, MAX ], " "channels = (int) [ 1, MAX ]; "
 131         "audio/x-raw-int, "
 132         "endianness = (int) { " ALSA_SRC_FACTORY_ENDIANNESS " }, "
 133         "signed = (boolean) { TRUE, FALSE }, "
 134         "width = (int) 16, "
 135         "depth = (int) 16, "
 136         "rate = (int) [ 1, MAX ], " "channels = (int) [ 1, MAX ]; "
 137         "audio/x-raw-int, "
 138         "signed = (boolean) { TRUE, FALSE }, "
 139         "width = (int) 8, "
 140         "depth = (int) 8, "
 141         "rate = (int) [ 1, MAX ], " "channels = (int) [ 1, MAX ]")
 142     );
 143
 144 static void
 145 gst_alsasrc_finalize (GObject * object)
 146 {
 147   GstAlsaSrc *src = GST_ALSA_SRC (object);
 148
 149   g_free (src->device);
 150   g_mutex_free (src->alsa_lock);
 151
 152   G_OBJECT_CLASS (parent_class)->finalize (object);
 153 }
 154
 155 static gboolean
 156 gst_alsasrc_interface_supported (GstAlsaSrc * this, GType interface_type)
 157 {
 158   /* only support this one interface (wrapped by GstImplementsInterface) */
 159   g_assert (interface_type == GST_TYPE_MIXER);
 160
 161   return gst_alsasrc_mixer_supported (this, interface_type);
 162 }
 163
 164 static void
 165 gst_implements_interface_init (GstImplementsInterfaceClass * klass)
 166 {
 167   klass->supported = (gpointer) gst_alsasrc_interface_supported;
 168 }
 169
 170 static void
 171 gst_alsasrc_init_interfaces (GType type)
 172 {
 173   static const GInterfaceInfo implements_iface_info = {
 174     (GInterfaceInitFunc) gst_implements_interface_init,
 175     NULL,
 176     NULL,
 177   };
 178   static const GInterfaceInfo mixer_iface_info = {
 179     (GInterfaceInitFunc) gst_alsasrc_mixer_interface_init,
 180     NULL,
 181     NULL,
 182   };
 183
 184   g_type_add_interface_static (type, GST_TYPE_IMPLEMENTS_INTERFACE,
 185       &implements_iface_info);
 186   g_type_add_interface_static (type, GST_TYPE_MIXER, &mixer_iface_info);
 187
 188   gst_alsa_type_add_device_property_probe_interface (type);
 189 }
 190
 191 static void
 192 gst_alsasrc_class_init (GstAlsaSrcClass * klass)
 193 {
 194   GObjectClass *gobject_class;
 195   GstElementClass *gstelement_class;
 196   GstBaseSrcClass *gstbasesrc_class;
 197   GstAudioSrcClass *gstaudiosrc_class;
 198
 199   gobject_class = (GObjectClass *) klass;
 200   gstelement_class = (GstElementClass *) klass;
 201   gstbasesrc_class = (GstBaseSrcClass *) klass;
 202   gstaudiosrc_class = (GstAudioSrcClass *) klass;
 203
 204   gobject_class->finalize = gst_alsasrc_finalize;
 205   gobject_class->get_property = gst_alsasrc_get_property;
 206   gobject_class->set_property = gst_alsasrc_set_property;
 207
 208   gst_element_class_set_details_simple (gstelement_class,
 209       "Audio source (ALSA)", "Source/Audio",
 210       "Read from a sound card via ALSA", "Wim Taymans <wim@fluendo.com>");
 211
 212   gst_element_class_add_pad_template (gstelement_class,
 213       gst_static_pad_template_get (&alsasrc_src_factory));
 214
 215   gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_alsasrc_change_state);
 216
 217   gstbasesrc_class->get_caps = GST_DEBUG_FUNCPTR (gst_alsasrc_getcaps);
 218   gstbasesrc_class->create = GST_DEBUG_FUNCPTR (gst_alsasrc_create);
 219
 220   gstaudiosrc_class->open = GST_DEBUG_FUNCPTR (gst_alsasrc_open);
 221   gstaudiosrc_class->prepare = GST_DEBUG_FUNCPTR (gst_alsasrc_prepare);
 222   gstaudiosrc_class->unprepare = GST_DEBUG_FUNCPTR (gst_alsasrc_unprepare);
 223   gstaudiosrc_class->close = GST_DEBUG_FUNCPTR (gst_alsasrc_close);
 224   gstaudiosrc_class->read = GST_DEBUG_FUNCPTR (gst_alsasrc_read);
 225   gstaudiosrc_class->delay = GST_DEBUG_FUNCPTR (gst_alsasrc_delay);
 226   gstaudiosrc_class->reset = GST_DEBUG_FUNCPTR (gst_alsasrc_reset);
 227
 228   g_object_class_install_property (gobject_class, PROP_DEVICE,
 229       g_param_spec_string ("device", "Device",
 230           "ALSA device, as defined in an asound configuration file",
 231           DEFAULT_PROP_DEVICE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 232
 233   g_object_class_install_property (gobject_class, PROP_DEVICE_NAME,
 234       g_param_spec_string ("device-name", "Device name",
 235           "Human-readable name of the sound device",
 236           DEFAULT_PROP_DEVICE_NAME, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
 237
 238   g_object_class_install_property (gobject_class, PROP_CARD_NAME,
 239       g_param_spec_string ("card-name", "Card name",
 240           "Human-readable name of the sound card",
 241           DEFAULT_PROP_CARD_NAME, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
 242 }
 243
 244 static GstClockTime
 245 gst_alsasrc_get_timestamp (GstAlsaSrc * src)
 246 {
 247   snd_pcm_status_t *status;
 248   snd_htimestamp_t tstamp;
 249   GstClockTime timestamp;
 250   snd_pcm_uframes_t availmax;
 251
 252   GST_DEBUG_OBJECT (src, "Getting alsa timestamp!");
 253
 254   if (!src) {
 255     GST_ERROR_OBJECT (src, "No alsa handle created yet !");
 256     return 0;
 257   }
 258
 259   if (snd_pcm_status_malloc (&status) != 0) {
 260     GST_ERROR_OBJECT (src, "snd_pcm_status_malloc failed");
 261   }
 262
 263   if (snd_pcm_status (src->handle, status) != 0) {
 264     GST_ERROR_OBJECT (src, "snd_pcm_status failed");
 265   }
 266
 267   /* get high resolution time stamp from driver */
 268   snd_pcm_status_get_htstamp (status, &tstamp);
 269   timestamp = GST_TIMESPEC_TO_TIME (tstamp);
 270
 271   /* Max available frames sets the depth of the buffer */
 272   availmax = snd_pcm_status_get_avail_max (status);
 273
 274   /* Compensate the fact that the timestamp references the last sample */
 275   timestamp -= gst_util_uint64_scale_int (availmax * 2, GST_SECOND, src->rate);
 276   /* Compensate for the delay until the package is available */
 277   timestamp += gst_util_uint64_scale_int (snd_pcm_status_get_delay (status),
 278       GST_SECOND, src->rate);
 279
 280   snd_pcm_status_free (status);
 281
 282   GST_DEBUG_OBJECT (src, "ALSA timestamp : %" GST_TIME_FORMAT,
 283       GST_TIME_ARGS (timestamp));
 284   return timestamp;
 285 }
 286
 287 static void
 288 gst_alsasrc_set_property (GObject * object, guint prop_id,
 289     const GValue * value, GParamSpec * pspec)
 290 {
 291   GstAlsaSrc *src;
 292
 293   src = GST_ALSA_SRC (object);
 294
 295   switch (prop_id) {
 296     case PROP_DEVICE:
 297       g_free (src->device);
 298       src->device = g_value_dup_string (value);
 299       if (src->device == NULL) {
 300         src->device = g_strdup (DEFAULT_PROP_DEVICE);
 301       }
 302       break;
 303     default:
 304       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 305       break;
 306   }
 307 }
 308
 309 static void
 310 gst_alsasrc_get_property (GObject * object, guint prop_id,
 311     GValue * value, GParamSpec * pspec)
 312 {
 313   GstAlsaSrc *src;
 314
 315   src = GST_ALSA_SRC (object);
 316
 317   switch (prop_id) {
 318     case PROP_DEVICE:
 319       g_value_set_string (value, src->device);
 320       break;
 321     case PROP_DEVICE_NAME:
 322       g_value_take_string (value,
 323           gst_alsa_find_device_name (GST_OBJECT_CAST (src),
 324               src->device, src->handle, SND_PCM_STREAM_CAPTURE));
 325       break;
 326     case PROP_CARD_NAME:
 327       g_value_take_string (value,
 328           gst_alsa_find_card_name (GST_OBJECT_CAST (src),
 329               src->device, SND_PCM_STREAM_CAPTURE));
 330       break;
 331     default:
 332       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 333       break;
 334   }
 335 }
 336
 337 static GstStateChangeReturn
 338 gst_alsasrc_change_state (GstElement * element, GstStateChange transition)
 339 {
 340   GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
 341   GstBaseAudioSrc *src = GST_BASE_AUDIO_SRC (element);
 342   GstAlsaSrc *asrc = GST_ALSA_SRC (element);
 343   GstClock *clk;
 344
 345   switch (transition) {
 346       /* Show the compiler that we care */
 347     case GST_STATE_CHANGE_NULL_TO_READY:
 348     case GST_STATE_CHANGE_READY_TO_PAUSED:
 349     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
 350     case GST_STATE_CHANGE_PAUSED_TO_READY:
 351     case GST_STATE_CHANGE_READY_TO_NULL:
 352       break;
 353
 354     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
 355       clk = src->clock;
 356       asrc->driver_timestamps = FALSE;
 357       if (GST_IS_SYSTEM_CLOCK (clk)) {
 358         gint clocktype;
 359         g_object_get (clk, "clock-type", &clocktype, NULL);
 360         if (clocktype == GST_CLOCK_TYPE_MONOTONIC) {
 361           asrc->driver_timestamps = TRUE;
 362         }
 363       }
 364       break;
 365   }
 366   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 367
 368   return ret;
 369 }
 370
 371 static GstFlowReturn
 372 gst_alsasrc_create (GstBaseSrc * bsrc, guint64 offset, guint length,
 373     GstBuffer ** outbuf)
 374 {
 375   GstFlowReturn ret = GST_FLOW_OK;
 376   GstAlsaSrc *asrc = GST_ALSA_SRC (bsrc);
 377
 378   ret =
 379       GST_BASE_SRC_CLASS (parent_class)->create (bsrc, offset, length, outbuf);
 380   if (asrc->driver_timestamps == TRUE && *outbuf) {
 381     GST_BUFFER_TIMESTAMP (*outbuf) =
 382         gst_alsasrc_get_timestamp ((GstAlsaSrc *) bsrc);
 383   }
 384
 385   return ret;
 386 }
 387
 388 static void
 389 gst_alsasrc_init (GstAlsaSrc * alsasrc)
 390 {
 391   GST_DEBUG_OBJECT (alsasrc, "initializing");
 392
 393   alsasrc->device = g_strdup (DEFAULT_PROP_DEVICE);
 394   alsasrc->cached_caps = NULL;
 395   alsasrc->driver_timestamps = FALSE;
 396
 397   alsasrc->alsa_lock = g_mutex_new ();
 398 }
 399
 400 #define CHECK(call, error) \
 401 G_STMT_START {                  \
 402 if ((err = call) < 0)           \
 403   goto error;                   \
 404 } G_STMT_END;
 405
 406
 407 static GstCaps *
 408 gst_alsasrc_getcaps (GstBaseSrc * bsrc, GstCaps * filter)
 409 {
 410   GstElementClass *element_class;
 411   GstPadTemplate *pad_template;
 412   GstAlsaSrc *src;
 413   GstCaps *caps, *templ_caps;
 414
 415   src = GST_ALSA_SRC (bsrc);
 416
 417   if (src->handle == NULL) {
 418     GST_DEBUG_OBJECT (src, "device not open, using template caps");
 419     return NULL;                /* base class will get template caps for us */
 420   }
 421
 422   if (src->cached_caps) {
 423     GST_LOG_OBJECT (src, "Returning cached caps");
 424     if (filter)
 425       return gst_caps_intersect_full (filter, src->cached_caps,
 426           GST_CAPS_INTERSECT_FIRST);
 427     else
 428       return gst_caps_ref (src->cached_caps);
 429   }
 430
 431   element_class = GST_ELEMENT_GET_CLASS (src);
 432   pad_template = gst_element_class_get_pad_template (element_class, "src");
 433   g_return_val_if_fail (pad_template != NULL, NULL);
 434
 435   templ_caps = gst_pad_template_get_caps (pad_template);
 436   caps = gst_alsa_probe_supported_formats (GST_OBJECT (src), src->handle,
 437       templ_caps);
 438   gst_caps_unref (templ_caps);
 439
 440   if (caps) {
 441     src->cached_caps = gst_caps_ref (caps);
 442   }
 443
 444   GST_INFO_OBJECT (src, "returning caps %" GST_PTR_FORMAT, caps);
 445
 446   if (filter) {
 447     GstCaps *intersection;
 448
 449     intersection =
 450         gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
 451     gst_caps_unref (caps);
 452     return intersection;
 453   } else {
 454     return caps;
 455   }
 456 }
 457
 458 static int
 459 set_hwparams (GstAlsaSrc * alsa)
 460 {
 461   guint rrate;
 462   gint err;
 463   snd_pcm_hw_params_t *params;
 464
 465   snd_pcm_hw_params_malloc (&params);
 466
 467   /* choose all parameters */
 468   CHECK (snd_pcm_hw_params_any (alsa->handle, params), no_config);
 469   /* set the interleaved read/write format */
 470   CHECK (snd_pcm_hw_params_set_access (alsa->handle, params, alsa->access),
 471       wrong_access);
 472   /* set the sample format */
 473   CHECK (snd_pcm_hw_params_set_format (alsa->handle, params, alsa->format),
 474       no_sample_format);
 475   /* set the count of channels */
 476   CHECK (snd_pcm_hw_params_set_channels (alsa->handle, params, alsa->channels),
 477       no_channels);
 478   /* set the stream rate */
 479   rrate = alsa->rate;
 480   CHECK (snd_pcm_hw_params_set_rate_near (alsa->handle, params, &rrate, NULL),
 481       no_rate);
 482   if (rrate != alsa->rate)
 483     goto rate_match;
 484
 485   if (alsa->buffer_time != -1) {
 486     /* set the buffer time */
 487     CHECK (snd_pcm_hw_params_set_buffer_time_near (alsa->handle, params,
 488             &alsa->buffer_time, NULL), buffer_time);
 489   }
 490   if (alsa->period_time != -1) {
 491     /* set the period time */
 492     CHECK (snd_pcm_hw_params_set_period_time_near (alsa->handle, params,
 493             &alsa->period_time, NULL), period_time);
 494   }
 495
 496   /* write the parameters to device */
 497   CHECK (snd_pcm_hw_params (alsa->handle, params), set_hw_params);
 498
 499   CHECK (snd_pcm_hw_params_get_buffer_size (params, &alsa->buffer_size),
 500       buffer_size);
 501
 502   CHECK (snd_pcm_hw_params_get_period_size (params, &alsa->period_size, NULL),
 503       period_size);
 504
 505   snd_pcm_hw_params_free (params);
 506   return 0;
 507
 508   /* ERRORS */
 509 no_config:
 510   {
 511     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 512         ("Broken configuration for recording: no configurations available: %s",
 513             snd_strerror (err)));
 514     snd_pcm_hw_params_free (params);
 515     return err;
 516   }
 517 wrong_access:
 518   {
 519     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 520         ("Access type not available for recording: %s", snd_strerror (err)));
 521     snd_pcm_hw_params_free (params);
 522     return err;
 523   }
 524 no_sample_format:
 525   {
 526     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 527         ("Sample format not available for recording: %s", snd_strerror (err)));
 528     snd_pcm_hw_params_free (params);
 529     return err;
 530   }
 531 no_channels:
 532   {
 533     gchar *msg = NULL;
 534
 535     if ((alsa->channels) == 1)
 536       msg = g_strdup (_("Could not open device for recording in mono mode."));
 537     if ((alsa->channels) == 2)
 538       msg = g_strdup (_("Could not open device for recording in stereo mode."));
 539     if ((alsa->channels) > 2)
 540       msg =
 541           g_strdup_printf (_
 542           ("Could not open device for recording in %d-channel mode"),
 543           alsa->channels);
 544     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, ("%s", msg),
 545         ("%s", snd_strerror (err)));
 546     g_free (msg);
 547     snd_pcm_hw_params_free (params);
 548     return err;
 549   }
 550 no_rate:
 551   {
 552     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 553         ("Rate %iHz not available for recording: %s",
 554             alsa->rate, snd_strerror (err)));
 555     snd_pcm_hw_params_free (params);
 556     return err;
 557   }
 558 rate_match:
 559   {
 560     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 561         ("Rate doesn't match (requested %iHz, get %iHz)", alsa->rate, err));
 562     snd_pcm_hw_params_free (params);
 563     return -EINVAL;
 564   }
 565 buffer_time:
 566   {
 567     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 568         ("Unable to set buffer time %i for recording: %s",
 569             alsa->buffer_time, snd_strerror (err)));
 570     snd_pcm_hw_params_free (params);
 571     return err;
 572   }
 573 buffer_size:
 574   {
 575     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 576         ("Unable to get buffer size for recording: %s", snd_strerror (err)));
 577     snd_pcm_hw_params_free (params);
 578     return err;
 579   }
 580 period_time:
 581   {
 582     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 583         ("Unable to set period time %i for recording: %s", alsa->period_time,
 584             snd_strerror (err)));
 585     snd_pcm_hw_params_free (params);
 586     return err;
 587   }
 588 period_size:
 589   {
 590     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 591         ("Unable to get period size for recording: %s", snd_strerror (err)));
 592     snd_pcm_hw_params_free (params);
 593     return err;
 594   }
 595 set_hw_params:
 596   {
 597     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 598         ("Unable to set hw params for recording: %s", snd_strerror (err)));
 599     snd_pcm_hw_params_free (params);
 600     return err;
 601   }
 602 }
 603
 604 static int
 605 set_swparams (GstAlsaSrc * alsa)
 606 {
 607   int err;
 608   snd_pcm_sw_params_t *params;
 609
 610   snd_pcm_sw_params_malloc (&params);
 611
 612   /* get the current swparams */
 613   CHECK (snd_pcm_sw_params_current (alsa->handle, params), no_config);
 614   /* allow the transfer when at least period_size samples can be processed */
 615   CHECK (snd_pcm_sw_params_set_avail_min (alsa->handle, params,
 616           alsa->period_size), set_avail);
 617   /* start the transfer on first read */
 618   CHECK (snd_pcm_sw_params_set_start_threshold (alsa->handle, params,
 619           0), start_threshold);
 620
 621 #if GST_CHECK_ALSA_VERSION(1,0,16)
 622   /* snd_pcm_sw_params_set_xfer_align() is deprecated, alignment is always 1 */
 623 #else
 624   /* align all transfers to 1 sample */
 625   CHECK (snd_pcm_sw_params_set_xfer_align (alsa->handle, params, 1), set_align);
 626 #endif
 627
 628   /* write the parameters to the recording device */
 629   CHECK (snd_pcm_sw_params (alsa->handle, params), set_sw_params);
 630
 631   snd_pcm_sw_params_free (params);
 632   return 0;
 633
 634   /* ERRORS */
 635 no_config:
 636   {
 637     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 638         ("Unable to determine current swparams for playback: %s",
 639             snd_strerror (err)));
 640     snd_pcm_sw_params_free (params);
 641     return err;
 642   }
 643 start_threshold:
 644   {
 645     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 646         ("Unable to set start threshold mode for playback: %s",
 647             snd_strerror (err)));
 648     snd_pcm_sw_params_free (params);
 649     return err;
 650   }
 651 set_avail:
 652   {
 653     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 654         ("Unable to set avail min for playback: %s", snd_strerror (err)));
 655     snd_pcm_sw_params_free (params);
 656     return err;
 657   }
 658 #if !GST_CHECK_ALSA_VERSION(1,0,16)
 659 set_align:
 660   {
 661     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 662         ("Unable to set transfer align for playback: %s", snd_strerror (err)));
 663     snd_pcm_sw_params_free (params);
 664     return err;
 665   }
 666 #endif
 667 set_sw_params:
 668   {
 669     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 670         ("Unable to set sw params for playback: %s", snd_strerror (err)));
 671     snd_pcm_sw_params_free (params);
 672     return err;
 673   }
 674 }
 675
 676 static gboolean
 677 alsasrc_parse_spec (GstAlsaSrc * alsa, GstRingBufferSpec * spec)
 678 {
 679   switch (spec->type) {
 680     case GST_BUFTYPE_LINEAR:
 681       alsa->format = snd_pcm_build_linear_format (spec->depth, spec->width,
 682           spec->sign ? 0 : 1, spec->bigend ? 1 : 0);
 683       break;
 684     case GST_BUFTYPE_FLOAT:
 685       switch (spec->format) {
 686         case GST_FLOAT32_LE:
 687           alsa->format = SND_PCM_FORMAT_FLOAT_LE;
 688           break;
 689         case GST_FLOAT32_BE:
 690           alsa->format = SND_PCM_FORMAT_FLOAT_BE;
 691           break;
 692         case GST_FLOAT64_LE:
 693           alsa->format = SND_PCM_FORMAT_FLOAT64_LE;
 694           break;
 695         case GST_FLOAT64_BE:
 696           alsa->format = SND_PCM_FORMAT_FLOAT64_BE;
 697           break;
 698         default:
 699           goto error;
 700       }
 701       break;
 702     case GST_BUFTYPE_A_LAW:
 703       alsa->format = SND_PCM_FORMAT_A_LAW;
 704       break;
 705     case GST_BUFTYPE_MU_LAW:
 706       alsa->format = SND_PCM_FORMAT_MU_LAW;
 707       break;
 708     default:
 709       goto error;
 710
 711   }
 712   alsa->rate = spec->rate;
 713   alsa->channels = spec->channels;
 714   alsa->buffer_time = spec->buffer_time;
 715   alsa->period_time = spec->latency_time;
 716   alsa->access = SND_PCM_ACCESS_RW_INTERLEAVED;
 717
 718   return TRUE;
 719
 720   /* ERRORS */
 721 error:
 722   {
 723     return FALSE;
 724   }
 725 }
 726
 727 static gboolean
 728 gst_alsasrc_open (GstAudioSrc * asrc)
 729 {
 730   GstAlsaSrc *alsa;
 731   gint err;
 732
 733   alsa = GST_ALSA_SRC (asrc);
 734
 735   CHECK (snd_pcm_open (&alsa->handle, alsa->device, SND_PCM_STREAM_CAPTURE,
 736           SND_PCM_NONBLOCK), open_error);
 737
 738   if (!alsa->mixer)
 739     alsa->mixer = gst_alsa_mixer_new (alsa->device, GST_ALSA_MIXER_CAPTURE);
 740
 741   return TRUE;
 742
 743   /* ERRORS */
 744 open_error:
 745   {
 746     if (err == -EBUSY) {
 747       GST_ELEMENT_ERROR (alsa, RESOURCE, BUSY,
 748           (_("Could not open audio device for recording. "
 749                   "Device is being used by another application.")),
 750           ("Device '%s' is busy", alsa->device));
 751     } else {
 752       GST_ELEMENT_ERROR (alsa, RESOURCE, OPEN_READ,
 753           (_("Could not open audio device for recording.")),
 754           ("Recording open error on device '%s': %s", alsa->device,
 755               snd_strerror (err)));
 756     }
 757     return FALSE;
 758   }
 759 }
 760
 761 static gboolean
 762 gst_alsasrc_prepare (GstAudioSrc * asrc, GstRingBufferSpec * spec)
 763 {
 764   GstAlsaSrc *alsa;
 765   gint err;
 766
 767   alsa = GST_ALSA_SRC (asrc);
 768
 769   if (!alsasrc_parse_spec (alsa, spec))
 770     goto spec_parse;
 771
 772   CHECK (snd_pcm_nonblock (alsa->handle, 0), non_block);
 773
 774   CHECK (set_hwparams (alsa), hw_params_failed);
 775   CHECK (set_swparams (alsa), sw_params_failed);
 776   CHECK (snd_pcm_prepare (alsa->handle), prepare_failed);
 777
 778   alsa->bytes_per_sample = spec->bytes_per_sample;
 779   spec->segsize = alsa->period_size * spec->bytes_per_sample;
 780   spec->segtotal = alsa->buffer_size / alsa->period_size;
 781   spec->silence_sample[0] = 0;
 782   spec->silence_sample[1] = 0;
 783   spec->silence_sample[2] = 0;
 784   spec->silence_sample[3] = 0;
 785
 786   return TRUE;
 787
 788   /* ERRORS */
 789 spec_parse:
 790   {
 791     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 792         ("Error parsing spec"));
 793     return FALSE;
 794   }
 795 non_block:
 796   {
 797     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 798         ("Could not set device to blocking: %s", snd_strerror (err)));
 799     return FALSE;
 800   }
 801 hw_params_failed:
 802   {
 803     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 804         ("Setting of hwparams failed: %s", snd_strerror (err)));
 805     return FALSE;
 806   }
 807 sw_params_failed:
 808   {
 809     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 810         ("Setting of swparams failed: %s", snd_strerror (err)));
 811     return FALSE;
 812   }
 813 prepare_failed:
 814   {
 815     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 816         ("Prepare failed: %s", snd_strerror (err)));
 817     return FALSE;
 818   }
 819 }
 820
 821 static gboolean
 822 gst_alsasrc_unprepare (GstAudioSrc * asrc)
 823 {
 824   GstAlsaSrc *alsa;
 825
 826   alsa = GST_ALSA_SRC (asrc);
 827
 828   snd_pcm_drop (alsa->handle);
 829   snd_pcm_hw_free (alsa->handle);
 830   snd_pcm_nonblock (alsa->handle, 1);
 831
 832   return TRUE;
 833 }
 834
 835 static gboolean
 836 gst_alsasrc_close (GstAudioSrc * asrc)
 837 {
 838   GstAlsaSrc *alsa = GST_ALSA_SRC (asrc);
 839
 840   snd_pcm_close (alsa->handle);
 841   alsa->handle = NULL;
 842
 843   if (alsa->mixer) {
 844     gst_alsa_mixer_free (alsa->mixer);
 845     alsa->mixer = NULL;
 846   }
 847
 848   gst_caps_replace (&alsa->cached_caps, NULL);
 849
 850   return TRUE;
 851 }
 852
 853 /*
 854  *   Underrun and suspend recovery
 855  */
 856 static gint
 857 xrun_recovery (GstAlsaSrc * alsa, snd_pcm_t * handle, gint err)
 858 {
 859   GST_DEBUG_OBJECT (alsa, "xrun recovery %d", err);
 860
 861   if (err == -EPIPE) {          /* under-run */
 862     err = snd_pcm_prepare (handle);
 863     if (err < 0)
 864       GST_WARNING_OBJECT (alsa,
 865           "Can't recovery from underrun, prepare failed: %s",
 866           snd_strerror (err));
 867     return 0;
 868   } else if (err == -ESTRPIPE) {
 869     while ((err = snd_pcm_resume (handle)) == -EAGAIN)
 870       g_usleep (100);           /* wait until the suspend flag is released */
 871
 872     if (err < 0) {
 873       err = snd_pcm_prepare (handle);
 874       if (err < 0)
 875         GST_WARNING_OBJECT (alsa,
 876             "Can't recovery from suspend, prepare failed: %s",
 877             snd_strerror (err));
 878     }
 879     return 0;
 880   }
 881   return err;
 882 }
 883
 884 static guint
 885 gst_alsasrc_read (GstAudioSrc * asrc, gpointer data, guint length)
 886 {
 887   GstAlsaSrc *alsa;
 888   gint err;
 889   gint cptr;
 890   gint16 *ptr;
 891
 892   alsa = GST_ALSA_SRC (asrc);
 893
 894   cptr = length / alsa->bytes_per_sample;
 895   ptr = data;
 896
 897   GST_ALSA_SRC_LOCK (asrc);
 898   while (cptr > 0) {
 899     if ((err = snd_pcm_readi (alsa->handle, ptr, cptr)) < 0) {
 900       if (err == -EAGAIN) {
 901         GST_DEBUG_OBJECT (asrc, "Read error: %s", snd_strerror (err));
 902         continue;
 903       } else if (xrun_recovery (alsa, alsa->handle, err) < 0) {
 904         goto read_error;
 905       }
 906       continue;
 907     }
 908
 909     ptr += err * alsa->channels;
 910     cptr -= err;
 911   }
 912   GST_ALSA_SRC_UNLOCK (asrc);
 913
 914   return length - (cptr * alsa->bytes_per_sample);
 915
 916 read_error:
 917   {
 918     GST_ALSA_SRC_UNLOCK (asrc);
 919     return length;              /* skip one period */
 920   }
 921 }
 922
 923 static guint
 924 gst_alsasrc_delay (GstAudioSrc * asrc)
 925 {
 926   GstAlsaSrc *alsa;
 927   snd_pcm_sframes_t delay;
 928   int res;
 929
 930   alsa = GST_ALSA_SRC (asrc);
 931
 932   res = snd_pcm_delay (alsa->handle, &delay);
 933   if (G_UNLIKELY (res < 0)) {
 934     GST_DEBUG_OBJECT (alsa, "snd_pcm_delay returned %d", res);
 935     delay = 0;
 936   }
 937
 938   return CLAMP (delay, 0, alsa->buffer_size);
 939 }
 940
 941 static void
 942 gst_alsasrc_reset (GstAudioSrc * asrc)
 943 {
 944   GstAlsaSrc *alsa;
 945   gint err;
 946
 947   alsa = GST_ALSA_SRC (asrc);
 948
 949   GST_ALSA_SRC_LOCK (asrc);
 950   GST_DEBUG_OBJECT (alsa, "drop");
 951   CHECK (snd_pcm_drop (alsa->handle), drop_error);
 952   GST_DEBUG_OBJECT (alsa, "prepare");
 953   CHECK (snd_pcm_prepare (alsa->handle), prepare_error);
 954   GST_DEBUG_OBJECT (alsa, "reset done");
 955   GST_ALSA_SRC_UNLOCK (asrc);
 956
 957   return;
 958
 959   /* ERRORS */
 960 drop_error:
 961   {
 962     GST_ERROR_OBJECT (alsa, "alsa-reset: pcm drop error: %s",
 963         snd_strerror (err));
 964     GST_ALSA_SRC_UNLOCK (asrc);
 965     return;
 966   }
 967 prepare_error:
 968   {
 969     GST_ERROR_OBJECT (alsa, "alsa-reset: pcm prepare error: %s",
 970         snd_strerror (err));
 971     GST_ALSA_SRC_UNLOCK (asrc);
 972     return;
 973   }
 974 }