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