sys/oss4/oss4-source.c

   1 /* GStreamer OSS4 audio source
   2  * Copyright (C) 2007-2008 Tim-Philipp Müller <tim centricular net>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /**
  21  * SECTION:element-oss4src
  22  *
  23  * <refsect2>
  24  * <para>
  25  * This element lets you record sound using the Open Sound System (OSS)
  26  * version 4.
  27  * </para>
  28  * <title>Example pipelines</title>
  29  * <para>
  30  * <programlisting>
  31  * gst-launch -v oss4src ! queue ! audioconvert ! vorbisenc ! oggmux ! filesink location=mymusic.ogg
  32  * </programlisting>
  33  * will record sound from your sound card using OSS4 and encode it to an
  34  * Ogg/Vorbis file (this will only work if your mixer settings are right
  35  * and the right inputs areenabled etc.)
  36  * </para>
  37  * </refsect2>
  38  *
  39  * Since: 0.10.7
  40  */
  41
  42 /* FIXME: make sure we're not doing ioctls from the app thread (e.g. via the
  43  * mixer interface) while recording */
  44
  45 #ifdef HAVE_CONFIG_H
  46 #include "config.h"
  47 #endif
  48
  49 #include <sys/types.h>
  50 #include <sys/stat.h>
  51 #include <sys/ioctl.h>
  52 #include <fcntl.h>
  53 #include <errno.h>
  54 #include <unistd.h>
  55 #include <string.h>
  56
  57 #include <gst/interfaces/mixer.h>
  58 #include <gst/gst-i18n-plugin.h>
  59
  60 #define NO_LEGACY_MIXER
  61 #include "oss4-audio.h"
  62 #include "oss4-source.h"
  63 #include "oss4-property-probe.h"
  64 #include "oss4-soundcard.h"
  65
  66 #define GST_OSS4_SOURCE_IS_OPEN(src)  (GST_OSS4_SOURCE(src)->fd != -1)
  67
  68 GST_DEBUG_CATEGORY_EXTERN (oss4src_debug);
  69 #define GST_CAT_DEFAULT oss4src_debug
  70
  71 #define DEFAULT_DEVICE       NULL
  72 #define DEFAULT_DEVICE_NAME  NULL
  73
  74 enum
  75 {
  76   PROP_0,
  77   PROP_DEVICE,
  78   PROP_DEVICE_NAME
  79 };
  80
  81 static void gst_oss4_source_init_interfaces (GType type);
  82
  83 GST_BOILERPLATE_FULL (GstOss4Source, gst_oss4_source, GstAudioSrc,
  84     GST_TYPE_AUDIO_SRC, gst_oss4_source_init_interfaces);
  85
  86 static void gst_oss4_source_get_property (GObject * object, guint prop_id,
  87     GValue * value, GParamSpec * pspec);
  88 static void gst_oss4_source_set_property (GObject * object, guint prop_id,
  89     const GValue * value, GParamSpec * pspec);
  90
  91 static void gst_oss4_source_dispose (GObject * object);
  92 static void gst_oss4_source_finalize (GstOss4Source * osssrc);
  93
  94 static GstCaps *gst_oss4_source_getcaps (GstBaseSrc * bsrc);
  95
  96 static gboolean gst_oss4_source_open (GstAudioSrc * asrc,
  97     gboolean silent_errors);
  98 static gboolean gst_oss4_source_open_func (GstAudioSrc * asrc);
  99 static gboolean gst_oss4_source_close (GstAudioSrc * asrc);
 100 static gboolean gst_oss4_source_prepare (GstAudioSrc * asrc,
 101     GstRingBufferSpec * spec);
 102 static gboolean gst_oss4_source_unprepare (GstAudioSrc * asrc);
 103 static guint gst_oss4_source_read (GstAudioSrc * asrc, gpointer data,
 104     guint length);
 105 static guint gst_oss4_source_delay (GstAudioSrc * asrc);
 106 static void gst_oss4_source_reset (GstAudioSrc * asrc);
 107
 108 static void
 109 gst_oss4_source_base_init (gpointer g_class)
 110 {
 111   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 112   GstPadTemplate *templ;
 113
 114   gst_element_class_set_details_simple (element_class,
 115       "OSS v4 Audio Source", "Source/Audio",
 116       "Capture from a sound card via OSS version 4",
 117       "Tim-Philipp Müller <tim centricular net>");
 118
 119   templ = gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
 120       gst_oss4_audio_get_template_caps ());
 121   gst_element_class_add_pad_template (element_class, templ);
 122 }
 123 static void
 124 gst_oss4_source_class_init (GstOss4SourceClass * klass)
 125 {
 126   GObjectClass *gobject_class;
 127   GstElementClass *gstelement_class;
 128   GstBaseSrcClass *gstbasesrc_class;
 129   GstBaseAudioSrcClass *gstbaseaudiosrc_class;
 130   GstAudioSrcClass *gstaudiosrc_class;
 131
 132   gobject_class = (GObjectClass *) klass;
 133   gstelement_class = (GstElementClass *) klass;
 134   gstbasesrc_class = (GstBaseSrcClass *) klass;
 135   gstbaseaudiosrc_class = (GstBaseAudioSrcClass *) klass;
 136   gstaudiosrc_class = (GstAudioSrcClass *) klass;
 137
 138   gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_oss4_source_dispose);
 139   gobject_class->finalize =
 140       (GObjectFinalizeFunc) GST_DEBUG_FUNCPTR (gst_oss4_source_finalize);
 141   gobject_class->get_property =
 142       GST_DEBUG_FUNCPTR (gst_oss4_source_get_property);
 143   gobject_class->set_property =
 144       GST_DEBUG_FUNCPTR (gst_oss4_source_set_property);
 145
 146   gstbasesrc_class->get_caps = GST_DEBUG_FUNCPTR (gst_oss4_source_getcaps);
 147
 148   gstaudiosrc_class->open = GST_DEBUG_FUNCPTR (gst_oss4_source_open_func);
 149   gstaudiosrc_class->prepare = GST_DEBUG_FUNCPTR (gst_oss4_source_prepare);
 150   gstaudiosrc_class->unprepare = GST_DEBUG_FUNCPTR (gst_oss4_source_unprepare);
 151   gstaudiosrc_class->close = GST_DEBUG_FUNCPTR (gst_oss4_source_close);
 152   gstaudiosrc_class->read = GST_DEBUG_FUNCPTR (gst_oss4_source_read);
 153   gstaudiosrc_class->delay = GST_DEBUG_FUNCPTR (gst_oss4_source_delay);
 154   gstaudiosrc_class->reset = GST_DEBUG_FUNCPTR (gst_oss4_source_reset);
 155
 156   g_object_class_install_property (gobject_class, PROP_DEVICE,
 157       g_param_spec_string ("device", "Device",
 158           "OSS4 device (e.g. /dev/oss/hdaudio0/pcm0 or /dev/dspN) "
 159           "(NULL = use first available device)",
 160           DEFAULT_DEVICE, G_PARAM_READWRITE));
 161
 162   g_object_class_install_property (gobject_class, PROP_DEVICE_NAME,
 163       g_param_spec_string ("device-name", "Device name",
 164           "Human-readable name of the sound device", DEFAULT_DEVICE_NAME,
 165           G_PARAM_READABLE));
 166 }
 167
 168 static void
 169 gst_oss4_source_init (GstOss4Source * osssrc, GstOss4SourceClass * g_class)
 170 {
 171   const gchar *device;
 172
 173   device = g_getenv ("AUDIODEV");
 174   if (device == NULL)
 175     device = DEFAULT_DEVICE;
 176
 177   osssrc->fd = -1;
 178   osssrc->device = g_strdup (device);
 179   osssrc->device_name = g_strdup (DEFAULT_DEVICE_NAME);
 180   osssrc->device_name = NULL;
 181 }
 182
 183 static void
 184 gst_oss4_source_finalize (GstOss4Source * oss)
 185 {
 186   g_free (oss->device);
 187   oss->device = NULL;
 188
 189   g_list_free (oss->property_probe_list);
 190   oss->property_probe_list = NULL;
 191
 192   G_OBJECT_CLASS (parent_class)->finalize ((GObject *) (oss));
 193 }
 194
 195 static void
 196 gst_oss4_source_dispose (GObject * object)
 197 {
 198   GstOss4Source *oss = GST_OSS4_SOURCE (object);
 199
 200   if (oss->probed_caps) {
 201     gst_caps_unref (oss->probed_caps);
 202     oss->probed_caps = NULL;
 203   }
 204
 205   G_OBJECT_CLASS (parent_class)->dispose (object);
 206 }
 207
 208 static void
 209 gst_oss4_source_set_property (GObject * object, guint prop_id,
 210     const GValue * value, GParamSpec * pspec)
 211 {
 212   GstOss4Source *oss;
 213
 214   oss = GST_OSS4_SOURCE (object);
 215
 216   switch (prop_id) {
 217     case PROP_DEVICE:
 218       GST_OBJECT_LOCK (oss);
 219       if (oss->fd == -1) {
 220         g_free (oss->device);
 221         oss->device = g_value_dup_string (value);
 222         g_free (oss->device_name);
 223         oss->device_name = NULL;
 224       } else {
 225         g_warning ("%s: can't change \"device\" property while audio source "
 226             "is open", GST_OBJECT_NAME (oss));
 227       }
 228       GST_OBJECT_UNLOCK (oss);
 229       break;
 230     default:
 231       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 232       break;
 233   }
 234 }
 235
 236 static void
 237 gst_oss4_source_get_property (GObject * object, guint prop_id,
 238     GValue * value, GParamSpec * pspec)
 239 {
 240   GstOss4Source *oss;
 241
 242   oss = GST_OSS4_SOURCE (object);
 243
 244   switch (prop_id) {
 245     case PROP_DEVICE:
 246       GST_OBJECT_LOCK (oss);
 247       g_value_set_string (value, oss->device);
 248       GST_OBJECT_UNLOCK (oss);
 249       break;
 250     case PROP_DEVICE_NAME:
 251       GST_OBJECT_LOCK (oss);
 252       /* If device is set, try to retrieve the name even if we're not open */
 253       if (oss->fd == -1 && oss->device != NULL) {
 254         if (gst_oss4_source_open (GST_AUDIO_SRC (oss), TRUE)) {
 255           g_value_set_string (value, oss->device_name);
 256           gst_oss4_source_close (GST_AUDIO_SRC (oss));
 257         } else {
 258           gchar *name = NULL;
 259
 260           gst_oss4_property_probe_find_device_name_nofd (GST_OBJECT (oss),
 261               oss->device, &name);
 262           g_value_set_string (value, name);
 263           g_free (name);
 264         }
 265       } else {
 266         g_value_set_string (value, oss->device_name);
 267       }
 268
 269       GST_OBJECT_UNLOCK (oss);
 270       break;
 271     default:
 272       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 273       break;
 274   }
 275 }
 276
 277 static GstCaps *
 278 gst_oss4_source_getcaps (GstBaseSrc * bsrc)
 279 {
 280   GstOss4Source *oss;
 281   GstCaps *caps;
 282
 283   oss = GST_OSS4_SOURCE (bsrc);
 284
 285   if (oss->fd == -1) {
 286     caps = gst_caps_copy (gst_oss4_audio_get_template_caps ());
 287   } else if (oss->probed_caps) {
 288     caps = gst_caps_copy (oss->probed_caps);
 289   } else {
 290     caps = gst_oss4_audio_probe_caps (GST_OBJECT (oss), oss->fd);
 291     if (caps != NULL && !gst_caps_is_empty (caps)) {
 292       oss->probed_caps = gst_caps_copy (caps);
 293     }
 294   }
 295
 296   return caps;
 297 }
 298
 299 /* note: we must not take the object lock here unless we fix up get_property */
 300 static gboolean
 301 gst_oss4_source_open (GstAudioSrc * asrc, gboolean silent_errors)
 302 {
 303   GstOss4Source *oss;
 304   gchar *device;
 305   int mode;
 306
 307   oss = GST_OSS4_SOURCE (asrc);
 308
 309   if (oss->device)
 310     device = g_strdup (oss->device);
 311   else
 312     device = gst_oss4_audio_find_device (GST_OBJECT_CAST (oss));
 313
 314   /* desperate times, desperate measures */
 315   if (device == NULL)
 316     device = g_strdup ("/dev/dsp0");
 317
 318   GST_INFO_OBJECT (oss, "Trying to open OSS4 device '%s'", device);
 319
 320   /* we open in non-blocking mode even if we don't really want to do writes
 321    * non-blocking because we can't be sure that this is really a genuine
 322    * OSS4 device with well-behaved drivers etc. We really don't want to
 323    * hang forever under any circumstances. */
 324   oss->fd = open (device, O_RDONLY | O_NONBLOCK, 0);
 325   if (oss->fd == -1) {
 326     switch (errno) {
 327       case EBUSY:
 328         goto busy;
 329       case EACCES:
 330         goto no_permission;
 331       default:
 332         goto open_failed;
 333     }
 334   }
 335
 336   GST_INFO_OBJECT (oss, "Opened device");
 337
 338   /* Make sure it's OSS4. If it's old OSS, let osssink handle it */
 339   if (!gst_oss4_audio_check_version (GST_OBJECT_CAST (oss), oss->fd))
 340     goto legacy_oss;
 341
 342   /* now remove the non-blocking flag. */
 343   mode = fcntl (oss->fd, F_GETFL);
 344   mode &= ~O_NONBLOCK;
 345   if (fcntl (oss->fd, F_SETFL, mode) < 0) {
 346     /* some drivers do no support unsetting the non-blocking flag, try to
 347      * close/open the device then. This is racy but we error out properly. */
 348     GST_WARNING_OBJECT (oss, "failed to unset O_NONBLOCK (buggy driver?), "
 349         "will try to re-open device now");
 350     gst_oss4_source_close (asrc);
 351     if ((oss->fd = open (device, O_RDONLY, 0)) == -1)
 352       goto non_block;
 353   }
 354
 355   oss->open_device = device;
 356
 357   /* not using ENGINEINFO here because it sometimes returns a different and
 358    * less useful name than AUDIOINFO for the same device */
 359   if (!gst_oss4_property_probe_find_device_name (GST_OBJECT (oss), oss->fd,
 360           oss->open_device, &oss->device_name)) {
 361     oss->device_name = NULL;
 362   }
 363
 364   return TRUE;
 365
 366   /* ERRORS */
 367 busy:
 368   {
 369     if (!silent_errors) {
 370       GST_ELEMENT_ERROR (oss, RESOURCE, BUSY,
 371           (_("Could not open audio device for playback. "
 372                   "Device is being used by another application.")), (NULL));
 373     }
 374     g_free (device);
 375     return FALSE;
 376   }
 377 no_permission:
 378   {
 379     if (!silent_errors) {
 380       GST_ELEMENT_ERROR (oss, RESOURCE, OPEN_READ,
 381           (_("Could not open audio device for playback."
 382                   "You don't have permission to open the device.")),
 383           GST_ERROR_SYSTEM);
 384     }
 385     g_free (device);
 386     return FALSE;
 387   }
 388 open_failed:
 389   {
 390     if (!silent_errors) {
 391       GST_ELEMENT_ERROR (oss, RESOURCE, OPEN_READ,
 392           (_("Could not open audio device for playback.")), GST_ERROR_SYSTEM);
 393     }
 394     g_free (device);
 395     return FALSE;
 396   }
 397 legacy_oss:
 398   {
 399     gst_oss4_source_close (asrc);
 400     if (!silent_errors) {
 401       GST_ELEMENT_ERROR (oss, RESOURCE, OPEN_READ,
 402           (_("Could not open audio device for playback."
 403                   "This version of the Open Sound System is not supported by this "
 404                   "element.")), ("Try the 'osssink' element instead"));
 405     }
 406     g_free (device);
 407     return FALSE;
 408   }
 409 non_block:
 410   {
 411     if (!silent_errors) {
 412       GST_ELEMENT_ERROR (oss, RESOURCE, SETTINGS, (NULL),
 413           ("Unable to set device %s into non-blocking mode: %s",
 414               oss->device, g_strerror (errno)));
 415     }
 416     g_free (device);
 417     return FALSE;
 418   }
 419 }
 420
 421 static gboolean
 422 gst_oss4_source_open_func (GstAudioSrc * asrc)
 423 {
 424   return gst_oss4_source_open (asrc, FALSE);
 425 }
 426
 427 static void
 428 gst_oss4_source_free_mixer_tracks (GstOss4Source * oss)
 429 {
 430   g_list_foreach (oss->tracks, (GFunc) g_object_unref, NULL);
 431   g_list_free (oss->tracks);
 432   oss->tracks = NULL;
 433 }
 434
 435 static gboolean
 436 gst_oss4_source_close (GstAudioSrc * asrc)
 437 {
 438   GstOss4Source *oss;
 439
 440   oss = GST_OSS4_SOURCE (asrc);
 441
 442   if (oss->fd != -1) {
 443     GST_DEBUG_OBJECT (oss, "closing device");
 444     close (oss->fd);
 445     oss->fd = -1;
 446   }
 447
 448   oss->bytes_per_sample = 0;
 449
 450   gst_caps_replace (&oss->probed_caps, NULL);
 451
 452   g_free (oss->open_device);
 453   oss->open_device = NULL;
 454
 455   g_free (oss->device_name);
 456   oss->device_name = NULL;
 457
 458   gst_oss4_source_free_mixer_tracks (oss);
 459
 460   return TRUE;
 461 }
 462
 463 static gboolean
 464 gst_oss4_source_prepare (GstAudioSrc * asrc, GstRingBufferSpec * spec)
 465 {
 466   GstOss4Source *oss;
 467
 468   oss = GST_OSS4_SOURCE (asrc);
 469
 470   if (!gst_oss4_audio_set_format (GST_OBJECT_CAST (oss), oss->fd, spec)) {
 471     GST_WARNING_OBJECT (oss, "Couldn't set requested format %" GST_PTR_FORMAT,
 472         spec->caps);
 473     return FALSE;
 474   }
 475
 476   oss->bytes_per_sample = spec->bytes_per_sample;
 477   return TRUE;
 478 }
 479
 480 static gboolean
 481 gst_oss4_source_unprepare (GstAudioSrc * asrc)
 482 {
 483   /* could do a SNDCTL_DSP_HALT, but the OSS manual recommends a close/open,
 484    * since HALT won't properly reset some devices, apparently */
 485
 486   if (!gst_oss4_source_close (asrc))
 487     goto couldnt_close;
 488
 489   if (!gst_oss4_source_open_func (asrc))
 490     goto couldnt_reopen;
 491
 492   return TRUE;
 493
 494   /* ERRORS */
 495 couldnt_close:
 496   {
 497     GST_DEBUG_OBJECT (asrc, "Couldn't close the audio device");
 498     return FALSE;
 499   }
 500 couldnt_reopen:
 501   {
 502     GST_DEBUG_OBJECT (asrc, "Couldn't reopen the audio device");
 503     return FALSE;
 504   }
 505 }
 506
 507 static guint
 508 gst_oss4_source_read (GstAudioSrc * asrc, gpointer data, guint length)
 509 {
 510   GstOss4Source *oss;
 511   int n;
 512
 513   oss = GST_OSS4_SOURCE_CAST (asrc);
 514
 515   n = read (oss->fd, data, length);
 516   GST_LOG_OBJECT (asrc, "%u bytes, %u samples", n, n / oss->bytes_per_sample);
 517
 518   if (G_UNLIKELY (n < 0)) {
 519     switch (errno) {
 520       case ENOTSUP:
 521       case EACCES:{
 522         /* This is the most likely cause, I think */
 523         GST_ELEMENT_ERROR (asrc, RESOURCE, READ,
 524             (_("Recording is not supported by this audio device.")),
 525             ("read: %s (device: %s) (maybe this is an output-only device?)",
 526                 g_strerror (errno), oss->open_device));
 527         break;
 528       }
 529       default:{
 530         GST_ELEMENT_ERROR (asrc, RESOURCE, READ,
 531             (_("Error recording from audio device.")),
 532             ("read: %s (device: %s)", g_strerror (errno), oss->open_device));
 533         break;
 534       }
 535     }
 536   }
 537
 538   return (guint) n;
 539 }
 540
 541 static guint
 542 gst_oss4_source_delay (GstAudioSrc * asrc)
 543 {
 544   audio_buf_info info = { 0, };
 545   GstOss4Source *oss;
 546   guint delay;
 547
 548   oss = GST_OSS4_SOURCE_CAST (asrc);
 549
 550   if (ioctl (oss->fd, SNDCTL_DSP_GETISPACE, &info) == -1) {
 551     GST_LOG_OBJECT (oss, "GETISPACE failed: %s", g_strerror (errno));
 552     return 0;
 553   }
 554
 555   delay = (info.fragstotal * info.fragsize) - info.bytes;
 556   GST_LOG_OBJECT (oss, "fragstotal:%d, fragsize:%d, bytes:%d, delay:%d",
 557       info.fragstotal, info.fragsize, info.bytes, delay);
 558   return delay;
 559 }
 560
 561 static void
 562 gst_oss4_source_reset (GstAudioSrc * asrc)
 563 {
 564   /* There's nothing we can do here really: OSS can't handle access to the
 565    * same device/fd from multiple threads and might deadlock or blow up in
 566    * other ways if we try an ioctl SNDCTL_DSP_HALT or similar */
 567 }
 568
 569 /* GstMixer interface, which we abuse here for input selection, because we
 570  * don't have a proper interface for that and because that's what
 571  * gnome-sound-recorder does. */
 572
 573 /* GstMixerTrack is a plain GObject, so let's just use the GLib macro here */
 574 G_DEFINE_TYPE (GstOss4SourceInput, gst_oss4_source_input, GST_TYPE_MIXER_TRACK);
 575
 576 static void
 577 gst_oss4_source_input_class_init (GstOss4SourceInputClass * klass)
 578 {
 579   /* nothing to do here */
 580 }
 581
 582 static void
 583 gst_oss4_source_input_init (GstOss4SourceInput * i)
 584 {
 585   /* nothing to do here */
 586 }
 587
 588 #if 0
 589
 590 static void
 591 gst_ossmixer_ensure_track_list (GstOssMixer * mixer)
 592 {
 593   gint i, master = -1;
 594
 595   g_return_if_fail (mixer->fd != -1);
 596
 597   if (mixer->tracklist)
 598     return;
 599
 600   /* find master volume */
 601   if (mixer->devmask & SOUND_MASK_VOLUME)
 602     master = SOUND_MIXER_VOLUME;
 603   else if (mixer->devmask & SOUND_MASK_PCM)
 604     master = SOUND_MIXER_PCM;
 605   else if (mixer->devmask & SOUND_MASK_SPEAKER)
 606     master = SOUND_MIXER_SPEAKER;       /* doubtful... */
 607   /* else: no master, so we won't set any */
 608
 609   /* build track list */
 610   for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
 611     if (mixer->devmask & (1 << i)) {
 612       GstMixerTrack *track;
 613       gboolean input = FALSE, stereo = FALSE, record = FALSE;
 614
 615       /* track exists, make up capabilities */
 616       if (MASK_BIT_IS_SET (mixer->stereomask, i))
 617         stereo = TRUE;
 618       if (MASK_BIT_IS_SET (mixer->recmask, i))
 619         input = TRUE;
 620       if (MASK_BIT_IS_SET (mixer->recdevs, i))
 621         record = TRUE;
 622
 623       /* do we want mixer in our list? */
 624       if (!((mixer->dir & GST_OSS_MIXER_CAPTURE && input == TRUE) ||
 625               (mixer->dir & GST_OSS_MIXER_PLAYBACK && i != SOUND_MIXER_PCM)))
 626         /* the PLAYBACK case seems hacky, but that's how 0.8 had it */
 627         continue;
 628
 629       /* add track to list */
 630       track = gst_ossmixer_track_new (mixer->fd, i, stereo ? 2 : 1,
 631           (record ? GST_MIXER_TRACK_RECORD : 0) |
 632           (input ? GST_MIXER_TRACK_INPUT :
 633               GST_MIXER_TRACK_OUTPUT) |
 634           ((master != i) ? 0 : GST_MIXER_TRACK_MASTER));
 635       mixer->tracklist = g_list_append (mixer->tracklist, track);
 636     }
 637   }
 638 }
 639
 640 /* unused with G_DISABLE_* */
 641 static G_GNUC_UNUSED gboolean
 642 gst_ossmixer_contains_track (GstOssMixer * mixer, GstOssMixerTrack * osstrack)
 643 {
 644   const GList *item;
 645
 646   for (item = mixer->tracklist; item != NULL; item = item->next)
 647     if (item->data == osstrack)
 648       return TRUE;
 649
 650   return FALSE;
 651 }
 652
 653 const GList *
 654 gst_ossmixer_list_tracks (GstOssMixer * mixer)
 655 {
 656   gst_ossmixer_ensure_track_list (mixer);
 657
 658   return (const GList *) mixer->tracklist;
 659 }
 660
 661 void
 662 gst_ossmixer_get_volume (GstOssMixer * mixer,
 663     GstMixerTrack * track, gint * volumes)
 664 {
 665   gint volume;
 666   GstOssMixerTrack *osstrack = GST_OSSMIXER_TRACK (track);
 667
 668   g_return_if_fail (mixer->fd != -1);
 669   g_return_if_fail (gst_ossmixer_contains_track (mixer, osstrack));
 670
 671   if (track->flags & GST_MIXER_TRACK_MUTE) {
 672     volumes[0] = osstrack->lvol;
 673     if (track->num_channels == 2) {
 674       volumes[1] = osstrack->rvol;
 675     }
 676   } else {
 677     /* get */
 678     if (ioctl (mixer->fd, MIXER_READ (osstrack->track_num), &volume) < 0) {
 679       g_warning ("Error getting recording device (%d) volume: %s",
 680           osstrack->track_num, g_strerror (errno));
 681       volume = 0;
 682     }
 683
 684     osstrack->lvol = volumes[0] = (volume & 0xff);
 685     if (track->num_channels == 2) {
 686       osstrack->rvol = volumes[1] = ((volume >> 8) & 0xff);
 687     }
 688   }
 689 }
 690
 691 void
 692 gst_ossmixer_set_mute (GstOssMixer * mixer, GstMixerTrack * track,
 693     gboolean mute)
 694 {
 695   int volume;
 696   GstOssMixerTrack *osstrack = GST_OSSMIXER_TRACK (track);
 697
 698   g_return_if_fail (mixer->fd != -1);
 699   g_return_if_fail (gst_ossmixer_contains_track (mixer, osstrack));
 700
 701   if (mute) {
 702     volume = 0;
 703   } else {
 704     volume = (osstrack->lvol & 0xff);
 705     if (MASK_BIT_IS_SET (mixer->stereomask, osstrack->track_num)) {
 706       volume |= ((osstrack->rvol & 0xff) << 8);
 707     }
 708   }
 709
 710   if (ioctl (mixer->fd, MIXER_WRITE (osstrack->track_num), &volume) < 0) {
 711     g_warning ("Error setting mixer recording device volume (0x%x): %s",
 712         volume, g_strerror (errno));
 713     return;
 714   }
 715
 716   if (mute) {
 717     track->flags |= GST_MIXER_TRACK_MUTE;
 718   } else {
 719     track->flags &= ~GST_MIXER_TRACK_MUTE;
 720   }
 721 }
 722 #endif
 723
 724 static gint
 725 gst_oss4_source_mixer_get_current_input (GstOss4Source * oss)
 726 {
 727   int cur = -1;
 728
 729   if (ioctl (oss->fd, SNDCTL_DSP_GET_RECSRC, &cur) == -1 || cur < 0)
 730     return -1;
 731
 732   return cur;
 733 }
 734
 735 static const gchar *
 736 gst_oss4_source_mixer_update_record_flags (GstOss4Source * oss, gint cur_route)
 737 {
 738   const gchar *cur_name = "";
 739   GList *t;
 740
 741   for (t = oss->tracks; t != NULL; t = t->next) {
 742     GstMixerTrack *track = t->data;
 743
 744     if (GST_OSS4_SOURCE_INPUT (track)->route == cur_route) {
 745       if (!GST_MIXER_TRACK_HAS_FLAG (track, GST_MIXER_TRACK_RECORD)) {
 746         track->flags |= GST_MIXER_TRACK_RECORD;
 747         /* no point in sending a mixer-record-changes message here */
 748       }
 749       cur_name = track->label;
 750     } else {
 751       if (GST_MIXER_TRACK_HAS_FLAG (track, GST_MIXER_TRACK_RECORD)) {
 752         track->flags &= ~GST_MIXER_TRACK_RECORD;
 753         /* no point in sending a mixer-record-changes message here */
 754       }
 755     }
 756   }
 757
 758   return cur_name;
 759 }
 760
 761 static const GList *
 762 gst_oss4_source_mixer_list_tracks (GstMixer * mixer)
 763 {
 764   oss_mixer_enuminfo names = { 0, };
 765   GstOss4Source *oss;
 766   const gchar *cur_name;
 767   GList *tracks = NULL;
 768   gint i, cur;
 769
 770   g_return_val_if_fail (mixer != NULL, NULL);
 771   g_return_val_if_fail (GST_IS_OSS4_SOURCE (mixer), NULL);
 772   g_return_val_if_fail (GST_OSS4_SOURCE_IS_OPEN (mixer), NULL);
 773
 774   oss = GST_OSS4_SOURCE (mixer);
 775
 776   if (oss->tracks != NULL && oss->tracks_static)
 777     goto done;
 778
 779   if (ioctl (oss->fd, SNDCTL_DSP_GET_RECSRC_NAMES, &names) == -1)
 780     goto get_recsrc_names_error;
 781
 782   oss->tracks_static = (names.version == 0);
 783
 784   GST_INFO_OBJECT (oss, "%d inputs (list is static: %s):", names.nvalues,
 785       (oss->tracks_static) ? "yes" : "no");
 786
 787   for (i = 0; i < MIN (names.nvalues, OSS_ENUM_MAXVALUE + 1); ++i) {
 788     GstMixerTrack *track;
 789
 790     track = g_object_new (GST_TYPE_OSS4_SOURCE_INPUT, NULL);
 791     track->label = g_strdup (&names.strings[names.strindex[i]]);
 792     track->flags = GST_MIXER_TRACK_INPUT;
 793     track->num_channels = 2;
 794     track->min_volume = 0;
 795     track->max_volume = 100;
 796     GST_OSS4_SOURCE_INPUT (track)->route = i;
 797
 798     GST_INFO_OBJECT (oss, " [%d] %s", i, track->label);
 799     tracks = g_list_append (tracks, track);
 800   }
 801
 802   gst_oss4_source_free_mixer_tracks (oss);
 803   oss->tracks = tracks;
 804
 805 done:
 806
 807   /* update RECORD flags */
 808   cur = gst_oss4_source_mixer_get_current_input (oss);
 809   cur_name = gst_oss4_source_mixer_update_record_flags (oss, cur);
 810   GST_DEBUG_OBJECT (oss, "current input route: %d (%s)", cur, cur_name);
 811
 812   return (const GList *) oss->tracks;
 813
 814 /* ERRORS */
 815 get_recsrc_names_error:
 816   {
 817     GST_WARNING_OBJECT (oss, "GET_RECSRC_NAMES failed: %s", g_strerror (errno));
 818     return NULL;
 819   }
 820 }
 821
 822 static void
 823 gst_oss4_source_mixer_set_volume (GstMixer * mixer, GstMixerTrack * track,
 824     gint * volumes)
 825 {
 826   GstOss4Source *oss;
 827   int new_vol, cur;
 828
 829   g_return_if_fail (mixer != NULL);
 830   g_return_if_fail (track != NULL);
 831   g_return_if_fail (GST_IS_MIXER_TRACK (track));
 832   g_return_if_fail (GST_IS_OSS4_SOURCE (mixer));
 833   g_return_if_fail (GST_OSS4_SOURCE_IS_OPEN (mixer));
 834
 835   oss = GST_OSS4_SOURCE (mixer);
 836
 837   cur = gst_oss4_source_mixer_get_current_input (oss);
 838   if (cur != GST_OSS4_SOURCE_INPUT (track)->route) {
 839     GST_DEBUG_OBJECT (oss, "track not selected input route, ignoring request");
 840     return;
 841   }
 842
 843   new_vol = (volumes[1] << 8) | volumes[0];
 844   if (ioctl (oss->fd, SNDCTL_DSP_SETRECVOL, &new_vol) == -1) {
 845     GST_WARNING_OBJECT (oss, "SETRECVOL failed: %s", g_strerror (errno));
 846   }
 847 }
 848
 849 static void
 850 gst_oss4_source_mixer_get_volume (GstMixer * mixer, GstMixerTrack * track,
 851     gint * volumes)
 852 {
 853   GstOss4Source *oss;
 854   int cur;
 855
 856   g_return_if_fail (mixer != NULL);
 857   g_return_if_fail (GST_IS_OSS4_SOURCE (mixer));
 858   g_return_if_fail (GST_OSS4_SOURCE_IS_OPEN (mixer));
 859
 860   oss = GST_OSS4_SOURCE (mixer);
 861
 862   cur = gst_oss4_source_mixer_get_current_input (oss);
 863   if (cur != GST_OSS4_SOURCE_INPUT (track)->route) {
 864     volumes[0] = 0;
 865     volumes[1] = 0;
 866   } else {
 867     int vol = -1;
 868
 869     if (ioctl (oss->fd, SNDCTL_DSP_GETRECVOL, &vol) == -1 || vol < 0) {
 870       GST_WARNING_OBJECT (oss, "GETRECVOL failed: %s", g_strerror (errno));
 871       volumes[0] = 100;
 872       volumes[1] = 100;
 873     } else {
 874       volumes[0] = MIN (100, vol & 0xff);
 875       volumes[1] = MIN (100, (vol >> 8) & 0xff);
 876     }
 877   }
 878 }
 879
 880 static void
 881 gst_oss4_source_mixer_set_record (GstMixer * mixer, GstMixerTrack * track,
 882     gboolean record)
 883 {
 884   GstOss4Source *oss;
 885   const gchar *cur_name;
 886   gint cur;
 887
 888   g_return_if_fail (mixer != NULL);
 889   g_return_if_fail (track != NULL);
 890   g_return_if_fail (GST_IS_MIXER_TRACK (track));
 891   g_return_if_fail (GST_IS_OSS4_SOURCE (mixer));
 892   g_return_if_fail (GST_OSS4_SOURCE_IS_OPEN (mixer));
 893
 894   oss = GST_OSS4_SOURCE (mixer);
 895
 896   cur = gst_oss4_source_mixer_get_current_input (oss);
 897
 898   /* stop recording for an input that's not selected anyway => nothing to do */
 899   if (!record && cur != GST_OSS4_SOURCE_INPUT (track)->route)
 900     goto done;
 901
 902   /* select recording for an input that's already selected => nothing to do
 903    * (or should we mess with the recording volume in this case maybe?) */
 904   if (record && cur == GST_OSS4_SOURCE_INPUT (track)->route)
 905     goto done;
 906
 907   /* make current input stop recording: we can't really make an input stop
 908    * recording, we can only select an input FOR recording, so we'll just ignore
 909    * all requests to stop for now */
 910   if (!record) {
 911     GST_WARNING_OBJECT (oss, "Can't un-select an input as such, only switch "
 912         "to a different input source");
 913     /* FIXME: set recording volume to 0 maybe? */
 914   } else {
 915     int new_route = GST_OSS4_SOURCE_INPUT (track)->route;
 916
 917     /* select this input for recording */
 918
 919     if (ioctl (oss->fd, SNDCTL_DSP_SET_RECSRC, &new_route) == -1) {
 920       GST_WARNING_OBJECT (oss, "Could not select input %d for recording: %s",
 921           new_route, g_strerror (errno));
 922     } else {
 923       cur = new_route;
 924     }
 925   }
 926
 927 done:
 928
 929   cur_name = gst_oss4_source_mixer_update_record_flags (oss, cur);
 930   GST_DEBUG_OBJECT (oss, "active input route: %d (%s)", cur, cur_name);
 931 }
 932
 933 static void
 934 gst_oss4_source_mixer_set_mute (GstMixer * mixer, GstMixerTrack * track,
 935     gboolean mute)
 936 {
 937   GstOss4Source *oss;
 938
 939   g_return_if_fail (mixer != NULL);
 940   g_return_if_fail (track != NULL);
 941   g_return_if_fail (GST_IS_MIXER_TRACK (track));
 942   g_return_if_fail (GST_IS_OSS4_SOURCE (mixer));
 943   g_return_if_fail (GST_OSS4_SOURCE_IS_OPEN (mixer));
 944
 945   oss = GST_OSS4_SOURCE (mixer);
 946
 947   /* FIXME: implement gst_oss4_source_mixer_set_mute() - what to do here? */
 948   /* oss4_mixer_set_mute (mixer->mixer, track, mute); */
 949 }
 950
 951 static void
 952 gst_oss4_source_mixer_interface_init (GstMixerClass * klass)
 953 {
 954   GST_MIXER_TYPE (klass) = GST_MIXER_HARDWARE;
 955
 956   klass->list_tracks = gst_oss4_source_mixer_list_tracks;
 957   klass->set_volume = gst_oss4_source_mixer_set_volume;
 958   klass->get_volume = gst_oss4_source_mixer_get_volume;
 959   klass->set_mute = gst_oss4_source_mixer_set_mute;
 960   klass->set_record = gst_oss4_source_mixer_set_record;
 961 }
 962
 963 /* Implement the horror that is GstImplementsInterface */
 964
 965 static gboolean
 966 gst_oss4_source_mixer_supported (GstImplementsInterface * iface,
 967     GType iface_type)
 968 {
 969   GstOss4Source *oss;
 970   gboolean is_open;
 971
 972   g_return_val_if_fail (GST_IS_OSS4_SOURCE (iface), FALSE);
 973   g_return_val_if_fail (iface_type == GST_TYPE_MIXER, FALSE);
 974
 975   oss = GST_OSS4_SOURCE (iface);
 976
 977   GST_OBJECT_LOCK (oss);
 978   is_open = GST_OSS4_SOURCE_IS_OPEN (iface);
 979   GST_OBJECT_UNLOCK (oss);
 980
 981   return is_open;
 982 }
 983
 984 static void
 985 gst_oss4_source_mixer_implements_interface_init (GstImplementsInterfaceClass *
 986     klass)
 987 {
 988   klass->supported = gst_oss4_source_mixer_supported;
 989 }
 990
 991 static void
 992 gst_oss4_source_init_interfaces (GType type)
 993 {
 994   static const GInterfaceInfo implements_iface_info = {
 995     (GInterfaceInitFunc) gst_oss4_source_mixer_implements_interface_init,
 996     NULL,
 997     NULL,
 998   };
 999   static const GInterfaceInfo mixer_iface_info = {
1000     (GInterfaceInitFunc) gst_oss4_source_mixer_interface_init,
1001     NULL,
1002     NULL,
1003   };
1004
1005   g_type_add_interface_static (type, GST_TYPE_IMPLEMENTS_INTERFACE,
1006       &implements_iface_info);
1007   g_type_add_interface_static (type, GST_TYPE_MIXER, &mixer_iface_info);
1008
1009   gst_oss4_add_property_probe_interface (type);
1010 }