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