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