| | Open Sound System |
| Do you have problems with sound/audio application development? Don't panic! Click here for help! |
Copyright (C) 4Front Technologies, 2002-2004. Released under GPLv2/CDDL.
This is a simple program which demonstrates use of mmapped DMA buffer of the sound driver directly from application program.
This program tries to open a file called "smpl" in the current directory and play it. If present this file must be a "raw" audio file recorded with the same sample rate and format as this program uses. There is no checking for the format in this program.
This program needs some fine tuning. At this moment it doesn't perform adequate error checkings.
#define VERBOSE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <soundcard.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#ifndef MAP_FILE
#define MAP_FILE 0
#endif
static int sinebuf[48] = {
0, 4276, 8480, 12539, 16383, 19947, 23169, 25995,
28377, 30272, 31650, 32486, 32767, 32486, 31650, 30272,
28377, 25995, 23169, 19947, 16383, 12539, 8480, 4276,
0, -4276, -8480, -12539, -16383, -19947, -23169, -25995,
-28377, -30272, -31650, -32486, -32767, -32486, -31650, -30272,
-28377, -25995, -23169, -19947, -16383, -12539, -8480, -4276
};
static int sinep = 0;
static void
produce_output (short *op, int offs, int len)
{
int i;
op += offs * 2;
for (i = 0; i < len; i++)
{
int v = sinebuf[sinep];
sinep = (sinep + 1) % 48;
*op++ = v; /* Left channel */
*op++ = v; /* Right channel */
}
}
int
main (int argc, char *argv[])
{
int fd, tmp;
int sz, fsz, num_samples;
int caps;
struct audio_buf_info info;
count_info ci;
caddr_t buf;
oss_audioinfo ai;
unsigned char *op;
int device_p, app_p;
This program must use O_RDWR in some operating systems like Linux. However in some other operating systems it may need to be O_WRONLY.
/dev/dsp_mmap is the default device for mmap applications.
if ((fd = open ("/dev/dsp_mmap", O_RDWR, 0)) == -1)
{
perror ("/dev/dsp_mmap");
exit (-1);
}
ai.dev = -1;
if (ioctl (fd, SNDCTL_ENGINEINFO, &ai) != -1)
{
printf ("Using audio device %s (engine %d)\n", ai.name, ai.dev);
}
Disable cooked mode to permit mmap() with some devices. Don't do any error checking since usually this call will fail. There is no need to care about the return value.
Cooked mode must be disabled before setting the sample rate and format.
tmp = 0; ioctl (fd, SNDCTL_DSP_COOKEDMODE, &tmp); /* Don't check the error return */
Set up the sample format. We will use AFMT_S16_LE because it's the most common audio file format. AFMT_S16_NE is better in programs that generate the audio signal themselves.
tmp = AFMT_S16_LE;
if (ioctl (fd, SNDCTL_DSP_SETFMT, &tmp) == -1)
{
perror ("SNDCTL_DSP_SETFMT");
exit (-1);
}
Check the format returned by the driver.
This program will simply refuse to work if it doesn't get the format it supports. Playing with incompatible formats will cause terrible noise so it must be avoided.
if (tmp != AFMT_S16_LE)
{
fprintf (stderr,
"Error: The device doesn't support the requested sample format\n");
exit (-1);
}
Set the number of channels and the sample rate. We do not care about the returned values. They will just be reported to the user.
Real applications must be prepared to support sampling rates between 8 kHz and 192 kHz (at least). Equally well the number of channels may be between 1 and 16 (or even more).
Two channels and 48 kHz is the most likely combination that works.
tmp = 2; /* Stereo */
if (ioctl (fd, SNDCTL_DSP_CHANNELS, &tmp) == -1)
{
perror ("SNDCTL_DSP_CHANNELS");
exit (-1);
}
printf ("Number of channels is %d\n", tmp);
tmp = 44100; /* 48000 is the most recommended rate */
if (ioctl (fd, SNDCTL_DSP_SPEED, &tmp) == -1)
{
perror ("SNDCTL_DSP_SPEED");
exit (-1);
}
printf ("Sample rate set to %d\n", tmp);
if (ioctl (fd, SNDCTL_DSP_GETCAPS, &caps) == -1)
{
perror ("/dev/dsp");
fprintf (stderr, "Sorry but your sound driver is too old\n");
exit (-1);
}
if (!(caps & PCM_CAP_TRIGGER))
{
fprintf (stderr, "Sorry but your soundcard can't do this (TRIGGER)\n");
exit (-1);
}
if (!(caps & PCM_CAP_MMAP))
{
fprintf (stderr, "Sorry but your soundcard can't do this (MMAP)\n");
exit (-1);
}
Compute total size of the buffer. It's important to use this value in mmap() call.
if (ioctl (fd, SNDCTL_DSP_GETOSPACE, &info) == -1)
{
perror ("GETOSPACE");
exit (-1);
}
sz = info.fragstotal * info.fragsize;
fsz = info.fragsize;
Call mmap().
IMPORTANT NOTE!!!!!!!!!!!
Full duplex audio devices have separate input and output buffers. It is not possible to map both of them at the same mmap() call. The buffer is selected based on the prot argument in the following way:
- PROT_READ (alone) selects the input buffer. - PROT_WRITE (alone) selects the output buffer. - PROT_WRITE|PROT_READ together select the output buffer. This combination is required in BSD to make the buffer accessible. With just PROT_WRITE every attempt to access the returned buffer will result in segmentation/bus error. PROT_READ|PROT_WRITE is also permitted in Linux with OSS version 3.8-beta16 and later (earlier versions don't accept it).
Non duplex devices have just one buffer. When an application wants to do both input and output it's recommended that the device is closed and re-opened when switching between modes. PROT_READ|PROT_WRITE can be used to open the buffer for both input and output (with OSS 3.8-beta16 and later) but the result may be unpredictable.
if ((buf =
mmap (NULL, sz, PROT_WRITE, MAP_FILE | MAP_SHARED, fd,
0)) == (caddr_t) - 1)
{
perror ("mmap (write)");
exit (-1);
}
printf ("mmap (out) returned %08lx\n", (long) buf);
op = buf;
op contains now a pointer to the DMA buffer. Preload some audio data.
num_samples = sz / 4; produce_output ((short *) op, 0, num_samples); app_p = 0;
Then it's time to start the engine. The driver doesn't allow read() and/or write() when the buffer is mapped. So the only way to start operation is to togle device's enable bits. First set them off. Setting them on enables recording and/or playback.
tmp = 0;
ioctl (fd, SNDCTL_DSP_SETTRIGGER, &tmp);
printf ("Trigger set to %08x\n", tmp);
It might be usefull to write some data to the buffer before starting.
tmp = PCM_ENABLE_OUTPUT;
ioctl (fd, SNDCTL_DSP_SETTRIGGER, &tmp);
printf ("Trigger set to %08x\n", tmp);
The machine is up and running now. Use SNDCTL_DSP_GETOPTR to get the buffer status.
NOTE! The driver empties each buffer fragmen after they have been played. This prevents looping sound if there are some performance problems in the application side. For similar reasons it recommended that the application uses some amout of play ahead. It can rewrite the unplayed data later if necessary.
while (1)
{
usleep (50 * 1000);
if (ioctl (fd, SNDCTL_DSP_GETOPTR, &ci) == -1)
{
perror ("SNDCTL_DSP_GETOPTR");
exit (-1);
}
device_p = ci.ptr / 4;
if (device_p < app_p)
{
produce_output ((short *) op, app_p, num_samples - app_p);
app_p = 0;
}
if (device_p > app_p)
{
produce_output ((short *) op, app_p, device_p - app_p);
app_p = device_p;
}
}
exit (0);
}