You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdemultimedia/kscd/cddaslave.c

533 lines
11 KiB

/*
* @(#)cddaslave.c 1.11 13 Sep 1995
*
* Digital audio manipulator for WorkMan.
*
* The CDDA architecture looks like this:
*
* WorkMan (or another UI!)
* ^^^
* ||| (separate processes connected by pipe)
* vvv
* +------------- cddaslave -------------+
* | | |
* command module CDDA reader audio output
* (portable) (per platform) (per platform)
*
* This source file has the command module and some of the scaffolding
* to hold cddaslave together, plus some non-system-dependent audio
* processing code. Look in plat_*_cdda.c for system-specific stuff.
*/
#include "libwm/include/wm_config.h"
#include "libwm/include/wm_cdda.h"
#ifdef BUILD_CDDA /* { */
#include <stdio.h>
#include <sys/types.h>
#include <sys/time.h>
#ifndef timerclear
#define timerclear(tvp) ((tvp)->tv_sec = (tvp)->tv_usec = 0)
#endif
int playing = 0; /* Should the CD be playing now? */
/*
* Loudness setting, plus the floating volume multiplier and decaying-average
* volume level.
*/
int loudness = 0;
unsigned int volume = 32768;
unsigned int level;
/*
* Playback speed (0 = slow)
*/
int speed = 128;
/*
* This is non-null if we're saving audio to a file.
*/
FILE *output = NULL;
/*
* Audio file header format.
*/
typedef unsigned long u_32;
struct auheader {
u_32 magic;
u_32 hdr_size;
u_32 data_size;
u_32 encoding;
u_32 sample_rate;
u_32 channels;
};
#ifdef BIG_ENDIAN
# ifndef htonl
# define htonl(x) (x)
# endif
#else
extern unsigned long htonl(x);
#endif
void *malloc();
long cdda_transform();
/*
* Send status information upstream.
*/
void
send_status(struct cdda_block *blk)
{
write(1, blk, sizeof(*blk));
}
/*
* Accept a command from our master.
*
* The protocol is byte-oriented:
* PmsfMSFxyz Play from msf to MSF (MSF can be 0,0,0 to play to end)
* xyz is the msf of the start of this chunk, i.e., the
* ending boundary for reverse play.
* S Stop.
* Q Quit.
* Vn Set volume level (0-255).
* Bn Set balance level (0-255).
* EnL Set an equalizer level (n = 0 for bass, 255 for treble)
* G Get current status.
* sn Set speed multiplier to n.
* dn Set direction to forward (n = 0) or reverse.
* Fllllx... Start saving to a file (length = l, followed by name)
* F0000 Stop saving.
* Ln Set loudness level (0-255).
*/
void
command(int cd_fd, struct cdda_block *blk)
{
unsigned char inbuf[10];
char *filename;
int namelen;
struct auheader hdr;
if (read(0, inbuf, 1) <= 0) /* Parent died. */
{
wmcdda_close();
wmaudio_close();
exit(0);
}
switch (inbuf[0]) {
case 'P':
read(0, inbuf, 9);
playing = 1;
wmaudio_stop();
wmcdda_setup(inbuf[0] * 60 * 75 + inbuf[1] * 75 + inbuf[2],
inbuf[3] * 60 * 75 + inbuf[4] * 75 + inbuf[5],
inbuf[6] * 60 * 75 + inbuf[7] * 75 + inbuf[8]);
wmaudio_ready();
level = 2500;
volume = 1 << 15;
blk->status = WMCDDA_ACK;
send_status(blk);
break;
case 'S':
playing = 0;
wmaudio_stop();
blk->status = WMCDDA_ACK;
send_status(blk);
blk->status = WMCDDA_STOPPED;
send_status(blk);
break;
case 'B':
read(0, inbuf, 1);
wmaudio_balance(inbuf[0]);
blk->status = WMCDDA_ACK;
send_status(blk);
break;
case 'V':
read(0, inbuf, 1);
wmaudio_volume(inbuf[0]);
blk->status = WMCDDA_ACK;
send_status(blk);
break;
case 'G':
blk->status = WMCDDA_ACK;
send_status(blk);
if (playing)
blk->status = WMCDDA_PLAYED;
else
blk->status = WMCDDA_STOPPED;
wmaudio_state(blk);
send_status(blk);
break;
case 'Q':
blk->status = WMCDDA_ACK;
send_status(blk);
wmcdda_close();
wmaudio_close();
exit(0);
case 's':
read(0, inbuf, 1);
speed = inbuf[0];
wmcdda_speed(speed);
blk->status = WMCDDA_ACK;
send_status(blk);
break;
case 'd':
read(0, inbuf, 1);
wmcdda_direction(inbuf[0]);
blk->status = WMCDDA_ACK;
send_status(blk);
break;
case 'L':
read(0, inbuf, 1);
loudness = inbuf[0];
blk->status = WMCDDA_ACK;
send_status(blk);
break;
case 'F':
read(0, &namelen, sizeof(namelen));
if (output != NULL)
{
fclose(output);
output = NULL;
}
if (namelen)
{
filename = malloc(namelen + 1);
if (filename == NULL)
{
perror("cddaslave");
wmcdda_close();
wmaudio_close();
exit(1);
}
read(0, filename, namelen);
filename[namelen] = '\0';
output = fopen(filename, "w");
if (output == NULL)
perror(filename);
else
{
/* Write an .au file header. */
hdr.magic = htonl(0x2e736e64);
hdr.hdr_size = htonl(sizeof(hdr) + 28);
hdr.data_size = htonl(~0);
hdr.encoding = htonl(3); /* linear-16 */
hdr.sample_rate = htonl(44100);
hdr.channels = htonl(2);
fwrite(&hdr, sizeof(hdr), 1, output);
fwrite("Recorded from CD by WorkMan", 28, 1,
output);
}
free(filename);
}
blk->status = WMCDDA_ACK;
send_status(blk);
}
}
/*
* Transform some CDDA data.
*/
long
wmcdda_transform(unsigned char *rawbuf, long buflen, struct cdda_block *block)
{
long i;
long *buf32 = (long *)rawbuf;
register short *buf16 = (short *)rawbuf;
register int aval;
/*
* Loudness transformation. Basically this is a self-adjusting
* volume control; our goal is to keep the average output level
* around a certain value (2500 seems to be pleasing.) We do this
* by maintaining a decaying average of the recent output levels
* (where "recent" is some fraction of a second.) All output levels
* are multiplied by the inverse of the decaying average; this has
* the volume-leveling effect we desire, and isn't too CPU-intensive.
*
* This is done by modifying the digital data, rather than adjusting
* the system volume control, because (at least on some systems)
* tweaking the system volume can generate little pops and clicks.
*
* There's probably a more elegant way to achieve this effect, but
* what the heck, I never took a DSP class and am making this up as
* I go along, with a little help from some friends.
*
* This is all done with fixed-point math, oriented around powers
* of two, which with luck will keep the CPU usage to a minimum.
* More could probably be done, for example using lookup tables to
* replace multiplies and divides; whether the memory hit (128K
* for each table) is worthwhile is unclear.
*/
if (loudness)
{
/* We aren't really going backwards, but i > 0 is fast */
for (i = buflen / 2; i > 0; i--)
{
/*
* Adjust this sample to the current level.
*/
aval = (*buf16 = (((long)*buf16) * volume) >> 15);
buf16++;
/*
* Don't adjust the decaying average for each sample;
* that just spends CPU time for very little benefit.
*/
if (i & 127)
continue;
/*
* We want to use absolute values to compute the
* decaying average; otherwise it'd sit around 0.
*/
if (aval < 0)
aval = -aval;
/*
* Adjust more quickly when we start hitting peaks,
* or we'll get clipping when there's a sudden loud
* section after lots of quiet.
*/
if (aval & ~8191)
aval <<= 3;
/*
* Adjust the decaying average.
*/
level = ((level << 11) - level + aval) >> 11;
/*
* Let *really* quiet sounds play softly, or we'll
* amplify background hiss to full volume and blast
* the user's speakers when real sound starts up.
*/
if (! (level & ~511))
level = 512;
/*
* And adjust the volume setting using the inverse
* of the decaying average.
*/
volume = (2500 << 15) / level;
}
}
if (speed == 128)
return (buflen);
/*
* Half-speed play. Stretch things out.
*/
if (speed == 0)
{
buflen /= 2; /* Since we're moving 32 bits at a time */
for (i = buflen - 1; i > 0; i--)
{
buf32[i] = buf32[i / 2];
}
buflen *= 4; /* 2 for doubling the buffer, 2 from above */
}
/*
* Slow play; can't optimize it as well as half-speed.
*/
if (speed && speed < 128)
{
int multiplier = ((speed + 128) * 128) / 256;
int newlen;
int tally = 0, pos;
buflen /= 4; /* Get the number of 32-bit values */
/*
* Buffer length doubles when speed is 0, stays the same
* when speed is 128.
*/
newlen = (buflen * 128) / multiplier;
pos = buflen - 1;
for (i = newlen - 1; i > 0; i--)
{
buf32[i] = buf32[pos];
tally += multiplier;
if (tally & 128)
{
pos--;
tally ^= 128;
}
}
buflen = newlen * 4;
}
return (buflen);
}
main(argc, argv)
char **argv;
{
int cd_fd = 3;
fd_set readfd, dummyfd;
struct timeval timeout;
char *cddabuf;
long cddabuflen;
struct cdda_block blockinfo;
long result;
int nfds;
char *devname;
/*
* Device name should be the command-line argument.
*/
if (argc < 2)
devname = "";
else
devname = argv[1];
/*
* If we're running setuid root, bump up our priority then lose
* superuser access.
*/
nice(-14);
setgid(getgid());
setuid(getuid());
if (getuid() != geteuid())
return 255;
FD_ZERO(&dummyfd);
FD_ZERO(&readfd);
timerclear(&timeout);
cd_fd = wmcdda_init(&cddabuf, &cddabuflen, cd_fd, devname);
if (cd_fd < 0)
exit(1);
wmaudio_init();
blockinfo.status = WMCDDA_ACK;
send_status(&blockinfo);
blockinfo.status = WMCDDA_STOPPED;
fprintf(stderr,"cddaslave: done init.");
/*
* Accept commands as they come in, and play some sound if we're
* supposed to be doing that.
*/
while (1)
{
FD_SET(0, &readfd);
/*
* If we're playing, we don't want select to block. Otherwise,
* wait a little while for the next command.
*/
if (playing)
timeout.tv_usec = 0;
else
timeout.tv_usec = 500000;
nfds = select(1, &readfd, &dummyfd, &dummyfd, &timeout);
if (nfds < 0) /* Broken pipe; our GUI exited. */
{
wmcdda_close(cd_fd);
wmaudio_close();
fprintf(stderr,"cddaslave: Borken pipe; GUI must have exited.");
exit(0);
}
if (FD_ISSET(0, &readfd))
{
command(cd_fd, &blockinfo);
/*
* Process all commands in rapid succession, rather
* than possibly waiting for a CDDA read.
*/
continue;
}
if (playing)
{
result = wmcdda_read(cd_fd, cddabuf, cddabuflen,
&blockinfo);
if (result <= 0)
{
/* Let the output queue drain. */
if (blockinfo.status == WMCDDA_DONE)
{
wmaudio_mark_last();
if (wmaudio_send_status())
{
/* queue drained, stop polling*/
playing = 0;
}
}
else
{
playing = 0;
send_status(&blockinfo);
}
}
else
{
result = wmcdda_normalize(cddabuf, result,
&blockinfo);
result = wmcdda_transform(cddabuf, result,
&blockinfo);
if (output)
fwrite(cddabuf, result, 1, output);
result = wmaudio_convert(cddabuf, result,
&blockinfo);
if (wmaudio_play(cddabuf, result, &blockinfo))
{
playing = 0;
wmaudio_stop();
send_status(&blockinfo);
}
}
}
else
send_status(&blockinfo);
}
}
#else /* BUILD_CDDA } { */
#include <stdio.h>
int main()
{
printf("cddaslave: will work only on Solaris 2.4 or newer.");
exit(0);
}
#endif /* } */