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