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 /* elementfactory information */
  55 static const GstElementDetails gst_alsasrc_details =
  56 GST_ELEMENT_DETAILS ("Audio source (ALSA)",
  57     "Source/Audio",
  58     "Read from a sound card via ALSA",
  59     "Wim Taymans <wim@fluendo.com>");
  60
  61 #define DEFAULT_PROP_DEVICE             "default"
  62 #define DEFAULT_PROP_DEVICE_NAME        ""
  63
  64 enum
  65 {
  66   PROP_0,
  67   PROP_DEVICE,
  68   PROP_DEVICE_NAME,
  69 };
  70
  71 static void gst_alsasrc_init_interfaces (GType type);
  72
  73 GST_BOILERPLATE_FULL (GstAlsaSrc, gst_alsasrc, GstAudioSrc,
  74     GST_TYPE_AUDIO_SRC, gst_alsasrc_init_interfaces);
  75
  76 GST_IMPLEMENT_ALSA_MIXER_METHODS (GstAlsaSrc, gst_alsasrc_mixer);
  77
  78 static void gst_alsasrc_finalize (GObject * object);
  79 static void gst_alsasrc_set_property (GObject * object,
  80     guint prop_id, const GValue * value, GParamSpec * pspec);
  81 static void gst_alsasrc_get_property (GObject * object,
  82     guint prop_id, GValue * value, GParamSpec * pspec);
  83
  84 static GstCaps *gst_alsasrc_getcaps (GstBaseSrc * bsrc);
  85
  86 static gboolean gst_alsasrc_open (GstAudioSrc * asrc);
  87 static gboolean gst_alsasrc_prepare (GstAudioSrc * asrc,
  88     GstRingBufferSpec * spec);
  89 static gboolean gst_alsasrc_unprepare (GstAudioSrc * asrc);
  90 static gboolean gst_alsasrc_close (GstAudioSrc * asrc);
  91 static guint gst_alsasrc_read (GstAudioSrc * asrc, gpointer data, guint length);
  92 static guint gst_alsasrc_delay (GstAudioSrc * asrc);
  93 static void gst_alsasrc_reset (GstAudioSrc * asrc);
  94
  95 /* AlsaSrc signals and args */
  96 enum
  97 {
  98   LAST_SIGNAL
  99 };
 100
 101 #if (G_BYTE_ORDER == G_LITTLE_ENDIAN)
 102 # define ALSA_SRC_FACTORY_ENDIANNESS   "LITTLE_ENDIAN, BIG_ENDIAN"
 103 #else
 104 # define ALSA_SRC_FACTORY_ENDIANNESS   "BIG_ENDIAN, LITTLE_ENDIAN"
 105 #endif
 106
 107 static GstStaticPadTemplate alsasrc_src_factory =
 108     GST_STATIC_PAD_TEMPLATE ("src",
 109     GST_PAD_SRC,
 110     GST_PAD_ALWAYS,
 111     GST_STATIC_CAPS ("audio/x-raw-int, "
 112         "endianness = (int) { " ALSA_SRC_FACTORY_ENDIANNESS " }, "
 113         "signed = (boolean) { TRUE, FALSE }, "
 114         "width = (int) 32, "
 115         "depth = (int) 32, "
 116         "rate = (int) [ 1, MAX ], " "channels = (int) [ 1, MAX ]; "
 117         "audio/x-raw-int, "
 118         "endianness = (int) { " ALSA_SRC_FACTORY_ENDIANNESS " }, "
 119         "signed = (boolean) { TRUE, FALSE }, "
 120         "width = (int) 32, "
 121         "depth = (int) 24, "
 122         "rate = (int) [ 1, MAX ], " "channels = (int) [ 1, MAX ]; "
 123         "audio/x-raw-int, "
 124         "endianness = (int) { " ALSA_SRC_FACTORY_ENDIANNESS " }, "
 125         "signed = (boolean) { TRUE, FALSE }, "
 126         "width = (int) 24, "
 127         "depth = (int) 24, "
 128         "rate = (int) [ 1, MAX ], " "channels = (int) [ 1, MAX ]; "
 129         "audio/x-raw-int, "
 130         "endianness = (int) { " ALSA_SRC_FACTORY_ENDIANNESS " }, "
 131         "signed = (boolean) { TRUE, FALSE }, "
 132         "width = (int) 16, "
 133         "depth = (int) 16, "
 134         "rate = (int) [ 1, MAX ], " "channels = (int) [ 1, MAX ]; "
 135         "audio/x-raw-int, "
 136         "signed = (boolean) { TRUE, FALSE }, "
 137         "width = (int) 8, "
 138         "depth = (int) 8, "
 139         "rate = (int) [ 1, MAX ], " "channels = (int) [ 1, MAX ]")
 140     );
 141
 142 static void
 143 gst_alsasrc_finalize (GObject * object)
 144 {
 145   GstAlsaSrc *src = GST_ALSA_SRC (object);
 146
 147   g_free (src->device);
 148   g_mutex_free (src->alsa_lock);
 149
 150   G_OBJECT_CLASS (parent_class)->finalize (object);
 151 }
 152
 153 static gboolean
 154 gst_alsasrc_interface_supported (GstAlsaSrc * this, GType interface_type)
 155 {
 156   /* only support this one interface (wrapped by GstImplementsInterface) */
 157   g_assert (interface_type == GST_TYPE_MIXER);
 158
 159   return gst_alsasrc_mixer_supported (this, interface_type);
 160 }
 161
 162 static void
 163 gst_implements_interface_init (GstImplementsInterfaceClass * klass)
 164 {
 165   klass->supported = (gpointer) gst_alsasrc_interface_supported;
 166 }
 167
 168 static void
 169 gst_alsasrc_init_interfaces (GType type)
 170 {
 171   static const GInterfaceInfo implements_iface_info = {
 172     (GInterfaceInitFunc) gst_implements_interface_init,
 173     NULL,
 174     NULL,
 175   };
 176   static const GInterfaceInfo mixer_iface_info = {
 177     (GInterfaceInitFunc) gst_alsasrc_mixer_interface_init,
 178     NULL,
 179     NULL,
 180   };
 181
 182   g_type_add_interface_static (type, GST_TYPE_IMPLEMENTS_INTERFACE,
 183       &implements_iface_info);
 184   g_type_add_interface_static (type, GST_TYPE_MIXER, &mixer_iface_info);
 185
 186   gst_alsa_type_add_device_property_probe_interface (type);
 187 }
 188
 189 static void
 190 gst_alsasrc_base_init (gpointer g_class)
 191 {
 192   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 193
 194   gst_element_class_set_details (element_class, &gst_alsasrc_details);
 195
 196   gst_element_class_add_pad_template (element_class,
 197       gst_static_pad_template_get (&alsasrc_src_factory));
 198 }
 199
 200 static void
 201 gst_alsasrc_class_init (GstAlsaSrcClass * klass)
 202 {
 203   GObjectClass *gobject_class;
 204   GstBaseSrcClass *gstbasesrc_class;
 205   GstAudioSrcClass *gstaudiosrc_class;
 206
 207   gobject_class = (GObjectClass *) klass;
 208   gstbasesrc_class = (GstBaseSrcClass *) klass;
 209   gstaudiosrc_class = (GstAudioSrcClass *) klass;
 210
 211   gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_alsasrc_finalize);
 212   gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_alsasrc_get_property);
 213   gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_alsasrc_set_property);
 214
 215   gstbasesrc_class->get_caps = GST_DEBUG_FUNCPTR (gst_alsasrc_getcaps);
 216
 217   gstaudiosrc_class->open = GST_DEBUG_FUNCPTR (gst_alsasrc_open);
 218   gstaudiosrc_class->prepare = GST_DEBUG_FUNCPTR (gst_alsasrc_prepare);
 219   gstaudiosrc_class->unprepare = GST_DEBUG_FUNCPTR (gst_alsasrc_unprepare);
 220   gstaudiosrc_class->close = GST_DEBUG_FUNCPTR (gst_alsasrc_close);
 221   gstaudiosrc_class->read = GST_DEBUG_FUNCPTR (gst_alsasrc_read);
 222   gstaudiosrc_class->delay = GST_DEBUG_FUNCPTR (gst_alsasrc_delay);
 223   gstaudiosrc_class->reset = GST_DEBUG_FUNCPTR (gst_alsasrc_reset);
 224
 225   g_object_class_install_property (gobject_class, PROP_DEVICE,
 226       g_param_spec_string ("device", "Device",
 227           "ALSA device, as defined in an asound configuration file",
 228           DEFAULT_PROP_DEVICE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 229
 230   g_object_class_install_property (gobject_class, PROP_DEVICE_NAME,
 231       g_param_spec_string ("device-name", "Device name",
 232           "Human-readable name of the sound device",
 233           DEFAULT_PROP_DEVICE_NAME, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
 234 }
 235
 236 static void
 237 gst_alsasrc_set_property (GObject * object, guint prop_id,
 238     const GValue * value, GParamSpec * pspec)
 239 {
 240   GstAlsaSrc *src;
 241
 242   src = GST_ALSA_SRC (object);
 243
 244   switch (prop_id) {
 245     case PROP_DEVICE:
 246       g_free (src->device);
 247       src->device = g_value_dup_string (value);
 248       if (src->device == NULL) {
 249         src->device = g_strdup (DEFAULT_PROP_DEVICE);
 250       }
 251       break;
 252     default:
 253       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 254       break;
 255   }
 256 }
 257
 258 static void
 259 gst_alsasrc_get_property (GObject * object, guint prop_id,
 260     GValue * value, GParamSpec * pspec)
 261 {
 262   GstAlsaSrc *src;
 263
 264   src = GST_ALSA_SRC (object);
 265
 266   switch (prop_id) {
 267     case PROP_DEVICE:
 268       g_value_set_string (value, src->device);
 269       break;
 270     case PROP_DEVICE_NAME:
 271       g_value_take_string (value,
 272           gst_alsa_find_device_name (GST_OBJECT_CAST (src),
 273               src->device, src->handle, SND_PCM_STREAM_CAPTURE));
 274       break;
 275     default:
 276       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 277       break;
 278   }
 279 }
 280
 281 static void
 282 gst_alsasrc_init (GstAlsaSrc * alsasrc, GstAlsaSrcClass * g_class)
 283 {
 284   GST_DEBUG_OBJECT (alsasrc, "initializing");
 285
 286   alsasrc->device = g_strdup (DEFAULT_PROP_DEVICE);
 287   alsasrc->cached_caps = NULL;
 288
 289   alsasrc->alsa_lock = g_mutex_new ();
 290 }
 291
 292 #define CHECK(call, error) \
 293 G_STMT_START {                  \
 294 if ((err = call) < 0)           \
 295   goto error;                   \
 296 } G_STMT_END;
 297
 298
 299 static GstCaps *
 300 gst_alsasrc_getcaps (GstBaseSrc * bsrc)
 301 {
 302   GstElementClass *element_class;
 303   GstPadTemplate *pad_template;
 304   GstAlsaSrc *src;
 305   GstCaps *caps;
 306
 307   src = GST_ALSA_SRC (bsrc);
 308
 309   if (src->handle == NULL) {
 310     GST_DEBUG_OBJECT (src, "device not open, using template caps");
 311     return NULL;                /* base class will get template caps for us */
 312   }
 313
 314   if (src->cached_caps) {
 315     GST_LOG_OBJECT (src, "Returning cached caps");
 316     return gst_caps_ref (src->cached_caps);
 317   }
 318
 319   element_class = GST_ELEMENT_GET_CLASS (src);
 320   pad_template = gst_element_class_get_pad_template (element_class, "src");
 321   g_return_val_if_fail (pad_template != NULL, NULL);
 322
 323   caps = gst_alsa_probe_supported_formats (GST_OBJECT (src), src->handle,
 324       gst_pad_template_get_caps (pad_template));
 325
 326   if (caps) {
 327     src->cached_caps = gst_caps_ref (caps);
 328   }
 329
 330   GST_INFO_OBJECT (src, "returning caps %" GST_PTR_FORMAT, caps);
 331
 332   return caps;
 333 }
 334
 335 static int
 336 set_hwparams (GstAlsaSrc * alsa)
 337 {
 338   guint rrate;
 339   gint err, dir;
 340   snd_pcm_hw_params_t *params;
 341
 342   snd_pcm_hw_params_malloc (&params);
 343
 344   /* choose all parameters */
 345   CHECK (snd_pcm_hw_params_any (alsa->handle, params), no_config);
 346   /* set the interleaved read/write format */
 347   CHECK (snd_pcm_hw_params_set_access (alsa->handle, params, alsa->access),
 348       wrong_access);
 349   /* set the sample format */
 350   CHECK (snd_pcm_hw_params_set_format (alsa->handle, params, alsa->format),
 351       no_sample_format);
 352   /* set the count of channels */
 353   CHECK (snd_pcm_hw_params_set_channels (alsa->handle, params, alsa->channels),
 354       no_channels);
 355   /* set the stream rate */
 356   rrate = alsa->rate;
 357   CHECK (snd_pcm_hw_params_set_rate_near (alsa->handle, params, &rrate, NULL),
 358       no_rate);
 359   if (rrate != alsa->rate)
 360     goto rate_match;
 361
 362   if (alsa->buffer_time != -1) {
 363     /* set the buffer time */
 364     CHECK (snd_pcm_hw_params_set_buffer_time_near (alsa->handle, params,
 365             &alsa->buffer_time, &dir), buffer_time);
 366   }
 367   if (alsa->period_time != -1) {
 368     /* set the period time */
 369     CHECK (snd_pcm_hw_params_set_period_time_near (alsa->handle, params,
 370             &alsa->period_time, &dir), period_time);
 371   }
 372
 373   /* write the parameters to device */
 374   CHECK (snd_pcm_hw_params (alsa->handle, params), set_hw_params);
 375
 376   CHECK (snd_pcm_hw_params_get_buffer_size (params, &alsa->buffer_size),
 377       buffer_size);
 378
 379   CHECK (snd_pcm_hw_params_get_period_size (params, &alsa->period_size, &dir),
 380       period_size);
 381
 382   snd_pcm_hw_params_free (params);
 383   return 0;
 384
 385   /* ERRORS */
 386 no_config:
 387   {
 388     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 389         ("Broken configuration for recording: no configurations available: %s",
 390             snd_strerror (err)));
 391     snd_pcm_hw_params_free (params);
 392     return err;
 393   }
 394 wrong_access:
 395   {
 396     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 397         ("Access type not available for recording: %s", snd_strerror (err)));
 398     snd_pcm_hw_params_free (params);
 399     return err;
 400   }
 401 no_sample_format:
 402   {
 403     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 404         ("Sample format not available for recording: %s", snd_strerror (err)));
 405     snd_pcm_hw_params_free (params);
 406     return err;
 407   }
 408 no_channels:
 409   {
 410     gchar *msg = NULL;
 411
 412     if ((alsa->channels) == 1)
 413       msg = g_strdup (_("Could not open device for recording in mono mode."));
 414     if ((alsa->channels) == 2)
 415       msg = g_strdup (_("Could not open device for recording in stereo mode."));
 416     if ((alsa->channels) > 2)
 417       msg =
 418           g_strdup_printf (_
 419           ("Could not open device for recording in %d-channel mode"),
 420           alsa->channels);
 421     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (msg), (snd_strerror (err)));
 422     g_free (msg);
 423     snd_pcm_hw_params_free (params);
 424     return err;
 425   }
 426 no_rate:
 427   {
 428     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 429         ("Rate %iHz not available for recording: %s",
 430             alsa->rate, snd_strerror (err)));
 431     snd_pcm_hw_params_free (params);
 432     return err;
 433   }
 434 rate_match:
 435   {
 436     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 437         ("Rate doesn't match (requested %iHz, get %iHz)", alsa->rate, err));
 438     snd_pcm_hw_params_free (params);
 439     return -EINVAL;
 440   }
 441 buffer_time:
 442   {
 443     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 444         ("Unable to set buffer time %i for recording: %s",
 445             alsa->buffer_time, snd_strerror (err)));
 446     snd_pcm_hw_params_free (params);
 447     return err;
 448   }
 449 buffer_size:
 450   {
 451     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 452         ("Unable to get buffer size for recording: %s", snd_strerror (err)));
 453     snd_pcm_hw_params_free (params);
 454     return err;
 455   }
 456 period_time:
 457   {
 458     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 459         ("Unable to set period time %i for recording: %s", alsa->period_time,
 460             snd_strerror (err)));
 461     snd_pcm_hw_params_free (params);
 462     return err;
 463   }
 464 period_size:
 465   {
 466     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 467         ("Unable to get period size for recording: %s", snd_strerror (err)));
 468     snd_pcm_hw_params_free (params);
 469     return err;
 470   }
 471 set_hw_params:
 472   {
 473     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 474         ("Unable to set hw params for recording: %s", snd_strerror (err)));
 475     snd_pcm_hw_params_free (params);
 476     return err;
 477   }
 478 }
 479
 480 static int
 481 set_swparams (GstAlsaSrc * alsa)
 482 {
 483   int err;
 484   snd_pcm_sw_params_t *params;
 485
 486   snd_pcm_sw_params_malloc (&params);
 487
 488   /* get the current swparams */
 489   CHECK (snd_pcm_sw_params_current (alsa->handle, params), no_config);
 490   /* allow the transfer when at least period_size samples can be processed */
 491   CHECK (snd_pcm_sw_params_set_avail_min (alsa->handle, params,
 492           alsa->period_size), set_avail);
 493   /* start the transfer on first read */
 494   CHECK (snd_pcm_sw_params_set_start_threshold (alsa->handle, params,
 495           0), start_threshold);
 496
 497 #if GST_CHECK_ALSA_VERSION(1,0,16)
 498   /* snd_pcm_sw_params_set_xfer_align() is deprecated, alignment is always 1 */
 499 #else
 500   /* align all transfers to 1 sample */
 501   CHECK (snd_pcm_sw_params_set_xfer_align (alsa->handle, params, 1), set_align);
 502 #endif
 503
 504   /* write the parameters to the recording device */
 505   CHECK (snd_pcm_sw_params (alsa->handle, params), set_sw_params);
 506
 507   snd_pcm_sw_params_free (params);
 508   return 0;
 509
 510   /* ERRORS */
 511 no_config:
 512   {
 513     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 514         ("Unable to determine current swparams for playback: %s",
 515             snd_strerror (err)));
 516     snd_pcm_sw_params_free (params);
 517     return err;
 518   }
 519 start_threshold:
 520   {
 521     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 522         ("Unable to set start threshold mode for playback: %s",
 523             snd_strerror (err)));
 524     snd_pcm_sw_params_free (params);
 525     return err;
 526   }
 527 set_avail:
 528   {
 529     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 530         ("Unable to set avail min for playback: %s", snd_strerror (err)));
 531     snd_pcm_sw_params_free (params);
 532     return err;
 533   }
 534 #if !GST_CHECK_ALSA_VERSION(1,0,16)
 535 set_align:
 536   {
 537     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 538         ("Unable to set transfer align for playback: %s", snd_strerror (err)));
 539     snd_pcm_sw_params_free (params);
 540     return err;
 541   }
 542 #endif
 543 set_sw_params:
 544   {
 545     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 546         ("Unable to set sw params for playback: %s", snd_strerror (err)));
 547     snd_pcm_sw_params_free (params);
 548     return err;
 549   }
 550 }
 551
 552 static gboolean
 553 alsasrc_parse_spec (GstAlsaSrc * alsa, GstRingBufferSpec * spec)
 554 {
 555   switch (spec->type) {
 556     case GST_BUFTYPE_LINEAR:
 557       alsa->format = snd_pcm_build_linear_format (spec->depth, spec->width,
 558           spec->sign ? 0 : 1, spec->bigend ? 1 : 0);
 559       break;
 560     case GST_BUFTYPE_FLOAT:
 561       switch (spec->format) {
 562         case GST_FLOAT32_LE:
 563           alsa->format = SND_PCM_FORMAT_FLOAT_LE;
 564           break;
 565         case GST_FLOAT32_BE:
 566           alsa->format = SND_PCM_FORMAT_FLOAT_BE;
 567           break;
 568         case GST_FLOAT64_LE:
 569           alsa->format = SND_PCM_FORMAT_FLOAT64_LE;
 570           break;
 571         case GST_FLOAT64_BE:
 572           alsa->format = SND_PCM_FORMAT_FLOAT64_BE;
 573           break;
 574         default:
 575           goto error;
 576       }
 577       break;
 578     case GST_BUFTYPE_A_LAW:
 579       alsa->format = SND_PCM_FORMAT_A_LAW;
 580       break;
 581     case GST_BUFTYPE_MU_LAW:
 582       alsa->format = SND_PCM_FORMAT_MU_LAW;
 583       break;
 584     default:
 585       goto error;
 586
 587   }
 588   alsa->rate = spec->rate;
 589   alsa->channels = spec->channels;
 590   alsa->buffer_time = spec->buffer_time;
 591   alsa->period_time = spec->latency_time;
 592   alsa->access = SND_PCM_ACCESS_RW_INTERLEAVED;
 593
 594   return TRUE;
 595
 596   /* ERRORS */
 597 error:
 598   {
 599     return FALSE;
 600   }
 601 }
 602
 603 static gboolean
 604 gst_alsasrc_open (GstAudioSrc * asrc)
 605 {
 606   GstAlsaSrc *alsa;
 607   gint err;
 608
 609   alsa = GST_ALSA_SRC (asrc);
 610
 611   CHECK (snd_pcm_open (&alsa->handle, alsa->device, SND_PCM_STREAM_CAPTURE,
 612           SND_PCM_NONBLOCK), open_error);
 613
 614   if (!alsa->mixer)
 615     alsa->mixer = gst_alsa_mixer_new (alsa->device, GST_ALSA_MIXER_CAPTURE);
 616
 617   return TRUE;
 618
 619   /* ERRORS */
 620 open_error:
 621   {
 622     if (err == -EBUSY) {
 623       GST_ELEMENT_ERROR (alsa, RESOURCE, BUSY,
 624           (_("Could not open audio device for recording. "
 625                   "Device is being used by another application.")),
 626           ("Device '%s' is busy", alsa->device));
 627     } else {
 628       GST_ELEMENT_ERROR (alsa, RESOURCE, OPEN_READ,
 629           (_("Could not open audio device for recording.")),
 630           ("Recording open error on device '%s': %s", alsa->device,
 631               snd_strerror (err)));
 632     }
 633     return FALSE;
 634   }
 635 }
 636
 637 static gboolean
 638 gst_alsasrc_prepare (GstAudioSrc * asrc, GstRingBufferSpec * spec)
 639 {
 640   GstAlsaSrc *alsa;
 641   gint err;
 642
 643   alsa = GST_ALSA_SRC (asrc);
 644
 645   if (!alsasrc_parse_spec (alsa, spec))
 646     goto spec_parse;
 647
 648   CHECK (snd_pcm_nonblock (alsa->handle, 0), non_block);
 649
 650   CHECK (set_hwparams (alsa), hw_params_failed);
 651   CHECK (set_swparams (alsa), sw_params_failed);
 652   CHECK (snd_pcm_prepare (alsa->handle), prepare_failed);
 653
 654   alsa->bytes_per_sample = spec->bytes_per_sample;
 655   spec->segsize = alsa->period_size * spec->bytes_per_sample;
 656   spec->segtotal = alsa->buffer_size / alsa->period_size;
 657   spec->silence_sample[0] = 0;
 658   spec->silence_sample[1] = 0;
 659   spec->silence_sample[2] = 0;
 660   spec->silence_sample[3] = 0;
 661
 662   return TRUE;
 663
 664   /* ERRORS */
 665 spec_parse:
 666   {
 667     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 668         ("Error parsing spec"));
 669     return FALSE;
 670   }
 671 non_block:
 672   {
 673     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 674         ("Could not set device to blocking: %s", snd_strerror (err)));
 675     return FALSE;
 676   }
 677 hw_params_failed:
 678   {
 679     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 680         ("Setting of hwparams failed: %s", snd_strerror (err)));
 681     return FALSE;
 682   }
 683 sw_params_failed:
 684   {
 685     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 686         ("Setting of swparams failed: %s", snd_strerror (err)));
 687     return FALSE;
 688   }
 689 prepare_failed:
 690   {
 691     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 692         ("Prepare failed: %s", snd_strerror (err)));
 693     return FALSE;
 694   }
 695 }
 696
 697 static gboolean
 698 gst_alsasrc_unprepare (GstAudioSrc * asrc)
 699 {
 700   GstAlsaSrc *alsa;
 701   gint err;
 702
 703   alsa = GST_ALSA_SRC (asrc);
 704
 705   CHECK (snd_pcm_drop (alsa->handle), drop);
 706
 707   CHECK (snd_pcm_hw_free (alsa->handle), hw_free);
 708
 709   CHECK (snd_pcm_nonblock (alsa->handle, 1), non_block);
 710
 711   return TRUE;
 712
 713   /* ERRORS */
 714 drop:
 715   {
 716     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 717         ("Could not drop samples: %s", snd_strerror (err)));
 718     return FALSE;
 719   }
 720 hw_free:
 721   {
 722     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 723         ("Could not free hw params: %s", snd_strerror (err)));
 724     return FALSE;
 725   }
 726 non_block:
 727   {
 728     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 729         ("Could not set device to nonblocking: %s", snd_strerror (err)));
 730     return FALSE;
 731   }
 732 }
 733
 734 static gboolean
 735 gst_alsasrc_close (GstAudioSrc * asrc)
 736 {
 737   GstAlsaSrc *alsa = GST_ALSA_SRC (asrc);
 738
 739   snd_pcm_close (alsa->handle);
 740   alsa->handle = NULL;
 741
 742   if (alsa->mixer) {
 743     gst_alsa_mixer_free (alsa->mixer);
 744     alsa->mixer = NULL;
 745   }
 746
 747   gst_caps_replace (&alsa->cached_caps, NULL);
 748
 749   return TRUE;
 750 }
 751
 752 /*
 753  *   Underrun and suspend recovery
 754  */
 755 static gint
 756 xrun_recovery (GstAlsaSrc * alsa, snd_pcm_t * handle, gint err)
 757 {
 758   GST_DEBUG_OBJECT (alsa, "xrun recovery %d", err);
 759
 760   if (err == -EPIPE) {          /* under-run */
 761     err = snd_pcm_prepare (handle);
 762     if (err < 0)
 763       GST_WARNING_OBJECT (alsa,
 764           "Can't recovery from underrun, prepare failed: %s",
 765           snd_strerror (err));
 766     return 0;
 767   } else if (err == -ESTRPIPE) {
 768     while ((err = snd_pcm_resume (handle)) == -EAGAIN)
 769       g_usleep (100);           /* wait until the suspend flag is released */
 770
 771     if (err < 0) {
 772       err = snd_pcm_prepare (handle);
 773       if (err < 0)
 774         GST_WARNING_OBJECT (alsa,
 775             "Can't recovery from suspend, prepare failed: %s",
 776             snd_strerror (err));
 777     }
 778     return 0;
 779   }
 780   return err;
 781 }
 782
 783 static guint
 784 gst_alsasrc_read (GstAudioSrc * asrc, gpointer data, guint length)
 785 {
 786   GstAlsaSrc *alsa;
 787   gint err;
 788   gint cptr;
 789   gint16 *ptr;
 790
 791   alsa = GST_ALSA_SRC (asrc);
 792
 793   cptr = length / alsa->bytes_per_sample;
 794   ptr = data;
 795
 796   GST_ALSA_SRC_LOCK (asrc);
 797   while (cptr > 0) {
 798     if ((err = snd_pcm_readi (alsa->handle, ptr, cptr)) < 0) {
 799       if (err == -EAGAIN) {
 800         GST_DEBUG_OBJECT (asrc, "Read error: %s", snd_strerror (err));
 801         continue;
 802       } else if (xrun_recovery (alsa, alsa->handle, err) < 0) {
 803         goto read_error;
 804       }
 805       continue;
 806     }
 807
 808     ptr += err * alsa->channels;
 809     cptr -= err;
 810   }
 811   GST_ALSA_SRC_UNLOCK (asrc);
 812
 813   return length - cptr;
 814
 815 read_error:
 816   {
 817     GST_ALSA_SRC_UNLOCK (asrc);
 818     return length;              /* skip one period */
 819   }
 820 }
 821
 822 static guint
 823 gst_alsasrc_delay (GstAudioSrc * asrc)
 824 {
 825   GstAlsaSrc *alsa;
 826   snd_pcm_sframes_t delay;
 827   int res;
 828
 829   alsa = GST_ALSA_SRC (asrc);
 830
 831   res = snd_pcm_delay (alsa->handle, &delay);
 832   if (G_UNLIKELY (res < 0)) {
 833     GST_DEBUG_OBJECT (alsa, "snd_pcm_delay returned %d", res);
 834     delay = 0;
 835   }
 836
 837   return CLAMP (delay, 0, alsa->buffer_size);
 838 }
 839
 840 static void
 841 gst_alsasrc_reset (GstAudioSrc * asrc)
 842 {
 843   GstAlsaSrc *alsa;
 844   gint err;
 845
 846   alsa = GST_ALSA_SRC (asrc);
 847
 848   GST_ALSA_SRC_LOCK (asrc);
 849   GST_DEBUG_OBJECT (alsa, "drop");
 850   CHECK (snd_pcm_drop (alsa->handle), drop_error);
 851   GST_DEBUG_OBJECT (alsa, "prepare");
 852   CHECK (snd_pcm_prepare (alsa->handle), prepare_error);
 853   GST_DEBUG_OBJECT (alsa, "reset done");
 854   GST_ALSA_SRC_UNLOCK (asrc);
 855
 856   return;
 857
 858   /* ERRORS */
 859 drop_error:
 860   {
 861     GST_ERROR_OBJECT (alsa, "alsa-reset: pcm drop error: %s",
 862         snd_strerror (err));
 863     GST_ALSA_SRC_UNLOCK (asrc);
 864     return;
 865   }
 866 prepare_error:
 867   {
 868     GST_ERROR_OBJECT (alsa, "alsa-reset: pcm prepare error: %s",
 869         snd_strerror (err));
 870     GST_ALSA_SRC_UNLOCK (asrc);
 871     return;
 872   }
 873 }