mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-18 06:16:36 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/sys/oss4/oss4-mixer.c

1856 lines
54 KiB
C
Raw Blame History

/* GStreamer OSS4 mixer implementation
* Copyright (C) 2007-2008 Tim-Philipp Müller <tim centricular net>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with mixer library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
/**
* SECTION:element-oss4mixer
*
* This element lets you adjust sound input and output levels with the
* Open Sound System (OSS) version 4. It supports the GstMixer interface, which
* can be used to obtain a list of available mixer tracks. Set the mixer
* element to READY state before using the GstMixer interface on it.
*
* <refsect2>
* <title>Example pipelines</title>
* <para>
* oss4mixer can&apos;t be used in a sensible way in gst-launch.
* </para>
* </refsect2>
*
* Since: 0.10.7
*/
/* Note: ioctl calls on the same open mixer device are serialised via
* the object lock to make sure we don't do concurrent ioctls from two
* different threads (e.g. app thread and mixer watch thread), since that
* will probably confuse OSS. */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <gst/interfaces/mixer.h>
#include <gst/gst-i18n-plugin.h>
#include <glib/gprintf.h>
#define NO_LEGACY_MIXER
#include "oss4-audio.h"
#include "oss4-mixer.h"
#include "oss4-mixer-enum.h"
#include "oss4-mixer-slider.h"
#include "oss4-mixer-switch.h"
#include "oss4-property-probe.h"
#include "oss4-soundcard.h"
#define GST_OSS4_MIXER_WATCH_INTERVAL 500 /* in millisecs, ie. 0.5s */
GST_DEBUG_CATEGORY_EXTERN (oss4mixer_debug);
#define GST_CAT_DEFAULT oss4mixer_debug
#define DEFAULT_DEVICE NULL
#define DEFAULT_DEVICE_NAME NULL
enum
{
PROP_0,
PROP_DEVICE,
PROP_DEVICE_NAME
};
static void gst_oss4_mixer_init_interfaces (GType type);
GST_BOILERPLATE_FULL (GstOss4Mixer, gst_oss4_mixer, GstElement,
GST_TYPE_ELEMENT, gst_oss4_mixer_init_interfaces);
static GstStateChangeReturn gst_oss4_mixer_change_state (GstElement *
element, GstStateChange transition);
static void gst_oss4_mixer_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
static void gst_oss4_mixer_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static void gst_oss4_mixer_finalize (GObject * object);
static gboolean gst_oss4_mixer_open (GstOss4Mixer * mixer,
gboolean silent_errors);
static void gst_oss4_mixer_close (GstOss4Mixer * mixer);
static gboolean gst_oss4_mixer_enum_control_update_enum_list (GstOss4Mixer * m,
GstOss4MixerControl * mc);
#ifndef GST_DISABLE_GST_DEBUG
static const gchar *mixer_ext_type_get_name (gint type);
static const gchar *mixer_ext_flags_get_string (gint flags);
#endif
static void
gst_oss4_mixer_base_init (gpointer klass)
{
gst_element_class_set_details_simple (GST_ELEMENT_CLASS (klass),
"OSS v4 Audio Mixer", "Generic/Audio",
"Control sound input and output levels with OSS4",
"Tim-Philipp Müller <tim centricular net>");
}
static void
gst_oss4_mixer_class_init (GstOss4MixerClass * klass)
{
GstElementClass *element_class;
GObjectClass *gobject_class;
element_class = (GstElementClass *) klass;
gobject_class = (GObjectClass *) klass;
gobject_class->finalize = gst_oss4_mixer_finalize;
gobject_class->set_property = gst_oss4_mixer_set_property;
gobject_class->get_property = gst_oss4_mixer_get_property;
/**
* GstOss4Mixer:device
*
* OSS4 mixer device (e.g. /dev/oss/hdaudio0/mix0 or /dev/mixerN)
*
**/
g_object_class_install_property (gobject_class, PROP_DEVICE,
g_param_spec_string ("device", "Device",
"OSS mixer device (e.g. /dev/oss/hdaudio0/mix0 or /dev/mixerN) "
"(NULL = use first mixer device found)", DEFAULT_DEVICE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GstOss4Mixer:device-name
*
* Human-readable name of the sound device. May be NULL if the device is
* not open (ie. when the mixer is in NULL state)
*
**/
g_object_class_install_property (gobject_class, PROP_DEVICE_NAME,
g_param_spec_string ("device-name", "Device name",
"Human-readable name of the sound device", DEFAULT_DEVICE_NAME,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
element_class->change_state = GST_DEBUG_FUNCPTR (gst_oss4_mixer_change_state);
}
static void
gst_oss4_mixer_finalize (GObject * obj)
{
GstOss4Mixer *mixer = GST_OSS4_MIXER (obj);
g_free (mixer->device);
G_OBJECT_CLASS (parent_class)->finalize (obj);
}
static void
gst_oss4_mixer_reset (GstOss4Mixer * mixer)
{
mixer->fd = -1;
mixer->need_update = TRUE;
memset (&mixer->last_mixext, 0, sizeof (oss_mixext));
}
static void
gst_oss4_mixer_init (GstOss4Mixer * mixer, GstOss4MixerClass * g_class)
{
mixer->device = g_strdup (DEFAULT_DEVICE);
mixer->device_name = NULL;
gst_oss4_mixer_reset (mixer);
}
static void
gst_oss4_mixer_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstOss4Mixer *mixer = GST_OSS4_MIXER (object);
switch (prop_id) {
case PROP_DEVICE:
GST_OBJECT_LOCK (mixer);
if (!GST_OSS4_MIXER_IS_OPEN (mixer)) {
g_free (mixer->device);
mixer->device = g_value_dup_string (value);
/* unset any cached device-name */
g_free (mixer->device_name);
mixer->device_name = NULL;
} else {
g_warning ("%s: can't change \"device\" property while mixer is open",
GST_OBJECT_NAME (mixer));
}
GST_OBJECT_UNLOCK (mixer);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_oss4_mixer_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstOss4Mixer *mixer = GST_OSS4_MIXER (object);
switch (prop_id) {
case PROP_DEVICE:
GST_OBJECT_LOCK (mixer);
g_value_set_string (value, mixer->device);
GST_OBJECT_UNLOCK (mixer);
break;
case PROP_DEVICE_NAME:
GST_OBJECT_LOCK (mixer);
/* If device is set, try to retrieve the name even if we're not open */
if (mixer->fd == -1 && mixer->device != NULL) {
if (gst_oss4_mixer_open (mixer, TRUE)) {
g_value_set_string (value, mixer->device_name);
gst_oss4_mixer_close (mixer);
} else {
g_value_set_string (value, mixer->device_name);
}
} else {
g_value_set_string (value, mixer->device_name);
}
GST_OBJECT_UNLOCK (mixer);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gboolean
gst_oss4_mixer_open (GstOss4Mixer * mixer, gboolean silent_errors)
{
struct oss_mixerinfo mi = { 0, };
gchar *device;
g_return_val_if_fail (!GST_OSS4_MIXER_IS_OPEN (mixer), FALSE);
if (mixer->device)
device = g_strdup (mixer->device);
else
device = gst_oss4_audio_find_device (GST_OBJECT_CAST (mixer));
/* desperate times, desperate measures */
if (device == NULL)
device = g_strdup ("/dev/mixer");
GST_INFO_OBJECT (mixer, "Trying to open OSS4 mixer device '%s'", device);
mixer->fd = open (device, O_RDWR, 0);
if (mixer->fd < 0)
goto open_failed;
/* Make sure it's OSS4. If it's old OSS, let the old ossmixer handle it */
if (!gst_oss4_audio_check_version (GST_OBJECT (mixer), mixer->fd))
goto legacy_oss;
GST_INFO_OBJECT (mixer, "Opened mixer device '%s', which is mixer %d",
device, mi.dev);
/* Get device name for currently open fd */
mi.dev = -1;
if (ioctl (mixer->fd, SNDCTL_MIXERINFO, &mi) == 0) {
mixer->modify_counter = mi.modify_counter;
if (mi.name[0] != '\0') {
mixer->device_name = g_strdup (mi.name);
}
} else {
mixer->modify_counter = 0;
}
if (mixer->device_name == NULL) {
mixer->device_name = g_strdup ("Unknown");
}
GST_INFO_OBJECT (mixer, "device name = '%s'", mixer->device_name);
mixer->open_device = device;
return TRUE;
/* ERRORS */
open_failed:
{
if (!silent_errors) {
GST_ELEMENT_ERROR (mixer, RESOURCE, OPEN_READ_WRITE,
(_("Could not open audio device for mixer control handling.")),
GST_ERROR_SYSTEM);
} else {
GST_DEBUG_OBJECT (mixer, "open failed: %s (ignoring errors)",
g_strerror (errno));
}
g_free (device);
return FALSE;
}
legacy_oss:
{
gst_oss4_mixer_close (mixer);
if (!silent_errors) {
GST_ELEMENT_ERROR (mixer, RESOURCE, OPEN_READ_WRITE,
(_("Could not open audio device for mixer control handling. "
"This version of the Open Sound System is not supported by this "
"element.")), ("Try the 'ossmixer' element instead"));
} else {
GST_DEBUG_OBJECT (mixer, "open failed: legacy oss (ignoring errors)");
}
g_free (device);
return FALSE;
}
}
static void
gst_oss4_mixer_control_free (GstOss4MixerControl * mc)
{
g_list_free (mc->children);
g_list_free (mc->mute_group);
g_free (mc->enum_vals);
memset (mc, 0, sizeof (GstOss4MixerControl));
g_free (mc);
}
static void
gst_oss4_mixer_free_tracks (GstOss4Mixer * mixer)
{
g_list_foreach (mixer->tracks, (GFunc) g_object_unref, NULL);
g_list_free (mixer->tracks);
mixer->tracks = NULL;
g_list_foreach (mixer->controls, (GFunc) gst_oss4_mixer_control_free, NULL);
g_list_free (mixer->controls);
mixer->controls = NULL;
}
static void
gst_oss4_mixer_close (GstOss4Mixer * mixer)
{
g_free (mixer->device_name);
mixer->device_name = NULL;
g_free (mixer->open_device);
mixer->open_device = NULL;
gst_oss4_mixer_free_tracks (mixer);
if (mixer->fd != -1) {
close (mixer->fd);
mixer->fd = -1;
}
gst_oss4_mixer_reset (mixer);
}
static void
gst_oss4_mixer_watch_process_changes (GstOss4Mixer * mixer)
{
GList *c, *t, *tracks = NULL;
GST_INFO_OBJECT (mixer, "mixer interface or control changed");
/* this is all with the mixer object lock held */
/* we go through the list backwards so we can bail out faster when the entire
* interface needs to be rebuilt */
for (c = g_list_last (mixer->controls); c != NULL; c = c->prev) {
GstOss4MixerControl *mc = c->data;
oss_mixer_value ossval = { 0, };
mc->changed = FALSE;
mc->list_changed = FALSE;
/* not interested in controls we don't expose in the mixer interface */
if (!mc->used)
continue;
/* don't try to read a value from controls that don't have one */
if (mc->mixext.type == MIXT_DEVROOT || mc->mixext.type == MIXT_GROUP)
continue;
/* is this an enum control whose list may change? */
if (mc->mixext.type == MIXT_ENUM && mc->enum_version != 0) {
if (gst_oss4_mixer_enum_control_update_enum_list (mixer, mc))
mc->list_changed = TRUE;
}
ossval.dev = mc->mixext.dev;
ossval.ctrl = mc->mixext.ctrl;
ossval.timestamp = mc->mixext.timestamp;
if (ioctl (mixer->fd, SNDCTL_MIX_READ, &ossval) == -1) {
if (errno == EIDRM || errno == EFAULT) {
GST_DEBUG ("%s has disappeared", mc->mixext.extname);
goto mixer_changed;
}
GST_WARNING_OBJECT (mixer, "MIX_READ failed: %s", g_strerror (errno));
/* just ignore, move on to next one */
continue;
}
if (ossval.value == mc->last_val) { /* no change */
/* GST_LOG_OBJECT (mixer, "%s hasn't changed", mc->mixext.extname); */
continue;
}
mc->last_val = ossval.value;
GST_LOG_OBJECT (mixer, "%s changed value to %u 0x%08x",
mc->mixext.extname, ossval.value, ossval.value);
mc->changed = TRUE;
}
/* copy list and take track refs, so we can safely drop the object lock,
* which we need to do to be able to post messages on the bus */
tracks = g_list_copy (mixer->tracks);
g_list_foreach (tracks, (GFunc) g_object_ref, NULL);
GST_OBJECT_UNLOCK (mixer);
/* since we don't know (or want to know exactly) which controls belong to
* which track, we just go through the tracks one-by-one now and make them
* check themselves if any of their controls have changed and which messages
* to post on the bus as a result */
for (t = tracks; t != NULL; t = t->next) {
GstMixerTrack *track = t->data;
if (GST_IS_OSS4_MIXER_SLIDER (track)) {
gst_oss4_mixer_slider_process_change_unlocked (track);
} else if (GST_IS_OSS4_MIXER_SWITCH (track)) {
gst_oss4_mixer_switch_process_change_unlocked (track);
} else if (GST_IS_OSS4_MIXER_ENUM (track)) {
gst_oss4_mixer_enum_process_change_unlocked (track);
}
g_object_unref (track);
}
g_list_free (tracks);
GST_OBJECT_LOCK (mixer);
return;
mixer_changed:
{
GST_OBJECT_UNLOCK (mixer);
gst_mixer_mixer_changed (GST_MIXER (mixer));
GST_OBJECT_LOCK (mixer);
return;
}
}
/* This thread watches the mixer for changes in a somewhat inefficient way
* (running an ioctl every half second or so). This is still better and
* cheaper than apps polling all tracks for changes a few times a second
* though. Needs more thought. There's probably (hopefully) a way to get
* notifications via the fd directly somehow. */
static gpointer
gst_oss4_mixer_watch_thread (gpointer thread_data)
{
GstOss4Mixer *mixer = GST_OSS4_MIXER_CAST (thread_data);
GST_DEBUG_OBJECT (mixer, "watch thread running");
GST_OBJECT_LOCK (mixer);
while (!mixer->watch_shutdown) {
oss_mixerinfo mi = { 0, };
GTimeVal tv;
mi.dev = -1;
if (ioctl (mixer->fd, SNDCTL_MIXERINFO, &mi) == 0) {
if (mixer->modify_counter != mi.modify_counter) {
/* GST_LOG ("processing changes"); */
gst_oss4_mixer_watch_process_changes (mixer);
mixer->modify_counter = mi.modify_counter;
} else {
/* GST_LOG ("no changes"); */
}
} else {
GST_WARNING_OBJECT (mixer, "MIXERINFO failed: %s", g_strerror (errno));
}
/* we could move the _get_current_time out of the loop and just do the
* add in ever iteration, which would be less exact, but who cares */
g_get_current_time (&tv);
g_time_val_add (&tv, GST_OSS4_MIXER_WATCH_INTERVAL * 1000);
(void) g_cond_timed_wait (mixer->watch_cond, GST_OBJECT_GET_LOCK (mixer),
&tv);
}
GST_OBJECT_UNLOCK (mixer);
GST_DEBUG_OBJECT (mixer, "watch thread done");
gst_object_unref (mixer);
return NULL;
}
/* call with object lock held */
static void
gst_oss4_mixer_wake_up_watch_task (GstOss4Mixer * mixer)
{
GST_LOG_OBJECT (mixer, "signalling watch thread to wake up");
g_cond_signal (mixer->watch_cond);
}
static void
gst_oss4_mixer_stop_watch_task (GstOss4Mixer * mixer)
{
if (mixer->watch_thread) {
GST_OBJECT_LOCK (mixer);
mixer->watch_shutdown = TRUE;
GST_LOG_OBJECT (mixer, "signalling watch thread to stop");
g_cond_signal (mixer->watch_cond);
GST_OBJECT_UNLOCK (mixer);
GST_LOG_OBJECT (mixer, "waiting for watch thread to join");
g_thread_join (mixer->watch_thread);
GST_DEBUG_OBJECT (mixer, "watch thread stopped");
mixer->watch_thread = NULL;
}
if (mixer->watch_cond) {
g_cond_free (mixer->watch_cond);
mixer->watch_cond = NULL;
}
}
static void
gst_oss4_mixer_start_watch_task (GstOss4Mixer * mixer)
{
GError *err = NULL;
mixer->watch_cond = g_cond_new ();
mixer->watch_shutdown = FALSE;
mixer->watch_thread = g_thread_create (gst_oss4_mixer_watch_thread,
gst_object_ref (mixer), TRUE, &err);
if (mixer->watch_thread == NULL) {
GST_ERROR_OBJECT (mixer, "Could not create watch thread: %s", err->message);
g_cond_free (mixer->watch_cond);
mixer->watch_cond = NULL;
g_error_free (err);
}
}
static GstStateChangeReturn
gst_oss4_mixer_change_state (GstElement * element, GstStateChange transition)
{
GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
GstOss4Mixer *mixer = GST_OSS4_MIXER (element);
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
if (!gst_oss4_mixer_open (mixer, FALSE))
return GST_STATE_CHANGE_FAILURE;
gst_oss4_mixer_start_watch_task (mixer);
break;
default:
break;
}
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
if (ret == GST_STATE_CHANGE_FAILURE)
return ret;
switch (transition) {
case GST_STATE_CHANGE_READY_TO_NULL:
gst_oss4_mixer_stop_watch_task (mixer);
gst_oss4_mixer_close (mixer);
break;
default:
break;
}
return ret;
}
/* === GstMixer interface === */
static inline gboolean
gst_oss4_mixer_contains_track (GstMixer * mixer, GstMixerTrack * track)
{
return (g_list_find (GST_OSS4_MIXER (mixer)->tracks, track) != NULL);
}
static inline gboolean
gst_oss4_mixer_contains_options (GstMixer * mixer, GstMixerOptions * options)
{
return (g_list_find (GST_OSS4_MIXER (mixer)->tracks, options) != NULL);
}
static void
gst_oss4_mixer_post_mixer_changed_msg (GstOss4Mixer * mixer)
{
/* only post mixer-changed message once */
if (!mixer->need_update) {
gst_mixer_mixer_changed (GST_MIXER (mixer));
mixer->need_update = TRUE;
}
}
/* call with mixer object lock held to serialise ioctl */
gboolean
gst_oss4_mixer_get_control_val (GstOss4Mixer * mixer, GstOss4MixerControl * mc,
int *val)
{
oss_mixer_value ossval = { 0, };
if (GST_OBJECT_TRYLOCK (mixer)) {
GST_ERROR ("must be called with mixer lock held");
GST_OBJECT_UNLOCK (mixer);
}
ossval.dev = mc->mixext.dev;
ossval.ctrl = mc->mixext.ctrl;
ossval.timestamp = mc->mixext.timestamp;
if (ioctl (mixer->fd, SNDCTL_MIX_READ, &ossval) == -1) {
if (errno == EIDRM) {
GST_DEBUG_OBJECT (mixer, "MIX_READ failed: mixer interface has changed");
gst_oss4_mixer_post_mixer_changed_msg (mixer);
} else {
GST_WARNING_OBJECT (mixer, "MIX_READ failed: %s", g_strerror (errno));
}
*val = 0;
mc->last_val = 0;
return FALSE;
}
*val = ossval.value;
mc->last_val = ossval.value;
GST_LOG_OBJECT (mixer, "got value 0x%08x from %s)", *val, mc->mixext.extname);
return TRUE;
}
/* call with mixer object lock held to serialise ioctl */
gboolean
gst_oss4_mixer_set_control_val (GstOss4Mixer * mixer, GstOss4MixerControl * mc,
int val)
{
oss_mixer_value ossval = { 0, };
ossval.dev = mc->mixext.dev;
ossval.ctrl = mc->mixext.ctrl;
ossval.timestamp = mc->mixext.timestamp;
ossval.value = val;
if (GST_OBJECT_TRYLOCK (mixer)) {
GST_ERROR ("must be called with mixer lock held");
GST_OBJECT_UNLOCK (mixer);
}
if (ioctl (mixer->fd, SNDCTL_MIX_WRITE, &ossval) == -1) {
if (errno == EIDRM) {
GST_LOG_OBJECT (mixer, "MIX_WRITE failed: mixer interface has changed");
gst_oss4_mixer_post_mixer_changed_msg (mixer);
} else {
GST_WARNING_OBJECT (mixer, "MIX_WRITE failed: %s", g_strerror (errno));
}
return FALSE;
}
mc->last_val = val;
GST_LOG_OBJECT (mixer, "set value 0x%08x on %s", val, mc->mixext.extname);
return TRUE;
}
#if 0
static gchar *
gst_oss4_mixer_control_get_pretty_name (GstOss4MixerControl * mc)
{
gchar *name;
const gchar *name, *u;
/* "The id field is the original name given by the driver when it called
* mixer_ext_create_control. This name can be used by fully featured GUI
* mixers. However this name should be downshifted and cut before the last
* underscore ("_") to get the proper name. For example mixer control name
* created as "MYDRV_MAINVOL" will become just "mainvol" after this
* transformation." */
name = mc->mixext.extname;
u = MAX (strrchr (name, '_'), strrchr (name, '.'));
if (u != NULL)
name = u + 1;
/* maybe capitalize the first letter? */
return g_ascii_strdown (name, -1);
/* the .id thing doesn't really seem to work right, ie. for some sliders
* it's just '-' so you have to use the name of the parent control etc.
* let's not use it for now, much too painful. */
if (g_str_has_prefix (mc->mixext.extname, "misc."))
name = g_strdup (mc->mixext.extname + 5);
else
name = g_strdup (mc->mixext.extname);
/* chop off trailing digit (only one for now) */
if (strlen (name) > 0 && g_ascii_isdigit (name[strlen (name) - 1]))
name[strlen (name) - 1] = '\0';
g_strdelimit (name, ".", ' ');
return name;
}
#endif
/* these translations are a bit ad-hoc and horribly incomplete; it is not
* really going to work this way with all the different chipsets and drivers.
* We also use these for translating option values. */
static struct
{
const gchar oss_name[32];
const gchar *label;
} labels[] = {
{
"volume", N_("Volume")}, {
"master", N_("Master")}, {
"front", N_("Front")}, {
"rear", N_("Rear")}, {
"headphones", N_("Headphones")}, {
"center", N_("Center")}, {
"lfe", N_("LFE")}, {
"surround", N_("Surround")}, {
"side", N_("Side")}, {
"speaker", N_("Built-in Speaker")}, {
"aux1-out", N_("AUX 1 Out")}, {
"aux2-out", N_("AUX 2 Out")}, {
"aux-out", N_("AUX Out")}, {
"bass", N_("Bass")}, {
"treble", N_("Treble")}, {
"3d-depth", N_("3D Depth")}, {
"3d-center", N_("3D Center")}, {
"3d-enhance", N_("3D Enhance")}, {
"phone", N_("Telephone")}, {
"mic", N_("Microphone")}, {
"line-out", N_("Line Out")}, {
"line-in", N_("Line In")}, {
"linein", N_("Line In")}, {
"cd", N_("Internal CD")}, {
"video", N_("Video In")}, {
"aux1-in", N_("AUX 1 In")}, {
"aux2-in", N_("AUX 2 In")}, {
"aux-in", N_("AUX In")}, {
"pcm", N_("PCM")}, {
"record-gain", N_("Record Gain")}, {
"igain", N_("Record Gain")}, {
"ogain", N_("Output Gain")}, {
"micboost", N_("Microphone Boost")}, {
"loopback", N_("Loopback")}, {
"diag", N_("Diagnostic")}, {
"loudness", N_("Bass Boost")}, {
"outputs", N_("Playback Ports")}, {
"input", N_("Input")}, {
"inputs", N_("Record Source")}, {
"record-source", N_("Record Source")}, {
"monitor-source", N_("Monitor Source")}, {
"beep", N_("Keyboard Beep")}, {
"monitor-gain", N_("Monitor")}, {
"stereo-simulate", N_("Simulate Stereo")}, {
"stereo", N_("Stereo")}, {
"multich", N_("Surround Sound")}, {
"mic-gain", N_("Microphone Gain")}, {
"speaker-source", N_("Speaker Source")}, {
"mic-source", N_("Microphone Source")}, {
"jack", N_("Jack")}, {
"center/lfe", N_("Center / LFE")}, {
"stereo-mix", N_("Stereo Mix")}, {
"mono-mix", N_("Mono Mix")}, {
"input-mix", N_("Input Mix")}, {
"spdif-in", N_("SPDIF In")}, {
"spdif-out", N_("SPDIF Out")}, {
"mic1", N_("Microphone 1")}, {
"mic2", N_("Microphone 2")}, {
"digital-out", N_("Digital Out")}, {
"digital-in", N_("Digital In")}, {
"hdmi", N_("HDMI")}, {
"modem", N_("Modem")}, {
"handset", N_("Handset")}, {
"other", N_("Other")}, {
"stereo", N_("Stereo")}, {
"none", N_("None")}, {
"on", N_("On")}, {
"off", N_("Off")}, {
"mute", N_("Mute")}, {
"fast", N_("Fast")}, {
/* TRANSLATORS: "Very Low" is a quality setting here */
"very-low", N_("Very Low")}, {
/* TRANSLATORS: "Low" is a quality setting here */
"low", N_("Low")}, {
/* TRANSLATORS: "Medium" is a quality setting here */
"medium", N_("Medium")}, {
/* TRANSLATORS: "High" is a quality setting here */
"high", N_("High")}, {
/* TRANSLATORS: "Very High" is a quality setting here */
"very-high", N_("Very High")}, {
"high+", N_("Very High")}, {
/* TRANSLATORS: "Production" is a quality setting here */
"production", N_("Production")}, {
"fp-mic", N_("Front Panel Microphone")}, {
"fp-linein", N_("Front Panel Line In")}, {
"fp-headphones", N_("Front Panel Headphones")}, {
"fp-lineout", N_("Front Panel Line Out")}, {
"green", N_("Green Connector")}, {
"pink", N_("Pink Connector")}, {
"blue", N_("Blue Connector")}, {
"white", N_("White Connector")}, {
"black", N_("Black Connector")}, {
"gray", N_("Gray Connector")}, {
"orange", N_("Orange Connector")}, {
"red", N_("Red Connector")}, {
"yellow", N_("Yellow Connector")}, {
"fp-green", N_("Green Front Panel Connector")}, {
"fp-pink", N_("Pink Front Panel Connector")}, {
"fp-blue", N_("Blue Front Panel Connector")}, {
"fp-white", N_("White Front Panel Connector")}, {
"fp-black", N_("Black Front Panel Connector")}, {
"fp-gray", N_("Gray Front Panel Connector")}, {
"fp-orange", N_("Orange Front Panel Connector")}, {
"fp-red", N_("Red Front Panel Connector")}, {
"fp-yellow", N_("Yellow Front Panel Connector")}, {
"spread", N_("Spread Output")}, {
"downmix", N_("Downmix")},
/* FIXME translate Audigy NX USB labels) */
/*
{ "rec.src", N_("Record Source") },
{ "output.mute", N_("Mute output") }
headph (Controller group)
headph.src (Enumeration control)
headph.mute (On/Off switch)
digital2 (Controller group)
digital2.src (Enumeration control)
digital2.mute (On/Off switch)
digital (Controller group)
digital.mute1 (On/Off switch)
digital.vol (Controller group)
digital.vol.front (Stereo slider (0-255))
digital.vol.surr (Stereo slider (0-255))
digital.vol.c/l (Stereo slider (0-255))
digital.vol.center (Stereo slider (0-255))
digital.mute2 (On/Off switch)
digital.vol (Stereo slider (0-255))
line (Controller group)
line.mute (On/Off switch)
line.vol (Stereo slider (0-255))
play-altset (Enumeration control)
rec-altset (Enumeration control)
*/
};
/* Decent i18n is pretty much impossible with OSS's way of providing us with
* mixer labels (and the fact that they are pretty much random), but that
* doesn't mean we shouldn't at least try. */
static gchar *
gst_oss4_mixer_control_get_translated_name (GstOss4MixerControl * mc)
{
gchar name[128] = { 0, };
gchar vmix_str[32] = { '\0', };
gchar *ptr;
int dummy, i;
int num = -1;
gboolean function_suffix = FALSE;
/* main virtual mixer controls (we hide the stream volumes) */
if (sscanf (mc->mixext.extname, "vmix%d-%32c", &dummy, vmix_str) == 2) {
if (strcmp (vmix_str, "src") == 0)
return g_strdup (_("Virtual Mixer Input"));
else if (strcmp (vmix_str, "vol") == 0)
return g_strdup (_("Virtual Mixer Output"));
else if (strcmp (vmix_str, "channels") == 0)
return g_strdup (_("Virtual Mixer Channels"));
}
g_strlcpy (name, mc->mixext.extname, sizeof (name));
/* we deal with either "connector." or "jack." */
if ((g_str_has_prefix (name, "connector.")) ||
(g_str_has_prefix (name, "jack."))) {
ptr = strchr (mc->mixext.extname, '.');
ptr++;
g_strlcpy (name, ptr, sizeof (name));
}
/* special handling for jack retasking suffixes */
if (g_str_has_suffix (name, ".function") || g_str_has_suffix (name, ".mode")) {
function_suffix = TRUE;
ptr = strrchr (name, '.');
*ptr = 0;
}
/* parse off trailing numbers */
i = strlen (name);
while ((i > 0) && (g_ascii_isdigit (name[i - 1]))) {
i--;
}
/* the check catches the case where the control name is just a number */
if ((i > 0) && (name[i] != '\0')) {
num = atoi (name + i);
name[i] = '\0';
}
/* look for a match, progressively skipping '.' delimited prefixes as we go */
ptr = name;
do {
if (*ptr == '.')
ptr++;
for (i = 0; i < G_N_ELEMENTS (labels); ++i) {
if (g_ascii_strcasecmp (ptr, labels[i].oss_name) == 0) {
g_strlcpy (name, _(labels[i].label), sizeof (name));
goto append_suffixes;
}
}
} while ((ptr = strchr (ptr, '.')) != NULL);
/* failing that, just replace periods with spaces */
g_strdelimit (name, ".", ' ');
append_suffixes:
if (num > -1) {
if (function_suffix) {
/* TRANSLATORS: name + number of a volume mixer control */
return g_strdup_printf (_("%s %d Function"), name, num);
} else {
return g_strdup_printf ("%s %d", name, num);
}
} else {
if (function_suffix) {
/* TRANSLATORS: name of a volume mixer control */
return g_strdup_printf (_("%s Function"), name);
} else {
return g_strdup (name);
}
}
}
static const gchar *
gst_oss4_mixer_control_get_translated_option (const gchar * name)
{
int i;
for (i = 0; i < G_N_ELEMENTS (labels); ++i) {
if (g_ascii_strcasecmp (name, labels[i].oss_name) == 0) {
return _(labels[i].label);
}
}
return (name);
}
#ifndef GST_DISABLE_GST_DEBUG
static const gchar *
mixer_ext_type_get_name (gint type)
{
switch (type) {
case MIXT_DEVROOT:
return "Device root entry";
case MIXT_GROUP:
return "Controller group";
case MIXT_ONOFF:
return "On/Off switch";
case MIXT_ENUM:
return "Enumeration control";
case MIXT_MONOSLIDER:
return "Mono slider (0-255)";
case MIXT_STEREOSLIDER:
return "Stereo slider (0-255)";
case MIXT_MESSAGE:
return "Textual message"; /* whatever this is */
case MIXT_MONOVU:
return "Mono VU meter value";
case MIXT_STEREOVU:
return "Stereo VU meter value";
case MIXT_MONOPEAK:
return "Mono VU meter peak value";
case MIXT_STEREOPEAK:
return "Stereo VU meter peak value";
case MIXT_RADIOGROUP:
return "Radio button group";
case MIXT_MARKER: /* Separator between normal and extension entries */
return "Separator";
case MIXT_VALUE:
return "Decimal value entry";
case MIXT_HEXVALUE:
return "Hex value entry";
case MIXT_SLIDER:
return "Mono slider (31-bit value range)";
case MIXT_3D:
return "3D"; /* what's this? */
case MIXT_MONOSLIDER16:
return "Mono slider (0-32767)";
case MIXT_STEREOSLIDER16:
return "Stereo slider (0-32767)";
case MIXT_MUTE:
return "Mute switch";
default:
break;
}
return "unknown";
}
#endif /* GST_DISABLE_GST_DEBUG */
#ifndef GST_DISABLE_GST_DEBUG
static const gchar *
mixer_ext_flags_get_string (gint flags)
{
struct
{
gint flag;
gchar nick[16];
} all_flags[] = {
/* first the important ones */
{
MIXF_MAINVOL, "MAINVOL"}, {
MIXF_PCMVOL, "PCMVOL"}, {
MIXF_RECVOL, "RECVOL"}, {
MIXF_MONVOL, "MONVOL"}, {
MIXF_DESCR, "DESCR"},
/* now the rest in the right order */
{
MIXF_READABLE, "READABLE"}, {
MIXF_WRITEABLE, "WRITABLE"}, {
MIXF_POLL, "POLL"}, {
MIXF_HZ, "HZ"}, {
MIXF_STRING, "STRING"}, {
MIXF_DYNAMIC, "DYNAMIC"}, {
MIXF_OKFAIL, "OKFAIL"}, {
MIXF_FLAT, "FLAT"}, {
MIXF_LEGACY, "LEGACY"}, {
MIXF_CENTIBEL, "CENTIBEL"}, {
MIXF_DECIBEL, "DECIBEL"}, {
MIXF_WIDE, "WIDE"}
};
GString *s;
GQuark q;
gint i;
if (flags == 0)
return "None";
s = g_string_new ("");
for (i = 0; i < G_N_ELEMENTS (all_flags); ++i) {
if ((flags & all_flags[i].flag)) {
if (s->len > 0)
g_string_append (s, " | ");
g_string_append (s, all_flags[i].nick);
flags &= ~all_flags[i].flag; /* unset */
}
}
/* unknown flags? */
if (flags != 0) {
if (s->len > 0)
g_string_append (s, " | ");
g_string_append (s, "???");
}
/* we'll just put it into the global quark table (cheeky, eh?) */
q = g_quark_from_string (s->str);
g_string_free (s, TRUE);
return g_quark_to_string (q);
}
#endif /* GST_DISABLE_GST_DEBUG */
#ifndef GST_DISABLE_GST_DEBUG
static void
gst_oss4_mixer_control_dump_tree (GstOss4MixerControl * mc, gint depth)
{
GList *c;
gchar spaces[64];
gint i;
depth = MIN (sizeof (spaces) - 1, depth);
for (i = 0; i < depth; ++i)
spaces[i] = ' ';
spaces[i] = '\0';
GST_LOG ("%s%s (%s)", spaces, mc->mixext.extname,
mixer_ext_type_get_name (mc->mixext.type));
for (c = mc->children; c != NULL; c = c->next) {
GstOss4MixerControl *child_mc = (GstOss4MixerControl *) c->data;
gst_oss4_mixer_control_dump_tree (child_mc, depth + 2);
}
}
#endif /* GST_DISABLE_GST_DEBUG */
static GList *
gst_oss4_mixer_get_controls (GstOss4Mixer * mixer)
{
GstOss4MixerControl *root_mc = NULL;
oss_mixerinfo mi = { 0, };
GList *controls = NULL;
GList *l;
guint i;
/* Get info for currently open fd */
mi.dev = -1;
if (ioctl (mixer->fd, SNDCTL_MIXERINFO, &mi) == -1)
goto no_mixerinfo;
if (mi.nrext <= 0) {
GST_DEBUG ("mixer %s has no controls", mi.id);
return NULL;
}
GST_INFO ("Reading controls for mixer %s", mi.id);
for (i = 0; i < mi.nrext; ++i) {
GstOss4MixerControl *mc;
oss_mixext mix_ext = { 0, };
mix_ext.dev = mi.dev;
mix_ext.ctrl = i;
if (ioctl (mixer->fd, SNDCTL_MIX_EXTINFO, &mix_ext) == -1) {
GST_DEBUG ("SNDCTL_MIX_EXTINFO failed on mixer %s, control %d: %s",
mi.id, i, g_strerror (errno));
continue;
}
/* if this is the last one, save it for is-interface-up-to-date checking */
if (i == mi.nrext)
mixer->last_mixext = mix_ext;
mc = g_new0 (GstOss4MixerControl, 1);
mc->mixext = mix_ext;
/* both control_no and desc fields are pretty useless, ie. not always set,
* if ever, so not listed here */
GST_INFO ("Control %d", mix_ext.ctrl);
GST_INFO (" name : %s", mix_ext.extname);
GST_INFO (" type : %s (%d)", mixer_ext_type_get_name (mix_ext.type),
mix_ext.type);
GST_INFO (" flags : %s (0x%04x)",
mixer_ext_flags_get_string (mix_ext.flags), mix_ext.flags);
GST_INFO (" parent : %d", mix_ext.parent);
if (!MIXEXT_IS_ROOT (mix_ext)) {
/* find parent (we assume it comes in the list before the child) */
for (l = controls; l != NULL; l = l->next) {
GstOss4MixerControl *parent_mc = (GstOss4MixerControl *) l->data;
if (parent_mc->mixext.ctrl == mix_ext.parent) {
mc->parent = parent_mc;
parent_mc->children = g_list_append (parent_mc->children, mc);
break;
}
}
if (mc->parent == NULL) {
GST_ERROR_OBJECT (mixer, "couldn't find parent for control %d", i);
g_free (mc);
continue;
}
} else if (root_mc == NULL) {
root_mc = mc;
} else {
GST_WARNING_OBJECT (mixer, "two root controls?!");
}
controls = g_list_prepend (controls, mc);
}
#ifndef GST_DISABLE_GST_DEBUG
gst_oss4_mixer_control_dump_tree (root_mc, 0);
#endif
return g_list_reverse (controls);
/* ERRORS */
no_mixerinfo:
{
GST_WARNING ("SNDCTL_MIXERINFO failed on mixer device %s: %s", mi.id,
g_strerror (errno));
return NULL;
}
}
static void
gst_oss4_mixer_controls_guess_master (GstOss4Mixer * mixer,
const GList * controls)
{
GstOss4MixerControl *master_mc = NULL;
const GList *l;
for (l = controls; l != NULL; l = l->next) {
GstOss4MixerControl *mc = (GstOss4MixerControl *) l->data;
/* do we need to check if it's a slider type here? */
if ((mc->mixext.flags & MIXF_PCMVOL)) {
GST_INFO_OBJECT (mixer, "First PCM control: %s", mc->mixext.extname);
master_mc = mc;
break;
}
if (((mc->mixext.flags & MIXF_MAINVOL)) && master_mc == NULL) {
GST_INFO_OBJECT (mixer, "First main volume control: %s",
mc->mixext.extname);
master_mc = mc;
}
}
if (master_mc != NULL)
master_mc->is_master = TRUE;
}
/* type: -1 for all types, otherwise just return siblings with requested type */
static GList *
gst_oss4_mixer_control_get_siblings (GstOss4MixerControl * mc, gint type)
{
GList *s, *siblings = NULL;
if (mc->parent == NULL)
return NULL;
for (s = mc->parent->children; s != NULL; s = s->next) {
GstOss4MixerControl *sibling = (GstOss4MixerControl *) s->data;
if (mc != sibling && (type < 0 || sibling->mixext.type == type))
siblings = g_list_append (siblings, sibling);
}
return siblings;
}
static void
gst_oss4_mixer_controls_find_sliders (GstOss4Mixer * mixer,
const GList * controls)
{
const GList *l;
for (l = controls; l != NULL; l = l->next) {
GstOss4MixerControl *mc = (GstOss4MixerControl *) l->data;
GList *s, *siblings;
if (!MIXEXT_IS_SLIDER (mc->mixext) || mc->parent == NULL || mc->used)
continue;
mc->is_slider = TRUE;
mc->used = TRUE;
siblings = gst_oss4_mixer_control_get_siblings (mc, -1);
/* Note: the names can be misleading and may not reflect the actual
* hierarchy of the controls, e.g. it's possible that a slider is called
* connector.green and the mute control then connector.green.mute, but
* both controls are in fact siblings and both children of the group
* 'green' instead of mute being a child of connector.green as the naming
* would seem to suggest */
GST_LOG ("Slider: %s, parent=%s, %d siblings", mc->mixext.extname,
mc->parent->mixext.extname, g_list_length (siblings));
for (s = siblings; s != NULL; s = s->next) {
GstOss4MixerControl *sibling = (GstOss4MixerControl *) s->data;
GST_LOG (" %s (%s)", sibling->mixext.extname,
mixer_ext_type_get_name (sibling->mixext.type));
if (sibling->mixext.type == MIXT_MUTE ||
g_str_has_suffix (sibling->mixext.extname, ".mute")) {
/* simple case: slider with single mute sibling. We assume the .mute
* suffix in the name won't change - can't really do much else anyway */
if (sibling->mixext.type == MIXT_ONOFF ||
sibling->mixext.type == MIXT_MUTE) {
GST_LOG (" mute control for %s is %s", mc->mixext.extname,
sibling->mixext.extname);
mc->mute = sibling;
sibling->used = TRUE;
}
/* a group of .mute controls. We assume they are all switches here */
if (sibling->mixext.type == MIXT_GROUP) {
GList *m;
for (m = sibling->children; m != NULL; m = m->next) {
GstOss4MixerControl *grouped_sibling = m->data;
if (grouped_sibling->mixext.type == MIXT_ONOFF ||
grouped_sibling->mixext.type == MIXT_MUTE) {
GST_LOG (" %s is grouped mute control for %s",
grouped_sibling->mixext.extname, mc->mixext.extname);
mc->mute_group = g_list_append (mc->mute_group, grouped_sibling);
}
}
GST_LOG (" %s has a group of %d mute controls",
mc->mixext.extname, g_list_length (mc->mute_group));
/* we don't mark the individual mute controls as used, only the
* group control, as we still want individual switches for the
* individual controls */
sibling->used = TRUE;
}
}
}
g_list_free (siblings);
}
}
/* should be called with the mixer object lock held because of the ioctl;
* returns TRUE if the list was read the first time or modified */
static gboolean
gst_oss4_mixer_enum_control_update_enum_list (GstOss4Mixer * mixer,
GstOss4MixerControl * mc)
{
oss_mixer_enuminfo ei = { 0, };
guint num_existing = 0;
int i;
/* count and existing values */
while (mc->enum_vals != NULL && mc->enum_vals[num_existing] != 0)
++num_existing;
ei.dev = mc->mixext.dev;
ei.ctrl = mc->mixext.ctrl;
/* if we have create a generic list with numeric IDs already and the
* number of values hasn't changed, then there's not much to do here */
if (mc->no_list && mc->enum_vals != NULL &&
num_existing == mc->mixext.maxvalue) {
return FALSE;
}
/* if we have a list and it doesn't change, there's nothing to do either */
if (mc->enum_vals != NULL && mc->enum_version == 0)
return FALSE;
if (ioctl (mixer->fd, SNDCTL_MIX_ENUMINFO, &ei) == -1) {
g_free (mc->enum_vals);
mc->enum_vals = g_new0 (GQuark, mc->mixext.maxvalue + 1);
GST_DEBUG ("no enum info available, creating numeric values from 0-%d",
mc->mixext.maxvalue - 1);
/* "It is possible that some enum controls don't have any name list
* available. In this case the application should automatically generate
* list of numbers (0 to N-1)" */
for (i = 0; i < mc->mixext.maxvalue; ++i) {
gchar num_str[8];
g_snprintf (num_str, sizeof (num_str), "%d", i);
mc->enum_vals[i] = g_quark_from_string (num_str);
}
mc->enum_version = 0; /* the only way to change is via maxvalue */
} else {
/* old list same as current list? */
if (mc->enum_vals != NULL && mc->enum_version == ei.version)
return FALSE;
/* no list yet, or the list has changed */
GST_LOG ("%s", (mc->enum_vals) ? "enum list has changed" : "reading list");
if (ei.nvalues != mc->mixext.maxvalue) {
GST_WARNING_OBJECT (mixer, "Enum: %s, nvalues %d != maxvalue %d",
mc->mixext.extname, ei.nvalues, mc->mixext.maxvalue);
mc->mixext.maxvalue = MIN (ei.nvalues, mc->mixext.maxvalue);
}
mc->mixext.maxvalue = MIN (mc->mixext.maxvalue, OSS_ENUM_MAXVALUE);
g_free (mc->enum_vals);
mc->enum_vals = g_new0 (GQuark, mc->mixext.maxvalue + 1);
for (i = 0; i < mc->mixext.maxvalue; ++i) {
GST_LOG (" %s", ei.strings + ei.strindex[i]);
mc->enum_vals[i] =
g_quark_from_string (gst_oss4_mixer_control_get_translated_option
(ei.strings + ei.strindex[i]));
}
}
return TRUE;
}
static void
gst_oss4_mixer_controls_find_enums (GstOss4Mixer * mixer,
const GList * controls)
{
const GList *l;
for (l = controls; l != NULL; l = l->next) {
GstOss4MixerControl *mc = (GstOss4MixerControl *) l->data;
if (mc->mixext.type != MIXT_ENUM || mc->used)
continue;
mc->is_enum = TRUE;
mc->used = TRUE;
/* Note: enums are special: for most controls, the maxvalue is inclusive,
* but for enum controls it's actually exclusive (boggle), so that
* mixext.maxvalue = num_values */
GST_LOG ("Enum: %s, parent=%s, num_enums=%d", mc->mixext.extname,
mc->parent->mixext.extname, mc->mixext.maxvalue);
gst_oss4_mixer_enum_control_update_enum_list (mixer, mc);
}
}
static void
gst_oss4_mixer_controls_find_switches (GstOss4Mixer * mixer,
const GList * controls)
{
const GList *l;
for (l = controls; l != NULL; l = l->next) {
GstOss4MixerControl *mc = (GstOss4MixerControl *) l->data;
if (mc->used)
continue;
if (mc->mixext.type != MIXT_ONOFF && mc->mixext.type != MIXT_MUTE)
continue;
mc->is_switch = TRUE;
mc->used = TRUE;
GST_LOG ("Switch: %s, parent=%s", mc->mixext.extname,
mc->parent->mixext.extname);
}
}
static void
gst_oss4_mixer_controls_find_virtual (GstOss4Mixer * mixer,
const GList * controls)
{
const GList *l;
for (l = controls; l != NULL; l = l->next) {
GstOss4MixerControl *mc = (GstOss4MixerControl *) l->data;
/* or sscanf (mc->mixext.extname, "vmix%d-out.", &n) == 1 ? */
/* for now we just flag all virtual controls with managed labels, those
* are really more appropriate for a pavucontrol-type control thing than
* the (more hardware-oriented) mixer interface */
if (mc->mixext.id[0] == '@') {
mc->is_virtual = TRUE;
GST_LOG ("%s is virtual control with managed label", mc->mixext.extname);
}
}
}
static void
gst_oss4_mixer_controls_dump_unused (GstOss4Mixer * mixer,
const GList * controls)
{
const GList *l;
for (l = controls; l != NULL; l = l->next) {
GstOss4MixerControl *mc = (GstOss4MixerControl *) l->data;
if (mc->used)
continue;
switch (mc->mixext.type) {
case MIXT_DEVROOT:
case MIXT_GROUP:
case MIXT_MESSAGE:
case MIXT_MONOVU:
case MIXT_STEREOVU:
case MIXT_MONOPEAK:
case MIXT_STEREOPEAK:
case MIXT_MARKER:
continue; /* not interested in these types of controls */
case MIXT_MONODB:
case MIXT_STEREODB:
GST_DEBUG ("obsolete control type %d", mc->mixext.type);
continue;
case MIXT_MONOSLIDER:
case MIXT_STEREOSLIDER:
case MIXT_SLIDER:
case MIXT_MONOSLIDER16:
case MIXT_STEREOSLIDER16:
/* this shouldn't happen */
GST_ERROR ("unused slider control?!");
continue;
case MIXT_VALUE:
case MIXT_HEXVALUE:
/* value entry, not sure what to do with that, skip for now */
continue;
case MIXT_ONOFF:
case MIXT_MUTE:
case MIXT_ENUM:
case MIXT_3D:
case MIXT_RADIOGROUP:
GST_DEBUG ("FIXME: handle %s %s",
mixer_ext_type_get_name (mc->mixext.type), mc->mixext.extname);
break;
default:
GST_WARNING ("unknown control type %d", mc->mixext.type);
continue;
}
}
}
static GList *
gst_oss4_mixer_create_tracks (GstOss4Mixer * mixer, const GList * controls)
{
const GList *c;
GList *tracks = NULL;
for (c = controls; c != NULL; c = c->next) {
GstOss4MixerControl *mc = (GstOss4MixerControl *) c->data;
GstMixerTrack *track = NULL;
if (mc->is_virtual)
continue;
if (mc->is_slider) {
track = gst_oss4_mixer_slider_new (mixer, mc);
} else if (mc->is_enum) {
track = gst_oss4_mixer_enum_new (mixer, mc);
} else if (mc->is_switch) {
track = gst_oss4_mixer_switch_new (mixer, mc);
}
if (track == NULL)
continue;
track->label = gst_oss4_mixer_control_get_translated_name (mc);
track->flags = 0;
GST_LOG ("translated label: %s [%s] = %s", track->label, mc->mixext.id,
track->label);
/* This whole 'a track is either INPUT or OUTPUT' model is just flawed,
* esp. if a slider's role can be changed on the fly, like when you change
* function of a connector. What should we do in that case? Change the flag
* and make the app rebuild the interface? Ignore it? */
if (mc->mixext.flags & (MIXF_MAINVOL | MIXF_PCMVOL)) {
track->flags = GST_MIXER_TRACK_OUTPUT | GST_MIXER_TRACK_WHITELIST;
} else if (mc->mixext.flags & MIXF_RECVOL) {
/* record gain whitelisted by default */
track->flags = GST_MIXER_TRACK_INPUT | GST_MIXER_TRACK_NO_RECORD |
GST_MIXER_TRACK_WHITELIST;
} else if (mc->mixext.flags & MIXF_MONVOL) {
/* monitor sources not whitelisted by default */
track->flags = GST_MIXER_TRACK_INPUT | GST_MIXER_TRACK_NO_RECORD;
}
/*
* The kernel may give us better clues about the scope of a control.
* If so, try to honor it.
*/
switch (mc->mixext.desc & MIXEXT_SCOPE_MASK) {
case MIXEXT_SCOPE_INPUT:
case MIXEXT_SCOPE_RECSWITCH:
track->flags |= GST_MIXER_TRACK_INPUT | GST_MIXER_TRACK_NO_RECORD |
GST_MIXER_TRACK_WHITELIST;
break;
case MIXEXT_SCOPE_MONITOR:
/* don't whitelist monitor tracks by default */
track->flags |= GST_MIXER_TRACK_INPUT | GST_MIXER_TRACK_NO_RECORD;
break;
case MIXEXT_SCOPE_OUTPUT:
track->flags = GST_MIXER_TRACK_OUTPUT | GST_MIXER_TRACK_WHITELIST;
break;
}
if (mc->is_master) {
track->flags |= GST_MIXER_TRACK_OUTPUT;
}
if (mc->is_master)
track->flags |= GST_MIXER_TRACK_MASTER;
tracks = g_list_append (tracks, track);
}
return tracks;
}
static void
gst_oss4_mixer_update_tracks (GstOss4Mixer * mixer)
{
GList *controls, *tracks;
/* read and process controls */
controls = gst_oss4_mixer_get_controls (mixer);
gst_oss4_mixer_controls_guess_master (mixer, controls);
gst_oss4_mixer_controls_find_sliders (mixer, controls);
gst_oss4_mixer_controls_find_enums (mixer, controls);
gst_oss4_mixer_controls_find_switches (mixer, controls);
gst_oss4_mixer_controls_find_virtual (mixer, controls);
gst_oss4_mixer_controls_dump_unused (mixer, controls);
tracks = gst_oss4_mixer_create_tracks (mixer, controls);
/* free old tracks and controls */
gst_oss4_mixer_free_tracks (mixer);
/* replace old with new */
mixer->tracks = tracks;
mixer->controls = controls;
}
static const GList *
gst_oss4_mixer_list_tracks (GstMixer * mixer_iface)
{
GstOss4Mixer *mixer = GST_OSS4_MIXER (mixer_iface);
g_return_val_if_fail (mixer != NULL, NULL);
g_return_val_if_fail (GST_OSS4_MIXER_IS_OPEN (mixer), NULL);
GST_OBJECT_LOCK (mixer);
/* Do a read on the last control to check if the interface has changed */
if (!mixer->need_update && mixer->last_mixext.ctrl > 0) {
GstOss4MixerControl mc = { {0,}
,
};
int val;
mc.mixext = mixer->last_mixext;
gst_oss4_mixer_get_control_val (mixer, &mc, &val);
}
if (mixer->need_update || mixer->tracks == NULL) {
gst_oss4_mixer_update_tracks (mixer);
mixer->need_update = FALSE;
}
GST_OBJECT_UNLOCK (mixer);
return (const GList *) mixer->tracks;
}
static void
gst_oss4_mixer_set_volume (GstMixer * mixer, GstMixerTrack * track,
gint * volumes)
{
GstOss4Mixer *oss;
g_return_if_fail (mixer != NULL);
g_return_if_fail (GST_IS_OSS4_MIXER (mixer));
g_return_if_fail (GST_OSS4_MIXER_IS_OPEN (mixer));
g_return_if_fail (gst_oss4_mixer_contains_track (mixer, track));
g_return_if_fail (volumes != NULL);
oss = GST_OSS4_MIXER (mixer);
GST_OBJECT_LOCK (oss);
if (GST_IS_OSS4_MIXER_SLIDER (track)) {
gst_oss4_mixer_slider_set_volume (GST_OSS4_MIXER_SLIDER (track), volumes);
}
GST_OBJECT_UNLOCK (oss);
}
static void
gst_oss4_mixer_get_volume (GstMixer * mixer, GstMixerTrack * track,
gint * volumes)
{
GstOss4Mixer *oss;
g_return_if_fail (mixer != NULL);
g_return_if_fail (GST_IS_OSS4_MIXER (mixer));
g_return_if_fail (GST_OSS4_MIXER_IS_OPEN (mixer));
g_return_if_fail (gst_oss4_mixer_contains_track (mixer, track));
g_return_if_fail (volumes != NULL);
oss = GST_OSS4_MIXER (mixer);
GST_OBJECT_LOCK (oss);
memset (volumes, 0, track->num_channels * sizeof (gint));
if (GST_IS_OSS4_MIXER_SWITCH (track)) {
gboolean enabled = FALSE;
gst_oss4_mixer_switch_get (GST_OSS4_MIXER_SWITCH (track), &enabled);
}
if (GST_IS_OSS4_MIXER_SLIDER (track)) {
gst_oss4_mixer_slider_get_volume (GST_OSS4_MIXER_SLIDER (track), volumes);
}
GST_OBJECT_UNLOCK (oss);
}
static void
gst_oss4_mixer_set_record (GstMixer * mixer, GstMixerTrack * track,
gboolean record)
{
GstOss4Mixer *oss;
g_return_if_fail (mixer != NULL);
g_return_if_fail (GST_IS_OSS4_MIXER (mixer));
g_return_if_fail (GST_OSS4_MIXER_IS_OPEN (mixer));
g_return_if_fail (gst_oss4_mixer_contains_track (mixer, track));
oss = GST_OSS4_MIXER (mixer);
GST_OBJECT_LOCK (oss);
if (GST_IS_OSS4_MIXER_SLIDER (track)) {
gst_oss4_mixer_slider_set_record (GST_OSS4_MIXER_SLIDER (track), record);
} else if (GST_IS_OSS4_MIXER_SWITCH (track)) {
if ((track->flags & GST_MIXER_TRACK_INPUT)) {
gst_oss4_mixer_switch_set (GST_OSS4_MIXER_SWITCH (track), record);
} else {
GST_WARNING_OBJECT (track, "set_record called on non-INPUT track");
}
}
GST_OBJECT_UNLOCK (oss);
}
static void
gst_oss4_mixer_set_mute (GstMixer * mixer, GstMixerTrack * track, gboolean mute)
{
GstOss4Mixer *oss;
g_return_if_fail (mixer != NULL);
g_return_if_fail (GST_IS_OSS4_MIXER (mixer));
g_return_if_fail (GST_OSS4_MIXER_IS_OPEN (mixer));
g_return_if_fail (gst_oss4_mixer_contains_track (mixer, track));
oss = GST_OSS4_MIXER (mixer);
GST_OBJECT_LOCK (oss);
if (GST_IS_OSS4_MIXER_SLIDER (track)) {
gst_oss4_mixer_slider_set_mute (GST_OSS4_MIXER_SLIDER (track), mute);
} else if (GST_IS_OSS4_MIXER_SWITCH (track)) {
gst_oss4_mixer_switch_set (GST_OSS4_MIXER_SWITCH (track), mute);
}
GST_OBJECT_UNLOCK (oss);
}
static void
gst_oss4_mixer_set_option (GstMixer * mixer, GstMixerOptions * options,
gchar * value)
{
GstOss4Mixer *oss;
g_return_if_fail (mixer != NULL);
g_return_if_fail (value != NULL);
g_return_if_fail (GST_IS_OSS4_MIXER (mixer));
g_return_if_fail (GST_OSS4_MIXER_IS_OPEN (mixer));
g_return_if_fail (GST_IS_OSS4_MIXER_ENUM (options));
g_return_if_fail (gst_oss4_mixer_contains_options (mixer, options));
oss = GST_OSS4_MIXER (mixer);
GST_OBJECT_LOCK (oss);
if (!gst_oss4_mixer_enum_set_option (GST_OSS4_MIXER_ENUM (options), value)) {
/* not much we can do here but wake up the watch thread early, so it
* can do its thing and post messages if anything has changed */
gst_oss4_mixer_wake_up_watch_task (oss);
}
GST_OBJECT_UNLOCK (oss);
}
static const gchar *
gst_oss4_mixer_get_option (GstMixer * mixer, GstMixerOptions * options)
{
GstOss4Mixer *oss;
const gchar *current_val;
g_return_val_if_fail (mixer != NULL, NULL);
g_return_val_if_fail (GST_IS_OSS4_MIXER (mixer), NULL);
g_return_val_if_fail (GST_OSS4_MIXER_IS_OPEN (mixer), NULL);
g_return_val_if_fail (GST_IS_OSS4_MIXER_ENUM (options), NULL);
g_return_val_if_fail (gst_oss4_mixer_contains_options (mixer, options), NULL);
oss = GST_OSS4_MIXER (mixer);
GST_OBJECT_LOCK (oss);
current_val = gst_oss4_mixer_enum_get_option (GST_OSS4_MIXER_ENUM (options));
if (current_val == NULL) {
/* not much we can do here but wake up the watch thread early, so it
* can do its thing and post messages if anything has changed */
gst_oss4_mixer_wake_up_watch_task (oss);
}
GST_OBJECT_UNLOCK (oss);
return current_val;
}
static GstMixerFlags
gst_oss4_mixer_get_mixer_flags (GstMixer * mixer)
{
return GST_MIXER_FLAG_AUTO_NOTIFICATIONS | GST_MIXER_FLAG_HAS_WHITELIST |
GST_MIXER_FLAG_GROUPING;
}
static void
gst_oss4_mixer_interface_init (GstMixerClass * klass)
{
GST_MIXER_TYPE (klass) = GST_MIXER_HARDWARE;
klass->list_tracks = gst_oss4_mixer_list_tracks;
klass->set_volume = gst_oss4_mixer_set_volume;
klass->get_volume = gst_oss4_mixer_get_volume;
klass->set_mute = gst_oss4_mixer_set_mute;
klass->set_record = gst_oss4_mixer_set_record;
klass->set_option = gst_oss4_mixer_set_option;
klass->get_option = gst_oss4_mixer_get_option;
klass->get_mixer_flags = gst_oss4_mixer_get_mixer_flags;
}
/* Implement the horror that is GstImplementsInterface */
static gboolean
gst_oss4_mixer_supported (GstImplementsInterface * iface, GType iface_type)
{
GstOss4Mixer *mixer;
g_return_val_if_fail (iface_type == GST_TYPE_MIXER, FALSE);
mixer = GST_OSS4_MIXER (iface);
return GST_OSS4_MIXER_IS_OPEN (mixer);
}
static void
gst_oss4_mixer_implements_interface_init (GstImplementsInterfaceClass * klass)
{
klass->supported = gst_oss4_mixer_supported;
}
static void
gst_oss4_mixer_init_interfaces (GType type)
{
static const GInterfaceInfo implements_iface_info = {
(GInterfaceInitFunc) gst_oss4_mixer_implements_interface_init,
NULL,
NULL,
};
static const GInterfaceInfo mixer_iface_info = {
(GInterfaceInitFunc) gst_oss4_mixer_interface_init,
NULL,
NULL,
};
g_type_add_interface_static (type, GST_TYPE_IMPLEMENTS_INTERFACE,
&implements_iface_info);
g_type_add_interface_static (type, GST_TYPE_MIXER, &mixer_iface_info);
gst_oss4_add_property_probe_interface (type);
}
Reference in a new issue View git blame Copy permalink