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 void
 156 gst_alsasrc_init_interfaces (GType type)
 157 {
 158   static const GInterfaceInfo mixer_iface_info = {
 159     (GInterfaceInitFunc) gst_alsasrc_mixer_interface_init,
 160     NULL,
 161     NULL,
 162   };
 163
 164   g_type_add_interface_static (type, GST_TYPE_MIXER, &mixer_iface_info);
 165
 166   gst_alsa_type_add_device_property_probe_interface (type);
 167 }
 168
 169 static void
 170 gst_alsasrc_class_init (GstAlsaSrcClass * klass)
 171 {
 172   GObjectClass *gobject_class;
 173   GstElementClass *gstelement_class;
 174   GstBaseSrcClass *gstbasesrc_class;
 175   GstAudioSrcClass *gstaudiosrc_class;
 176
 177   gobject_class = (GObjectClass *) klass;
 178   gstelement_class = (GstElementClass *) klass;
 179   gstbasesrc_class = (GstBaseSrcClass *) klass;
 180   gstaudiosrc_class = (GstAudioSrcClass *) klass;
 181
 182   gobject_class->finalize = gst_alsasrc_finalize;
 183   gobject_class->get_property = gst_alsasrc_get_property;
 184   gobject_class->set_property = gst_alsasrc_set_property;
 185
 186   gst_element_class_set_details_simple (gstelement_class,
 187       "Audio source (ALSA)", "Source/Audio",
 188       "Read from a sound card via ALSA", "Wim Taymans <wim@fluendo.com>");
 189
 190   gst_element_class_add_pad_template (gstelement_class,
 191       gst_static_pad_template_get (&alsasrc_src_factory));
 192
 193   gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_alsasrc_change_state);
 194
 195   gstbasesrc_class->get_caps = GST_DEBUG_FUNCPTR (gst_alsasrc_getcaps);
 196   gstbasesrc_class->create = GST_DEBUG_FUNCPTR (gst_alsasrc_create);
 197
 198   gstaudiosrc_class->open = GST_DEBUG_FUNCPTR (gst_alsasrc_open);
 199   gstaudiosrc_class->prepare = GST_DEBUG_FUNCPTR (gst_alsasrc_prepare);
 200   gstaudiosrc_class->unprepare = GST_DEBUG_FUNCPTR (gst_alsasrc_unprepare);
 201   gstaudiosrc_class->close = GST_DEBUG_FUNCPTR (gst_alsasrc_close);
 202   gstaudiosrc_class->read = GST_DEBUG_FUNCPTR (gst_alsasrc_read);
 203   gstaudiosrc_class->delay = GST_DEBUG_FUNCPTR (gst_alsasrc_delay);
 204   gstaudiosrc_class->reset = GST_DEBUG_FUNCPTR (gst_alsasrc_reset);
 205
 206   g_object_class_install_property (gobject_class, PROP_DEVICE,
 207       g_param_spec_string ("device", "Device",
 208           "ALSA device, as defined in an asound configuration file",
 209           DEFAULT_PROP_DEVICE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 210
 211   g_object_class_install_property (gobject_class, PROP_DEVICE_NAME,
 212       g_param_spec_string ("device-name", "Device name",
 213           "Human-readable name of the sound device",
 214           DEFAULT_PROP_DEVICE_NAME, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
 215
 216   g_object_class_install_property (gobject_class, PROP_CARD_NAME,
 217       g_param_spec_string ("card-name", "Card name",
 218           "Human-readable name of the sound card",
 219           DEFAULT_PROP_CARD_NAME, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
 220 }
 221
 222 static GstClockTime
 223 gst_alsasrc_get_timestamp (GstAlsaSrc * src)
 224 {
 225   snd_pcm_status_t *status;
 226   snd_htimestamp_t tstamp;
 227   GstClockTime timestamp;
 228   snd_pcm_uframes_t availmax;
 229
 230   GST_DEBUG_OBJECT (src, "Getting alsa timestamp!");
 231
 232   if (!src) {
 233     GST_ERROR_OBJECT (src, "No alsa handle created yet !");
 234     return 0;
 235   }
 236
 237   if (snd_pcm_status_malloc (&status) != 0) {
 238     GST_ERROR_OBJECT (src, "snd_pcm_status_malloc failed");
 239   }
 240
 241   if (snd_pcm_status (src->handle, status) != 0) {
 242     GST_ERROR_OBJECT (src, "snd_pcm_status failed");
 243   }
 244
 245   /* get high resolution time stamp from driver */
 246   snd_pcm_status_get_htstamp (status, &tstamp);
 247   timestamp = GST_TIMESPEC_TO_TIME (tstamp);
 248
 249   /* Max available frames sets the depth of the buffer */
 250   availmax = snd_pcm_status_get_avail_max (status);
 251
 252   /* Compensate the fact that the timestamp references the last sample */
 253   timestamp -= gst_util_uint64_scale_int (availmax * 2, GST_SECOND, src->rate);
 254   /* Compensate for the delay until the package is available */
 255   timestamp += gst_util_uint64_scale_int (snd_pcm_status_get_delay (status),
 256       GST_SECOND, src->rate);
 257
 258   snd_pcm_status_free (status);
 259
 260   GST_DEBUG_OBJECT (src, "ALSA timestamp : %" GST_TIME_FORMAT,
 261       GST_TIME_ARGS (timestamp));
 262   return timestamp;
 263 }
 264
 265 static void
 266 gst_alsasrc_set_property (GObject * object, guint prop_id,
 267     const GValue * value, GParamSpec * pspec)
 268 {
 269   GstAlsaSrc *src;
 270
 271   src = GST_ALSA_SRC (object);
 272
 273   switch (prop_id) {
 274     case PROP_DEVICE:
 275       g_free (src->device);
 276       src->device = g_value_dup_string (value);
 277       if (src->device == NULL) {
 278         src->device = g_strdup (DEFAULT_PROP_DEVICE);
 279       }
 280       break;
 281     default:
 282       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 283       break;
 284   }
 285 }
 286
 287 static void
 288 gst_alsasrc_get_property (GObject * object, guint prop_id,
 289     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_value_set_string (value, src->device);
 298       break;
 299     case PROP_DEVICE_NAME:
 300       g_value_take_string (value,
 301           gst_alsa_find_device_name (GST_OBJECT_CAST (src),
 302               src->device, src->handle, SND_PCM_STREAM_CAPTURE));
 303       break;
 304     case PROP_CARD_NAME:
 305       g_value_take_string (value,
 306           gst_alsa_find_card_name (GST_OBJECT_CAST (src),
 307               src->device, SND_PCM_STREAM_CAPTURE));
 308       break;
 309     default:
 310       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 311       break;
 312   }
 313 }
 314
 315 static GstStateChangeReturn
 316 gst_alsasrc_change_state (GstElement * element, GstStateChange transition)
 317 {
 318   GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
 319   GstBaseAudioSrc *src = GST_BASE_AUDIO_SRC (element);
 320   GstAlsaSrc *asrc = GST_ALSA_SRC (element);
 321   GstClock *clk;
 322
 323   switch (transition) {
 324       /* Show the compiler that we care */
 325     case GST_STATE_CHANGE_NULL_TO_READY:
 326     case GST_STATE_CHANGE_READY_TO_PAUSED:
 327     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
 328     case GST_STATE_CHANGE_PAUSED_TO_READY:
 329     case GST_STATE_CHANGE_READY_TO_NULL:
 330       break;
 331
 332     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
 333       clk = src->clock;
 334       asrc->driver_timestamps = FALSE;
 335       if (GST_IS_SYSTEM_CLOCK (clk)) {
 336         gint clocktype;
 337         g_object_get (clk, "clock-type", &clocktype, NULL);
 338         if (clocktype == GST_CLOCK_TYPE_MONOTONIC) {
 339           asrc->driver_timestamps = TRUE;
 340         }
 341       }
 342       break;
 343   }
 344   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 345
 346   return ret;
 347 }
 348
 349 static GstFlowReturn
 350 gst_alsasrc_create (GstBaseSrc * bsrc, guint64 offset, guint length,
 351     GstBuffer ** outbuf)
 352 {
 353   GstFlowReturn ret = GST_FLOW_OK;
 354   GstAlsaSrc *asrc = GST_ALSA_SRC (bsrc);
 355
 356   ret =
 357       GST_BASE_SRC_CLASS (parent_class)->create (bsrc, offset, length, outbuf);
 358   if (asrc->driver_timestamps == TRUE && *outbuf) {
 359     GST_BUFFER_TIMESTAMP (*outbuf) =
 360         gst_alsasrc_get_timestamp ((GstAlsaSrc *) bsrc);
 361   }
 362
 363   return ret;
 364 }
 365
 366 static void
 367 gst_alsasrc_init (GstAlsaSrc * alsasrc)
 368 {
 369   GST_DEBUG_OBJECT (alsasrc, "initializing");
 370
 371   alsasrc->device = g_strdup (DEFAULT_PROP_DEVICE);
 372   alsasrc->cached_caps = NULL;
 373   alsasrc->driver_timestamps = FALSE;
 374
 375   alsasrc->alsa_lock = g_mutex_new ();
 376 }
 377
 378 #define CHECK(call, error) \
 379 G_STMT_START {                  \
 380 if ((err = call) < 0)           \
 381   goto error;                   \
 382 } G_STMT_END;
 383
 384
 385 static GstCaps *
 386 gst_alsasrc_getcaps (GstBaseSrc * bsrc, GstCaps * filter)
 387 {
 388   GstElementClass *element_class;
 389   GstPadTemplate *pad_template;
 390   GstAlsaSrc *src;
 391   GstCaps *caps, *templ_caps;
 392
 393   src = GST_ALSA_SRC (bsrc);
 394
 395   if (src->handle == NULL) {
 396     GST_DEBUG_OBJECT (src, "device not open, using template caps");
 397     return NULL;                /* base class will get template caps for us */
 398   }
 399
 400   if (src->cached_caps) {
 401     GST_LOG_OBJECT (src, "Returning cached caps");
 402     if (filter)
 403       return gst_caps_intersect_full (filter, src->cached_caps,
 404           GST_CAPS_INTERSECT_FIRST);
 405     else
 406       return gst_caps_ref (src->cached_caps);
 407   }
 408
 409   element_class = GST_ELEMENT_GET_CLASS (src);
 410   pad_template = gst_element_class_get_pad_template (element_class, "src");
 411   g_return_val_if_fail (pad_template != NULL, NULL);
 412
 413   templ_caps = gst_pad_template_get_caps (pad_template);
 414   caps = gst_alsa_probe_supported_formats (GST_OBJECT (src), src->handle,
 415       templ_caps);
 416   gst_caps_unref (templ_caps);
 417
 418   if (caps) {
 419     src->cached_caps = gst_caps_ref (caps);
 420   }
 421
 422   GST_INFO_OBJECT (src, "returning caps %" GST_PTR_FORMAT, caps);
 423
 424   if (filter) {
 425     GstCaps *intersection;
 426
 427     intersection =
 428         gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
 429     gst_caps_unref (caps);
 430     return intersection;
 431   } else {
 432     return caps;
 433   }
 434 }
 435
 436 static int
 437 set_hwparams (GstAlsaSrc * alsa)
 438 {
 439   guint rrate;
 440   gint err;
 441   snd_pcm_hw_params_t *params;
 442
 443   snd_pcm_hw_params_malloc (&params);
 444
 445   /* choose all parameters */
 446   CHECK (snd_pcm_hw_params_any (alsa->handle, params), no_config);
 447   /* set the interleaved read/write format */
 448   CHECK (snd_pcm_hw_params_set_access (alsa->handle, params, alsa->access),
 449       wrong_access);
 450   /* set the sample format */
 451   CHECK (snd_pcm_hw_params_set_format (alsa->handle, params, alsa->format),
 452       no_sample_format);
 453   /* set the count of channels */
 454   CHECK (snd_pcm_hw_params_set_channels (alsa->handle, params, alsa->channels),
 455       no_channels);
 456   /* set the stream rate */
 457   rrate = alsa->rate;
 458   CHECK (snd_pcm_hw_params_set_rate_near (alsa->handle, params, &rrate, NULL),
 459       no_rate);
 460   if (rrate != alsa->rate)
 461     goto rate_match;
 462
 463   if (alsa->buffer_time != -1) {
 464     /* set the buffer time */
 465     CHECK (snd_pcm_hw_params_set_buffer_time_near (alsa->handle, params,
 466             &alsa->buffer_time, NULL), buffer_time);
 467   }
 468   if (alsa->period_time != -1) {
 469     /* set the period time */
 470     CHECK (snd_pcm_hw_params_set_period_time_near (alsa->handle, params,
 471             &alsa->period_time, NULL), period_time);
 472   }
 473
 474   /* write the parameters to device */
 475   CHECK (snd_pcm_hw_params (alsa->handle, params), set_hw_params);
 476
 477   CHECK (snd_pcm_hw_params_get_buffer_size (params, &alsa->buffer_size),
 478       buffer_size);
 479
 480   CHECK (snd_pcm_hw_params_get_period_size (params, &alsa->period_size, NULL),
 481       period_size);
 482
 483   snd_pcm_hw_params_free (params);
 484   return 0;
 485
 486   /* ERRORS */
 487 no_config:
 488   {
 489     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 490         ("Broken configuration for recording: no configurations available: %s",
 491             snd_strerror (err)));
 492     snd_pcm_hw_params_free (params);
 493     return err;
 494   }
 495 wrong_access:
 496   {
 497     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 498         ("Access type not available for recording: %s", snd_strerror (err)));
 499     snd_pcm_hw_params_free (params);
 500     return err;
 501   }
 502 no_sample_format:
 503   {
 504     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 505         ("Sample format not available for recording: %s", snd_strerror (err)));
 506     snd_pcm_hw_params_free (params);
 507     return err;
 508   }
 509 no_channels:
 510   {
 511     gchar *msg = NULL;
 512
 513     if ((alsa->channels) == 1)
 514       msg = g_strdup (_("Could not open device for recording in mono mode."));
 515     if ((alsa->channels) == 2)
 516       msg = g_strdup (_("Could not open device for recording in stereo mode."));
 517     if ((alsa->channels) > 2)
 518       msg =
 519           g_strdup_printf (_
 520           ("Could not open device for recording in %d-channel mode"),
 521           alsa->channels);
 522     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, ("%s", msg),
 523         ("%s", snd_strerror (err)));
 524     g_free (msg);
 525     snd_pcm_hw_params_free (params);
 526     return err;
 527   }
 528 no_rate:
 529   {
 530     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 531         ("Rate %iHz not available for recording: %s",
 532             alsa->rate, snd_strerror (err)));
 533     snd_pcm_hw_params_free (params);
 534     return err;
 535   }
 536 rate_match:
 537   {
 538     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 539         ("Rate doesn't match (requested %iHz, get %iHz)", alsa->rate, err));
 540     snd_pcm_hw_params_free (params);
 541     return -EINVAL;
 542   }
 543 buffer_time:
 544   {
 545     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 546         ("Unable to set buffer time %i for recording: %s",
 547             alsa->buffer_time, snd_strerror (err)));
 548     snd_pcm_hw_params_free (params);
 549     return err;
 550   }
 551 buffer_size:
 552   {
 553     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 554         ("Unable to get buffer size for recording: %s", snd_strerror (err)));
 555     snd_pcm_hw_params_free (params);
 556     return err;
 557   }
 558 period_time:
 559   {
 560     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 561         ("Unable to set period time %i for recording: %s", alsa->period_time,
 562             snd_strerror (err)));
 563     snd_pcm_hw_params_free (params);
 564     return err;
 565   }
 566 period_size:
 567   {
 568     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 569         ("Unable to get period size for recording: %s", snd_strerror (err)));
 570     snd_pcm_hw_params_free (params);
 571     return err;
 572   }
 573 set_hw_params:
 574   {
 575     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 576         ("Unable to set hw params for recording: %s", snd_strerror (err)));
 577     snd_pcm_hw_params_free (params);
 578     return err;
 579   }
 580 }
 581
 582 static int
 583 set_swparams (GstAlsaSrc * alsa)
 584 {
 585   int err;
 586   snd_pcm_sw_params_t *params;
 587
 588   snd_pcm_sw_params_malloc (&params);
 589
 590   /* get the current swparams */
 591   CHECK (snd_pcm_sw_params_current (alsa->handle, params), no_config);
 592   /* allow the transfer when at least period_size samples can be processed */
 593   CHECK (snd_pcm_sw_params_set_avail_min (alsa->handle, params,
 594           alsa->period_size), set_avail);
 595   /* start the transfer on first read */
 596   CHECK (snd_pcm_sw_params_set_start_threshold (alsa->handle, params,
 597           0), start_threshold);
 598
 599 #if GST_CHECK_ALSA_VERSION(1,0,16)
 600   /* snd_pcm_sw_params_set_xfer_align() is deprecated, alignment is always 1 */
 601 #else
 602   /* align all transfers to 1 sample */
 603   CHECK (snd_pcm_sw_params_set_xfer_align (alsa->handle, params, 1), set_align);
 604 #endif
 605
 606   /* write the parameters to the recording device */
 607   CHECK (snd_pcm_sw_params (alsa->handle, params), set_sw_params);
 608
 609   snd_pcm_sw_params_free (params);
 610   return 0;
 611
 612   /* ERRORS */
 613 no_config:
 614   {
 615     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 616         ("Unable to determine current swparams for playback: %s",
 617             snd_strerror (err)));
 618     snd_pcm_sw_params_free (params);
 619     return err;
 620   }
 621 start_threshold:
 622   {
 623     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 624         ("Unable to set start threshold mode for playback: %s",
 625             snd_strerror (err)));
 626     snd_pcm_sw_params_free (params);
 627     return err;
 628   }
 629 set_avail:
 630   {
 631     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 632         ("Unable to set avail min for playback: %s", snd_strerror (err)));
 633     snd_pcm_sw_params_free (params);
 634     return err;
 635   }
 636 #if !GST_CHECK_ALSA_VERSION(1,0,16)
 637 set_align:
 638   {
 639     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 640         ("Unable to set transfer align for playback: %s", snd_strerror (err)));
 641     snd_pcm_sw_params_free (params);
 642     return err;
 643   }
 644 #endif
 645 set_sw_params:
 646   {
 647     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 648         ("Unable to set sw params for playback: %s", snd_strerror (err)));
 649     snd_pcm_sw_params_free (params);
 650     return err;
 651   }
 652 }
 653
 654 static gboolean
 655 alsasrc_parse_spec (GstAlsaSrc * alsa, GstRingBufferSpec * spec)
 656 {
 657   switch (spec->type) {
 658     case GST_BUFTYPE_LINEAR:
 659       alsa->format = snd_pcm_build_linear_format (spec->depth, spec->width,
 660           spec->sign ? 0 : 1, spec->bigend ? 1 : 0);
 661       break;
 662     case GST_BUFTYPE_FLOAT:
 663       switch (spec->format) {
 664         case GST_FLOAT32_LE:
 665           alsa->format = SND_PCM_FORMAT_FLOAT_LE;
 666           break;
 667         case GST_FLOAT32_BE:
 668           alsa->format = SND_PCM_FORMAT_FLOAT_BE;
 669           break;
 670         case GST_FLOAT64_LE:
 671           alsa->format = SND_PCM_FORMAT_FLOAT64_LE;
 672           break;
 673         case GST_FLOAT64_BE:
 674           alsa->format = SND_PCM_FORMAT_FLOAT64_BE;
 675           break;
 676         default:
 677           goto error;
 678       }
 679       break;
 680     case GST_BUFTYPE_A_LAW:
 681       alsa->format = SND_PCM_FORMAT_A_LAW;
 682       break;
 683     case GST_BUFTYPE_MU_LAW:
 684       alsa->format = SND_PCM_FORMAT_MU_LAW;
 685       break;
 686     default:
 687       goto error;
 688
 689   }
 690   alsa->rate = spec->rate;
 691   alsa->channels = spec->channels;
 692   alsa->buffer_time = spec->buffer_time;
 693   alsa->period_time = spec->latency_time;
 694   alsa->access = SND_PCM_ACCESS_RW_INTERLEAVED;
 695
 696   return TRUE;
 697
 698   /* ERRORS */
 699 error:
 700   {
 701     return FALSE;
 702   }
 703 }
 704
 705 static gboolean
 706 gst_alsasrc_open (GstAudioSrc * asrc)
 707 {
 708   GstAlsaSrc *alsa;
 709   gint err;
 710
 711   alsa = GST_ALSA_SRC (asrc);
 712
 713   CHECK (snd_pcm_open (&alsa->handle, alsa->device, SND_PCM_STREAM_CAPTURE,
 714           SND_PCM_NONBLOCK), open_error);
 715
 716   if (!alsa->mixer)
 717     alsa->mixer = gst_alsa_mixer_new (alsa->device, GST_ALSA_MIXER_CAPTURE);
 718
 719   return TRUE;
 720
 721   /* ERRORS */
 722 open_error:
 723   {
 724     if (err == -EBUSY) {
 725       GST_ELEMENT_ERROR (alsa, RESOURCE, BUSY,
 726           (_("Could not open audio device for recording. "
 727                   "Device is being used by another application.")),
 728           ("Device '%s' is busy", alsa->device));
 729     } else {
 730       GST_ELEMENT_ERROR (alsa, RESOURCE, OPEN_READ,
 731           (_("Could not open audio device for recording.")),
 732           ("Recording open error on device '%s': %s", alsa->device,
 733               snd_strerror (err)));
 734     }
 735     return FALSE;
 736   }
 737 }
 738
 739 static gboolean
 740 gst_alsasrc_prepare (GstAudioSrc * asrc, GstRingBufferSpec * spec)
 741 {
 742   GstAlsaSrc *alsa;
 743   gint err;
 744
 745   alsa = GST_ALSA_SRC (asrc);
 746
 747   if (!alsasrc_parse_spec (alsa, spec))
 748     goto spec_parse;
 749
 750   CHECK (snd_pcm_nonblock (alsa->handle, 0), non_block);
 751
 752   CHECK (set_hwparams (alsa), hw_params_failed);
 753   CHECK (set_swparams (alsa), sw_params_failed);
 754   CHECK (snd_pcm_prepare (alsa->handle), prepare_failed);
 755
 756   alsa->bytes_per_sample = spec->bytes_per_sample;
 757   spec->segsize = alsa->period_size * spec->bytes_per_sample;
 758   spec->segtotal = alsa->buffer_size / alsa->period_size;
 759   spec->silence_sample[0] = 0;
 760   spec->silence_sample[1] = 0;
 761   spec->silence_sample[2] = 0;
 762   spec->silence_sample[3] = 0;
 763
 764   return TRUE;
 765
 766   /* ERRORS */
 767 spec_parse:
 768   {
 769     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 770         ("Error parsing spec"));
 771     return FALSE;
 772   }
 773 non_block:
 774   {
 775     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 776         ("Could not set device to blocking: %s", snd_strerror (err)));
 777     return FALSE;
 778   }
 779 hw_params_failed:
 780   {
 781     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 782         ("Setting of hwparams failed: %s", snd_strerror (err)));
 783     return FALSE;
 784   }
 785 sw_params_failed:
 786   {
 787     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 788         ("Setting of swparams failed: %s", snd_strerror (err)));
 789     return FALSE;
 790   }
 791 prepare_failed:
 792   {
 793     GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),
 794         ("Prepare failed: %s", snd_strerror (err)));
 795     return FALSE;
 796   }
 797 }
 798
 799 static gboolean
 800 gst_alsasrc_unprepare (GstAudioSrc * asrc)
 801 {
 802   GstAlsaSrc *alsa;
 803
 804   alsa = GST_ALSA_SRC (asrc);
 805
 806   snd_pcm_drop (alsa->handle);
 807   snd_pcm_hw_free (alsa->handle);
 808   snd_pcm_nonblock (alsa->handle, 1);
 809
 810   return TRUE;
 811 }
 812
 813 static gboolean
 814 gst_alsasrc_close (GstAudioSrc * asrc)
 815 {
 816   GstAlsaSrc *alsa = GST_ALSA_SRC (asrc);
 817
 818   snd_pcm_close (alsa->handle);
 819   alsa->handle = NULL;
 820
 821   if (alsa->mixer) {
 822     gst_alsa_mixer_free (alsa->mixer);
 823     alsa->mixer = NULL;
 824   }
 825
 826   gst_caps_replace (&alsa->cached_caps, NULL);
 827
 828   return TRUE;
 829 }
 830
 831 /*
 832  *   Underrun and suspend recovery
 833  */
 834 static gint
 835 xrun_recovery (GstAlsaSrc * alsa, snd_pcm_t * handle, gint err)
 836 {
 837   GST_DEBUG_OBJECT (alsa, "xrun recovery %d", err);
 838
 839   if (err == -EPIPE) {          /* under-run */
 840     err = snd_pcm_prepare (handle);
 841     if (err < 0)
 842       GST_WARNING_OBJECT (alsa,
 843           "Can't recovery from underrun, prepare failed: %s",
 844           snd_strerror (err));
 845     return 0;
 846   } else if (err == -ESTRPIPE) {
 847     while ((err = snd_pcm_resume (handle)) == -EAGAIN)
 848       g_usleep (100);           /* wait until the suspend flag is released */
 849
 850     if (err < 0) {
 851       err = snd_pcm_prepare (handle);
 852       if (err < 0)
 853         GST_WARNING_OBJECT (alsa,
 854             "Can't recovery from suspend, prepare failed: %s",
 855             snd_strerror (err));
 856     }
 857     return 0;
 858   }
 859   return err;
 860 }
 861
 862 static guint
 863 gst_alsasrc_read (GstAudioSrc * asrc, gpointer data, guint length)
 864 {
 865   GstAlsaSrc *alsa;
 866   gint err;
 867   gint cptr;
 868   gint16 *ptr;
 869
 870   alsa = GST_ALSA_SRC (asrc);
 871
 872   cptr = length / alsa->bytes_per_sample;
 873   ptr = data;
 874
 875   GST_ALSA_SRC_LOCK (asrc);
 876   while (cptr > 0) {
 877     if ((err = snd_pcm_readi (alsa->handle, ptr, cptr)) < 0) {
 878       if (err == -EAGAIN) {
 879         GST_DEBUG_OBJECT (asrc, "Read error: %s", snd_strerror (err));
 880         continue;
 881       } else if (xrun_recovery (alsa, alsa->handle, err) < 0) {
 882         goto read_error;
 883       }
 884       continue;
 885     }
 886
 887     ptr += err * alsa->channels;
 888     cptr -= err;
 889   }
 890   GST_ALSA_SRC_UNLOCK (asrc);
 891
 892   return length - (cptr * alsa->bytes_per_sample);
 893
 894 read_error:
 895   {
 896     GST_ALSA_SRC_UNLOCK (asrc);
 897     return length;              /* skip one period */
 898   }
 899 }
 900
 901 static guint
 902 gst_alsasrc_delay (GstAudioSrc * asrc)
 903 {
 904   GstAlsaSrc *alsa;
 905   snd_pcm_sframes_t delay;
 906   int res;
 907
 908   alsa = GST_ALSA_SRC (asrc);
 909
 910   res = snd_pcm_delay (alsa->handle, &delay);
 911   if (G_UNLIKELY (res < 0)) {
 912     GST_DEBUG_OBJECT (alsa, "snd_pcm_delay returned %d", res);
 913     delay = 0;
 914   }
 915
 916   return CLAMP (delay, 0, alsa->buffer_size);
 917 }
 918
 919 static void
 920 gst_alsasrc_reset (GstAudioSrc * asrc)
 921 {
 922   GstAlsaSrc *alsa;
 923   gint err;
 924
 925   alsa = GST_ALSA_SRC (asrc);
 926
 927   GST_ALSA_SRC_LOCK (asrc);
 928   GST_DEBUG_OBJECT (alsa, "drop");
 929   CHECK (snd_pcm_drop (alsa->handle), drop_error);
 930   GST_DEBUG_OBJECT (alsa, "prepare");
 931   CHECK (snd_pcm_prepare (alsa->handle), prepare_error);
 932   GST_DEBUG_OBJECT (alsa, "reset done");
 933   GST_ALSA_SRC_UNLOCK (asrc);
 934
 935   return;
 936
 937   /* ERRORS */
 938 drop_error:
 939   {
 940     GST_ERROR_OBJECT (alsa, "alsa-reset: pcm drop error: %s",
 941         snd_strerror (err));
 942     GST_ALSA_SRC_UNLOCK (asrc);
 943     return;
 944   }
 945 prepare_error:
 946   {
 947     GST_ERROR_OBJECT (alsa, "alsa-reset: pcm prepare error: %s",
 948         snd_strerror (err));
 949     GST_ALSA_SRC_UNLOCK (asrc);
 950     return;
 951   }
 952 }