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