| | Open Sound System |
| Do you have problems with sound/audio application development? Don't panic! Click here for help! |
Copyright (C) 4Front Technologies, 2007. Released under GPLv2/CDDL.
This program is not usefull by itself. It just demonstrates techniques that can be used when developing very simple mixer applets that control just the key volumes in the system.
The full OSS 4.0 mixer API is rather complex and designed for allmighty master mixer applications. However there is a subset of the API that can be used rather easily. This subset is limited to control of the main output volume, audio/wave/pcm playback volume and/or recording input level. It cannot be used for anything else.
This program demonstrates three main techniques to be used by mixer applets:
1) How to find the default mixer device that controls the primary sound card/device in the system. This device is connected to the primary (desktop) speakers and the default system sounds/beep are directed to it. Normally this device is the audio chip installed on the motherboard of the computer.
2) How to find out the main, pcm and recording volume controls for the given device.
3) How to read the current volume and how to change it.
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <soundcard.h>
#include <time.h>
#include <errno.h>
oss_sysinfo sysinfo;
#define MAX_CTL 50
static int mixer_dev = -1; /* Use the default mixer */
int
find_default_mixer (int mixer_fd)
{
int default_mix = -1;
int best_pri = -2;
oss_mixerinfo mi;
int i;
The default mixer device in the system can be found by checking the priority parameter of all mixer devices in the system. The device with the highest priority value is the winner. If there are multiple devices with the same priority then the first one should be selected.
Note that there should be some method for selecting the mixer device number. In many cases the user actually wants to use some other mixer than the motherboard one.
for (i = 0; i < sysinfo.nummixers; i++)
{
mi.dev = i;
if (ioctl (mixer_fd, SNDCTL_MIXERINFO, &mi) == -1)
{
perror ("SNDCTL_MIXERINFO");
continue;
}
if (mi.priority < -1) /* Not suitable default mixer */
continue;
if (mi.priority > best_pri)
{
default_mix = i;
best_pri = mi.priority;
}
}
printf("Mixer device %d seems to be the most probable motherboard device\n",
default_mix);
return default_mix;
}
void
show_controls (int mixer_fd, char *heading, int mixer_dev, int ctls[], int count)
{
oss_mixext ext;
oss_mixer_value val;
int ctl, i;
printf("\n***** %s *****\n", heading);
for (i=0;i<count;i++)
{
ctl = ctls[i];
Obtain the mixer extension definition. It might be a good idea to cache this info in global variables so that doesn't need to be reloaded every time.
Reloading this info every time may cause serious troubles because in that way the application cannot be noticed after the mixer interface has changed.
ext.dev = mixer_dev;
ext.ctrl = ctl;
if (ioctl (mixer_fd, SNDCTL_MIX_EXTINFO, &ext) == -1)
{
perror ("SNDCTL_MIX_EXTINFO");
exit (-1);
}
Have to initialize the dev, ctl and timestamp fields before reading the actual value.
val.dev = mixer_dev;
val.ctrl = ctl;
val.timestamp = ext.timestamp;
if (ioctl (mixer_fd, SNDCTL_MIX_READ, &val) == -1)
{
if (errno == EIDRM)
{
Getting errno=EIDRM tells that the mixer struicture has been changed. This may happen for example if new firmware gets loaded to the device. In such case the application should start from the beginning and to load all the information again.
fprintf (stderr, "Mixer structure changed. Please try again\n");
exit (-1);
}
perror ("SNDCTL_MIX_READ");
exit (-1);
}
printf ("\t%3d: %s\t ", ctl, ext.extname);
switch (ext.type)
{
case MIXT_MONOSLIDER:
printf ("monoslider %d ", val.value & 0xff);
break;
case MIXT_STEREOSLIDER:
printf ("stereoslider %d:%d ", val.value & 0xff,
(val.value >> 8) & 0xff);
break;
case MIXT_SLIDER:
printf ("slider %d ", val.value);
break;
case MIXT_MONOSLIDER16:
printf ("monoslider %d ", val.value & 0xffff);
break;
case MIXT_STEREOSLIDER16:
printf ("stereoslider %d:%d ", val.value & 0xffff,
(val.value >> 16) & 0xffff);
break;
Sometimes there may be just a MUTE control instead of a slider. However it's also possible that there is both mute and a slider.
case MIXT_ONOFF:
printf ("ONOFF %d ", val.value);
break;
case MIXT_MUTE:
printf ("mute %d ", val.value);
break;
Enumerated controls may be used for example for recording source selection.
case MIXT_ENUM:
printf ("Selection %d ", val.value);
break;
default:
printf ("Unknown control type (%d), value=0x%08x ", ext.type,
val.value);
}
printf ("\n");
}
}
int
main (int argc, char *argv[])
{
int mixer_fd = -1;
int i, n;
Bins for the mixer controls.
#define ADD_TO_BIN(bin, ctl) \
if (n_##bin >= MAX_CTL) \
{ \
fprintf(stderr, #bin " table is full\n"); exit(-1); \
} \
bin##_ctls[n_##bin++] = ctl
int mainvol_ctls[MAX_CTL];
int pcmvol_ctls[MAX_CTL];
int recvol_ctls[MAX_CTL];
int monvol_ctls[MAX_CTL];
int n_mainvol=0, n_pcmvol=0, n_recvol=0, n_monvol=0;
char *devmixer;
if ((devmixer=getenv("OSS_MIXERDEV"))==NULL)
devmixer = "/dev/mixer";
Get the mixer device number from command line.
if (argc > 1)
mixer_dev = atoi (argv[1]);
Open /dev/mixer. This device file can be used regardless of the actual mixer device number.
if ((mixer_fd = open (devmixer, O_RDWR, 0)) == -1)
{
perror (devmixer);
exit (-1);
}
Get OSS system info to a global buffer.
if (ioctl (mixer_fd, SNDCTL_SYSINFO, &sysinfo) == -1)
{
perror ("SNDCTL_SYSINFO");
exit (-1);
}
Check the mixer device number.
if (mixer_dev == -1)
mixer_dev = find_default_mixer (mixer_fd);
if (mixer_dev < 0 || mixer_dev >= sysinfo.nummixers)
{
fprintf (stderr, "Nonexistent mixer device %d\n", mixer_dev);
exit (-1);
}
printf ("Using OSS mixer device %d\n", mixer_dev);
The second step is to find the main volume, audio/pcm playback volume and recording level controls.
It's important to understand that many mixer devices don't have such controls. This is perfectly normal and the mixer applet must be able to handle this. Aborting or displaying loud error message should be avoided.
It's also possible that some mixers have multiple main volume, pcm or record level controls. In such case the application can support all of of them or select just the first one. Having multiple controls means that the device hase multiple sets of speakers or audio devices and each of them has separate volume controls.
n = mixer_dev;
if (ioctl (mixer_fd, SNDCTL_MIX_NREXT, &n) == -1)
{
perror ("SNDCTL_MIX_NREXT");
exit (-1);
}
for (i = 0; i < n; i++)
{
oss_mixext ext;
ext.dev = mixer_dev;
ext.ctrl = i;
if (ioctl (mixer_fd, SNDCTL_MIX_EXTINFO, &ext) == -1)
{
perror ("SNDCTL_MIX_EXTINFO");
exit (-1);
}
The MIXF_MAINVOL, MIXF_PCMVOL, MIXF_MONVOL and MIXF_RECVOL flags are used to mark potential main volume, pcm and recording level controls. This makes it possible to implement support for these common types of controls without having to implement fully featured mixer program.
Mixer applets using this simplified interface should ignore all mixer controls that don't have any of these three flags. However
Note that while mixer controls should have at most one of thse flags defined it may happen that some devices violate this rule. It's up to application what it does with such controls. Preferably it gets added to all of the bins.
if (ext.
flags & (MIXF_MAINVOL | MIXF_PCMVOL | MIXF_RECVOL | MIXF_MONVOL))
{
printf ("Mixer control %d is ", i);
if (ext.flags & MIXF_MAINVOL)
{
printf ("Mainvol ");
ADD_TO_BIN(mainvol, i);
}
if (ext.flags & MIXF_PCMVOL)
{
printf ("PCMvol ");
ADD_TO_BIN(pcmvol, i);
}
if (ext.flags & MIXF_RECVOL)
{
printf ("Recvol ");
ADD_TO_BIN(recvol, i);
}
if (ext.flags & MIXF_MONVOL)
{
printf ("Monvol ");
ADD_TO_BIN(monvol, i);
}
It is possible that many/most/all mixer controls don't have any of the above flags set. This means that such controls are for expert use only. It is recommended that mixer applets have an [Advanced options] button that is enabled if such controls are found. This button can launch ossxmix (or some configurable program).
printf ("%s\n", ext.extname);
}
}
Now we have selected the mixer controls. Next show their values. Since setting the value is pretty much identical to reading them we don't demonstrate it in this program.
printf ("\n");
if (n_mainvol > 0)
show_controls (mixer_fd, "Main volume controls", mixer_dev, mainvol_ctls, n_mainvol);
else
printf ("No main volume control available\n");
if (n_pcmvol > 0)
show_controls (mixer_fd, "Pcm volume controls", mixer_dev, pcmvol_ctls, n_pcmvol);
else
printf ("No pcm volume control available\n");
if (n_recvol > 0)
show_controls (mixer_fd, "Rec volume controls", mixer_dev, recvol_ctls, n_recvol);
else
printf ("No rec volume control available\n");
if (n_monvol > 0)
show_controls (mixer_fd, "Monitor volume controls", mixer_dev, monvol_ctls, n_monvol);
else
printf ("No monitor volume control available\n");
close (mixer_fd);
if (n_mainvol + n_pcmvol + n_recvol + n_monvol == 0)
{
printf("\nNo 'simple' mixer controls available for this device\n");
printf("It may be a good idea to start 'ossxmix -d %d' which can access advanced options.\n", mixer_dev);
}
exit (0);
}