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