newlib-cygwin/winsup/testsuite/winsup.api/devdsp.c

784 lines
19 KiB
C

/* devdsp.c: Device tests for /dev/dsp
Copyright 2004 Red Hat, Inc
Written by Gerd Spalink (Gerd.Spalink@t-online.de)
This file is part of Cygwin.
This software is a copyrighted work licensed under the terms of the
Cygwin license. Please consult the file "CYGWIN_LICENSE" for
details. */
/* Conventions used here:
We use the libltp framework
1. Any unexpected behaviour leads to an exit with nonzero exit status
2. Unexpected behaviour from /dev/dsp results in an exit status of TFAIL
3. Unexpected behaviour from OS (malloc, fork, waitpid...) result
in an exit status of TBROK */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/soundcard.h>
#include <math.h>
#include <errno.h>
#include "test.h" /* use libltp framework */
/* Controls if a child can open the device after the parent */
#define CHILD_EXPECT 0 /* 0 or 1 */
static const char wavfile_okay[] =
{
#include "devdsp_okay.h" /* a sound sample */
};
/* Globals required by libltp */
const char *TCID = "devdsp"; /* set test case identifier */
int TST_TOTAL = 37;
/* Prototypes */
void sinegen (void *wave, int rate, int bits, int len, int stride);
void sinegenw (int freq, int samprate, short *value, int len, int stride);
void sinegenb (int freq, int samprate, unsigned char *value, int len,
int stride);
void playtest (int fd, int rate, int stereo, int bits);
void rectest (int fd, int rate, int stereo, int bits);
void rwtest (int fd, int rate, int stereo, int bits);
void setpars (int fd, int rate, int stereo, int bits);
void forkplaytest (void);
void forkrectest (void);
void recordingtest (void);
void playbacktest (void);
void monitortest (void);
void ioctltest (void);
void abortplaytest (void);
void playwavtest (void);
void syncwithchild (pid_t pid, int expected_exit_status);
void cleanup (void);
void dup_test (void);
static int expect_child_failure = 0;
/* Sampling rates we want to test */
static const int rates[] = { 44100, 22050, 8000 };
/* Combinations of stereo/bits we want to test */
struct sb
{
int stereo;
int bits;
};
static const struct sb sblut[] = { {0, 8}, {0, 16}, {1, 8}, {1, 16} };
int
main (int argc, char *argv[])
{
/* tst_brkm(TBROK, cleanup, "see if it breaks all right"); */
ioctltest ();
playbacktest ();
recordingtest ();
monitortest ();
forkplaytest ();
forkrectest ();
abortplaytest ();
playwavtest ();
dup_test ();
tst_exit ();
/* NOTREACHED */
return 0;
}
/* test some extra ioctls */
void
ioctltest (void)
{
int audio1;
int ioctl_par;
int channels;
tst_resm (TINFO, "Running %s", __FUNCTION__);
audio1 = open ("/dev/dsp", O_WRONLY);
if (audio1 < 0)
{
tst_brkm (TFAIL, cleanup, "open W: %s", strerror (errno));
}
setpars (audio1, 44100, 1, 16);
channels = ioctl_par = 1;
while (ioctl (audio1, SNDCTL_DSP_CHANNELS, &ioctl_par) == 0)
{
channels++;
ioctl_par = channels;
}
if (channels == ioctl_par)
tst_resm (TFAIL, "Max channels=%d failed", ioctl_par);
else
tst_resm (TPASS, "Max channels=%d failed, OK=%d", channels, ioctl_par);
/* Note: block size may depend on parameters */
if (ioctl (audio1, SNDCTL_DSP_GETBLKSIZE, &ioctl_par) < 0)
{
tst_brkm (TFAIL, cleanup, "ioctl GETBLKSIZE: %s", strerror (errno));
}
tst_resm (TPASS, "ioctl get buffer size=%d", ioctl_par);
if (ioctl (audio1, SNDCTL_DSP_GETFMTS, &ioctl_par) < 0)
{
tst_brkm (TFAIL, cleanup, "ioctl GETFMTS: %s", strerror (errno));
}
tst_resm (TPASS, "ioctl get formats=%08x", ioctl_par);
if (ioctl (audio1, SNDCTL_DSP_GETCAPS, &ioctl_par) < 0)
{
tst_brkm (TFAIL, cleanup, "ioctl GETCAPS: %s", strerror (errno));
}
tst_resm (TPASS, "ioctl get caps=%08x", ioctl_par);
if (close (audio1) < 0)
{
tst_brkm (TFAIL, cleanup, "Close audio: %s", strerror (errno));
}
}
/* test write / play */
void
playbacktest (void)
{
int audio1, audio2;
int rate, k;
tst_resm (TINFO, "Running %s", __FUNCTION__);
audio1 = open ("/dev/dsp", O_WRONLY);
if (audio1 < 0)
{
tst_brkm (TFAIL, cleanup, "Error open /dev/dsp W: %s",
strerror (errno));
}
audio2 = open ("/dev/dsp", O_WRONLY);
if (audio2 >= 0)
{
tst_brkm (TFAIL, cleanup,
"Second open /dev/dsp W succeeded, but is expected to fail");
}
else if (errno != EBUSY)
{
tst_brkm (TFAIL, cleanup, "Expected EBUSY here, exit: %s",
strerror (errno));
}
for (rate = 0; rate < sizeof (rates) / sizeof (int); rate++)
for (k = 0; k < sizeof (sblut) / sizeof (struct sb); k++)
{
playtest (audio1, rates[rate], sblut[k].stereo, sblut[k].bits);
tst_resm (TPASS, "Play bits=%2d stereo=%d rate=%5d",
sblut[k].bits, sblut[k].stereo, rates[rate]);
}
if (close (audio1) < 0)
{
tst_brkm (TFAIL, cleanup, "Close audio: %s", strerror (errno));
}
}
/* test read / record */
void
recordingtest (void)
{
int audio1, audio2;
int rate, k;
/* test read / record */
tst_resm (TINFO, "Running %s", __FUNCTION__);
audio1 = open ("/dev/dsp", O_RDONLY);
if (audio1 < 0)
{
tst_brkm (TFAIL, cleanup, "Error open /dev/dsp R: %s",
strerror (errno));
}
audio2 = open ("/dev/dsp", O_RDONLY);
if (audio2 >= 0)
{
tst_brkm (TFAIL, cleanup,
"Second open /dev/dsp R succeeded, but is expected to fail");
}
else if (errno != EBUSY)
{
tst_brkm (TFAIL, cleanup, "Expected EBUSY here, exit: %s",
strerror (errno));
}
for (rate = 0; rate < sizeof (rates) / sizeof (int); rate++)
for (k = 0; k < sizeof (sblut) / sizeof (struct sb); k++)
{
rectest (audio1, rates[rate], sblut[k].stereo, sblut[k].bits);
tst_resm (TPASS, "Record bits=%2d stereo=%d rate=%5d",
sblut[k].bits, sblut[k].stereo, rates[rate]);
}
if (close (audio1) < 0)
{
tst_brkm (TFAIL, cleanup, "Close audio: %s", strerror (errno));
}
}
/* simultaneous read/write */
void
monitortest (void)
{
int fd;
tst_resm (TINFO, "Running %s", __FUNCTION__);
fd = open ("/dev/dsp", O_RDWR);
if (fd < 0)
{
tst_brkm (TFAIL, cleanup, "open RW: %s", strerror (errno));
}
rwtest (fd, 44100, 1, 16);
tst_resm (TPASS, "Record+Play rate=44100, stereo, 16 bits");
if (close (fd) < 0)
{
tst_brkm (TFAIL, cleanup, "Close audio: %s", strerror (errno));
}
}
void
forkrectest (void)
{
int pid;
int fd;
tst_resm (TINFO, "Running %s", __FUNCTION__);
fd = open ("/dev/dsp", O_RDONLY);
if (fd < 0)
{
tst_brkm (TFAIL, cleanup, "Error open /dev/dsp R: %s",
strerror (errno));
}
pid = fork ();
if (pid < 0)
{
tst_brkm (TBROK, cleanup, "Fork failed: %s", strerror (errno));
}
if (pid)
{
tst_resm (TINFO, "forked, child PID=%d", pid);
syncwithchild (pid, 0);
tst_resm (TINFO, "parent records..");
rectest (fd, 22050, 1, 16);
tst_resm (TINFO, "parent done");
}
else
{ /* child */
tst_resm (TINFO, "child records..");
rectest (fd, 44100, 1, 16);
tst_resm (TINFO, "child done");
fflush (stdout);
exit (0); /* implicit close */
}
tst_resm (TPASS, "child records after fork");
/* fork again, but now we have done a read before,
* so the child is expected to fail
*/
pid = fork ();
if (pid < 0)
{
tst_brkm (TBROK, cleanup, "Fork failed: %s", strerror (errno));
}
if (pid)
{
tst_resm (TINFO, "forked, child PID=%d", pid);
syncwithchild (pid, CHILD_EXPECT?TFAIL:0); /* expecting error exit */
tst_resm (TINFO, "parent records again ..");
rectest (fd, 22050, 1, 16);
tst_resm (TINFO, "parent done");
}
else
{ /* child */
expect_child_failure = CHILD_EXPECT;
tst_resm (TINFO, "child trying to record %s",
CHILD_EXPECT?"(should fail)..":"");
rectest (fd, 44100, 1, 16);
/* NOTREACHED */
tst_resm (TINFO, "child done");
fflush (stdout);
exit (0); /* implicit close */
}
if (close (fd) < 0)
{
tst_brkm (TFAIL, cleanup, "Close audio: %s", strerror (errno));
}
tst_resm (TPASS, "child tries to record while parent is already recording");
}
void
forkplaytest (void)
{
int pid;
int fd;
tst_resm (TINFO, "Running %s", __FUNCTION__);
fd = open ("/dev/dsp", O_WRONLY);
if (fd < 0)
{
tst_brkm (TFAIL, cleanup, "Error open /dev/dsp R: %s",
strerror (errno));
}
pid = fork ();
if (pid < 0)
{
tst_brkm (TBROK, cleanup, "Fork failed: %s", strerror (errno));
}
if (pid)
{
tst_resm (TINFO, "forked, child PID=%d", pid);
syncwithchild (pid, 0);
tst_resm (TINFO, "parent plays..");
playtest (fd, 22050, 0, 8);
tst_resm (TINFO, "parent done");
}
else
{ /* child */
tst_resm (TINFO, "child plays..");
playtest (fd, 44100, 1, 16);
tst_resm (TINFO, "child done");
fflush (stdout);
exit (0); /* implicit close */
}
tst_resm (TPASS, "child plays after fork");
/* fork again, but now we have done a write before,
* so the child is expected to fail
*/
pid = fork ();
if (pid < 0)
{
tst_brkm (TBROK, cleanup, "Fork failed");
}
if (pid)
{
tst_resm (TINFO, "forked, child PID=%d", pid);
syncwithchild (pid, CHILD_EXPECT?TFAIL:0); /* expected failure */
tst_resm (TINFO, "parent plays again..");
playtest (fd, 22050, 0, 8);
tst_resm (TINFO, "parent done");
}
else
{ /* child */
expect_child_failure = CHILD_EXPECT;
tst_resm (TINFO, "child trying to play %s",
CHILD_EXPECT?"(should fail)..":"");
playtest (fd, 44100, 1, 16);
/* NOTREACHED */
tst_resm (TINFO, "child done");
fflush (stdout);
exit (0); /* implicit close */
}
if (close (fd) < 0)
{
tst_brkm (TFAIL, cleanup, "Close audio: %s", strerror (errno));
}
tst_resm (TPASS, "child tries to play while parent is already playing");
}
void
playtest (int fd, int rate, int stereo, int bits)
{ /* Play sine waves, always 0.25 sec */
void *wave;
int n, c, b;
int size;
if (stereo)
c = 2;
else
c = 1;
if (bits == 8)
b = 1;
else
b = 2;
size = rate / 4 * c * b;
wave = malloc (size);
if (wave == NULL)
{
tst_brkm (TBROK, cleanup, "Malloc failed, exit");
}
setpars (fd, rate, stereo, bits);
sinegen (wave, rate, bits, rate / 4, c);
if ((n = write (fd, wave, size)) < 0)
{
tst_brkm (TFAIL, cleanup, "write: %s", strerror (errno));
}
if (n != size)
{
tst_brkm (TFAIL, cleanup, "Wrote %d, expected %d; exit", n, size);
}
free (wave);
}
void
rectest (int fd, int rate, int stereo, int bits)
{
void *wave;
int n, c, b;
int size;
if (stereo)
c = 2;
else
c = 1;
if (bits == 8)
b = 1;
else
b = 2;
size = rate / 4 * c * b;
wave = malloc (size);
if (wave == NULL)
{
tst_brkm (TBROK, cleanup, "Malloc failed, exit");
}
setpars (fd, rate, stereo, bits);
if ((n = read (fd, wave, size)) < 0)
{
tst_brkm (TFAIL, cleanup, "read: %s", strerror (errno));
}
if (n != size)
{
tst_brkm (TFAIL, cleanup, "Read n=%d (%d expected); exit", n, size);
}
if ((n = read (fd, wave, size)) < 0)
{
tst_brkm (TFAIL, cleanup, "read: %s", strerror (errno));
}
if (n != size)
{
tst_brkm (TFAIL, cleanup, "Read n=%d (%d expected); exit", n, size);
}
free (wave);
}
void
rwtest (int fd, int rate, int stereo, int bits)
{
int pid;
void *wave;
int n, c, b;
int size;
if (stereo)
c = 2;
else
c = 1;
if (bits == 8)
b = 1;
else
b = 2;
size = rate / 4 * c * b;
wave = malloc (size);
if (wave == NULL)
{
tst_brkm (TBROK, cleanup, "Malloc failed, exit");
}
setpars (fd, rate, stereo, bits);
pid = fork ();
if (pid < 0)
{
tst_brkm (TBROK, cleanup, "Fork failed: %s", strerror (errno));
}
if (pid)
{
tst_resm (TINFO, "forked, child PID=%d parent records", pid);
if ((n = read (fd, wave, size)) < 0)
{
tst_brkm (TFAIL, cleanup, "read: %s", strerror (errno));
}
if (n != size)
{
tst_brkm (TFAIL, cleanup, "Read n=%d (%d expected)", n, size);
}
free (wave);
syncwithchild (pid, 0);
}
else
{ /* child */
tst_resm (TINFO, "child plays");
sinegen (wave, rate, bits, rate / 4, c);
if ((n = write (fd, wave, size)) < 0)
{
tst_brkm (TFAIL, cleanup, "child write: %s", strerror (errno));
}
if (n != size)
{
tst_brkm (TFAIL, cleanup, "child write n=%d OK (%d expected)", n,
size);
}
free (wave);
exit (0);
}
}
void
setpars (int fd, int rate, int stereo, int bits)
{
int ioctl_par = 0;
if (ioctl (fd, SNDCTL_DSP_SAMPLESIZE, &bits) < 0)
{
if (expect_child_failure)
{ /* Note: Don't print this to stderr because we expect failures here
* for the some cases after fork()
*/
tst_resm (TINFO, "ioctl SNDCTL_DSP_SAMPLESIZE: %s",
strerror (errno));
exit (TFAIL);
}
else
{
tst_brkm (TFAIL, cleanup, "ioctl SNDCTL_DSP_SAMPLESIZE: %s",
strerror (errno));
}
}
if (ioctl (fd, SNDCTL_DSP_STEREO, &stereo) < 0)
{
tst_brkm (TFAIL, cleanup, "ioctl SNDCTL_DSP_STEREO: %s",
strerror (errno));
}
if (ioctl (fd, SNDCTL_DSP_SPEED, &rate) < 0)
{
tst_brkm (TFAIL, cleanup, "ioctl SNDCTL_DSP_SPEED: %s",
strerror (errno));
}
if (ioctl (fd, SNDCTL_DSP_SYNC, &ioctl_par) < 0)
{
tst_brkm (TFAIL, cleanup, "ioctl SNDCTL_DSP_SYNC: %s",
strerror (errno));
}
}
void
syncwithchild (pid_t pid, int expected_exit_status)
{
int status;
if (waitpid (pid, &status, 0) != pid)
{
tst_brkm (TBROK, cleanup, "Wait for child: %s", strerror (errno));
}
if (!WIFEXITED (status))
{
tst_brkm (TBROK, cleanup, "Child had abnormal exit");
}
if (WEXITSTATUS (status) != expected_exit_status)
{
tst_brkm (TFAIL, cleanup, "Child had exit status %d != %d",
WEXITSTATUS (status), expected_exit_status);
}
}
void
sinegen (void *wave, int rate, int bits, int len, int stride)
{
if (bits == 8)
{
sinegenb (1000, rate, (unsigned char *) wave, len, stride);
if (stride == 2)
sinegenb (800, rate, (unsigned char *) wave + 1, len, stride);
}
else
{
sinegenw (1000, rate, (short *) wave, len, stride);
if (stride == 2)
sinegenw (800, rate, (short *) wave + 1, len, stride);
}
}
void
sinegenw (int freq, int samprate, short *value, int len, int stride)
{
double phase, incr;
phase = 0.0;
incr = M_PI * 2.0 * (double) freq / (double) samprate;
while (len-- > 0)
{
*value = (short) floor (0.5 + 6553 * sin (phase));
value += stride;
phase += incr;
}
}
void
sinegenb (int freq, int samprate, unsigned char *value, int len, int stride)
{
double phase, incr;
phase = 0.0;
incr = M_PI * 2.0 * (double) freq / (double) samprate;
while (len-- > 0)
{
*value = (unsigned char) floor (128.5 + 26 * sin (phase));
value += stride;
phase += incr;
}
}
void
abortplaytest (void)
{
int audio;
int size = sizeof (wavfile_okay);
int n;
int ioctl_par = 0;
tst_resm (TINFO, "Running %s", __FUNCTION__);
audio = open ("/dev/dsp", O_WRONLY);
if (audio < 0)
{
tst_brkm (TFAIL, cleanup, "Error open /dev/dsp W: %s",
strerror (errno));
}
if ((n = write (audio, wavfile_okay, size)) < 0)
{
tst_brkm (TFAIL, cleanup, "write: %s", strerror (errno));
}
if (n != size)
{
tst_brkm (TFAIL, cleanup, "Wrote %d, expected %d; exit", n, size);
}
if (ioctl (audio, SNDCTL_DSP_RESET, &ioctl_par) < 0)
{
tst_brkm (TFAIL, cleanup, "ioctl DSP_RESET: %s", strerror (errno));
}
if (close (audio) < 0)
{
tst_brkm (TFAIL, cleanup, "Close audio: %s", strerror (errno));
}
tst_resm (TPASS, "Playwav + ioctl DSP_RESET=%d", ioctl_par);
}
void
playwavtest (void)
{
int audio;
int size = sizeof (wavfile_okay);
int n;
tst_resm (TINFO, "Running %s", __FUNCTION__);
audio = open ("/dev/dsp", O_WRONLY);
if (audio < 0)
{
tst_brkm (TFAIL, cleanup, "Error open /dev/dsp W: %s",
strerror (errno));
}
if ((n = write (audio, wavfile_okay, size)) < 0)
{
tst_brkm (TFAIL, cleanup, "write: %s", strerror (errno));
}
if (n != size)
{
tst_brkm (TFAIL, cleanup, "Wrote %d, expected %d; exit", n, size);
}
if (close (audio) < 0)
{
tst_brkm (TFAIL, cleanup, "Close audio: %s", strerror (errno));
}
tst_resm (TPASS, "Set parameters from wave file header");
}
void dup_test (void)
{
int audio, fd, n;
int bits1, bits2;
int size = sizeof (wavfile_okay);
int header = 44;
const char *okay = wavfile_okay + header;
tst_resm (TINFO, "Running %s", __FUNCTION__);
audio = open ("/dev/dsp", O_WRONLY);
if (audio < 0)
{
tst_brkm (TFAIL, cleanup, "Error open /dev/dsp W: %s",
strerror (errno));
}
/* write header once to set parameters correctly */
n = write (audio, wavfile_okay, header);
if (n != header)
{
tst_brkm (TFAIL, cleanup, "Wrote %d, expected %d; exit", n, header);
}
size = size - header;
/* dup / close */
for (fd = audio+1; fd <= audio+5; fd++)
if (dup2 (fd-1, fd) != -1)
{
if (fd-2 >= audio)
if (close (fd-2) < 0)
{
tst_brkm (TFAIL, cleanup, "Close audio: %s", strerror (errno));
}
if ((n = write (fd, okay, size)) < 0)
{
tst_brkm (TFAIL, cleanup, "write: %s", strerror (errno));
}
if (n != size)
{
tst_brkm (TFAIL, cleanup, "Wrote %d, expected %d; exit", n, size);
}
}
else
tst_brkm (TFAIL, cleanup, "dup: %s", strerror (errno));
for (fd = audio+4; fd <= audio+5; fd++)
if (close (fd) < 0)
{
tst_brkm (TFAIL, cleanup, "Close audio: %s", strerror (errno));
}
tst_resm (TPASS, "Write to duped fd");
audio = open ("/dev/dsp", O_WRONLY);
if (audio < 0)
{
tst_brkm (TFAIL, cleanup, "Error open /dev/dsp W: %s",
strerror (errno));
}
fd = audio + 1;
if (dup2 (audio, fd) == -1)
{
tst_brkm (TFAIL, cleanup, "dup: %s", strerror (errno));
}
bits1 = AFMT_U8;
if (ioctl (audio, SNDCTL_DSP_SAMPLESIZE, &bits1) < 0)
{
tst_brkm (TFAIL, cleanup, "ioctl: %s", strerror (errno));
}
bits1 = AFMT_S16_LE;
if (ioctl (fd, SNDCTL_DSP_SAMPLESIZE, &bits1) < 0)
{
tst_brkm (TFAIL, cleanup, "ioctl: %s", strerror (errno));
}
bits1 = AFMT_QUERY;
if (ioctl (audio, SNDCTL_DSP_SAMPLESIZE, &bits1) < 0)
{
tst_brkm (TFAIL, cleanup, "ioctl: %s", strerror (errno));
}
bits2 = AFMT_QUERY;
if (ioctl (fd, SNDCTL_DSP_SAMPLESIZE, &bits2) < 0)
{
tst_brkm (TFAIL, cleanup, "ioctl: %s", strerror (errno));
}
if (bits1 != AFMT_S16_LE || bits2 != AFMT_S16_LE)
{
tst_brkm (TFAIL, cleanup, "Inconsistent state of duped fd: %d %d %d",
AFMT_S16_LE,bits1,bits2);
}
if (close (audio) < 0)
{
tst_brkm (TFAIL, cleanup, "Close audio: %s", strerror (errno));
}
if (close (fd) < 0)
{
tst_brkm (TFAIL, cleanup, "Close audio: %s", strerror (errno));
}
tst_resm (TPASS, "Parameter change to duped fd");
}
void
cleanup (void)
{
}