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