diff options
Diffstat (limited to 'kscd/libwm')
56 files changed, 19242 insertions, 0 deletions
diff --git a/kscd/libwm/Makefile.am b/kscd/libwm/Makefile.am new file mode 100644 index 00000000..ae2a9144 --- /dev/null +++ b/kscd/libwm/Makefile.am @@ -0,0 +1,23 @@ +# +# Makefile.am for libworkman. Based on the example Makefile.am for a +# shared library. +# + +subdirs = include +SUBDIRS = audio +INCLUDES = $(all_includes) + +noinst_LTLIBRARIES = libworkman.la + +libworkman_la_LDFLAGS = $(ARTSC_LIBS) $(all_libraries) +libworkman_la_LIBADD = audio/libworkmanaudio.la $(ARTS_LIBASOUND) + +libworkman_la_SOURCES = cddb.c cdinfo.c cdrom.c wm_helpers.c cdtext.c\ +database.c index.c scsi.c cdda.c plat_linux_cdda.c plat_sun_cdda.c\ +plat_aix.c plat_bsd386.c plat_freebsd.c plat_hpux.c plat_irix.c \ +plat_linux.c plat_svr4.c plat_ultrix.c plat_news.c plat_openbsd.c \ +plat_osf1.c plat_sun.c plat_scor5.c \ +drv_sony.c drv_toshiba.c + +#libworkmanincludedir = $(includedir)/libwm +#libworkmaninclude_HEADERS = include/wm_cdrom.h include/wm_cdtext.h diff --git a/kscd/libwm/PLAT_IMPL_STATUS b/kscd/libwm/PLAT_IMPL_STATUS new file mode 100644 index 00000000..d1919728 --- /dev/null +++ b/kscd/libwm/PLAT_IMPL_STATUS @@ -0,0 +1,48 @@ +LIBRARY IMPLEMENTATION STATUS +----------------------------- + +This table should show up where the platform codes differ. + +- function not available +X function available +\ function dummy, null implementation or commented out +(X) function available in special configurations + +function |aix |bsd386|freebsd|hpux |irix |linux|news |openbsd|osf1 |scor5|sun |svr4 |ultrix| +------------------------+-----+------+-------+-----+-----+-----+-----+-------+-----+-----+-----+-----+------+ +find_cdrom() | - | - | - | - | - | - | - | - | X | - | X | X | X | +gen_init() | \ | \ | \ | \ | (X) | \ | \ | \ | \ | \ | X | \ | \ | +wmcd_open() | X | X | X | X | X | X | X | X | X | X | X | X | X | +wmcd_close() | - | - | - | - | - | - | X | - | - | - | - | - | - | +wmcd_reopen() | X | X | X | X | X | X | X | X | X | X | X | X | X | +wm_scsi() | \ | \ | \ | X | \ | X | \ | \ | \ | X | X | X | \ | +keep_cd_open() | - | - | - | - | - | \ | - | - | - | \ | - | - | - | +gen_get_drive_status() | X | X | X | X | X | X | X | X | X | X | X | X | X | +------------------------+-----+------+-------+-----+-----+-----+-----+-------+-----+-----+-----+-----+------+ +gen_get_trackcount() | X | X | X | X | X | X | X | X | X | X | X | X | X | +gen_get_trackinfo() | X | X | X | X | X | X | X | X | X | X | X | X | X | +gen_get_cdlen() | X | X | X | X | X | X | X | X | X | X | X | X | X | +------------------------+-----+------+-------+-----+-----+-----+-----+-------+-----+-----+-----+-----+------+ +gen_play() | X | X | X | X | X | X | X | X | X | X | X | X | X | +gen_pause() | X | X | X | X | X | X | X | X | X | X | X | X | X | +gen_resume() | X | X | X | X | X | X | X | X | X | X | X | X | X | +gen_stop() | X | X | X | X | X | X | X | X | X | X | X | X | X | +gen_eject() | X | X | X | X | X | X | X | X | X | X | X | X | X | +gen_closetray() | X | X | X | X | X | X | X | X | X | X | X | X | X | +------------------------+-----+------+-------+-----+-----+-----+-----+-------+-----+-----+-----+-----+------+ +scale_volume() | X | X | X | - | - | X | - | X | X | - | - | - | X | +unscale_volume() | X | X | X | - | - | - | - | X | X | - | - | - | X | +gen_set_volume() | X | X | X | X | X | X | X | X | X | X | X | X | X | +gen_get_volume() | X | X | X | X | X | X | X | X | X | X | X | X | X | +------------------------+-----+------+-------+-----+-----+-----+-----+-------+-----+-----+-----+-----+------+ +cdda_init() | - | - | - | - | - | \ | - | - | - | - | X | - | - | +get_ack() | - | - | - | - | - | \ | - | - | - | - | X | - | - | +cdda_kill() | - | - | - | - | - | \ | - | - | - | - | X | - | - | +gen_set_direction() | - | - | - | - | - | \ | - | - | - | - | X | - | - | +gen_set_speed() | - | - | - | - | - | \ | - | - | - | - | X | - | - | +gen_set_loudness() | - | - | - | - | - | \ | - | - | - | - | X | - | - | +gen_save() | - | - | - | - | - | \ | - | - | - | - | X | - | - | +------------------------+-----+------+-------+-----+-----+-----+-----+-------+-----+-----+-----+-----+------+ + + + diff --git a/kscd/libwm/README b/kscd/libwm/README new file mode 100644 index 00000000..69b4ae65 --- /dev/null +++ b/kscd/libwm/README @@ -0,0 +1,20 @@ +$Id$ + +This directory contains the WorkMan library. + +libworkman is a multi-plaform CD-Player library for creating various +CD-Player-UIs. + +06.03.2003 Alex Kern <alex.kern@gmx.de> + I have reworked most part of libworkman, get rid of most of externals + add cdda support for linux and, I hope not breaked it for SUN ;-) + + Interface was cleaned, that means for a potentialy application developers + new rules: + 1. please include only wm_cdrom.h it's all defines and functions, what + you need. You have any exceptions. + 2. for cdtext, include wm_cdtext.h + 3. for cddb, include wm_cddb.h (think, it's not so powerfull and can be replaced with + any new external library. + 4. wm_cdinfo declares any externals now, I will change it in the future +
\ No newline at end of file diff --git a/kscd/libwm/audio/Makefile.am b/kscd/libwm/audio/Makefile.am new file mode 100644 index 00000000..318cb0a3 --- /dev/null +++ b/kscd/libwm/audio/Makefile.am @@ -0,0 +1,5 @@ +INCLUDES = $(all_includes) $(ARTSC_INCLUDE) + +noinst_LTLIBRARIES = libworkmanaudio.la + +libworkmanaudio_la_SOURCES = audio.c audio_alsa.c audio_arts.c audio_sun.c diff --git a/kscd/libwm/audio/audio.c b/kscd/libwm/audio/audio.c new file mode 100644 index 00000000..39c8330d --- /dev/null +++ b/kscd/libwm/audio/audio.c @@ -0,0 +1,29 @@ +#include "audio.h" + +#include <string.h> + +struct audio_oops* setup_arts(const char *dev, const char *ctl); +struct audio_oops* setup_alsa(const char *dev, const char *ctl); + +struct audio_oops* setup_soundsystem(const char* ss, const char* dev, const char* ctl) +{ + if(!ss) { + ERRORLOG("audio: Internal error, trying to setup a NULL soundsystem.\n"); + return NULL; + } + +#ifdef USE_ARTS + if(!strcmp(ss, "arts")) + return setup_arts(dev, ctl); +#endif +#if defined(HAVE_ARTS_LIBASOUND2) + if(!strcmp(ss, "alsa")) + return setup_alsa(dev, ctl); +#endif +#ifdef USE_SUN_AUDIO + if(!strcmp(ss, "sun")) + return setup_sun_audio(dev, ctl); +#endif + ERRORLOG("audio: unknown soundsystem '%s'\n", ss); + return NULL; +} diff --git a/kscd/libwm/audio/audio.h b/kscd/libwm/audio/audio.h new file mode 100644 index 00000000..089ea116 --- /dev/null +++ b/kscd/libwm/audio/audio.h @@ -0,0 +1,21 @@ +/* + * Audio 'LIB' defines + */ +#include "../include/wm_cdda.h" + +#ifndef NULL +#define NULL 0 +#endif + +struct audio_oops { + int (*wmaudio_open)(void); + int (*wmaudio_close)(void); + int (*wmaudio_play)(struct cdda_block*); + int (*wmaudio_stop)(void); + int (*wmaudio_state)(struct cdda_block*); + int (*wmaudio_balance)(int); + int (*wmaudio_volume)(int); +}; + +extern struct audio_oops* setup_soundsystem(const char*, const char*, const char*); + diff --git a/kscd/libwm/audio/audio_alsa.c b/kscd/libwm/audio/audio_alsa.c new file mode 100644 index 00000000..b1d4e938 --- /dev/null +++ b/kscd/libwm/audio/audio_alsa.c @@ -0,0 +1,334 @@ +/* + * Driver for Advanced Linux Sound Architecture, http://alsa.jcu.cz + * + * mpg123 comments: + * Code by Anders Semb Hermansen <ahermans@vf.telia.no> + * Cleanups by Jaroslav Kysela <perex@jcu.cz> + * Ville Syrjala <syrjala@sci.fi> + * + * adopted for libworkman cdda audio backend from Alexander Kern alex.kern@gmx.de + * + * Adapted to support both ALSA V0.x and V1.x APIs for PCM calls + * (Philip Nelson <teamdba@scotdb.com> 2004-03-15) + * + * This file comes under GPL license. + */ + + + +#include <config.h> + +#if defined(HAVE_ARTS_LIBASOUND2) + +#include <alsa/asoundlib.h> +#include "audio.h" + +char* device = NULL; +snd_pcm_t *handle; + +snd_pcm_format_t format = SND_PCM_FORMAT_S16; /* sample format */ +int rate = 44100; /* stream rate */ +int channels = 2; /* count of channels */ +int buffer_time = 2000000; /* ring buffer length in us */ +int period_time = 100000; /* period time in us */ + +snd_pcm_sframes_t buffer_size; +snd_pcm_sframes_t period_size; + +int alsa_open(void); +int alsa_close(void); +int alsa_stop(void); +int alsa_play(struct cdda_block *blk); +int alsa_state(struct cdda_block *blk); +struct audio_oops* setup_alsa(const char *dev, const char *ctl); + +static int set_hwparams(snd_pcm_hw_params_t *params, + snd_pcm_access_t accesspar) +{ + int err, dir, new_rate; + + /* choose all parameters */ + err = snd_pcm_hw_params_any(handle, params); + if (err < 0) { + ERRORLOG("Broken configuration for playback: no configurations available: %s\n", snd_strerror(err)); + return err; + } + /* set the interleaved read/write format */ + err = snd_pcm_hw_params_set_access(handle, params, accesspar); + if (err < 0) { + ERRORLOG("Access type not available for playback: %s\n", snd_strerror(err)); + return err; + } + /* set the sample format */ + err = snd_pcm_hw_params_set_format(handle, params, format); + if (err < 0) { + ERRORLOG("Sample format not available for playback: %s\n", snd_strerror(err)); + return err; + } + /* set the count of channels */ + err = snd_pcm_hw_params_set_channels(handle, params, channels); + if (err < 0) { + ERRORLOG("Channels count (%i) not available for playbacks: %s\n", channels, snd_strerror(err)); + return err; + } + /* set the stream rate */ +#if (SND_LIB_MAJOR < 1) + err = new_rate = snd_pcm_hw_params_set_rate_near(handle, params, rate, 0); +#else + new_rate = rate; + err = snd_pcm_hw_params_set_rate_near(handle, params, &new_rate, 0); +#endif + if (err < 0) { + ERRORLOG("Rate %iHz not available for playback: %s\n", rate, snd_strerror(err)); + return err; + } + if (new_rate != rate) { + ERRORLOG("Rate doesn't match (requested %iHz, get %iHz)\n", rate, new_rate); + return -EINVAL; + } + /* set the buffer time */ +#if (SND_LIB_MAJOR < 1) + err = snd_pcm_hw_params_set_buffer_time_near(handle, params, buffer_time, &dir); +#else + err = snd_pcm_hw_params_set_buffer_time_near(handle, params, &buffer_time, &dir); +#endif + if (err < 0) { + ERRORLOG("Unable to set buffer time %i for playback: %s\n", buffer_time, snd_strerror(err)); + return err; + } +#if (SND_LIB_MAJOR < 1) + buffer_size = snd_pcm_hw_params_get_buffer_size(params); +#else + err = snd_pcm_hw_params_get_buffer_size(params, &buffer_size); + if (err < 0) { + ERRORLOG("Unable to get buffer size : %s\n", snd_strerror(err)); + return err; + } +#endif + DEBUGLOG("buffersize %i\n", buffer_size); + + /* set the period time */ +#if (SND_LIB_MAJOR < 1) + err = snd_pcm_hw_params_set_period_time_near(handle, params, period_time, &dir); +#else + err = snd_pcm_hw_params_set_period_time_near(handle, params, &period_time, &dir); +#endif + if (err < 0) { + ERRORLOG("Unable to set period time %i for playback: %s\n", period_time, snd_strerror(err)); + return err; + } + +#if (SND_LIB_MAJOR < 1) + period_size = snd_pcm_hw_params_get_period_size(params, &dir); +#else + err = snd_pcm_hw_params_get_period_size(params, &period_size, &dir); + if (err < 0) { + ERRORLOG("Unable to get hw period size: %s\n", snd_strerror(err)); + } +#endif + + DEBUGLOG("period_size %i\n", period_size); + + /* write the parameters to device */ + err = snd_pcm_hw_params(handle, params); + if (err < 0) { + ERRORLOG("Unable to set hw params for playback: %s\n", snd_strerror(err)); + return err; + } + return 0; +} + +static int set_swparams(snd_pcm_sw_params_t *swparams) +{ + int err; + + /* get the current swparams */ + err = snd_pcm_sw_params_current(handle, swparams); + if (err < 0) { + ERRORLOG("Unable to determine current swparams for playback: %s\n", snd_strerror(err)); + return err; + } + /* start the transfer when the buffer is full */ + err = snd_pcm_sw_params_set_start_threshold(handle, swparams, buffer_size); + if (err < 0) { + ERRORLOG("Unable to set start threshold mode for playback: %s\n", snd_strerror(err)); + return err; + } + /* allow the transfer when at least period_size samples can be processed */ + err = snd_pcm_sw_params_set_avail_min(handle, swparams, period_size); + if (err < 0) { + ERRORLOG("Unable to set avail min for playback: %s\n", snd_strerror(err)); + return err; + } + /* align all transfers to 1 sample */ + err = snd_pcm_sw_params_set_xfer_align(handle, swparams, 1); + if (err < 0) { + ERRORLOG("Unable to set transfer align for playback: %s\n", snd_strerror(err)); + return err; + } + /* write the parameters to the playback device */ + err = snd_pcm_sw_params(handle, swparams); + if (err < 0) { + ERRORLOG("Unable to set sw params for playback: %s\n", snd_strerror(err)); + return err; + } + return 0; +} + +int alsa_open( void ) +{ + int err; + + snd_pcm_hw_params_t *hwparams; + snd_pcm_sw_params_t *swparams; + + DEBUGLOG("alsa_open\n"); + + snd_pcm_hw_params_alloca(&hwparams); + snd_pcm_sw_params_alloca(&swparams); + + if((err = snd_pcm_open(&handle, device, SND_PCM_STREAM_PLAYBACK, 0/*SND_PCM_NONBLOCK*/)) < 0 ) { + ERRORLOG("open failed: %s\n", snd_strerror(err)); + return -1; + } + + if((err = set_hwparams(hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) { + ERRORLOG("Setting of hwparams failed: %s\n", snd_strerror(err)); + return -1; + } + if((err = set_swparams(swparams)) < 0) { + ERRORLOG("Setting of swparams failed: %s\n", snd_strerror(err)); + return -1; + } + + return 0; +} + +int alsa_close( void ) +{ + int err; + + DEBUGLOG("alsa_close\n"); + + err = alsa_stop(); + +#if (SND_LIB_MAJOR < 1) + err = snd_pcm_close(handle); +#else + err = snd_pcm_close(handle); +#endif + + free(device); + + return err; +} + +/* + * Play some audio and pass a status message upstream, if applicable. + * Returns 0 on success. + */ +int +alsa_play(struct cdda_block *blk) +{ + signed short *ptr; + int err = 0, frames; + + ptr = (signed short *)blk->buf; + frames = blk->buflen / (channels * 2); + DEBUGLOG("play %i frames, %i bytes\n", frames, blk->buflen); + while (frames > 0) { + err = snd_pcm_writei(handle, ptr, frames); + + if (err == -EAGAIN) + continue; + if(err == -EPIPE) { + err = snd_pcm_prepare(handle); + continue; + } else if (err < 0) + break; + + ptr += err * channels; + frames -= err; + DEBUGLOG("played %i, rest %i\n", err / channels, frames); + } + + if (err < 0) { + ERRORLOG("alsa_write failed: %s\n", snd_strerror(err)); + err = snd_pcm_prepare(handle); + + if (err < 0) { + ERRORLOG("Unable to snd_pcm_prepare pcm stream: %s\n", snd_strerror(err)); + } + blk->status = WM_CDM_CDDAERROR; + return err; + } + + return 0; +} + +/* + * Stop the audio immediately. + */ +int +alsa_stop( void ) +{ + int err; + + DEBUGLOG("alsa_stop\n"); + + err = snd_pcm_drop(handle); + if (err < 0) { + ERRORLOG("Unable to drop pcm stream: %s\n", snd_strerror(err)); + } + + err = snd_pcm_prepare(handle); + if (err < 0) { + ERRORLOG("Unable to snd_pcm_prepare pcm stream: %s\n", snd_strerror(err)); + } + + return err; +} + +/* + * Get the current audio state. + */ +int +alsa_state(struct cdda_block *blk) +{ + return -1; /* not implemented yet for ALSA */ +} + +static struct audio_oops alsa_oops = { + .wmaudio_open = alsa_open, + .wmaudio_close = alsa_close, + .wmaudio_play = alsa_play, + .wmaudio_stop = alsa_stop, + .wmaudio_state = alsa_state, + .wmaudio_balance = NULL, + .wmaudio_volume = NULL +}; + +struct audio_oops* +setup_alsa(const char *dev, const char *ctl) +{ + static int init_complete = 0; + + if(dev && strlen(dev) > 0) { + device = strdup(dev); + } else { + device = strdup("plughw:0,0"); /* playback device */ + } + + if(init_complete) { + ERRORLOG("already initialized\n"); + return NULL; + } + if(!alsa_open()) + init_complete = 1; + else + return NULL; + + return &alsa_oops; +} + +#endif /* ALSA */ diff --git a/kscd/libwm/audio/audio_arts.c b/kscd/libwm/audio/audio_arts.c new file mode 100644 index 00000000..a7b033c9 --- /dev/null +++ b/kscd/libwm/audio/audio_arts.c @@ -0,0 +1,141 @@ +/* + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * Linux digital audio functions. + * + * + * Forget /dev/audio + * most modern soundcards accept 16LE with 44.1kHz + * Alexander Kern alex.kern@gmx.de + */ + +#include <config.h> + +#ifdef USE_ARTS + +#include <artsc.h> + +#include "audio.h" + +arts_stream_t arts_stream = NULL; + +int arts_open(void); +int arts_close(void); +int arts_stop(void); +int arts_play(struct cdda_block *blk); +int arts_state(struct cdda_block *blk); +struct audio_oops* setup_arts(const char *dev, const char *ctl); + +/* + * Initialize the audio device. + */ +int +arts_open(void) +{ + int err; + + DEBUGLOG("arts_open\n"); + + if(!(arts_stream = arts_play_stream(44100, 16, 2, "cddaslave"))) { + ERRORLOG("cannot open ARTS stream for playback\n"); + return -1; + } + /* 1000 ms because we read 75 frames = 1 sec */ + if((err = arts_stream_set(arts_stream, ARTS_P_BUFFER_TIME, 1000)) < 0) { + ERRORLOG("arts_stream_set failed (%s)\n", arts_error_text(err)); + return -1; + } + return 0; +} + +/* + * Close the audio device. + */ +int +arts_close(void) +{ + arts_stop(); + + DEBUGLOG("arts_close\n"); + arts_close_stream(arts_stream); + + arts_free(); + + return 0; +} + +/* + * Play some audio and pass a status message upstream, if applicable. + * Returns 0 on success. + */ +int +arts_play(struct cdda_block *blk) +{ + int err; + + if((err = arts_write(arts_stream, blk->buf, blk->buflen)) < 0) { + ERRORLOG("arts_write failed (%s)\n", arts_error_text(err)); + blk->status = WM_CDM_CDDAERROR; + return -1; + } + + return 0; +} + +/* + * Stop the audio immediately. + */ +int +arts_stop(void) +{ + DEBUGLOG("arts_stop\n"); + return 0; +} + +/* + * Get the current audio state. + */ +int +arts_state(struct cdda_block *blk) +{ + return -1; /* not implemented yet for ARTS */ +} + +static struct audio_oops arts_oops = { + .wmaudio_open = arts_open, + .wmaudio_close = arts_close, + .wmaudio_play = arts_play, + .wmaudio_stop = arts_stop, + .wmaudio_state = arts_state, + .wmaudio_balance = NULL, + .wmaudio_volume = NULL +}; + +struct audio_oops* +setup_arts(const char *dev, const char *ctl) +{ + int err; + + if((err = arts_init())) { + ERRORLOG("cannot initialize ARTS audio subsystem (%s)\n", arts_error_text(err)); + return NULL; + } + + arts_open(); + + return &arts_oops; +} +#endif diff --git a/kscd/libwm/audio/audio_sun.c b/kscd/libwm/audio/audio_sun.c new file mode 100644 index 00000000..78b1ab21 --- /dev/null +++ b/kscd/libwm/audio/audio_sun.c @@ -0,0 +1,525 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * Sun (really Solaris) digital audio functions. + */ + +#include <config.h> + +#ifdef USE_SUN_AUDIO + +#include <stdio.h> +#include <malloc.h> +#include <sys/ioctl.h> +#include <sys/audioio.h> +#include <sys/stropts.h> +#include <sys/time.h> +#include <errno.h> +#include <fcntl.h> +#include <signal.h> + +#include "audio.h" + +#define WM_MSG_CLASS WM_MSG_CLASS_PLATFORM + +/* + * Since there's a lag time between writing audio to the audio device and + * hearing it, we need to make sure the status indicators correlate to what's + * playing out the speaker. Luckily, Solaris gives us some audio + * synchronization facilities that make this pretty easy. + * + * We maintain a circular queue of status information. When we write some + * sound to the audio device, we put its status info into the queue. We write + * a marker into the audio stream; when the audio device driver encounters the + * marker, it increments a field in a status structure. When we see that + * field go up, we grab the next status structure from the queue and send it + * to the parent process. + * + * The minimum size of the queue depends on the latency of the audio stream. + */ +#define QSIZE 500 + +struct cdda_block queue[QSIZE]; +int qtail; +int qstart; + +/* + * We only send WM_CDM_PLAYING status messages upstream when the CD is supposed + * to be playing; this is used to keep track. + */ +extern int playing; + +static int aufd, aucfd; +static int raw_audio = 1; /* Can /dev/audio take 44.1KHz stereo? */ + +/* + * For fast linear-to-ulaw mapping, we use a lookup table that's generated + * at startup. + */ +unsigned char *ulawmap, linear_to_ulaw(); + +char *getenv(); + +/* + * Dummy signal handler so writes to /dev/audio will interrupt. + */ +static void +dummy( void ) +{ + signal(SIGALRM, dummy); +} + +/* + * Initialize the audio device. + */ +void +sun_audio_init( void ) +{ + audio_info_t info; + char *audiodev, *acdev; + int linval; + + audiodev = getenv("AUDIODEV"); + if (audiodev == NULL || + strncmp("/dev/", audiodev, 5) || + strstr(audiodev, "/../") ) + audiodev = "/dev/audio"; + + acdev = malloc(strlen(audiodev) + 4); + if (acdev == NULL) + { + perror("Can't allocate audio control filename"); + exit(1); + } + strcpy(acdev, audiodev); + strcat(acdev, "ctl"); + + aucfd = open(acdev, O_WRONLY, 0); + if (aucfd < 0) + { + perror(acdev); + exit(1); + } + free(acdev); + + aufd = open(audiodev, O_WRONLY, 0); + if (aufd < 0) + { + perror(audiodev); + exit(1); + } + + signal(SIGALRM, dummy); + + /* + * Try to set the device to CD-style audio; we can process it + * with the least CPU overhead. + */ + AUDIO_INITINFO(&info); + info.play.sample_rate = 44100; + info.play.channels = 2; + info.play.precision = 16; + info.play.encoding = AUDIO_ENCODING_LINEAR; + info.play.pause = 0; + info.record.pause = 0; + info.monitor_gain = 0; + + if (ioctl(aufd, AUDIO_SETINFO, &info) < 0) + if (errno == EINVAL) + { + /* + * Oh well, so much for that idea. + */ + AUDIO_INITINFO(&info); + info.play.sample_rate = 8000; + info.play.channels = 1; + info.play.precision = 8; + info.play.encoding = AUDIO_ENCODING_ULAW; + info.play.pause = 0; + info.record.pause = 0; + info.monitor_gain = 0; + if (ioctl(aufd, AUDIO_SETINFO, &info) < 0) + { + perror("Can't set up audio device"); + exit(1); + } + + /* + * Initialize the linear-to-ulaw mapping table. + */ + if (ulawmap == NULL) + ulawmap = malloc(65536); + if (ulawmap == NULL) + { + perror("malloc"); + exit(1); + } + for (linval = 0; linval < 65536; linval++) + ulawmap[linval] = linear_to_ulaw(linval-32768); + ulawmap += 32768; + raw_audio = 0; + } + else + { + perror(audiodev); + exit(1); + } +} + +/* + * Get ready to play some sound. + */ +void +sun_audio_ready( void ) +{ + audio_info_t info; + + /* + * Start at the correct queue position. + */ + if (ioctl(aucfd, AUDIO_GETINFO, &info) < 0) perror("AUDIO_GETINFO"); + qtail = info.play.eof % QSIZE; + qstart = qtail; + + queue[qtail].status = WM_CDM_PLAYING; +} + +/* + * Stop the audio immediately. + */ +int +sun_audio_stop( void ) +{ + if (ioctl(aufd, I_FLUSH, FLUSHRW) < 0) + perror("flush"); + return 0; +} + +/* + * Close the audio device. + */ +int +sun_audio_close( void ) +{ + wmaudio_stop(); + close(aufd); + close(aucfd); + return 0; +} + +/* + * Set the volume level. + */ +int +sun_audio_volume(int level) +{ + audio_info_t info; + + AUDIO_INITINFO(&info); + if (ioctl(aucfd, AUDIO_GETINFO, &info) < 0) perror("AUDIO_GETINFO"); + info.play.gain = level; + if (ioctl(aucfd, AUDIO_SETINFO, &info) < 0) { + perror("AUDIO_SETINFO"); + return -1; + } + return 0; +} + +/* + * Set the balance level. + */ +int +sun_audio_balance(int level) +{ + audio_info_t info; + + AUDIO_INITINFO(&info); + if (ioctl(aucfd, AUDIO_GETINFO, &info) < 0) perror("AUDIO_GETINFO"); + level *= AUDIO_RIGHT_BALANCE; + info.play.balance = level / 255; + if (ioctl(aucfd, AUDIO_SETINFO, &info) < 0) { + perror("AUDIO_SETINFO"); + return -1; + } + return 0; +} + +/* + * Mark the most recent audio block on the queue as the last one. + */ +void +sun_audio_mark_last( void ) +{ + queue[qtail].status = WM_CDM_TRACK_DONE; +} + +/* + * Figure out the most recent status information and send it upstream. + */ +int +sun_audio_send_status( void ) +{ + audio_info_t info; + int qhead; + + /* + * Now send the most current status information to our parent. + */ + if (ioctl(aucfd, AUDIO_GETINFO, &info) < 0) + perror("AUDIO_GETINFO"); + qhead = info.play.eof % QSIZE; + + if (qhead != qstart && playing) + { + int balance; + + if (queue[qhead].status != WM_CDM_TRACK_DONE) + queue[qhead].status = WM_CDM_PLAYING; + queue[qhead].volume = info.play.gain; + queue[qhead].balance = (info.play.balance * 255) / + AUDIO_RIGHT_BALANCE; + + send_status(queue + qhead); + qstart = -1; + } + + return (queue[qhead].status == WM_CDM_TRACK_DONE); +} + +/* + * Play some audio and pass a status message upstream, if applicable. + * Returns 0 on success. + */ +int +sun_audio_play(unsigned char *rawbuf, long buflen, struct cdda_block *blk) +{ + int i; + short *buf16; + int alarmcount = 0; + struct itimerval it; + long playablelen; + + alarm(1); + playablelen = dev_audio_convert(rawbuf, buflen, blk); + while (write(aufd, rawbuf, playablelen) <= 0) + if (errno == EINTR) + { + if (! raw_audio && alarmcount++ < 5) + { + /* + * 8KHz /dev/audio blocks for several seconds + * waiting for its queue to drop below a low + * water mark. + */ + wmaudio_send_status(); + timerclear(&it.it_interval); + timerclear(&it.it_value); + it.it_value.tv_usec = 500000; + setitimer(ITIMER_REAL, &it, NULL); + continue; + } + +/* close(aufd); + close(aucfd); + wmaudio_init(); +*/ sun_audio_stop(); + alarm(2); + continue; + } + else + { + blk->status = WM_CDM_CDDAERROR; + return (-1); + } + alarm(0); + + /* + * Mark this spot in the audio stream. + * + * Marks don't always succeed (if the audio buffer is empty + * this call will block forever) so do it asynchronously. + */ + fcntl(aufd, F_SETFL, O_NONBLOCK); + if (write(aufd, rawbuf, 0) < 0) + { + if (errno != EAGAIN) + perror("audio mark"); + } + else + qtail = (qtail + 1) % QSIZE; + + fcntl(aufd, F_SETFL, 0); + + queue[qtail] = *blk; + + if (wmaudio_send_status() < 0) + return (-1); + else + return (0); +} + +/* + * Get the current audio state. + */ +int +sun_audio_state(struct cdda_block *blk) +{ + audio_info_t info; + int balance; + + if (ioctl(aucfd, AUDIO_GETINFO, &info) < 0) + perror("AUDIO_GETINFO"); + blk->volume = info.play.gain; + blk->balance = (info.play.balance * 255) / AUDIO_RIGHT_BALANCE; + return 0; +} + +/* +** This routine converts from linear to ulaw. +** +** Craig Reese: IDA/Supercomputing Research Center +** Joe Campbell: Department of Defense +** 29 September 1989 +** +** References: +** 1) CCITT Recommendation G.711 (very difficult to follow) +** 2) "A New Digital Technique for Implementation of Any +** Continuous PCM Companding Law," Villeret, Michel, +** et al. 1973 IEEE Int. Conf. on Communications, Vol 1, +** 1973, pg. 11.12-11.17 +** 3) MIL-STD-188-113,"Interoperability and Performance Standards +** for Analog-to_Digital Conversion Techniques," +** 17 February 1987 +** +** Input: Signed 16 bit linear sample +** Output: 8 bit ulaw sample +*/ +#define ZEROTRAP /* turn on the trap as per the MIL-STD */ +#define BIAS 0x84 /* define the add-in bias for 16 bit samples */ +#define CLIP 32635 + +unsigned char +linear_to_ulaw( sample ) +int sample; +{ + static int exp_lut[256] = {0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3, + 4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4, + 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5, + 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5, + 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, + 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, + 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, + 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7}; + int sign, exponent, mantissa; + unsigned char ulawbyte; + + /* Get the sample into sign-magnitude. */ + sign = (sample >> 8) & 0x80; /* set aside the sign */ + if ( sign != 0 ) sample = -sample; /* get magnitude */ + if ( sample > CLIP ) sample = CLIP; /* clip the magnitude */ + + /* Convert from 16 bit linear to ulaw. */ + sample = sample + BIAS; + exponent = exp_lut[( sample >> 7 ) & 0xFF]; + mantissa = ( sample >> ( exponent + 3 ) ) & 0x0F; + ulawbyte = ~ ( sign | ( exponent << 4 ) | mantissa ); +#ifdef ZEROTRAP + if ( ulawbyte == 0 ) ulawbyte = 0x02; /* optional CCITT trap */ +#endif + + return ulawbyte; +} + +/* + * Downsample a block of CDDA data, if necessary, for playing out an old-style + * audio device. + */ +long +dev_audio_convert(unsigned char *rawbuf, long buflen, struct cdda_block *blk) +{ + short *buf16 = (short *)rawbuf; + int i, j, samples; + int mono_value; + unsigned char *rbend = rawbuf + buflen; + + /* Don't do anything if the audio device can take the raw values. */ + if (raw_audio) + return (buflen); + + for (i = 0; buf16 < (short *)(rbend); i++) + { + /* Downsampling to 8KHz is a little irregular. */ + samples = (i & 1) ? ((i % 20) ? 10 : 12) : 12; + + /* And unfortunately, we don't always end on a nice boundary. */ + if (buf16 + samples > (short *)(rbend)) + samples = ((short *)rbend) - buf16; + + /* + * No need to average all the values; taking the first one + * is sufficient and less CPU-intensive. But we do need to + * do both channels. + */ + mono_value = (buf16[0] + buf16[1]) / 2; + buf16 += samples; + rawbuf[i] = ulawmap[mono_value]; + } + + return (i); +} + +static struct audio_oops sun_audio_oops = { + .wmaudio_open = sun_audio_open, + .wmaudio_close = sun_audio_close, + .wmaudio_play = sun_audio_play, + .wmaudio_stop = sun_audio_stop, + .wmaudio_state = sun_audio_state, + .wmaudio_balance = sun_audio_balance, + .wmaudio_volume = sun_audio_volume +}; + +struct audio_oops* +setup_sun_audio(const char *dev, const char *ctl) +{ + int err; + + if((err = sun_audio_init())) { + ERRORLOG("cannot initialize SUN /dev/audio subsystem \n"); + return NULL; + } + + sun_audio_open(); + + return &sun_audio_oops; +} + +#endif /* USE_SUN_AUDIO */ diff --git a/kscd/libwm/buildindex.c b/kscd/libwm/buildindex.c new file mode 100644 index 00000000..8edc3684 --- /dev/null +++ b/kscd/libwm/buildindex.c @@ -0,0 +1,221 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * Build a WorkMan database index file from a flat text file. Requires + * 4.4BSD libdb library. + */ + +static char buildindex_id[] = "$Id$"; + +#include <stdio.h> +#include <db.h> +#include <fcntl.h> +#include <errno.h> +#include <netinet/in.h> /* for htonl() */ +#include <sys/types.h> +#include <sys/param.h> +#include <sys/stat.h> +#include <unistd.h> + +char *strrchr(); + +main(argc, argv) + int argc; + char **argv; +{ + DB *db; + DBT key, data; + FILE *fp; + int lock = 1, i = 0, locked, frame; + char buf[1000], indname[MAXPATHLEN + 100], framebuf[8], *c; + unsigned long pos; + BTREEINFO bt; + struct stat st; + + if (argc > 2 && !strcmp(argv[1], "-n")) + { + lock = 0; + i++; + } + + if (argc < i + 2) + { + fprintf(stderr, "Usage: %s [-n] dbfile [dbfile ...]\n", + argv[0]); + exit(1); + } + + data.data = &pos; + data.size = sizeof(pos); + key.data = framebuf; + key.size = 7; /* %07d */ + + while (++i < argc) + { + fprintf(stderr, "Building index for %s\n", argv[i]); + + if ((fp = fopen(argv[i], "r")) == NULL) + { + perror(argv[i]); + continue; + } + + /* + * Figure out the file's mode, uid, gid, so we can set the + * permissions on the index file to the same thing. + */ + if (fstat(fileno(fp), &st)) + { + sprintf(indname, "%s: fstat", argv[i]); + perror(indname); + fclose(fp); + continue; + } + + if (lock && lockit(fileno(fp), F_WRLCK)) + { + sprintf(indname, "%s: Warning: Couldn't lock", argv[i]); + perror(indname); + locked = 0; + } + else + locked = 1; + + /* + * Create a database file. + */ + bt.flags = R_DUP; /* allow duplicate keys */ + bt.cachesize = 0; + bt.psize = 0; + bt.lorder = 4321; + bt.minkeypage = 0; + bt.compare = NULL; /* use lexical comparison */ + bt.prefix = NULL; /* no prefix comparisons */ + + /* Index files have ".ind" extensions */ + sprintf(indname, "%s.ind", argv[i]); + if ((db = dbopen(indname, O_CREAT | O_RDWR | O_TRUNC, + st.st_mode, DB_BTREE, &bt)) == NULL) + { + perror(indname); + if (locked) + lockit(fileno(fp), F_UNLCK); + fclose(fp); + continue; + } + + /* + * Now loop through the text file, inserting a record into + * the index file for each "tracks" line. + */ + while (! feof(fp)) + { + pos = ftell(fp); + buf[0] = '\0'; + if (fgets(buf, sizeof(buf), fp) == NULL || ! buf[0]) + { + /* End of file? */ + if (feof(fp)) + break; + + /* Nope. A read error. Unlink the database. */ + perror(argv[i]); + (void) unlink(indname); + break; + } + + if (strncmp(buf, "tracks ", 7)) + continue; + + /* + * Found the start of a record. Figure out the start + * time of the last track and put an entry in the + * index file with that as the key. + */ + c = strrchr(buf, ' '); /* this will always succeed */ + *c = '\0'; + c = strrchr(buf, ' '); /* this should too, but... */ + if (c == NULL) + { + fprintf(stderr, + "%s: Malformed tracks line at %lu\n", + argv[i], pos); + continue; + } + sscanf(c+1, "%d", &frame); + sprintf(framebuf, "%07d", frame); + pos = htonl(pos); + + if ((db->put)(db, &key, &data, 0)) + { + perror(indname); + unlink(indname); + break; + } + } + + /* + * Clean up. + */ + (void) (db->close)(db); + if (locked) + lockit(fileno(fp), F_UNLCK); + } +} + +/* + * Lock a file. Time out after a little while if we can't get a lock; + * this usually means the locking system is broken. + * + * Unfortunately, if there are lots of people contending for a lock, + * this can result in the file not getting locked when it probably should. + */ +int +lockit(fd, type) + int fd; + int type; +{ + struct flock fl; + int result, timer = 0; + + fl.l_type = type; + fl.l_whence = 0; + fl.l_start = 0; + fl.l_len = 0; + + while ((result = fcntl(fd, F_SETLK, &fl)) < 0) + { + if (errno != EACCES || errno != EAGAIN) + break; + if (timer++ == 30) + { + errno = ETIMEDOUT; + break; + } + + sleep(1); + } + + return (result); +} diff --git a/kscd/libwm/cdda.c b/kscd/libwm/cdda.c new file mode 100644 index 00000000..ca8d76ba --- /dev/null +++ b/kscd/libwm/cdda.c @@ -0,0 +1,458 @@ +/*************************************************************************** + cdda.c - description + ------------------- + begin : Mon Jan 27 2003 + copyright : (C) 2003 by Alex Kern + email : alex.kern@gmx.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ +/*************************************************************************** + * * + * This is a common cddamaster piece of code * + * * + ***************************************************************************/ + +#include <string.h> +#include <sys/poll.h> +#include <sys/wait.h> +#include <stdio.h> +#include <unistd.h> +#include "include/wm_config.h" +#include "include/wm_struct.h" +#include "include/wm_cdda.h" +#include "include/wm_cdrom.h" +#include "audio/audio.h" +#include <pthread.h> + +#if defined(BUILD_CDDA) + +static pthread_t thread_read; +static pthread_t thread_play; + +int get_next_block(int x); +void *cdda_fct_read(void* arg); +void *cdda_fct_play(void* arg); + +#define NUMBLOCKS 2 +#define NUMFRAMES 10 + +static struct cdda_block blks[NUMBLOCKS]; +static pthread_mutex_t blks_mutex[NUMBLOCKS]; + +static struct cdda_device dev; +static pthread_cond_t wakeup_audio; + +/* + * Loudness setting, plus the floating volume multiplier and decaying-average + * volume level. + */ +static unsigned int loudness = 0, volume = 32768, level; + +/* + * This is non-null if we're saving audio to a file. + */ +static FILE *output = NULL; + +/* + * These are driverdependent oops + * + */ +static struct audio_oops *oops = 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; +}; + +/* had to change #ifdef to #if -> see wm_cdda.h */ +#ifdef __FreeBSD__ +/* Phungus not with htonl on FreeBSD */ +#include <sys/param.h> +#else +#if WM_BIG_ENDIAN +# ifndef htonl +# define htonl(x) (x) +# endif +#else +extern unsigned long htonl(unsigned long); +#endif +#endif + +/* + * Try to initialize the CDDA slave. Returns 0 on success. + */ +int +gen_cdda_init( struct wm_drive *d ) +{ + int ret = 0; + + if (d->cdda_slave > -1) + return 0; + + memset(&blks, 0, sizeof(blks)); + + dev.fd = -1; + dev.frames_at_once = NUMFRAMES; + dev.blocks = blks; + dev.numblocks = NUMBLOCKS; + dev.status = WM_CDM_UNKNOWN; + dev.devname = d->cd_device; + + if ((ret = wmcdda_init(&dev))) + return ret; + + oops = setup_soundsystem(d->soundsystem, d->sounddevice, d->ctldevice); + if (!oops) { + ERRORLOG("cdda: setup_soundsystem failed\n"); + wmcdda_close(&dev); + return -1; + } + + if(pthread_create(&thread_read, NULL, cdda_fct_read, &dev)) { + ERRORLOG("error by create pthread"); + oops->wmaudio_close(); + wmcdda_close(&dev); + return -1; + } + + if(pthread_create(&thread_play, NULL, cdda_fct_play, &dev)) { + ERRORLOG("error by create pthread"); + oops->wmaudio_close(); + wmcdda_close(&dev); + return -1; + } + d->cdda_slave = 0; + return 0; +} + +int +cdda_get_drive_status( struct wm_drive *d, int oldmode, + int *mode, int *frame, int *track, int *ind ) +{ + if (d->cdda_slave > -1) { + if(dev.status) + *mode = dev.status; + else + *mode = oldmode; + + if (*mode == WM_CDM_PLAYING) { + *track = dev.track; + *ind = dev.index; + *frame = dev.frame; + } else if (*mode == WM_CDM_CDDAERROR) { + /* + * An error near the end of the CD probably + * just means we hit the end. + */ + *mode = WM_CDM_TRACK_DONE; + } + return 0; + } + + return -1; +} + +int +cdda_play( struct wm_drive *d, int start, int end, int realstart ) +{ + if (d->cdda_slave > -1) { + dev.command = WM_CDM_STOPPED; + + wmcdda_setup(start, end, realstart); + + level = 2500; + volume = 1 << 15; + + dev.track = -1; + dev.index = 0; + dev.frame = start; + dev.command = WM_CDM_PLAYING; + + return 0; + } + + return -1; +} + +int +cdda_pause( struct wm_drive *d ) +{ + if (d->cdda_slave > -1) { + if(WM_CDM_PLAYING == dev.command) { + dev.command = WM_CDM_PAUSED; + } else { + dev.command = WM_CDM_PLAYING; + } + + return 0; + } + + return -1; +} + +int +cdda_stop( struct wm_drive *d ) +{ + if (d->cdda_slave > -1) { + dev.command = WM_CDM_STOPPED; + oops->wmaudio_stop(); + return 0; + } + + return -1; +} + +int +cdda_eject( struct wm_drive *d ) +{ + if (d->cdda_slave > -1) { + dev.command = WM_CDM_EJECTED; + oops->wmaudio_stop(); + /*wmcdda_close(&dev);*/ + return 0; + } + + return -1; +} + +int +cdda_set_volume( struct wm_drive *d, int left, int right ) +{ + if (d->cdda_slave > -1) { + int bal, vol; + + bal = (right - left) + 100; + bal *= 255; + bal /= 200; + if (right > left) + vol = right; + else + vol = left; + vol *= 255; + vol /= 100; + + if(oops->wmaudio_balance) + oops->wmaudio_balance(bal); + if(oops->wmaudio_volume) + oops->wmaudio_volume(vol); + + return 0; + } + + return -1; +} + +/* + * Read the initial volume from the drive, if available. Each channel + * ranges from 0 to 100, with -1 indicating data not available. + */ +int +cdda_get_volume( struct wm_drive *d, int *left, int *right ) +{ + if (d->cdda_slave > -1) { + if(!oops->wmaudio_state) { + dev.volume = -1; + dev.balance = 128; + } + + *left = *right = (dev.volume * 100 + 254) / 255; + + if (dev.balance < 110) + *right = (((dev.volume * dev.balance + 127) / 128) * 100 + 254) / 255; + else if (dev.balance > 146) + *left = (((dev.volume * (255 - dev.balance) + 127) / 128) * 100 + 254) / 255; + + return 0; + } + + return -1; +} + +/* + * Turn off the CDDA slave. + */ +void +cdda_kill( struct wm_drive *d ) +{ + if (d->cdda_slave > -1) { + dev.command = WM_CDM_STOPPED; + oops->wmaudio_stop(); + sleep(1); + wmcdda_close(&dev); + oops->wmaudio_close(); + + dev.blocks = NULL; + wait(NULL); + d->cdda_slave = -1; + } +} + +/* + * Tell the CDDA slave to set the loudness level. + */ +void +cdda_set_loudness( struct wm_drive *d, int loud ) +{ + if (d->cdda_slave > -1) { + loudness = loud; + } +} + +/* + * Tell the CDDA slave to start (or stop) saving to a file. + */ +void +cdda_save( struct wm_drive *d, char *filename ) +{ + #if 0 + int len; + + if (filename == NULL || filename[0] == '\0') + len = 0; + else + len = strlen(filename); + write(d->cdda_slave, "F", 1); + write(d->cdda_slave, &len, sizeof(len)); + if (len) + write(d->cdda_slave, filename, len); + + + read(0, &namelen, sizeof(namelen)); + if (output != NULL) { + fclose(output); + output = NULL; + } + if (namelen) { + filename = malloc(namelen + 1); + if (filename == NULL) { + perror("cddas"); + wmcdda_close(dev); + oops->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); + +#endif +} + +int get_next_block(int x) +{ + int y = ++x; + return (y < NUMBLOCKS)?y:0; +} + +void *cdda_fct_read(void* arg) +{ + struct cdda_device *cddadev = (struct cdda_device*)arg; + int i, j, wakeup; + long result; + + while (cddadev->blocks) { + while(cddadev->command != WM_CDM_PLAYING) { + cddadev->status = cddadev->command; + sleep(1); + } + + i = 0; + pthread_mutex_lock(&blks_mutex[i]); + wakeup = 1; + + while(cddadev->command == WM_CDM_PLAYING) { + + result = wmcdda_read(cddadev, &blks[i]); + + if (result <= 0 && blks[i].status != WM_CDM_TRACK_DONE) { + ERRORLOG("cdda: wmcdda_read failed, stop playing\n"); + cddadev->command = WM_CDM_STOPPED; + break; + } else { + if (output) + fwrite(blks[i].buf, blks[i].buflen, 1, output); + } + + j = get_next_block(i); + pthread_mutex_lock(&blks_mutex[j]); + + if(wakeup) { + wakeup = 0; + pthread_cond_signal(&wakeup_audio); + } + + pthread_mutex_unlock(&blks_mutex[i]); + /* audio can start here */ + + i = j; + } + + pthread_mutex_unlock(&blks_mutex[i]); + } + + return 0; +} + +void *cdda_fct_play(void* arg) +{ + struct cdda_device *cddadev = (struct cdda_device*)arg; + int i = 0; + + while (cddadev->blocks) { + if(cddadev->command != WM_CDM_PLAYING) { + i = 0; + pthread_mutex_lock(&blks_mutex[i]); + pthread_cond_wait(&wakeup_audio, &blks_mutex[i]); + } else { + i = get_next_block(i); + pthread_mutex_lock(&blks_mutex[i]); + } + + if (oops->wmaudio_play(&blks[i])) { + oops->wmaudio_stop(); + ERRORLOG("cdda: wmaudio_play failed\n"); + cddadev->command = WM_CDM_STOPPED; + } + cddadev->frame = blks[i].frame; + cddadev->track = blks[i].track; + cddadev->index = blks[i].index; + cddadev->status = blks[i].status; + + pthread_mutex_unlock(&blks_mutex[i]); + } + + return 0; +} + +#endif diff --git a/kscd/libwm/cddaslave.c b/kscd/libwm/cddaslave.c new file mode 100644 index 00000000..9a008b84 --- /dev/null +++ b/kscd/libwm/cddaslave.c @@ -0,0 +1,572 @@ +/* + * $id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + ****************************************************************** + * + * 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 "include/wm_cdda.h" + +#ifdef BUILD_CDDA + +static char cddaslave_id[] = "$Id$"; + +#include <stdio.h> +#include <sys/types.h> +#include <sys/time.h> +#include <unistd.h> +#include <stdlib.h> +#include <string.h> +#include "include/wm_struct.h" +#include "include/wm_cdda.h" +#include "include/wm_platform.h" +#include "audio/audio.h" + +void send_status(struct cdda_block *); + +#define SEND_ACK(b); { (b)->status |= WMCDDA_ACK; send_status(b); } +#define SEND_STATUS(b); { (b)->status &= ~WMCDDA_ACK; send_status(b); } +#define SEND_STATUS_ACK(b, s); { (b)->status = ((s) | WMCDDA_ACK); send_status(b); } + +int receive_command(struct cdda_device *, struct cdda_block *); + +int playing = 0; /* Should the CD be playing now? */ +int pausing = 0; + +/* + * 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; + +/* + * These are driverdependent oops + * + */ +struct audio_oops *oops = 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; +}; + +/* had to change #ifdef to #if -> see wm_cdda.h */ +#ifdef __FreeBSD__ +/* Phungus not with htonl on FreeBSD */ +#include <sys/param.h> +#else +#if WM_BIG_ENDIAN +# ifndef htonl +# define htonl(x) (x) +# endif +#else +extern unsigned long htonl(x); +#endif +#endif + +void *malloc(); +long cdda_transform(); + +/* + * Send status information upstream. + */ +void +send_status(struct cdda_block *blk) +{ + DEBUGLOG("send_status, send %i(%s | %s)\n", blk->status, + gen_status(blk->status & WMCDDA_ACK), gen_status(blk->status & ~WMCDDA_ACK)); + 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. + * E Eject. This means we just close the CD device and + * open it again later. + * 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). + * A Pause/Resume + * I Get status, current frame + */ +int +receive_command(struct cdda_device *dev, struct cdda_block* blk) +{ + unsigned char inbuf[10]; + char *filename; + int namelen; + struct auheader hdr; + + if (read(0, inbuf, 1) <= 0) { + wmcdda_close(dev); + oops->wmaudio_close(); +/* ERRORLOG("cddaslave: parent died, exit\n");*/ + exit(0); + } + + DEBUGLOG("cddaslave: CMD %c\n", inbuf[0]); + + switch (inbuf[0]) { + case 'I': + if(dev->fd < 0) wmcdda_init(dev, blk); + SEND_ACK(blk); + break; + case 'A': /* pause/resume */ + if(WMCDDA_PLAYING & blk->status) { + oops->wmaudio_stop(); + SEND_STATUS_ACK(blk, WMCDDA_PAUSED); + } else if (WMCDDA_PAUSED & blk->status) { + SEND_STATUS_ACK(blk, WMCDDA_PLAYING); + } else { + SEND_ACK(blk); + } + break; + case 'E': + oops->wmaudio_stop(); + wmcdda_close(dev); + SEND_ACK(blk); + break; + case 'P': + read(0, inbuf, 9); + + 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]); + + level = 2500; + volume = 1 << 15; + + blk->track = -1; + blk->index = 0; + blk->minute = inbuf[6]; + blk->second = inbuf[7]; + blk->frame = inbuf[8]; + SEND_STATUS_ACK(blk, WMCDDA_PLAYING); + break; + case 'S': + oops->wmaudio_stop(); + SEND_STATUS_ACK(blk, WMCDDA_STOPPED); + break; + case 'B': + read(0, inbuf, 1); + if(oops->wmaudio_balance) + oops->wmaudio_balance(inbuf[0]); + break; + case 'V': + read(0, inbuf, 1); + if(oops->wmaudio_balance) + oops->wmaudio_volume(inbuf[0]); + break; + case 'G': + SEND_ACK(blk); + if(!oops->wmaudio_state || oops->wmaudio_state(blk) == -1) { + blk->volume = -1; + blk->balance = 128; + } + send_status(blk); + break; + case 'Q': + SEND_ACK(blk); + wmcdda_close(dev); + oops->wmaudio_close(); + exit(0); +/* + case 's': + read(0, inbuf, 1); + speed = inbuf[0]; + wmcdda_speed(speed); + SEND_STATUS(blk, WMCDDA_ACK); + break; + + case 'd': + read(0, inbuf, 1); + wmcdda_direction(inbuf[0]); + SEND_STATUS(blk, WMCDDA_ACK); + break; +*/ + case 'L': + read(0, inbuf, 1); + loudness = inbuf[0]; + SEND_ACK(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(dev); + oops->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); + } + SEND_ACK(blk); + } + + return(dev->fd); +} + + +/* + * 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); +} + + +int main(int argc, char **argv) +{ + fd_set readfd, dummyfd; + struct timeval timeout; + struct cdda_block blockinfo; + long result; + int nfds; + struct cdda_device dev; + const char *sondsystem; + const char *sounddevice; + const char *sounddevicectl; + + memset(&blockinfo, 0, sizeof(struct cdda_block)); + + /* + * Device name should be the command-line argument. + */ + if (argc < 2) + dev.devname = NULL; + else + dev.devname = argv[1]; + + if (argc < 3) + sondsystem = "arts"; + else + sondsystem = argv[2]; + + if (argc < 4) + sounddevice = NULL; + else + sounddevice = argv[3]; + + if (argc < 5) + sounddevicectl = NULL; + else + sounddevicectl = argv[3]; + + DEBUGLOG("cddaslave: called with %s %s %s %s\n", + dev.devname?dev.devname:"", + sondsystem?sondsystem:"", + sounddevice?sounddevice:"", + sounddevicectl?sounddevicectl:""); + + /* + * If we're running setuid root, bump up our priority then lose + * superuser access. + */ + nice(-14); + setgid(getgid()); + setuid(getuid()); + if (geteuid() != getuid()) + return 255; + + FD_ZERO(&dummyfd); + FD_ZERO(&readfd); + + timerclear(&timeout); + + dev.fd = -1; + wmcdda_init(&dev, &blockinfo); + + oops = setup_soundsystem(sondsystem, sounddevice, sounddevicectl); + if (!oops) { + ERRORLOG("cddaslave: setup_soundsystem failed\n"); + exit(1); + } + + DEBUGLOG("cddaslave: sent first ACK\n"); + SEND_ACK(&blockinfo); + + /* + * 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(&dev); + oops->wmaudio_close(); + exit(0); + } + + if (FD_ISSET(0, &readfd)) { + receive_command(&dev, &blockinfo); + /* + * Process all commands in rapid succession, rather + * than possibly waiting for a CDDA read. + */ + continue; + } + + if ((blockinfo.status & ~WMCDDA_ACK) == WMCDDA_PLAYING) { + result = wmcdda_read(&dev, &blockinfo); + if (result <= 0 && blockinfo.status != WMCDDA_DONE) { + ERRORLOG("cddaslave: wmcdda_read failed\n"); + blockinfo.status = WMCDDA_STOPPED; + send_status(&blockinfo); + } else { + result = wmcdda_normalize(&dev, &blockinfo); + if (output) + fwrite(dev.buf, result, 1, output); + + if (oops->wmaudio_play(dev.buf, dev.buflen, &blockinfo)) { + oops->wmaudio_stop(); + ERRORLOG("cddaslave: wmaudio_play failed\n"); + blockinfo.status = WMCDDA_STOPPED; + send_status(&blockinfo); + } + } + } else + send_status(&blockinfo); + } + + return 0; +} + +#endif /* BUILD_CDDA */ diff --git a/kscd/libwm/cddb.c b/kscd/libwm/cddb.c new file mode 100644 index 00000000..657ab6a4 --- /dev/null +++ b/kscd/libwm/cddb.c @@ -0,0 +1,588 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * establish connection to cddb server and get data + * socket stuff gotten from gnu port of the finger command + * + * provided by Sven Oliver Moll + * + */ + +#include <stdio.h> +#include <stdlib.h> +#include <strings.h> +#include <string.h> +#include <unistd.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <sys/signal.h> +#include <ctype.h> +#include <sys/time.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <netdb.h> + +#include "include/wm_config.h" +#include "include/wm_struct.h" +#include "include/wm_cdinfo.h" +#include "include/wm_helpers.h" +#include "include/wm_cddb.h" + +struct wm_cddb cddb; + +extern struct wm_cdinfo thiscd; +static int cur_cddb_protocol; +static char *cur_cddb_server; +static char *cur_cddb_mail_adress; +static char *cur_cddb_path_to_cgi; +static char *cur_cddb_proxy_server; + +/* local prototypes */ +int cddb_sum(int); +char *string_split(char *line, char delim); +void string_makehello(char *line, char delim); +int connect_open(void); +void connect_close(void); +void connect_getline(char *line); +void connect_read_entry(void); +void cddbp_send(const char *line); +void cddbp_read(char *category, unsigned int id); +void http_send(char* line); +void http_read(char *category, unsigned int id); +void cddb_request(void); +/* local prototypes END */ + +static int Socket; +static FILE *Connection; + +/* + * + */ +void +cddb_cur2struct(void) +{ + cddb.protocol = cur_cddb_protocol; + strcpy(cddb.cddb_server, cur_cddb_server); + strcpy(cddb.mail_adress, cur_cddb_mail_adress); + strcpy(cddb.path_to_cgi, cur_cddb_path_to_cgi); + strcpy(cddb.proxy_server, cur_cddb_proxy_server); +} /* cddb_cur2struct() */ + +/* + * + */ +void +cddb_struct2cur(void) +{ + cur_cddb_protocol = cddb.protocol; + cur_cddb_server = (cddb.cddb_server); + cur_cddb_mail_adress = (cddb.mail_adress); + cur_cddb_path_to_cgi = (cddb.path_to_cgi); + cur_cddb_proxy_server = (cddb.proxy_server); +} /* cddb_struct2cur() */ + + +/* + * Subroutine from cddb_discid + */ +int +cddb_sum(int n) +{ + char buf[12], + *p; + int ret = 0; + + /* For backward compatibility this algorithm must not change */ + sprintf(buf, "%lu", (unsigned long)n); + for (p = buf; *p != '\0'; p++) + ret += (*p - '0'); + + return (ret); +} /* cddb_sum() */ + + +/* + * Calculate the discid of a CD according to cddb + */ +unsigned long +cddb_discid(void) +{ + int i, + t, + n = 0; + + /* For backward compatibility this algorithm must not change */ + for (i = 0; i < thiscd.ntracks; i++) { + + n += cddb_sum(thiscd.trk[i].start / 75); + /* + * Just for demonstration (See below) + * + * t += (thiscd.trk[i+1].start / 75) - + * (thiscd.trk[i ].start / 75); + */ + } + + /* + * Mathematics can be fun. Example: How to reduce a full loop to + * a simple statement. The discid algorhythm is so half-hearted + * developed that it doesn't even use the full 32bit range. + * But it seems to be always this way: The bad standards will be + * accepted, the good ones turned down. + * Boy, you pulled out the /75. This is not correct here, because + * this calculation needs the integer division for both .start + * fields. + */ + + t = (thiscd.trk[thiscd.ntracks].start / 75) + - (thiscd.trk[0].start / 75); + return ((n % 0xff) << 24 | t << 8 | thiscd.ntracks); +} /* cddb_discid() */ + +/* + * Split a string into two components according to the first occurrence of + * the delimiter. + */ +char * +string_split(char *line, char delim) +{ + char *p1; + + for (p1=line;*p1;p1++) + { + if(*p1 == delim) + { + *p1 = 0; + return ++p1; + } + } + return (NULL); +} /* string_split() */ + +/* + * Generate the hello string according to the cddb protocol + * delimiter is either ' ' (cddbp) or '+' (http) + */ +void +string_makehello(char *line,char delim) +{ + char mail[84],*host; + + strcpy(mail,cddb.mail_adress); + host=string_split(mail,'@'); + + sprintf(line,"%shello%c%s%c%s%c%s%c%s", + delim == ' ' ? "cddb " : "&", + delim == ' ' ? ' ' : '=', + mail,delim, + host,delim, + WORKMAN_NAME,delim, + WORKMAN_VERSION); +} /* string_makehello() */ + +/* + * Open the TCP connection to the cddb/proxy server + */ +int +connect_open(void) +{ + char *host; + struct hostent *hp; + struct sockaddr_in soc_in; + int port; + + if(cddb.protocol == 3) /* http proxy */ + host = wm_strdup(cddb.proxy_server); + else + host = wm_strdup(cddb.cddb_server); + /* + * t=string_split(host,':'); + */ + port=atoi(string_split(host,':')); + if(!port) + port=8880; + +#ifndef NDEBUG + printf("%s:%d\n",host,port); +#endif + hp =gethostbyname(host); + + if (hp == NULL) + { + static struct hostent def; + static struct in_addr defaddr; + static char *alist[1]; + static char namebuf[128]; + int inet_addr(); + + defaddr.s_addr = inet_addr(host); + if ((int) defaddr.s_addr == -1) + { +#ifndef NDEBUG + printf("unknown host: %s\n", host); +#endif + return (-1); + } + strcpy(namebuf, host); + def.h_name = namebuf; + def.h_addr_list = alist, def.h_addr = (char *)&defaddr; + def.h_length = sizeof (struct in_addr); + def.h_addrtype = AF_INET; + def.h_aliases = 0; + hp = &def; + } + soc_in.sin_family = hp->h_addrtype; + bcopy(hp->h_addr, (char *)&soc_in.sin_addr, hp->h_length); + soc_in.sin_port = htons(port); + Socket = socket(hp->h_addrtype, SOCK_STREAM, 0); + if (Socket < 0) + { + perror("socket"); + return (-1); + } + fflush(stdout); + if (connect(Socket, (struct sockaddr *)&soc_in, sizeof (soc_in)) < 0) + { + perror("connect"); + close(Socket); + return (-1); + } + + Connection = fdopen(Socket, "r"); + return (0); +} /* connect_open() */ + + +/* + * Close the connection + */ +void +connect_close(void) +{ + (void)fclose(Connection); + close(Socket); +} /* connect_close() */ + +/* + * Get a line from the connection with CR and LF stripped + */ +void +connect_getline(char *line) +{ + char c; + + while ((c = getc(Connection)) != '\n') + { + *line = c; + if ((c != '\r') && (c != (char)0xff)) + line++; + } + *line=0; +} /* connect_getline() */ + +/* + * Read the CD data from the server and place them into the cd struct + */ +void +connect_read_entry(void) +{ + char type; + int trknr; + + char *t,*t2,tempbuf[2000]; + + while(strcmp(tempbuf,".")) + { + connect_getline(tempbuf); + + t=string_split(tempbuf,'='); + if(t != NULL) + { + type=tempbuf[0]; + + if(strncmp("TITLE",tempbuf+1,5)) + continue; + + if('D' == type) + { + /* + * Annahme: "Interpret / Titel" ist falsch. + * Daher: NULL-String erwarten. + */ + t2=string_split(t,'/'); + if(t2 == NULL) + t2 = t; + if(*t2 == ' ') + t2++; + strncpy(cd->cdname,t2,sizeof(cd->cdname)-1); + cd->cdname[sizeof(cd->cdname)-1]='\0'; + + for(t2=t;*t2;t2++) + { + if((*t2 == ' ') && (*(t2+1) == 0)) + *t2=0; + } + strncpy(cd->artist,t,sizeof(cd->artist)-1); + cd->artist[sizeof(cd->artist)-1]='\0'; + } + + if('T' == type) + { + trknr=atoi(tempbuf+6); + /* + * printf("Track %d:%s\n",trknr,t); + */ + wm_strmcpy(&cd->trk[trknr].songname,t); + } + /* + * fprintf(stderr, "%s %s\n",tempbuf,t); + */ + } + } +} /* connect_read_entry() */ + +/* + * Send a command to the server using cddbp + */ +void +cddbp_send(const char *line) +{ + write(Socket, line, strlen(line)); + write(Socket, "\n", 1); +} /* cddbp_send() */ + +/* + * Send the "read from cddb" command to the server using cddbp + */ +void +cddbp_read(char *category, unsigned int id) +{ + char tempbuf[84]; + sprintf(tempbuf, "cddb read %s %08x", category, id); + cddbp_send(tempbuf); +} /* cddbp_read() */ + +/* + * Send a command to the server using http + */ +void +http_send(char* line) +{ + char tempbuf[2000]; + + write(Socket, "GET ", 4); +#ifndef NDEBUG + printf("GET "); +#endif + if(cddb.protocol == 3) + { + write(Socket, "http://", 7); + write(Socket, cddb.cddb_server, strlen(cddb.cddb_server)); +#ifndef NDEBUG + printf("http://%s",cddb.cddb_server); +#endif + } + write(Socket, cddb.path_to_cgi, strlen(cddb.path_to_cgi)); + write(Socket, "?cmd=" ,5); + write(Socket, line, strlen(line)); +#ifndef NDEBUG + printf("%s?cmd=%s",cddb.path_to_cgi,line); +#endif + string_makehello(tempbuf,'+'); + write(Socket, tempbuf, strlen(tempbuf)); +#ifndef NDEBUG + printf("%s",tempbuf); +#endif + write(Socket, "&proto=1 HTTP/1.0\n\n", 19); +#ifndef NDEBUG + printf("&proto=1 HTTP/1.0\n"); +#endif + do + connect_getline(tempbuf); + while(strcmp(tempbuf,"")); +} /* http_send() */ + +/* + * Send the "read from cddb" command to the server using http + */ +void +http_read(char *category, unsigned int id) +{ + char tempbuf[84]; + sprintf(tempbuf, "cddb+read+%s+%08x", category, id); + http_send(tempbuf); +} /* http_read() */ + +/* + * The main routine called from the ui + */ +void +cddb_request(void) +{ + int i; + char tempbuf[2000]; + extern int cur_ntracks; + + int status; + char category[21]; + unsigned int id; + + strcpy(cddb.cddb_server,"localhost:888"); + strcpy(cddb.mail_adress,"svolli@bigfoot.com"); + /* + * cddb.protocol = 1; + */ + wipe_cdinfo(); + + switch(cddb.protocol) + { + case 1: /* cddbp */ +#ifndef NDEBUG + printf("USING CDDBP\n"); + printf("open\n"); +#endif + connect_open(); + connect_getline(tempbuf); +#ifndef NDEBUG + printf("[%s]\n",tempbuf); +#endif + /* + * if(atoi(tempbuf) == 201) return; + */ + + /* + * strcpy(tempbuf,"cddb hello svolli bigfoot.com Eierkratzer eins"); + */ + string_makehello(tempbuf,' '); +#ifndef NDEBUG + fprintf(stderr, "%s\n", tempbuf); +#endif + cddbp_send(tempbuf); + connect_getline(tempbuf); +#ifndef NDEBUG + printf("[%s]\n",tempbuf); + printf("query\n"); +#endif + sprintf(tempbuf, "cddb query %08x %d",thiscd.cddbid,thiscd.ntracks); + for (i = 0; i < cur_ntracks; i++) + if (thiscd.trk[i].section < 2) + sprintf(tempbuf + strlen(tempbuf), " %d", + thiscd.trk[i].start); + sprintf(tempbuf + strlen(tempbuf), " %d\n", thiscd.length); +#ifndef NDEBUG + printf(">%s<\n",tempbuf); +#endif + cddbp_send(tempbuf); + connect_getline(tempbuf); +#ifndef NDEBUG + printf("[%s]\n",tempbuf); +#endif + status=atoi(tempbuf); + /* + * fprintf(stderr, "status:%d\n",status); + * fprintf(stderr,"category:%s\n",category); + * fprintf(stderr,"id:%s\n",id); + */ + if(status == 200) /* Exact match */ + { + sscanf(tempbuf,"%d %20s %08x",&status,category,&id); + cddbp_read(category,id); + connect_read_entry(); + } + + if(status == 211) /* Unexact match, multiple possible + * Hack: always use first. */ + { + connect_getline(tempbuf); + sscanf(tempbuf,"%20s %08x",category,&id); + while(strcmp(tempbuf,".")) + connect_getline(tempbuf); + cddbp_read(category,id); + connect_read_entry(); + } + + cddbp_send("quit"); + connect_close(); +#ifndef NDEBUG + printf("close\n"); +#endif + break; + case 2: /* http */ + case 3: /* http proxy */ +#ifndef NDEBUG + printf("USING HTTP%s\n", + (cddb.protocol == 3) ? " WITH PROXY" : ""); + printf("query\n"); +#endif + sprintf(tempbuf, "cddb+query+%08x+%d",thiscd.cddbid,thiscd.ntracks); + for (i = 0; i < cur_ntracks; i++) + if (thiscd.trk[i].section < 2) + sprintf(tempbuf + strlen(tempbuf), "+%d", + thiscd.trk[i].start); + sprintf(tempbuf + strlen(tempbuf), "+%d", thiscd.length); +#ifndef NDEBUG + printf(">%s<\n",tempbuf); +#endif + connect_open(); + http_send(tempbuf); + connect_getline(tempbuf); +#ifndef NDEBUG + printf("[%s]\n",tempbuf); +#endif + status=atoi(tempbuf); + /* + * fprintf(stderr, "status:%d\n",status); + * fprintf(stderr, "category:%s\n",category); + * fprintf(stderr, "id:%s\n",id); + */ + + if(status == 200) /* Exact match */ + { + connect_close(); + connect_open(); + sscanf(tempbuf,"%d %20s %08x",&status,category,&id); + http_read(category,id); + connect_read_entry(); + } + + if(status == 211) /* Unexact match, multiple possible + * Hack: always use first. */ + { + connect_getline(tempbuf); + sscanf(tempbuf,"%20s %08x",category,&id); + while(strcmp(tempbuf,".")) + connect_getline(tempbuf); + connect_close(); + connect_open(); + http_read(category,id); + connect_read_entry(); + } + /* moved close above break */ + connect_close(); + break; + default: /* off */ + break; + } +} /* cddb_request() */ + diff --git a/kscd/libwm/cdinfo.c b/kscd/libwm/cdinfo.c new file mode 100644 index 00000000..b04dec69 --- /dev/null +++ b/kscd/libwm/cdinfo.c @@ -0,0 +1,890 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * Get information about a CD. + */ + +#include <errno.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/types.h> + +#include "include/wm_config.h" + +#include "include/wm_struct.h" +#include "include/wm_cdrom.h" +#include "include/wm_cdinfo.h" +#include "include/wm_database.h" +#include "include/wm_helpers.h" + +struct wm_play *playlist = NULL; +struct wm_cdinfo thiscd, *cd = &thiscd; + +int cur_track = -1; /* Current track number, starting at 1 */ +int cur_index = 0; /* Current index mark */ +int cur_lasttrack = 999; /* Last track to play in current chunk */ +int cur_firsttrack = 0; /* First track of current chunk */ +int cur_pos_abs; /* Current absolute position in seconds */ +int cur_frame; /* Current frame number */ +int cur_pos_rel; /* Current track-relative position in seconds */ +int cur_tracklen; /* Length in seconds of current track */ +int cur_cdlen; /* Length in seconds of entire CD */ +int cur_ntracks; /* Number of tracks on CD (= tracks + sections) */ +int cur_nsections; /* Number of sections currently defined */ + +int cur_listno; /* Current index into the play list, if playing */ +char * cur_artist; /* Name of current CD's artist */ +char * cur_cdname; /* Album name */ +char * cur_trackname; /* Take a guess */ +char cur_contd; /* Continued flag */ +char cur_avoid; /* Avoid flag */ + +int exit_on_eject = 0; + +int cur_stopmode = -1; +int info_modified; + +/* + * insert_trackinfo() + * + * Add a new track to the CD info structure. Pass the position of the new + * entry in the track list -- 0 will make this the first track, 1 the second, + * etc. The new entry will be zeroed out. + */ +static void +insert_trackinfo(int num) +{ + struct wm_trackinfo *newtrk; + + /* Easy case: the list is empty */ + if (cd->trk == NULL) { + if ((cd->trk = (struct wm_trackinfo *) calloc(1, + sizeof(*newtrk))) == NULL) + { + perror("insert_trackinfo"); + exit(1); + } else { + return; + } /* if() else */ + } /* if() */ + /* Stick the new entry in cd->trk[]. */ + if ((newtrk = (struct wm_trackinfo *) malloc(sizeof(*newtrk) * + (cur_ntracks + 1))) == NULL) + { + perror("insert_trackinfo"); + exit(1); + } + + if (num) + memcpy(newtrk, cd->trk, sizeof(*newtrk) * num); + memset(&newtrk[num], 0, sizeof(*newtrk)); + if (num < cur_ntracks) + memcpy(&newtrk[num + 1], &cd->trk[num], sizeof(*newtrk) * + (cur_ntracks - num)); + + free(cd->trk); + cd->trk = newtrk; +} + +/* + * split_trackinfo() + * + * Split a track in two at a particular position (absolute, in frames). All + * internal data structures and variables will be adjusted to the new + * numbering scheme. Pass in the track number (>=1) to split, which is also + * the index into cd->trk[] of the new entry. + * + * If pos is within 1 second of the start of another track, the split fails. + * + * Returns 1 on success, 0 if the track couldn't be inserted. + * + * Note: updating user interface elements is up to the caller. + */ +int +split_trackinfo( int pos ) +{ + int i, l, num; + + if (pos < cd->trk[0].start) + return (0); + + /* First find the appropriate track. */ + for (num = 0; num < cur_ntracks; num++) + if (cd->trk[num].start - 75 < pos && + cd->trk[num].start + 75 > pos) + return (0); + else if (cd->trk[num].start > pos) + break; + if (num == 0) + return (0); + + /* Insert the new entry into the track array. */ + insert_trackinfo(num); + + /* Update the easy variables. */ + if (cur_track > num) + cur_track++; + if (cur_firsttrack > num) + cur_firsttrack++; + if (cur_lasttrack > num) + cur_lasttrack++; + + /* Update the user-defined playlists. */ + if (cd->lists != NULL) + for (l = 0; cd->lists[l].name != NULL; l++) + if (cd->lists[l].list != NULL) + for (i = 0; cd->lists[l].list[i]; i++) + if (cd->lists[l].list[i] > num) + cd->lists[l].list[i]++; + + /* Update the internal playlist. */ + if (playlist != NULL) + for (i = 0; playlist[i].start; i++) + { + if (playlist[i].start > num) + playlist[i].start++; + if (playlist[i].end > num) + playlist[i].end++; + } + + /* Now adjust the information in cd->trk[]. */ + cd->trk[num].start = pos; + if (num == cur_ntracks) + cd->trk[num].length = cur_cdlen - pos / 75; + else + cd->trk[num].length = (cd->trk[num + 1].start - pos) / 75; + cd->trk[num - 1].length -= cd->trk[num].length; + if (cur_track == num) + cur_tracklen -= cd->trk[num].length; + cd->trk[num].track = cd->trk[num - 1].track; + cd->trk[num].data = cd->trk[num - 1].data; + cd->trk[num].contd = 1; + cd->trk[num].volume = cd->trk[num - 1].volume; + + if (cd->trk[num - 1].section == 0) + cd->trk[num - 1].section = 1; + cd->trk[num].section = cd->trk[num - 1].section + 1; + + cur_ntracks++; + cur_nsections++; + + for (i = num + 1; i < cur_ntracks; i++) + if (cd->trk[i].track == cd->trk[num].track) + cd->trk[i].section++; + + return (1); +} + +/* + * remove_trackinfo() + * + * Remove a track's internal data. This is similar to split_trackinfo() + * above, but simpler. A track's initial section can't be removed. Track + * numbers start at 0. + * + * Returns 1 on success, 0 on failure. + */ +int +remove_trackinfo( int num ) +{ + int i, l; + + if (num < 1 || num >= cur_ntracks || cd->trk[num].section < 2) + return (0); + + cd->trk[num - 1].length += cd->trk[num].length; + + for (i = num; i < cur_ntracks - 1; i++) + memcpy(&cd->trk[i], &cd->trk[i + 1], sizeof(cd->trk[0])); + + if (cur_track > num) + cur_track--; + if (cur_firsttrack > num) + cur_firsttrack--; + if (cur_lasttrack > num) + cur_lasttrack--; + + /* Update the user-defined playlists. */ + if (cd->lists != NULL) + for (l = 0; cd->lists[l].name != NULL; l++) + if (cd->lists[l].list != NULL) + for (i = 0; cd->lists[l].list[i]; i++) + if (cd->lists[l].list[i] > num) + cd->lists[l].list[i]--; + + /* Update the internal playlist. */ + if (playlist != NULL) + for (i = 0; playlist[i].start; i++) + { + if (playlist[i].start > num) + playlist[i].start--; + if (playlist[i].end > num) + playlist[i].end--; + } + + cur_ntracks--; + cur_nsections--; + + /* + * Update the section numbers for this track. If this is the only + * user-created section in a track, get rid of the section number + * in the track's entry. + */ + if (num == cur_ntracks || cd->trk[num - 1].track != cd->trk[num].track) + { + if (cd->trk[num - 1].section == 1) + cd->trk[num - 1].section = 0; + } + else + for (i = num; i < cur_ntracks; i++) + if (cd->trk[i].track == cd->trk[num - 1].track) + cd->trk[i].section--; + + return (1); +} + +/* + * listentry() + * + * Return a scrolling list entry. + */ +char * +listentry( int num ) +{ + static char buf[600]; + const char *name; + char tracknum[20]; + int digits; + int sdigits; + + if (num >= 0 && num < cur_ntracks) + { + +/* + if (big_spaces) + { + digits = 2; + sdigits = cur_nsections < 9 ? -1 : -2; + } + else + { + digits = cd->trk[num].track < 10 ? 3 : 2; + sdigits = cur_nsections < 9 ? -1 : -3; + } +*/ + + digits = 2; + sdigits = cur_nsections < 9 ? -1 : -2; + + name = cd->trk[num].songname ? cd->trk[num].songname : ""; + + if (cur_nsections) + { + if (cd->trk[num].section > 9) + { + sprintf(tracknum, "%*d.%d", digits, + cd->trk[num].track, + cd->trk[num].section); + } else { + if (cd->trk[num].section) + { + sprintf(tracknum, "%*d.%*d", digits, + cd->trk[num].track, sdigits, + cd->trk[num].section); + } else { + sprintf(tracknum, "%*d%*s", digits, + cd->trk[num].track, + 2 - sdigits, " "); +/* 2 - sdigits - big_spaces, " ");*/ + } + } + } else { + sprintf(tracknum, "%*d", digits, cd->trk[num].track); + } + + if (cd->trk[num].data) + { + sprintf(buf, "%s) %3dMB %s", tracknum, + cd->trk[num].length / 1024, name); + } else { + sprintf(buf, "%s) %02d:%02d %s", tracknum, + cd->trk[num].length / 60, + cd->trk[num].length % 60, name); + } + + return (buf); + } else { + return (NULL); + } +} /* listentry() */ + +/* + * trackname() + * + * Return a track's name. + */ +const char * +trackname( int num ) +{ + if (num >= 0 && num < cur_ntracks) + { + if (cd->trk[num].songname) + { + return (cd->trk[num].songname); + } else { + return (""); + } + } else { + return (NULL); + } +} /* trackname() */ + +/* + * tracklen() + * + * Return a track's length in seconds. + */ +int +tracklen( int num ) +{ + if (cd != NULL && num >= 0 && num < cur_ntracks) + return (cd->trk[num].length); + else + return (0); +} + +/* + * get_default_volume() + * + * Return the default volume (0-32, 0=none) for the CD or a track. + */ +int +get_default_volume( int track ) +{ + if (! track) + return (cd->volume); + else if (track <= cur_ntracks) + return (cd->trk[track - 1].volume); + else + return (0); +} + +/* + * get_contd() + * + * Return the contd value for a track. + */ +int +get_contd( int num ) +{ + if (num >= 0 && num < cur_ntracks) + return (cd->trk[num].contd); + else + return (0); +} + +/* + * get_avoid() + * + * Return the avoid value for a track. + */ +int +get_avoid( int num ) +{ + if (num >= 0 && num < cur_ntracks) + return (cd->trk[num].avoid); + else + return (0); +} + +/* + * get_autoplay() + * + * Is autoplay set on this disc? + */ +int +get_autoplay( void ) +{ + return ( cd->autoplay ); +} + +/* + * get_playmode() + * + * Return the default playmode for the CD. + */ +int +get_playmode( void ) +{ + return ( cd->playmode ); +} + +/* + * get_runtime() + * + * Return the total running time for the current playlist in seconds. + */ +int +get_runtime( void ) +{ + int i; + + if (playlist == NULL || playlist[0].start == 0 || cur_firsttrack == -1) + return (cd == NULL ? 0 : cd->length); + + for (i = 0; playlist[i].start; i++) + ; + + return (playlist[i].starttime); +} + +/* + * default_volume() + * + * Set the default volume for the CD or a track. + */ +void +default_volume( int track, int vol ) +{ + if (track == 0) + cd->volume = vol; + else if (track <= cur_ntracks) + cd->trk[track - 1].volume = vol; +} + +/* + * Play the next thing on the playlist, if any. + */ +void +play_next_entry( int forward ) +{ + if (cd == NULL) + return; + if (playlist != NULL && playlist[cur_listno].start) + { + wm_cd_play(playlist[cur_listno].start, 0, + playlist[cur_listno].end); + cur_listno++; + } + else + wm_cd_stop(); +} + +/* + * Play the next track, following playlists as necessary. + */ +void +play_next_track( int forward ) +{ + if (cd == NULL) + return; + + /* Is the current playlist entry done? Move on, if so. */ + if (playlist == NULL || cur_track + 1 == playlist[cur_listno - 1].end) + play_next_entry( forward ); + else + wm_cd_play(cur_track + 1, 0, playlist[cur_listno - 1].end); +} + +/* + * Play the previous track, hopping around the playlist as necessary. + */ +void +play_prev_track( int forward ) +{ + if (cd == NULL) + return; + + if (playlist == NULL) + return; + + /* If we're in the middle of this playlist entry, go back one track */ + if (cur_track > playlist[cur_listno - 1].start) + wm_cd_play(cur_track - 1, 0, playlist[cur_listno - 1].end); + else + if (cur_listno > 1) + { + cur_listno--; + wm_cd_play(playlist[cur_listno - 1].end - 1, 0, + playlist[cur_listno - 1].end); + } + else + wm_cd_play(playlist[0].start, 0, playlist[0].end); +} + +/* + * stash_cdinfo(artist, cdname) + */ +void +stash_cdinfo(char *artist, char *cdname, int autoplay, int playmode ) +{ + if (cd != NULL) + { + if (strcmp(cd->artist, artist)) + info_modified = 1; + strncpy(cd->artist, artist,sizeof(cd->artist)-1); + cd->artist[sizeof(cd->artist)-1]='\0'; + + if (strcmp(cd->cdname, cdname)) + info_modified = 1; + strncpy(cd->cdname, cdname,sizeof(cd->cdname)-1); + cd->cdname[sizeof(cd->cdname)-1]='\0'; + + if (!!cd->autoplay != !!autoplay) + info_modified = 1; + cd->autoplay = autoplay; + + if (!!cd->playmode != !!playmode) + info_modified = 1; + cd->playmode = playmode; + } +} /* stash_cdinfo() */ + +/* + * wipe_cdinfo() + * + * Clear out all a CD's soft information (presumably in preparation for + * reloading from the database.) + */ +void +wipe_cdinfo( void ) +{ + struct wm_playlist *l; + int i; + + if (cd != NULL) + { + cd->artist[0] = cd->cdname[0] = '\0'; + cd->autoplay = cd->playmode = cd->volume = 0; + cd->whichdb = NULL; + freeup(&cd->otherrc); + freeup(&cd->otherdb); + + if (thiscd.lists != NULL) + { + for (l = thiscd.lists; l->name != NULL; l++) + { + free(l->name); + free(l->list); + } + free(thiscd.lists); + thiscd.lists = NULL; + } + + for (i = 0; i < cur_ntracks; i++) + { + freeup(&cd->trk[i].songname); + freeup(&cd->trk[i].otherrc); + freeup(&cd->trk[i].otherdb); + cd->trk[i].avoid = cd->trk[i].contd = 0; + cd->trk[i].volume = 0; + if (cd->trk[i].section > 1) + remove_trackinfo(i--); + } + } +} + +/* + * stash_trkinfo(track, songname, contd, avoid) + * + * Update information about a track on the current CD. + */ +void +stash_trkinfo( int track, char *songname, int contd, int avoid ) +{ + if (cd != NULL) + { + track--; + if (!!cd->trk[track].contd != !!contd) + info_modified = 1; + cd->trk[track].contd = track ? contd : 0; + + if (!!cd->trk[track].avoid != !!avoid) + info_modified = 1; + cd->trk[track].avoid = avoid; + + if ((cd->trk[track].songname == NULL && songname[0]) || + (cd->trk[track].songname != NULL && + strcmp(cd->trk[track].songname, songname))) + { + info_modified = 1; + wm_strmcpy(&cd->trk[track].songname, songname); + } + } +} + +/* + * new_playlist() + * + * Add a playlist to a CD. + */ +struct wm_playlist * +new_playlist(struct wm_cdinfo* cdinfo, char* listname) +{ + int nlists = 0; + struct wm_playlist *l; + + if (cdinfo->lists != NULL) + { + for (nlists = 0; cdinfo->lists[nlists].name != NULL; nlists++) + ; + l = (struct wm_playlist *)realloc(cdinfo->lists, (nlists + 2) * + sizeof (struct wm_playlist)); + } + else + l = (struct wm_playlist *)malloc(2 * sizeof (struct wm_playlist)); + + if (l == NULL) + return (NULL); + + l[nlists + 1].name = NULL; + l[nlists].name = NULL; /* so wm_strmcpy doesn't free() it */ + wm_strmcpy(&l[nlists].name, listname); + l[nlists].list = NULL; + cdinfo->lists = l; + + return (&l[nlists]); +} + +/* + * make_playlist() + * + * Construct a playlist for the current CD. If we're in shuffle mode, play + * each non-avoided track once, keeping continued tracks in the right order. + * + * If playmode is 2, use playlist number (playmode-2). XXX should do + * bounds checking on this, probably. + * + * If consecutive tracks are being played, only make one playlist entry for + * them, so the CD player won't pause between tracks while we wake up. + */ +void +make_playlist( int playmode, int starttrack ) +{ + int i, avoiding = 1, entry = 0, count, track, + *thislist; + + cur_listno = 0; + if (playlist != NULL) + free(playlist); + playlist = malloc(sizeof (*playlist) * (cur_ntracks + 1)); + if (playlist == NULL) + { + perror("playlist"); + exit(1); + } + + /* If this is a data-only CD, we can't play it. */ + if ((starttrack && cd->trk[starttrack - 1].data) || + (cur_ntracks == 1 && cd->trk[0].data)) + { + playlist[0].start = 0; + playlist[0].end = 0; + playlist[1].start = 0; + return; + } + + if (playmode == 1) + { + char *done = malloc(cur_ntracks); + + if (done == NULL) + { + perror("randomizer"); + exit(1); + } + + count = cur_ntracks; + if (starttrack && cd->trk[starttrack - 1].avoid) + count++; + for (i = 0; i < cur_ntracks; i++) + if (cd->trk[i].contd || cd->trk[i].avoid || + cd->trk[i].data) + { + done[i] = 1; + count--; + } + else + done[i] = 0; + + for (i = 0; i < count; i++) + { + int end; /* for readability */ + if (starttrack) + { + track = starttrack - 1; + starttrack = 0; + } + else + while (done[track = rand() % cur_ntracks]) + ; + + playlist[i].start = track + 1; + + /* play all subsequent continuation tracks too */ + for (end = track + 1; end < cur_ntracks + 1; end++) + if (! cd->trk[end].contd || + cd->trk[end].avoid || + cd->trk[end].data) + break; + playlist[i].end = end + 1; + + done[track]++; + } + playlist[i].start = 0; + + free(done); + } + else if (playmode >= 2 && cd->lists && cd->lists[playmode - 2].name) + { + count = 2; /* one terminating entry, and one for start */ + thislist = cd->lists[playmode - 2].list; + + for (i = 0; thislist[i]; i++) + if (thislist[i + 1] != thislist[i] + 1) + count++; + + if (playlist != NULL) + free(playlist); + playlist = malloc(sizeof (*playlist) * count); + if (playlist == NULL) + { + perror("playlist"); + exit(1); + } + + count = 0; + if (starttrack) + { + playlist[0].start = starttrack; + for (track = 0; thislist[track]; track++) + if (starttrack == thislist[track]) + break; + if (! thislist[track]) + { + playlist[0].end = starttrack + 1; + playlist[1].start = thislist[0]; + count = 1; + track = 0; + } + } + else + { + playlist[0].start = thislist[0]; + track = 0; + } + + for (i = track; thislist[i]; i++) + if (thislist[i + 1] != thislist[i] + 1) + { + playlist[count].end = thislist[i] + 1; + count++; + playlist[count].start = thislist[i + 1]; + } + } + else + { + for (i = starttrack ? starttrack - 1 : 0; i < cur_ntracks; i++) + if (avoiding && ! (cd->trk[i].avoid || cd->trk[i].data)) + { + playlist[entry].start = i + 1; + avoiding = 0; + } + else if (! avoiding && (cd->trk[i].avoid || + cd->trk[i].data)) + { + playlist[entry].end = i + 1; + avoiding = 1; + entry++; + } + if (! avoiding) + playlist[entry].end = i + 1; + playlist[entry + !avoiding].start = 0; + } + + /* + * Now go through the list, whatever its source, and figure out + * cumulative starting times for each entry. + */ + entry = count = 0; + do { + playlist[entry].starttime = count; + + if (playlist[entry].start) + for (i = playlist[entry].start; i < + playlist[entry].end; i++) + count += cd->trk[i - 1].length; + } while (playlist[entry++].start); +} + +/* + * Find a particular track's location in the current playlist. Sets the + * appropriate variables (cur_listno, cur_firsttrack, cur_lasttrack). + */ +void +pl_find_track( int track ) +{ + int i; + + if (playlist == NULL) + { +#ifndef NDEBUG + fprintf(stderr, "Null playlist! Huh?\n"); +#endif + return; + } + + for (i = 0; playlist[i].start; i++) + if (track >= playlist[i].start && track < playlist[i].end) + { + cur_listno = i + 1; + cur_firsttrack = playlist[i].start; + cur_lasttrack = playlist[i].end - 1; + return; + } + + /* + * Couldn't find the track in question. Make a special entry with + * just that track. + */ + if (! playlist[i].start) + { + playlist = realloc(playlist, (i + 2) * sizeof(*playlist)); + if (playlist == NULL) + { + perror("playlist realloc"); + exit(1); + } + + playlist[i + 1].start = playlist[i + 1].end = 0; + playlist[i + 1].starttime = playlist[i].starttime + + cd->trk[track - 1].length; + playlist[i].start = track; + playlist[i].end = track + 1; + cur_listno = i + 1; + cur_firsttrack = track; + cur_lasttrack = track; + } +} diff --git a/kscd/libwm/cdrom.c b/kscd/libwm/cdrom.c new file mode 100644 index 00000000..980ce3ce --- /dev/null +++ b/kscd/libwm/cdrom.c @@ -0,0 +1,899 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * Interface between most of WorkMan and the low-level CD-ROM library + * routines defined in plat_*.c and drv_*.c. The goal is to have no + * platform- or drive-dependent code here. + */ + +#include <errno.h> +#include <stdio.h> +#include <unistd.h> +#include <stdlib.h> +#include <string.h> +#include <sys/types.h> +/* #include <sys/time.h> */ + +#include "config.h" + +#include "include/wm_config.h" +#include "include/wm_struct.h" +#include "include/wm_cddb.h" +#include "include/wm_cdrom.h" +#include "include/wm_database.h" +#include "include/wm_platform.h" +#include "include/wm_helpers.h" +#include "include/wm_cdinfo.h" +#include "include/wm_cdtext.h" + +#ifdef CAN_CLOSE +#include <fcntl.h> +#endif + +/* local prototypes */ +int read_toc(void); + +#define WM_MSG_CLASS WM_MSG_CLASS_CDROM + +/* extern struct wm_drive generic_proto, toshiba_proto, sony_proto; */ +/* toshiba33_proto; <=== Somehow, this got lost */ + +/* + * The supported drive types are listed here. NULL means match anything. + * The first match in the list is used, and substring matches are done (so + * put long names before their shorter prefixes.) + */ +struct drivelist { + const char *ven; + const char *mod; + const char *rev; + struct wm_drive_proto *proto; +} drives[] = { +{ "TOSHIBA", "XM-3501", NULL, &toshiba_proto }, +{ "TOSHIBA", "XM-3401", NULL, &toshiba_proto }, +{ "TOSHIBA", "XM-3301", NULL, &toshiba_proto }, +{ "SONY", "CDU-8012", NULL, &sony_proto }, +{ "SONY", "CDU 561", NULL, &sony_proto }, +{ "SONY", "CDU-76S", NULL, &sony_proto }, +{ WM_STR_GENVENDOR, WM_STR_GENMODEL, WM_STR_GENREV, &generic_proto }, +{ NULL, NULL, NULL, &generic_proto } +}; + +/* + * Solaris 2.2 will remove the device out from under us. Getting an ENOENT + * is therefore sometimes not a problem. + */ +int intermittent_dev = 0; + +static int wm_cd_cur_balance = 10; +static int wm_cur_cdmode = WM_CDM_UNKNOWN; +static char *wm_cd_device = NULL; /* do not use this extern */ + +static struct wm_drive drive = { + 0, + NULL, + NULL, + NULL, + NULL, + -1, + -1, + NULL, + NULL, + NULL, + NULL, + NULL, + + NULL +}; + +extern struct wm_cdinfo thiscd; + +/* + * Macro magic + * + */ +#define FREE(x); if(x) free(x); x = NULL; + +#define STRDUP(old, neu); \ + if(old) free(old); old = NULL;\ + if(neu) old = strdup(neu); + +#define CARRAY(id) ((id)-1) + +#define DATATRACK 1 +/* + * init the workmanlib + */ +int wm_cd_init( int cdin, const char *cd_device, const char *soundsystem, + const char *sounddevice, const char *ctldevice ) +{ + drive.cdda = (WM_CDDA == cdin); +#if !defined(BUILD_CDDA) + if(drive.cdda) { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "Libworkman library was compiled without cdda support\n"); + return -1; + } +#endif + wm_cd_destroy(); + + STRDUP(wm_cd_device, cd_device); + drive.cd_device = wm_cd_device; + STRDUP(drive.soundsystem, soundsystem); + STRDUP(drive.sounddevice, sounddevice); + STRDUP(drive.ctldevice, ctldevice); + + return wm_cd_status(); +} + +int wm_cd_destroy( void ) +{ + free_cdtext(); + + if(drive.fd != -1) { + /* first free one old */ + if(drive.proto && drive.proto->gen_close) + drive.proto->gen_close(&drive); + else + close(drive.fd); + } + drive.fd = -1; + FREE(wm_cd_device); + FREE(drive.soundsystem); + FREE(drive.sounddevice); + FREE(drive.ctldevice); + FREE(drive.vendor); + FREE(drive.model); + FREE(drive.revision); + drive.proto = NULL; + + return 0; +} +/* + * Give information about the drive we found during wmcd_open() + */ +const char *wm_drive_vendor( void ) +{ + return drive.vendor?drive.vendor:""; +} + +const char *wm_drive_model( void ) +{ + return drive.model?drive.model:""; +} + +const char *wm_drive_revision( void ) +{ + return drive.revision?drive.revision:""; +} + +const char *wm_drive_device( void ) +{ + return drive.cd_device ? drive.cd_device : ""; +} + +/* + * Figure out which prototype drive structure we should be using based + * on the vendor, model, and revision of the current drive. + */ +int +find_drive_struct(const char *vendor, const char *model, const char *rev) +{ + struct drivelist *d; + + for (d = drives; d; d++) { + if(((d->ven != NULL) && strncmp(d->ven, vendor, strlen(d->ven))) || + ((d->mod != NULL) && strncmp(d->mod, model, strlen(d->mod))) || + ((d->rev != NULL) && strncmp(d->rev, rev, strlen(d->rev)))) + continue; + + if(!(d->proto)) + goto fail; + + STRDUP(drive.vendor, vendor); + STRDUP(drive.model, model); + STRDUP(drive.revision, rev); + + drive.proto = d->proto; + return 0; + } + +fail: + return -1; +} /* find_drive_struct() */ + +/* + * read_toc() + * + * Read the table of contents from the CD. Return a pointer to a wm_cdinfo + * struct containing the relevant information (minus artist/cdname/etc.) + * This is a static struct. Returns NULL if there was an error. + * + * XXX allocates one trackinfo too many. + */ +int +read_toc( void ) +{ + struct wm_playlist *l; + int i; + int pos; + + if(!drive.proto) + return -1; + + if(drive.proto && drive.proto->gen_get_trackcount && + (drive.proto->gen_get_trackcount)(&drive, &thiscd.ntracks) < 0) { + return -1 ; + } + + thiscd.artist[0] = thiscd.cdname[0] = '\0'; + thiscd.whichdb = thiscd.otherrc = thiscd.otherdb = thiscd.user = NULL; + thiscd.length = 0; + thiscd.autoplay = thiscd.playmode = thiscd.volume = 0; + + /* Free up any left-over playlists. */ + if (thiscd.lists != NULL) { + for (l = thiscd.lists; l->name != NULL; l++) { + free(l->name); + free(l->list); + } + free(thiscd.lists); + thiscd.lists = NULL; + } + + if (thiscd.trk != NULL) + free(thiscd.trk); + + thiscd.trk = malloc((thiscd.ntracks + 1) * sizeof(struct wm_trackinfo)); + if (thiscd.trk == NULL) { + perror("malloc"); + return -1; + } + + for (i = 0; i < thiscd.ntracks; i++) { + if(drive.proto && drive.proto->gen_get_trackinfo && + (drive.proto->gen_get_trackinfo)(&drive, i + 1, &thiscd.trk[i].data, + &thiscd.trk[i].start) < 0) { + return -1; + } + + thiscd.trk[i].avoid = thiscd.trk[i].data; + thiscd.trk[i].length = thiscd.trk[i].start / 75; + + thiscd.trk[i].songname = thiscd.trk[i].otherrc = + thiscd.trk[i].otherdb = NULL; + thiscd.trk[i].contd = 0; + thiscd.trk[i].volume = 0; + thiscd.trk[i].track = i + 1; + thiscd.trk[i].section = 0; + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "track %i, start frame %i\n", + thiscd.trk[i].track, thiscd.trk[i].start); + } + + if(drive.proto && drive.proto->gen_get_cdlen && + (drive.proto->gen_get_cdlen)(&drive, &thiscd.trk[i].start) < 0) { + return -1; + } + thiscd.trk[i].length = thiscd.trk[i].start / 75; + +/* Now compute actual track lengths. */ + pos = thiscd.trk[0].length; + for (i = 0; i < thiscd.ntracks; i++) { + thiscd.trk[i].length = thiscd.trk[i+1].length - pos; + pos = thiscd.trk[i+1].length; + if (thiscd.trk[i].data) + thiscd.trk[i].length = (thiscd.trk[i + 1].start - thiscd.trk[i].start) * 2; + if (thiscd.trk[i].avoid) + wm_strmcpy(&thiscd.trk[i].songname, "DATA TRACK"); + } + + thiscd.length = thiscd.trk[thiscd.ntracks].length; + thiscd.cddbid = cddb_discid(); + + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "read_toc() successful\n"); + return 0; +} /* read_toc() */ + +/* + * wm_cd_status() + * + * Return values: + * see wm_cdrom.h + * + * Updates variables. + */ +int +wm_cd_status( void ) +{ + static int oldmode = WM_CDM_UNKNOWN; + int mode, err, tmp; + + if(!drive.proto) { + oldmode = WM_CDM_UNKNOWN; + err = wmcd_open( &drive ); + if (err < 0) { + wm_cur_cdmode = WM_CDM_UNKNOWN; + return err; + } + } + + if(drive.proto && drive.proto->gen_get_drive_status && + (drive.proto->gen_get_drive_status)(&drive, oldmode, &mode, &cur_frame, + &(thiscd.curtrack), &cur_index) < 0) { + perror("WM gen_get_drive_status"); + return -1; + } else { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, + "gen_get_drive_status returns status %s, track %i, frame %i\n", + gen_status(mode), thiscd.curtrack, cur_frame); + } + + if(WM_CDS_NO_DISC(oldmode) && WM_CDS_DISC_READY(mode)) { + /* device changed */ + thiscd.ntracks = 0; + if(read_toc() || 0 == thiscd.ntracks) + { + close(drive.fd); + drive.fd = -1; + mode = WM_CDM_NO_DISC; + } + else /* refresh cdtext info */ + get_glob_cdtext(&drive, 1); + + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "device status changed() from %s to %s\n", + gen_status(oldmode), gen_status(mode)); + } + oldmode = mode; + + /* + * it seems all driver have'nt state for stop + */ + if(WM_CDM_PAUSED == mode && 0 == cur_frame) { + mode = WM_CDM_STOPPED; + thiscd.curtrack = 0; + } + + switch (mode) { + case WM_CDM_PLAYING: + case WM_CDM_PAUSED: + cur_pos_abs = cur_frame / 75; + /* search for right track */ + for(tmp = thiscd.ntracks; + tmp > 1 && cur_frame < thiscd.trk[CARRAY(tmp)].start; + tmp--) + ; + thiscd.curtrack = tmp; + /* Fall through */ + + + case WM_CDM_UNKNOWN: + if (mode == WM_CDM_UNKNOWN) + { + mode = WM_CDM_NO_DISC; + cur_lasttrack = cur_firsttrack = -1; + } + /* Fall through */ + + case WM_CDM_STOPPED: + if(thiscd.curtrack >= 1 && thiscd.curtrack <= thiscd.ntracks && thiscd.trk != NULL) { + cur_trackname = thiscd.trk[CARRAY(thiscd.curtrack)].songname; + cur_avoid = thiscd.trk[CARRAY(thiscd.curtrack)].avoid; + cur_contd = thiscd.trk[CARRAY(thiscd.curtrack)].contd; + cur_pos_rel = (cur_frame - thiscd.trk[CARRAY(thiscd.curtrack)].start) / 75; + if (cur_pos_rel < 0) + cur_pos_rel = -cur_pos_rel; + } + if((playlist != NULL) && playlist[0].start & (cur_listno > 0)) { + cur_pos_abs -= thiscd.trk[playlist[CARRAY(cur_listno)].start - 1].start / 75; + cur_pos_abs += playlist[CARRAY(cur_listno)].starttime; + } + if (cur_pos_abs < 0) + cur_pos_abs = cur_frame = 0; + + if (thiscd.curtrack < 1) + thiscd.curtracklen = thiscd.length; + else + thiscd.curtracklen = thiscd.trk[CARRAY(thiscd.curtrack)].length; + /* Fall through */ + + case WM_CDM_TRACK_DONE: + wm_cur_cdmode = mode; + break; + case WM_CDM_FORWARD: + case WM_CDM_EJECTED: + wm_cur_cdmode = mode; + break; + } + + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, + "wm_cd_status returns %s\n", gen_status(wm_cur_cdmode)); + return wm_cur_cdmode; +} + +int +wm_cd_getcurtrack( void ) +{ + if(WM_CDS_NO_DISC(wm_cur_cdmode)) + return 0; + return thiscd.curtrack; +} + +int +wm_cd_getcurtracklen( void ) +{ + if(WM_CDS_NO_DISC(wm_cur_cdmode)) + return 0; + + return thiscd.curtracklen; +} + +int +wm_cd_getcountoftracks( void ) +{ + if(WM_CDS_NO_DISC(wm_cur_cdmode)) + return 0; + + return thiscd.ntracks; +} + +int wm_cd_gettracklen( int track ) +{ + if (track < 1 || + track > thiscd.ntracks || + thiscd.trk == NULL) + return 0; + + return thiscd.trk[CARRAY(track)].length; +} + +/* + * wm_cd_play(starttrack, pos, endtrack) + * + * Start playing the CD or jump to a new position. "pos" is in seconds, + * relative to start of track. + */ +int +wm_cd_play( int start, int pos, int end ) +{ + int real_start, real_end, status; + + status = wm_cd_status(); + if(WM_CDS_NO_DISC(status) || thiscd.ntracks < 1) + return -1; + + /* + * check ranges + */ + for(real_end = thiscd.ntracks; (thiscd.trk[CARRAY(real_end)].data == DATATRACK); real_end--) + ; + for(real_start = 1; (thiscd.trk[CARRAY(real_start)].data == DATATRACK); real_start++) + ; + + if(end == WM_ENDTRACK) end = real_end; + if(end > real_end) end = real_end; + + /* + * handle as overrun + */ + if(start < real_start) start = real_start; + if(start > real_end) start = real_end; + + /* + * Try to avoid mixed mode and CD-EXTRA data tracks + */ + if(start > end || thiscd.trk[CARRAY(start)].data == DATATRACK) { + wm_cd_stop(); + return -1; + } + + cur_firsttrack = start; + cur_lasttrack = end; + + wm_cd_play_chunk(thiscd.trk[CARRAY(start)].start + pos * 75, end == thiscd.ntracks ? + thiscd.length * 75 : thiscd.trk[CARRAY(end)].start - 1, thiscd.trk[CARRAY(start)].start); + /* So we don't update the display with the old frame number */ + wm_cd_status(); + + return thiscd.curtrack; +} + +/* + * wm_cd_play_chunk(start, end) + * + * Play the CD from one position to another (both in frames.) + */ +int +wm_cd_play_chunk( int start, int end, int realstart ) +{ + int status; + + status = wm_cd_status(); + if(WM_CDS_NO_DISC(status)) + return -1; + + end--; + if (start >= end) + start = end-1; + + if(!(drive.proto) || !(drive.proto->gen_play)) { + perror("WM gen_play: function pointer NULL"); + return -1; + } + + return (drive.proto->gen_play)(&drive, start, end, realstart); +} + +/* + * Set the offset into the current track and play. -1 means end of track + * (i.e., go to next track.) + */ +int +wm_cd_play_from_pos( int pos ) +{ + int status; + + status = wm_cd_status(); + if(WM_CDS_NO_DISC(status)) + return -1; + + if (pos == -1) + pos = thiscd.trk[thiscd.curtrack - 1].length - 1; + + if (wm_cur_cdmode == WM_CDM_PLAYING) + return wm_cd_play(thiscd.curtrack, pos, playlist[cur_listno-1].end); + else + return -1; +} /* wm_cd_play_from_pos() */ + +/* + * wm_cd_pause() + * + * Pause the CD, if it's in play mode. If it's already paused, go back to + * play mode. + */ +int +wm_cd_pause( void ) +{ + static int paused_pos; + int status; + + status = wm_cd_status(); + if(WM_CDS_NO_DISC(status)) + return -1; + + if(WM_CDM_PLAYING == wm_cur_cdmode) { + if(drive.proto && drive.proto->gen_pause) + (drive.proto->gen_pause)(&drive); + + paused_pos = cur_pos_rel; + } else if(WM_CDM_PAUSED == status) { + if(!(drive.proto->gen_resume) || (drive.proto->gen_resume(&drive) > 0)) { + wm_cd_play(thiscd.curtrack, paused_pos, playlist[cur_listno-1].end); + } + } else { + return -1; + } + wm_cd_status(); + return 0; +} /* wm_cd_pause() */ + +/* + * wm_cd_stop() + * + * Stop the CD if it's not already stopped. + */ +int +wm_cd_stop( void ) +{ + int status; + + status = wm_cd_status(); + if(WM_CDS_NO_DISC(status)) + return -1; + + if (status != WM_CDM_STOPPED) { + + if(drive.proto && drive.proto->gen_stop) + (drive.proto->gen_stop)(&drive); + + status = wm_cd_status(); + } + + return (status != WM_CDM_STOPPED); +} /* wm_cd_stop() */ + +/* + * Eject the current CD, if there is one, and set the mode to 5. + * + * Returns 0 on success, 1 if the CD couldn't be ejected, or 2 if the + * CD contains a mounted filesystem. + */ +int +wm_cd_eject( void ) +{ + int err = -1; + + wm_cd_stop(); + + if(drive.proto && drive.proto->gen_eject) + err = (drive.proto->gen_eject)(&drive); + + if (err < 0) { + if (err == -3) { + return 2; + } else { + return 1; + } + } + + wm_cd_status(); + + return 0; +} + +int wm_cd_closetray(void) +{ + int status, err = -1; + + status = wm_cd_status(); + if (status == WM_CDM_UNKNOWN || status == WM_CDM_NO_DISC) + return -1; + + if(drive.proto->gen_closetray) + err = (drive.proto->gen_closetray)(&drive); + + return(err ? 0 : wm_cd_status()==2 ? 1 : 0); +} /* wm_cd_closetray() */ + +struct cdtext_info* +wm_cd_get_cdtext( void ) +{ + int status; + + status = wm_cd_status(); + + if(WM_CDS_NO_DISC(status)) + return NULL; + + return get_glob_cdtext(&drive, 0); +} + +/* + * find_trkind(track, index, start) + * + * Start playing at a particular track and index, optionally using a particular + * frame as a starting position. Returns a frame number near the start of the + * index mark if successful, 0 if the track/index didn't exist. + * + * This is made significantly more tedious (though probably easier to port) + * by the fact that CDROMPLAYTRKIND doesn't work as advertised. The routine + * does a binary search of the track, terminating when the interval gets to + * around 10 frames or when the next track is encountered, at which point + * it's a fair bet the index in question doesn't exist. + */ +int +wm_find_trkind( int track, int ind, int start ) +{ + int top = 0, bottom, current, interval, ret = 0, i, status; + + status = wm_cd_status(); + if(WM_CDS_NO_DISC(status)) + return 0; + + for (i = 0; i < thiscd.ntracks; i++) { + if (thiscd.trk[i].track == track) + break; + } + + bottom = thiscd.trk[i].start; + + for (; i < thiscd.ntracks; i++) { + if (thiscd.trk[i].track > track) + break; + } + + top = i == thiscd.ntracks ? (thiscd.length - 1) * 75 : thiscd.trk[i].start; + if (start > bottom && start < top) + bottom = start; + + current = (top + bottom) / 2; + interval = (top - bottom) / 4; + + do { + wm_cd_play_chunk(current, current + 75, current); + + if (wm_cd_status() != 1) + return 0; + while (cur_frame < current) { + if(wm_cd_status() != 1 || wm_cur_cdmode != WM_CDM_PLAYING) + return 0; + else + wm_susleep(1); + } + + if (thiscd.trk[thiscd.curtrack - 1].track > track) + break; + + if(cur_index >= ind) { + ret = current; + current -= interval; + } else { + current += interval; + } + + interval /= 2; + + } while (interval > 2); + + return ret; +} /* find_trkind() */ + +int +wm_cd_set_verbosity( int level ) +{ + wm_lib_set_verbosity(level); + return wm_lib_get_verbosity(); +} + +/* + * volume is valid WM_VOLUME_MUTE <= vol <= WM_VOLUME_MAXIMAL, + * balance is valid WM_BALANCE_ALL_LEFTS <= balance <= WM_BALANCE_ALL_RIGHTS + */ + +int +wm_cd_volume( int vol, int bal ) +{ + int left, right; + const int bal1 = (vol - WM_VOLUME_MUTE)/(WM_BALANCE_ALL_RIGHTS - WM_BALANCE_SYMMETRED); + +/* + * Set "left" and "right" to volume-slider values accounting for the + * balance setting. + * + */ + if(vol < WM_VOLUME_MUTE) vol = WM_VOLUME_MUTE; + if(vol > WM_VOLUME_MAXIMAL) vol = WM_VOLUME_MAXIMAL; + if(bal < WM_BALANCE_ALL_LEFTS) bal = WM_BALANCE_ALL_LEFTS; + if(bal > WM_BALANCE_ALL_RIGHTS) bal = WM_BALANCE_ALL_RIGHTS; + + left = vol - (bal * bal1); + right = vol + (bal * bal1); + + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "calculate volume left %i, right %i\n", left, right); + + if (left > WM_VOLUME_MAXIMAL) + left = WM_VOLUME_MAXIMAL; + if (right > WM_VOLUME_MAXIMAL) + right = WM_VOLUME_MAXIMAL; + + if(!(drive.proto) || !(drive.proto->gen_set_volume)) + return -1; + else + return (drive.proto->gen_set_volume)(&drive, left, right); +} /* cd_volume() */ + +int +wm_cd_getvolume( void ) +{ + int left, right; + + if(!(drive.proto) || !(drive.proto->gen_get_volume) || + (drive.proto->gen_get_volume)(&drive, &left, &right) < 0 || left == -1) + return -1; + + if (left < right) { + wm_cd_cur_balance = (right - left) / 2; + if (wm_cd_cur_balance > WM_BALANCE_ALL_RIGHTS) + wm_cd_cur_balance = WM_BALANCE_ALL_RIGHTS; + return right; + } else if (left == right) { + wm_cd_cur_balance = WM_BALANCE_SYMMETRED; + return left; + } else { + wm_cd_cur_balance = (right - left) / 2; + if (wm_cd_cur_balance < WM_BALANCE_ALL_LEFTS) + wm_cd_cur_balance = WM_BALANCE_ALL_LEFTS; + return left; + } +} + +int +wm_cd_getbalance( void ) +{ + int left, right; + + if(!(drive.proto) || !(drive.proto->gen_get_volume) || + (drive.proto->gen_get_volume)(&drive, &left, &right) < 0 || left == -1) + return WM_BALANCE_SYMMETRED; + + if (left < right) { + wm_cd_cur_balance = (right - left) / 2; + if (wm_cd_cur_balance > WM_BALANCE_ALL_RIGHTS) + wm_cd_cur_balance = WM_BALANCE_ALL_RIGHTS; + } else if (left == right) { + wm_cd_cur_balance = WM_BALANCE_SYMMETRED; + } else { + wm_cd_cur_balance = (right - left) / 2; + if (wm_cd_cur_balance < WM_BALANCE_ALL_LEFTS) + wm_cd_cur_balance = WM_BALANCE_ALL_LEFTS; + } + return wm_cd_cur_balance; +} + +/* + * Prototype wm_drive structure, with generic functions. The generic functions + * will be replaced with drive-specific functions as appropriate once the drive + * type has been sensed. + */ +struct wm_drive_proto generic_proto = { + gen_init, /* functions... */ + gen_close, + gen_get_trackcount, + gen_get_cdlen, + gen_get_trackinfo, + gen_get_drive_status, + gen_get_volume, + gen_set_volume, + gen_pause, + gen_resume, + gen_stop, + gen_play, + gen_eject, + gen_closetray, + gen_get_cdtext +}; + +const char* +gen_status(int status) +{ + static char tmp[250]; + switch(status) { + case WM_CDM_TRACK_DONE: + return "WM_CDM_TRACK_DONE"; + case WM_CDM_PLAYING: + return "WM_CDM_PLAYING"; + case WM_CDM_FORWARD: + return "WM_CDM_FORWARD"; + case WM_CDM_PAUSED: + return "WM_CDM_PAUSED"; + case WM_CDM_STOPPED: + return "WM_CDM_STOPPED"; + case WM_CDM_EJECTED: + return "WM_CDM_EJECTED"; + case WM_CDM_DEVICECHANGED: + return "WM_CDM_DEVICECHANGED"; + case WM_CDM_NO_DISC: + return "WM_CDM_NO_DISC"; + case WM_CDM_UNKNOWN: + return "WM_CDM_UNKNOWN"; + case WM_CDM_CDDAERROR: + return "WM_CDM_CDDAERROR"; + case WM_CDM_CDDAACK: + return "WM_CDM_CDDAACK"; + default: + { + sprintf(tmp, "unexpected status %i", status); + return tmp; + } + } +} diff --git a/kscd/libwm/cdtext.c b/kscd/libwm/cdtext.c new file mode 100644 index 00000000..bb4e19b8 --- /dev/null +++ b/kscd/libwm/cdtext.c @@ -0,0 +1,428 @@ +/*************************************************************************** + cdtext.c - description + ------------------- + begin : Mon Feb 12 2001 + copyright : (C) 2001,2003 by Alex Kern + email : alex.kern@gmx.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ + +#include <errno.h> +#include <stdio.h> +#include <unistd.h> +#include <stdlib.h> +#include <string.h> +#include <sys/types.h> +#ifdef libunicode + #include <unicode.h> +#endif + +#include "include/wm_config.h" +#include "include/wm_struct.h" +#include "include/wm_cdrom.h" +#include "include/wm_database.h" +#include "include/wm_platform.h" +#include "include/wm_helpers.h" +#include "include/wm_cdinfo.h" +#include "include/wm_cdtext.h" + +#define WM_MSG_CLASS WM_MSG_CLASS_MISC + +/* local prototypes */ +int free_cdtext_info_block(struct cdtext_info_block* cdtextinfoblock); +int free_cdtext_info(struct cdtext_info* cdtextinfo); +struct cdtext_info_block* malloc_cdtext_info_block(int count_of_tracks); +void get_data_from_cdtext_pack( + const struct cdtext_pack_data_header *pack, + const struct cdtext_pack_data_header *pack_previous, + cdtext_string *p_componente); + +struct cdtext_info wm_cdtext_info = { 0, 0, 0, 0 }; + +int free_cdtext_info_block(struct cdtext_info_block* cdtextinfoblock) +{ + if(cdtextinfoblock) + { + if(cdtextinfoblock->name) + free(cdtextinfoblock->name); + if(cdtextinfoblock->performer) + free(cdtextinfoblock->performer); + if(cdtextinfoblock->songwriter) + free(cdtextinfoblock->songwriter); + if(cdtextinfoblock->composer) + free(cdtextinfoblock->composer); + if(cdtextinfoblock->arranger) + free(cdtextinfoblock->arranger); + if(cdtextinfoblock->message) + free(cdtextinfoblock->message); + if(cdtextinfoblock->UPC_EAN_ISRC_code) + free(cdtextinfoblock->UPC_EAN_ISRC_code); + + if(cdtextinfoblock->block_encoding_text) + free(cdtextinfoblock->block_encoding_text); + } + + return 0; +} + +int free_cdtext_info(struct cdtext_info* cdtextinfo) +{ + int i; + wm_lib_message(WM_MSG_LEVEL_DEBUG | WM_MSG_CLASS, + "CDTEXT INFO: free_cdtext_info() called\n"); + + if(cdtextinfo) + { + for(i = 0; i < 8; i++) + { + if(cdtextinfo->blocks[i]) + { + free_cdtext_info_block(cdtextinfo->blocks[i]); + } + } + memset(cdtextinfo, 0, sizeof(struct cdtext_info)); + } + + return 0; +} + +struct cdtext_info_block* malloc_cdtext_info_block(int count_of_tracks) +{ + int memamount; + struct cdtext_info_block* lp_block; + + lp_block = malloc(sizeof(struct cdtext_info_block)); + if(!lp_block) + { + return (struct cdtext_info_block*)0; + } + memset(lp_block, 0, sizeof(struct cdtext_info_block)); + + memamount = count_of_tracks * sizeof(cdtext_string); + + lp_block->name = malloc(memamount); + if(!lp_block->name) + return (struct cdtext_info_block*)free_cdtext_info_block(lp_block); + memset(lp_block->name, 0, memamount); + + lp_block->performer = malloc(memamount); + if(!lp_block->performer) + return (struct cdtext_info_block*)free_cdtext_info_block(lp_block); + memset(lp_block->performer, 0, memamount); + + lp_block->songwriter = malloc(memamount); + if(!lp_block->songwriter) + return (struct cdtext_info_block*)free_cdtext_info_block(lp_block); + memset(lp_block->songwriter, 0, memamount); + + lp_block->composer = malloc(memamount); + if(!lp_block->composer) + return (struct cdtext_info_block*)free_cdtext_info_block(lp_block); + memset(lp_block->composer, 0, memamount); + + lp_block->arranger = malloc(memamount); + if(!lp_block->arranger) + return (struct cdtext_info_block*)free_cdtext_info_block(lp_block); + memset(lp_block->arranger, 0, memamount); + + lp_block->message = malloc(memamount); + if(!lp_block->message) + return (struct cdtext_info_block*)free_cdtext_info_block(lp_block); + memset(lp_block->message, 0, memamount); + + lp_block->UPC_EAN_ISRC_code = malloc(memamount); + if(!lp_block->UPC_EAN_ISRC_code) + return (struct cdtext_info_block*)free_cdtext_info_block(lp_block); + memset(lp_block->UPC_EAN_ISRC_code, 0, memamount); + + return lp_block; +} + +void get_data_from_cdtext_pack( + const struct cdtext_pack_data_header *pack, + const struct cdtext_pack_data_header *pack_previous, + cdtext_string *p_componente) +{ + + int arr = pack->header_field_id2_tracknumber; + int i; + int language_block; + int unicode; + + language_block = (pack->header_field_id4_block_no >> 4) & 0x07; + unicode = pack->header_field_id4_block_no & 0x80; + + if(!unicode) + { + for(i = 0; i < DATAFIELD_LENGHT_IN_PACK; i++) + { + if(pack->text_data_field[i] == 0x00) /* end marker */ + { + arr++; + } + else if(pack->text_data_field[i] == 0x09) /* repeat last marker */ + { + /* ASSERT(arr > 0) */ + strcat((char*)(p_componente[arr]), (char*)(p_componente[arr-1])); + arr++; + } + else + { + strncat((char*)(p_componente[arr]), (char*)(&(pack->text_data_field[i])), 1); + } + } + } +#ifdef libunicode + else /* doublebytes ;-) */ + { + for(i = 0; i < DATAFIELD_LENGHT_IN_PACK; i += 2) + { + if((Uchar)(pack->text_data_field[i]) == 0x0000) /* end marker */ + { + arr++; + } + else if((Uchar)(pack->text_data_field[i]) == 0x0909) /* repeat last marker */ + { + /* ASSERT(arr > 0) */ + strcat((char*)(p_componente[arr]), (char*)(p_componente[arr-1])); + arr++; + } + else + { + strncat((char*)(p_componente[arr]), u_uc_to_utf8((Uchar*)(&(pack->text_data_field[i]))), 1); + } + } + } +#else + else { + wm_lib_message(WM_MSG_LEVEL_ERROR | WM_MSG_CLASS, "can't handle unicode"); + } +#endif +} + +struct cdtext_info* +get_glob_cdtext(struct wm_drive *d, int redo) +{ + /* alloc cdtext_info */ + + unsigned char *buffer; + int buffer_length; + int ret; + int i; + struct cdtext_pack_data_header *pack, *pack_previous; + cdtext_string *p_componente; + struct cdtext_info_block *lp_block; + if(!d->proto || d->proto->gen_get_cdtext == NULL || d->proto->gen_get_trackcount == NULL) { + return NULL; + } + + if(!redo && wm_cdtext_info.valid) { + wm_lib_message(WM_MSG_LEVEL_DEBUG | WM_MSG_CLASS, "CDTEXT DEBUG: recycle cdtext\n"); + return &wm_cdtext_info; + } else + free_cdtext_info(&wm_cdtext_info); + + lp_block = 0; + p_componente = 0; + buffer = 0; + buffer_length = 0; + + ret = (d->proto->gen_get_cdtext)(d, &buffer, &buffer_length); + if(!ret) + { + (d->proto->gen_get_trackcount)(d, &(wm_cdtext_info.count_of_entries)); + if( wm_cdtext_info.count_of_entries < 0 ) + wm_cdtext_info.count_of_entries = 1; + else + wm_cdtext_info.count_of_entries++; + + i = 0; + + pack = 0; /* NULL pointer*/ + while(i < buffer_length) + { + pack_previous = pack; + pack = (struct cdtext_pack_data_header*)(buffer+i); + /* to implement: check_crc(pack); */ + + /* only for valid packs */ + if(pack->header_field_id1_typ_of_pack >= 0x80 && pack->header_field_id1_typ_of_pack < 0x90) + { + int code, j; + wm_lib_message(WM_MSG_LEVEL_DEBUG | WM_MSG_CLASS, + "CDTEXT DEBUG: valid packet at 0x%08X: 0x %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n", + i, + pack->header_field_id1_typ_of_pack, + pack->header_field_id2_tracknumber, + pack->header_field_id3_sequence, + pack->header_field_id4_block_no, + pack->text_data_field[0], + pack->text_data_field[1], + pack->text_data_field[2], + pack->text_data_field[3], + pack->text_data_field[4], + pack->text_data_field[5], + pack->text_data_field[6], + pack->text_data_field[7], + pack->text_data_field[8], + pack->text_data_field[9], + pack->text_data_field[10], + pack->text_data_field[11], + pack->crc_byte1, + pack->crc_byte2); + wm_cdtext_info.count_of_valid_packs++; + + code = (pack->header_field_id4_block_no >> 4) & 0x07; + if(0 == lp_block || lp_block->block_code != code) /* find or create one new block */ + { + lp_block = 0; + for(j = 0; j < MAX_LANGUAGE_BLOCKS && wm_cdtext_info.blocks[j] != 0 && 0 == lp_block; j++) + { + if(wm_cdtext_info.blocks[j]->block_code == code) + { + lp_block = wm_cdtext_info.blocks[j]; + } + } + + if(MAX_LANGUAGE_BLOCKS <= j) + { + free_cdtext_info(&wm_cdtext_info); + wm_lib_message(WM_MSG_LEVEL_ERROR | WM_MSG_CLASS, + "CDTEXT ERROR: more as 8 languageblocks defined\n"); + return NULL; + } + + if(0 == lp_block) + { + /* make next new block */ + lp_block = malloc_cdtext_info_block(wm_cdtext_info.count_of_entries); + if(0 == lp_block) + { + wm_lib_message(WM_MSG_LEVEL_ERROR | WM_MSG_CLASS, + "CDTEXT ERROR: out of memory, can't create a new language block\n"); + free_cdtext_info(&wm_cdtext_info); + return NULL /*ENOMEM*/; + } + else + { + wm_cdtext_info.blocks[j] = lp_block; + wm_cdtext_info.blocks[j]->block_code = code; + wm_cdtext_info.blocks[j]->block_unicode = pack->header_field_id4_block_no & 0x80; + wm_lib_message(WM_MSG_LEVEL_DEBUG | WM_MSG_CLASS, + "CDTEXT INFO: created a new language block; code %i, %s characters\n", code, lp_block->block_unicode?"doublebyte":"singlebyte"); +/* + unsigned char block_encoding; not jet! + cdtext_string* block_encoding_text; +*/ + } + } + } + } + + switch(pack->header_field_id1_typ_of_pack) + { + case 0x80: + p_componente = (lp_block->name); + get_data_from_cdtext_pack(pack, pack_previous, p_componente); + break; + case 0x81: + p_componente = (lp_block->performer); + get_data_from_cdtext_pack(pack, pack_previous, p_componente); + break; + case 0x82: + p_componente = (lp_block->songwriter); + get_data_from_cdtext_pack(pack, pack_previous, p_componente); + break; + case 0x83: + p_componente = (lp_block->composer); + get_data_from_cdtext_pack(pack, pack_previous, p_componente); + break; + case 0x84: + p_componente = (lp_block->arranger); + get_data_from_cdtext_pack(pack, pack_previous, p_componente); + break; + case 0x85: + p_componente = (lp_block->message); + get_data_from_cdtext_pack(pack, pack_previous, p_componente); + break; + case 0x86: + memcpy((char*)(lp_block->binary_disc_identification_info), + (char*)(pack->text_data_field), DATAFIELD_LENGHT_IN_PACK); + break; + case 0x87: + memcpy((char*)(lp_block->binary_genreidentification_info), + (char*)(pack->text_data_field), DATAFIELD_LENGHT_IN_PACK); + break; + case 0x88: + wm_lib_message(WM_MSG_LEVEL_DEBUG | WM_MSG_CLASS, + "CDTEXT INFO: PACK with code 0x88 (TOC)\n"); + break; + case 0x89: + wm_lib_message(WM_MSG_LEVEL_DEBUG | WM_MSG_CLASS, + "CDTEXT INFO: PACK with code 0x89 (second TOC)\n"); + break; + case 0x8A: + case 0x8B: + case 0x8C: + wm_lib_message(WM_MSG_LEVEL_DEBUG | WM_MSG_CLASS, + "CDTEXT INFO: PACK with code 0x%02X (reserved)\n", pack->header_field_id1_typ_of_pack); + break; + case 0x8D: + wm_lib_message(WM_MSG_LEVEL_DEBUG | WM_MSG_CLASS, + "CDTEXT INFO: PACK with code 0x8D (for content provider only)\n"); + break; + case 0x8E: + p_componente = (lp_block->UPC_EAN_ISRC_code); + get_data_from_cdtext_pack(pack, pack_previous, p_componente); + break; + case 0x8F: + memcpy((char*)(lp_block->binary_size_information), + (char*)(pack->text_data_field), DATAFIELD_LENGHT_IN_PACK); + break; + default: + wm_lib_message(WM_MSG_LEVEL_DEBUG | WM_MSG_CLASS, + "CDTEXT ERROR: invalid packet at 0x%08X: 0x %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n", + i, + pack->header_field_id1_typ_of_pack, + pack->header_field_id2_tracknumber, + pack->header_field_id3_sequence, + pack->header_field_id4_block_no, + pack->text_data_field[0], + pack->text_data_field[1], + pack->text_data_field[2], + pack->text_data_field[3], + pack->text_data_field[4], + pack->text_data_field[5], + pack->text_data_field[6], + pack->text_data_field[7], + pack->text_data_field[8], + pack->text_data_field[9], + pack->text_data_field[10], + pack->text_data_field[11], + pack->crc_byte1, + pack->crc_byte2); + wm_cdtext_info.count_of_invalid_packs++; + } + i += sizeof(struct cdtext_pack_data_header); + } /* while */ + } + + if(0 == ret && wm_cdtext_info.count_of_valid_packs > 0) + wm_cdtext_info.valid = 1; + + return &wm_cdtext_info; +} + +void free_cdtext(void) +{ + if (wm_cdtext_info.valid) + free_cdtext_info(&wm_cdtext_info); +} diff --git a/kscd/libwm/configure.in.in b/kscd/libwm/configure.in.in new file mode 100644 index 00000000..a0ce3ab7 --- /dev/null +++ b/kscd/libwm/configure.in.in @@ -0,0 +1,72 @@ +dnl +-------------------------------+ +dnl | Checks for LIBWORKMAN | +dnl +-------------------------------+ +AC_MSG_CHECKING(for CDDA) + +AC_ARG_WITH(kscd-cdda, [ --with-kscd-cdda build CDDA support in kscd [default=yes]], +[ + if test $withval = yes; then + libwm_with_cdda=yes + else + libwm_with_cdda=no + fi +],libwm_with_cdda=yes) + +if test "$libwm_with_cdda" = "yes"; then +case $host in + *-*-linux*) + AC_CHECK_HEADERS(pthread.h) + AC_TRY_COMPILE( + [ +#ifndef __GNUC__ +#define __GNUC__ 1 +#endif +/* needed for vanilla kernel headers, which do provide __u64 only + for ansi */ +#undef __STRICT_ANSI__ +/* needed for non-ansi kernel headers */ +#define asm __asm__ +#define inline __inline__ +#include <linux/types.h> +#include <linux/cdrom.h> +#undef asm +#undef inline + ],[ +#if defined(__linux__) +ioctl(1, CDROMREADAUDIO, 0); +#else + #error platform? +#endif + ],, libwm_with_cdda=no) + ;; + *-*-sunos*) + AC_CHECK_HEADERS(pthread.h) + AC_TRY_COMPILE( + [ +#include <sys/types.h> +#include <sys/cdio.h> + ],[ +#if defined(__sun) || defined(sun) +ioctl(1, CDROMCDDA, 0); +#else + #error platform? +#endif + ],, libwm_with_cdda=no) + ;; + *) + libwm_with_cdda=no + ;; +esac +fi + +if test "$libwm_with_cdda" = "yes"; then + AC_DEFINE(BUILD_CDDA, 1, [Define if you will CDDA support in kscd]) +fi +AM_CONDITIONAL(libwm_with_cdda, test "$libwm_with_cdda" = "yes") + +AC_MSG_RESULT($libwm_with_cdda) + + +dnl +-------------------------------+ +dnl | End LIBWORKMAN checks | +dnl +-------------------------------+ diff --git a/kscd/libwm/database.c b/kscd/libwm/database.c new file mode 100644 index 00000000..f7f4e7cc --- /dev/null +++ b/kscd/libwm/database.c @@ -0,0 +1,1543 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * Manage the CD database. All these routines assume that the "cd" global + * structure contains current information (as far as the outside world knows; + * obviously it won't contain track titles just after a CD is inserted.) + */ + +#define RCFILE "/.workmanrc" +#define DBFILE "/.workmandb" +#define FUZZFRAMES 75 + +#include <errno.h> +#include <stdio.h> +#include <fcntl.h> +#include <unistd.h> +#include <ctype.h> +#include <stdlib.h> +#include <string.h> +#include <sys/types.h> +#include <sys/param.h> +#include <sys/time.h> +#include <sys/stat.h> +#include <time.h> +#include "include/wm_config.h" +#include "include/wm_helpers.h" +#include "include/wm_struct.h" +#include "include/wm_cdinfo.h" +#include "include/wm_cddb.h" +#include "include/wm_index.h" +#include "include/wm_database.h" + +#define WM_MSG_CLASS WM_MSG_CLASS_DB + +#define SWALLOW_LINE(fp) { int _c; while ((_c = getc(fp)) != '\n' && _c != EOF); } + +/* local prototypes */ +char *print_cdinfo(struct wm_cdinfo *pcd, int prefs); +FILE *open_rcfile(const char *name, const char *mode); +int *reset_tracks(void); +int search_db( FILE *fp, int prefs, int scan, int holesize_wanted ); +void spinwheels(int secs); +int lockit(int fd, int type); +void save_globals(FILE *fp); +int save_entry(char *filename, int pref); +/* local prototypes END */ + +static int suppress_locking = 0; /* Turn off locking of datafile (dangerous) */ + +static char *rcfile = NULL; /* Personal rcfile */ +static char *dbfiles = NULL; /* Colon-separated list of databases */ +static char **databases = NULL; /* NULL-terminated list of databases */ + +static char *otherrc = NULL; /* Unrecognized cruft from start of rcfile */ + +static long rcpos, rclen; /* XXX */ + +static int found_in_db, found_in_rc; +static long holepos, firstpos; + +static int fuzz_frames = FUZZFRAMES; + +static int wm_db_save_disabled = FALSE; + +static int cur_playnew = -1; + +extern int cur_ntracks, cur_nsections; + +int mark_a = 0; +int mark_b = 0; + + +/* + * + */ +int wm_db_get_playnew( void ) +{ + return 0; +} + +/* + * split_workmandb() + * + * Split the WORKMANDB environment variable, if any, into a list of database + * files in the global "databases". If WORKMANDB is not available, make + * a single entry with $HOME/DBFILE. + * + * Also, fill the "rcfile" global with the personal preferences filename. + * + * The environment variables should have already been read and placed in the + * "rcfile" and "dbfiles" globals, respectively. + */ +void +split_workmandb( void ) +{ + int ndbs, i; + char *home, *wmdb; + int no_rc = 0, no_db = 0; + + if (rcfile == NULL) + { + if ((home = getenv("HOME")) != NULL) + { + rcfile = malloc(strlen(home) + sizeof(RCFILE)); + if (rcfile == NULL) + { + +nomem: + perror("split_workmandb()"); + exit(1); + } + + strcpy(rcfile, home); + strcat(rcfile, RCFILE); + } + else + no_rc = 1; + + } + + if ((wmdb = dbfiles) == NULL) + { + if ((home = getenv("HOME")) != NULL) + { + wmdb = malloc(strlen(home) + sizeof(DBFILE)); + if (wmdb == NULL) + goto nomem; + + databases = malloc(2 * sizeof (databases[0])); + if (databases == NULL) + goto nomem; + + strcpy(wmdb, home); + strcat(wmdb, DBFILE); + databases[0] = wmdb; + databases[1] = NULL; + } + else + { + static char *emptydb = NULL; + + databases = &emptydb; + no_db = 1; + } + } + else + { + ndbs = 1; + for (home = wmdb; *home; home++) + if (*home == ':') + { + *home = '\0'; + ndbs++; + } + + databases = malloc((ndbs + 1) * sizeof(databases[0])); + if (databases == NULL) + goto nomem; + + for (i = 0; i < ndbs; i++) + { + databases[i] = wmdb; + wmdb += strlen(wmdb) + 1; + } + + databases[i] = NULL; + } + + if (no_db || no_rc) + { +#ifndef NDEBUG + fprintf(stderr, +"WorkMan was run without a home directory, probably by a system daemon.\n"); + fprintf(stderr, "It doesn't know where to find "); + if (no_rc) + { + fprintf(stderr, "your personal preferences file "); + if (no_db) + fprintf(stderr, "or the\ndatabase of CD descriptions"); + } + else + fprintf(stderr, "the database of CD descriptions"); + + fprintf(stderr, +".\nYou can use the X resources \"workman.db.shared\" and \"workman.db.personal\"\nto tell WorkMan where to look.\n"); +#endif + wm_db_save_disabled = TRUE; + } +} + +/* + * print_cdinfo(cd, prefs) + * + * cd A pointer to a cdinfo struct. + * prefs Flag: write personal preferences? + * + * Print a CD's information (in more or less readable form) to a buffer. + * Returns a pointer to the buffer. + * + * XXX - could be more efficient about calling wm_strmcat() and strlen(). + */ +char * +print_cdinfo(struct wm_cdinfo *cd, int prefs) +{ + int i; + char tempbuf[2000]; /* XXX - is this always big enough? */ + static char *cdibuf = NULL; + struct wm_playlist *l; + + sprintf(tempbuf, "\ntracks %d", cd->ntracks); + for (i = 0; i < cur_ntracks; i++) + if (cd->trk[i].section < 2) + sprintf(tempbuf + strlen(tempbuf), " %d", + cd->trk[i].start); + sprintf(tempbuf + strlen(tempbuf), " %d\n", cd->length); + + wm_strmcpy(&cdibuf, tempbuf); + + if (cur_nsections) + { + sprintf(tempbuf, "sections %d", cur_nsections); + /* fixed a bug here */ + for (i = 0; i < cur_ntracks; i++) + if (cd->trk[i].section > 1) + sprintf(tempbuf + strlen(tempbuf), " %d", + cd->trk[i].start); + sprintf(tempbuf + strlen(tempbuf), "\n"); + + wm_strmcat(&cdibuf, tempbuf); + } + + if (prefs) + { + if (cd->autoplay) + wm_strmcat(&cdibuf, "autoplay\n"); + for (l = cd->lists; l != NULL && l->name != NULL; l++) + { + wm_strmcat(&cdibuf, "playlist "); + + i = strlen(cdibuf) - 1; + wm_strmcat(&cdibuf, l->name); + while (cdibuf[++i]) + if (cdibuf[i] == ' ' || cdibuf[i] == '\t') + cdibuf[i] = '_'; + + if (l->list != NULL) + { + for (i = 0; l->list[i]; i++) + ; + sprintf(tempbuf, " %d", i); + wm_strmcat(&cdibuf, tempbuf); + for (i = 0; l->list[i]; i++) + { + sprintf(tempbuf, " %d", l->list[i]); + wm_strmcat(&cdibuf, tempbuf); + } + wm_strmcat(&cdibuf, "\n"); + } + else + wm_strmcat(&cdibuf, " 0\n"); + } + + if (cd->volume) + { + /* + * Have to maintain compatibility with old versions, + * where volume was 0-32. + */ + sprintf(tempbuf, "cdvolume %d\n", (cd->volume * 32) / 100); + wm_strmcat(&cdibuf, tempbuf); + } + + if (cd->playmode) + { + sprintf(tempbuf, "playmode %d\n", cd->playmode); + wm_strmcat(&cdibuf, tempbuf); + } + + if (mark_a) + { + sprintf(tempbuf, "mark %d START\n", mark_a); + wm_strmcat(&cdibuf, tempbuf); + } + if (mark_b) + { + sprintf(tempbuf, "mark %d END\n", mark_b); + wm_strmcat(&cdibuf, tempbuf); + } + + if (cd->otherrc) + wm_strmcat(&cdibuf, cd->otherrc); + + for (i = 0; i < cur_ntracks; i++) + { + if (cd->trk[i].avoid) + { + sprintf(tempbuf, "dontplay %d\n", i + 1); + wm_strmcat(&cdibuf, tempbuf); + } + if (cd->trk[i].volume) + { + sprintf(tempbuf, "volume %d %d\n", i + 1, + (cd->trk[i].volume * 32) / 100); + wm_strmcat(&cdibuf, tempbuf); + } + if (cd->trk[i].otherrc) + wm_strmcat(&cdibuf, cd->trk[i].otherrc); + } + } + else + { + if (cd->cdname[0]) + { + wm_strmcat(&cdibuf, "cdname "); + wm_strmcat(&cdibuf, cd->cdname); + wm_strmcat(&cdibuf, "\n"); + } + + if (cd->artist[0]) + { + wm_strmcat(&cdibuf, "artist "); + wm_strmcat(&cdibuf, cd->artist); + wm_strmcat(&cdibuf, "\n"); + } + + if (cd->otherdb) + wm_strmcat(&cdibuf, cd->otherdb); + + for (i = 0; i < cur_ntracks; i++) + { + if (cd->trk[i].section > 1) + wm_strmcat(&cdibuf, "s-"); + wm_strmcat(&cdibuf, "track "); + if (cd->trk[i].songname != NULL) + wm_strmcat(&cdibuf, cd->trk[i].songname); + wm_strmcat(&cdibuf, "\n"); + if (cd->trk[i].contd) + { + if (cd->trk[i].section > 1) + wm_strmcat(&cdibuf, "s-"); + wm_strmcat(&cdibuf, "continue\n"); + } + if (cd->trk[i].otherdb) + wm_strmcat(&cdibuf, cd->trk[i].otherdb); + } + } + + return (cdibuf); +} /* print_cdinfo() */ + +/* + * Open the rcfile for reading or writing. + * + * name Filename + * mode "r" or "w" + */ +FILE * +open_rcfile(const char *name, const char *mode) +{ + FILE *fp; + struct stat st; + + fp = fopen(name, mode); + if (fp == NULL) + { + if (errno != ENOENT || mode[0] == 'w') + perror(name); + } + else + { + /* Don't let people open directories or devices */ + if (fstat(fileno(fp), &st) < 0) + { + perror(name); + fclose(fp); + return (NULL); + } + +#ifdef S_ISREG + if (! S_ISREG(st.st_mode)) +#else + if ((st.st_mode & S_IFMT) != S_IFREG) +#endif + { + errno = EISDIR; + perror(name); + fclose(fp); + return (NULL); + } + + if (mode[0] == 'w') /* create -- put data in so locks work */ + { + fputs("# WorkMan database file\n", fp); + fclose(fp); + fp = fopen(name, "r+"); + if (fp == NULL) + if (errno != ENOENT) + perror(name); + } + } + + return (fp); +} + +/* + * + * allocate and clear "trackmap". + * + */ +int *reset_tracks(void) +{ + int i, j; + int *trackmap; + /* + * Since we access track numbers indirectly (to handle sections + * with at least a little elegance), the track mapping needs to be + * set up before we read anything. Initially it must assume that + * no sections will appear in this datafile. + */ + trackmap = malloc(sizeof(int) * cur_ntracks); + if (trackmap == NULL) + { + perror("trackmap"); + exit(1); + } + j = 0; + for (i = 0; i < cd->ntracks; i++) + { + trackmap[i] = j; + while (cd->trk[++j].section > 1) + ; + } + return trackmap; +} /* reset_tracks() */ + +/* + * Load a new-format database file, searching for a match with the currently + * inserted CD. Modify the in-core copy of the CD info based on what's found + * in the database. + * + * Returns 1 if there was a match or 0 if not. + * + * fp FILE* of database or rcfile. + * prefs 1 if we're searching .workmanrc, 0 for .workmandb, + * 2 if just reading settings + * scan Scan for "tracks" location and entry size only + * holesize_wanted How big a hole we're looking for, if any. + * + * If a hole was found along the way, update the global "holepos" with its + * starting offset in the file. A hole is defined as a bunch of blank lines + * preceding a "tracks" line. Holepos will contain the best match. + * + * In addition, "firstpos" will be filled with the position of the first + * "tracks" keyword, so we know how much room is available for global + * settings at the rcfile's start. + */ +int +search_db( FILE *fp, int prefs, int scan, int holesize_wanted ) + +{ + char keyword[64], listname[64], *c; + int b, i, j, track = 0, listsize, ntracks, scratch, searching = 1; + int *trackmap = 0, gotsections = 0; + int fudge, maxfudge, sizediff, bestfudge = 0; + long pos = 0, thisholepos = -1, holesize = 99991239; + struct wm_playlist *l; + + rclen = 0; + + wm_lib_message(WM_MSG_CLASS_DB|WM_MSG_LEVEL_DEBUG , "db: Reached search_db()\n" ); + + /* We may not find any holes at all! */ + if (holesize_wanted) + holepos = -1; + + if( prefs != 2 ) + trackmap = reset_tracks(); + + if (prefs) + freeup(&otherrc); + firstpos = -1; + while (! feof(fp)) + { + pos = ftell(fp); + keyword[0] = '\0'; + do + b = getc(fp); + while (b != EOF && b != '\n' && isspace(b)); + + if (b == EOF || feof(fp)) + break; + + if (b != '\n') + { + keyword[0] = b; + fscanf(fp, "%62s", &keyword[1]); + } + if (keyword[0] == '\0') /* Blank line. */ + { + if (thisholepos < 0) + thisholepos = pos; + continue; + } + + /* Strip off "s-" if we've seen a "sections" keyword */ + if (gotsections && keyword[0] == 's' && keyword[1] == '-') + { + for (c = &keyword[2]; (c[-2] = *c) != '\0'; c++) + ; + wm_lib_message(WM_MSG_CLASS_DB|WM_MSG_LEVEL_DEBUG , "db: stripped off the 's-'. Result is %s\n", keyword); + } + + /* If this is the start of a CD entry, see if it matches. */ + if (! strcmp(keyword, "tracks")) + { + if (prefs == 2) + break; + + /* Is this the end of a hole? */ + if (holesize_wanted && (thisholepos >= 0)) + { + /* Yep. Is it better than the last one? */ + if (pos - thisholepos < holesize && pos - + thisholepos >= holesize_wanted) + { + holepos = thisholepos; + holesize = pos - thisholepos; + } + thisholepos = -1; + } + + /* Is it the start of the CD entries? */ + if (firstpos == -1) + firstpos = pos; + + /* Is this the end of the entry we really wanted? */ + if (! searching) + { + rclen = pos - rcpos; + break; + } + + /* If we have a near match, indicate that we + should stop reading tracks, etc now */ + if (searching == 2) + { + searching = 3; + continue; + } + + fscanf(fp, "%d", &ntracks); + + if (ntracks != cd->ntracks) + { +chomp: + SWALLOW_LINE(fp); + continue; + } + + fudge = 0; + maxfudge = (ntracks * fuzz_frames) >> 1; + track = 0; + for (i = 0; i < ntracks; i++) + { + fscanf(fp, "%d", &scratch); + if (scratch != cd->trk[track].start) + { + sizediff = abs(scratch - cd->trk[track].start); + if (sizediff > fuzz_frames || + (sizediff && scan)) + break; + fudge += sizediff; + } + while (cd->trk[++track].section > 1) + ; + } + if (i != ntracks) + goto chomp; + + if (fudge > 0) /* best near match? */ + { + if (fudge > maxfudge) + goto chomp; + if (bestfudge == 0 || fudge < bestfudge) + bestfudge = fudge; + else + goto chomp; + rcpos = pos; + track = 0; + searching = 2; + } + else /* probably exact match */ + { + fscanf(fp, "%d", &scratch); + + if (scratch != -1 && scratch != cd->length) + goto chomp; + + /* Found it! */ + rcpos = pos; + track = 0; + searching = 0; + } + + SWALLOW_LINE(fp); /* Get rid of newline */ + } + + /* Global mode stuff goes here */ + else if (! strcmp(keyword, "cddbprotocol")) + { + getc(fp); + i = getc(fp); /* only first letter is used */ + cddb.protocol = i == 'c' ? 1 : + i == 'h' ? 2 : 3 ; + do + i = getc(fp); + while (i != '\n' && i != EOF); + } + + else if (! strcmp(keyword, "cddbserver")) + { + getc(fp); /* lose the space */ + if (cddb.cddb_server[0]) + do + i = getc(fp); + while (i != '\n' && i != EOF); + else + { + fgets(cddb.cddb_server, + sizeof(cddb.cddb_server), fp); + if ((i = strlen(cddb.cddb_server))) + cddb.cddb_server[i - 1] = '\0'; + } + } + + else if (! strcmp(keyword, "cddbmailadress")) + { + getc(fp); /* lose the space */ + if (cddb.mail_adress[0]) + do + i = getc(fp); + while (i != '\n' && i != EOF); + else + { + fgets(cddb.mail_adress, + sizeof(cddb.mail_adress), fp); + if ((i = strlen(cddb.mail_adress))) + cddb.mail_adress[i - 1] = '\0'; + } + } + + else if (! strcmp(keyword, "cddbpathtocgi")) + { + getc(fp); /* lose the space */ + if (cddb.path_to_cgi[0]) + do + i = getc(fp); + while (i != '\n' && i != EOF); + else + { + fgets(cddb.path_to_cgi, + sizeof(cddb.path_to_cgi), fp); + if ((i = strlen(cddb.path_to_cgi))) + cddb.path_to_cgi[i - 1] = '\0'; + } + } + + else if (! strcmp(keyword, "cddbproxy")) + { + getc(fp); /* lose the space */ + if (cddb.proxy_server[0]) + do + i = getc(fp); + while (i != '\n' && i != EOF); + else + { + fgets(cddb.proxy_server, + sizeof(cddb.proxy_server), fp); + if ((i = strlen(cddb.proxy_server))) + cddb.proxy_server[i - 1] = '\0'; + } + } + + else if (! strcmp(keyword, "whendone")) + { + getc(fp); + i = getc(fp); /* only first letter is used */ + if (cur_stopmode == -1) /* user's setting preferred */ + cur_stopmode = i == 's' ? 0 : i == 'r' ? 1 : 2; + do + i = getc(fp); + while (i != '\n' && i != EOF); + } + + else if (! strcmp(keyword, "playnew")) + { + if (cur_playnew == -1) + cur_playnew = 1; + SWALLOW_LINE(fp); + } + + /* If we're searching, skip to the next "tracks" line. */ + else if (((searching & 1)|| scan) + && !(prefs && firstpos == -1)) + SWALLOW_LINE(fp) + + else if (! strcmp(keyword, "sections")) + { + gotsections = 1; + fscanf(fp, "%d", &ntracks); + + free(trackmap); + trackmap = (int *) malloc(sizeof(int) * + (cur_ntracks + ntracks)); + if (trackmap == NULL) + { + perror("section mapping"); + exit(1); + } + + /* + * If sections are already defined, use these as a + * reference, mapping this CD entry's section numbers + * to the ones in core. + * + * Otherwise, split the CD up according to the sections + * listed here. + */ + if (cur_nsections) + { + track = 0; + i = 0; + while (ntracks) + { + ntracks--; + fscanf(fp, "%d", &scratch); + while (scratch > cd->trk[track].start) + { + if (cd->trk[track].section < 2) + trackmap[i++] = track; + ++track; + + if (track == cur_ntracks) + break; + } + + /* rc has later sections than db... */ + if (track == cur_ntracks) + break; + + /* Matches can be approximate */ + if (scratch+75 > cd->trk[track].start && + scratch-75 < cd->trk[track].start) + trackmap[i++] = track++; + else + trackmap[i++] = -1; + + if (track == cur_ntracks) + break; + } + + /* This only happens if track == cur_ntracks */ + while (ntracks--) + trackmap[i++] = -1; + + while (track < cur_ntracks) + { + if (cd->trk[track].section < 2) + trackmap[i++] = track; + track++; + } + + track = 0; + SWALLOW_LINE(fp); + } + else + { + while (ntracks--) + { + fscanf(fp, "%d", &scratch); + split_trackinfo(scratch); + } + + for (i = 0; i < cur_ntracks; i++) + { + trackmap[i] = i; + /* split_trackinfo() sets this */ + cd->trk[i].contd = 0; + } + + SWALLOW_LINE(fp); + } + } + + else if (! strcmp(keyword, "track")) + { + char buf[502]; + + getc(fp); /* lose the space */ + + /* don't overwrite existing track names. */ + /* However, overwrite them if there was a "bad" fuzzy match before */ + if ((trackmap[track] == -1 || track > (cd->ntracks + cur_nsections)) && (searching == 2)) + SWALLOW_LINE(fp) + else if (cd->trk[trackmap[track]].songname && + cd->trk[trackmap[track]].songname[0]) + do + i = getc(fp); + while (i != '\n' && i != EOF); + else + { + fgets(buf, sizeof(buf), fp); + wm_lib_message(WM_MSG_CLASS_DB|WM_MSG_LEVEL_DEBUG, "found track %s\n", buf); + if( (i = strlen(buf)) ) + buf[i - 1] = '\0'; + wm_strmcpy(&cd->trk[trackmap[track]].songname, buf); + } + track++; + } + + else if (! strcmp(keyword, "playmode")) + fscanf(fp, "%d", &cd->playmode); + + else if (! strcmp(keyword, "autoplay")) + cd->autoplay = 1; + + else if (! strcmp(keyword, "cdname")) + { + /* because of fuzzy matching that may change + the disk contents, we reset everything when + we find the name, in hopes that we will recover + most, if not all, of the information from the + file. */ +/* + * nasty bug was here. Was it? BUGBUGBUG + * + * wipe_cdinfo(); + * trackmap = reset_tracks(); + */ + + getc(fp); /* lose the space */ + /* don't overwrite existing cd name. */ + if (cd->cdname[0] && (searching == 2)) + do + i = getc(fp); + while (i != '\n' && i != EOF); + else + { + if (searching > 1) + { + strcpy(cd->cdname, "Probably://"); + fgets(cd->cdname + strlen(cd->cdname), sizeof(cd->cdname), fp); + } + else + { + fgets(cd->cdname, sizeof(cd->cdname), fp); + } + if ( (i = strlen(cd->cdname)) ) + cd->cdname[i - 1] = '\0'; + } + } + + else if (! strcmp(keyword, "artist")) + { + getc(fp); /* lose the space */ + /* don't overwrite existing artist names. */ + if (cd->artist[0]) + do + i = getc(fp); + while (i != '\n' && i != EOF); + else + { + fgets(cd->artist, sizeof(cd->artist), fp); + if( (i = strlen(cd->artist)) ) + cd->artist[i - 1] = '\0'; + } + } + + else if (! strcmp(keyword, "cdvolume")) + { + fscanf(fp, "%d", &cd->volume); + cd->volume = (cd->volume * 100) / 32; + } + + else if (! strcmp(keyword, "dontplay")) + { + fscanf(fp, "%d", &i); + if (trackmap[i - 1] != -1) + cd->trk[trackmap[i - 1]].avoid = 1; + } + + else if (! strcmp(keyword, "continue")) + { + if (trackmap[track - 1] != -1) + cd->trk[trackmap[track - 1]].contd = 1; + } + + else if (! strcmp(keyword, "volume")) + { + fscanf(fp, "%d", &i); + if (trackmap[i - 1] == -1) + SWALLOW_LINE(fp) + else + { + i = trackmap[i - 1]; + fscanf(fp, "%d", &cd->trk[i].volume); + cd->trk[i].volume = (cd->trk[i].volume*100)/32; + if (cd->trk[i].volume > 32) + cd->trk[i].volume = 0; + } + } + + else if (! strcmp(keyword, "playlist")) + { + getc(fp); + fscanf(fp, "%63s", listname); + +/* XXX take this out at some point */ + if (! strcmp(listname, "Default")) + strcpy(listname, "List A"); + + for (i = 0; listname[i]; i++) + if (listname[i] == '_') + listname[i] = ' '; + + l = new_playlist(cd, listname); + if (l == NULL) + { +plnomem: + perror("playlist read"); + exit(1); + } + + fscanf(fp, "%d", &listsize); + + l->list = malloc(sizeof(int) * (listsize + 1)); + if (l->list == NULL) + goto plnomem; + + /* Leave out tracks that weren't in .workmandb. */ + j = 0; + for (i = 0; i < listsize; i++) + { + fscanf(fp, "%d", &scratch); + scratch = trackmap[scratch - 1]; + if (scratch != -1) + l->list[j++] = scratch + 1; + } + + l->list[j] = 0; + } + + else if (! strcmp(keyword, "mark")) + { + int mark_val = -1, mark_namelen; + char mark_name[32]; + + fscanf(fp, "%d", &mark_val); + if (mark_val == -1) + goto chomp; + + if (getc(fp) != ' ') + continue; + + fgets(mark_name, sizeof(mark_name), fp); + if( ( mark_namelen = strlen(mark_name)) ) + mark_name[mark_namelen - 1] = '\0'; + +/* + if (! strcmp(mark_name, "START")) + set_abtimer(0, mark_val); + else if (! strcmp(mark_name, "END")) + set_abtimer(1, mark_val); + +*/ + } + + /* Unrecognized keyword. Put it in the right place. */ + else + { + char **buf, input[BUFSIZ]; + + if (track && trackmap[track - 1] == -1) + { + SWALLOW_LINE(fp); + continue; + } + + i = track ? trackmap[track - 1] : 0; + buf = prefs ? i ? &cd->trk[i].otherrc : &cd->otherrc : + i ? &cd->trk[i].otherdb : &cd->otherdb; + if (firstpos == -1) { + if (prefs) { + buf = &otherrc; + } else { + goto chomp; + } /* if() else */ + } /* if() */ + wm_strmcat(buf, keyword); + do { + input[sizeof(input) - 1] = 'x'; + fgets(input, sizeof(input), fp); + wm_strmcat(buf, input); + } while (input[sizeof(input) - 1] != 'x'); + } + } + + if (rclen == 0 && !searching) + rclen = pos - rcpos; + + if (searching > 1) /* A near match has been found. Good enough. */ + searching = 0; + + cddb_struct2cur(); + return (! searching); + +} /* search_db() */ + +/* + * Delay some amount of time without using interval timers. + */ +void +spinwheels(int secs) { + struct timeval tv; + + tv.tv_usec = 0; + tv.tv_sec = secs; + select(0, NULL, NULL, NULL, &tv); +} /* spinwheels() */ + +/* + * lockit(fd, type) + * + * fd file descriptor + * type lock type + * + * Lock a file. Time out after a little while if we can't get a lock; + * this usually means the locking system is broken. + * + * Unfortunately, if there are lots of people contending for a lock, + * this can result in the file not getting locked when it probably should. + */ +int +lockit(int fd, int type) +{ + struct flock fl; + int result, timer = 0; + + if (suppress_locking) + return (0); + + fl.l_type = type; + fl.l_whence = 0; + fl.l_start = 0; + fl.l_len = 0; + + while ((result = fcntl(fd, F_SETLK, &fl)) < 0) + { + if (errno != EACCES || errno != EAGAIN) + break; + if (timer++ == 30) + { + errno = ETIMEDOUT; + break; + } + + spinwheels(1); + } + + return (result); +} /* lockit() */ + +/* + * Search all the database files and our personal preference file for + * more information about the current CD. + */ +void +load( void ) +{ + FILE *fp; + char **dbfile; + int locked = 0; + int dbfound = 0, *trklist, i; + unsigned long dbpos; + +/* This is some kind of profiling code. I don't change it + to wm_lib_message() for now... */ +#ifndef NDEBUG + long t1, t2; + if( getenv( "WORKMAN_DEBUG" ) != NULL ) + { + time(&t1); + printf("%s (%d): search start = %ld\n", __FILE__, __LINE__, t1); + fflush(stdout); + } +#endif + + dbfile = databases; + + found_in_db = 0; + + /* Turn the cd->trk array into a simple array of ints. */ + trklist = (int *)malloc(sizeof(int) * cd->ntracks); + for (i = 0; i < cd->ntracks; i++) + trklist[i] = cd->trk[i].start; + + do { + if (*dbfile && idx_find_entry(*dbfile, cd->ntracks, trklist, + cd->length * 75, 0, &dbpos) == 0) + dbfound = 1; + + fp = *dbfile ? open_rcfile(*dbfile, "r") : NULL; + if (fp != NULL) + { + if (lockit(fileno(fp), F_RDLCK)) + perror("Couldn't get read (db) lock"); + else + locked = 1; + + if (dbfound) + fseek(fp, dbpos, 0); + + if (search_db(fp, 0, 0, 0)) + { + found_in_db = 1; + cd->whichdb = *dbfile; + } + + if (locked && lockit(fileno(fp), F_UNLCK)) + perror("Couldn't relinquish (db) lock"); + + fclose(fp); + } + } while (*++dbfile != NULL && cd->whichdb == NULL); + +#ifndef NDEBUG + if( getenv( "WORKMAN_DEBUG" ) != NULL ) + { + time(&t2); + printf("%s (%d): db search end = %ld, elapsed = %ld\n", __FILE__, __LINE__, t2, t2 - t1); + fflush(stdout); + } +#endif + + fp = rcfile ? open_rcfile(rcfile, "r") : NULL; + if (fp != NULL) + { + locked = 0; + if (lockit(fileno(fp), F_RDLCK)) + perror("Couldn't get read (rc) lock"); + else + locked = 1; + + rcpos = 0; + found_in_rc = search_db(fp, 1, 0, 0); + if (! found_in_rc) + cd->autoplay = wm_db_get_playnew(); + + if (locked && lockit(fileno(fp), F_UNLCK)) + perror("Couldn't relinquish (rc) lock"); + + fclose(fp); + } + + free(trklist); + + if (cur_playnew == -1) + cur_playnew = 0; + +#ifndef NDEBUG + if( getenv( "WORKMAN_DEBUG" ) != NULL ) + { + time(&t2); + printf("%s (%d): search end = %ld, elapsed = %ld\n", __FILE__, __LINE__, t2, t2 - t1); + fflush(stdout); + } +#endif +} /* load() */ + +/* + * Load program settings from the rcfile. + */ +void +load_settings( void ) +{ + FILE *fp; + int locked; + + fp = rcfile ? open_rcfile(rcfile, "r") : NULL; + if (fp != NULL) + { + locked = 0; + if (lockit(fileno(fp), F_RDLCK)) + perror("Couldn't get read (rc) lock"); + else + locked = 1; + + rcpos = 0; + found_in_rc = search_db(fp, 2, 0, 0); + if (! found_in_rc) + cd->autoplay = wm_db_get_playnew(); + + if (locked && lockit(fileno(fp), F_UNLCK)) + perror("Couldn't relinquish (rc) lock"); + + fclose(fp); + } +} /* load_settings() */ + +/* + * save_globals() + * + * Save the global preferences, scooting CD entries to the end if needed. + * The assumption here is that the rcfile is locked, and that firstpos has + * been set by a previous scan. + */ +void +save_globals(FILE *fp) +{ + char *globes = NULL, *cdentry = NULL, temp[100]; + long curpos; + int globesize, hit_cdent = 0, c = 0; + + if (otherrc) + wm_strmcpy(&globes, otherrc); + + if (cddb.protocol) + { + sprintf(temp, "cddbprotocol "); + switch(cddb.protocol) + { + case 1: /* cddbp */ + sprintf(temp + strlen(temp), "cddbp\n"); + break; + case 2: /* http */ + sprintf(temp + strlen(temp), "http\n"); + break; + case 3: /* proxy */ + sprintf(temp + strlen(temp), "proxy\n"); + break; + default: + break; + } + wm_strmcat(&globes, temp); + + if(cddb.mail_adress[0]) + { + sprintf(temp,"cddbmailadress %s\n", + cddb.mail_adress); + wm_strmcat(&globes, temp); + } + + if(cddb.cddb_server[0]) + { + sprintf(temp,"cddbserver %s\n", + cddb.cddb_server); + wm_strmcat(&globes, temp); + } + + if(cddb.path_to_cgi[0]) + { + sprintf(temp,"cddbpathtocgi %s\n", + cddb.mail_adress); + wm_strmcat(&globes, temp); + } + + if(cddb.proxy_server[0]) + { + sprintf(temp,"cddbproxy %s\n", + cddb.mail_adress); + wm_strmcat(&globes, temp); + } + } + + if (cur_stopmode == 1 || cur_stopmode == 2) + { + sprintf(temp, "whendone %s\n", cur_stopmode == 1 ? "repeat" : + "eject"); + wm_strmcat(&globes, temp); + } + + if (cur_playnew == 1) + wm_strmcat(&globes, "playnew\n"); + + curpos = firstpos; + if (curpos < 0) + curpos = 0; + + fseek(fp, curpos, SEEK_SET); + + if (firstpos < (globesize = globes != NULL ? strlen(globes) : 0)) + { + while (1) + { + temp[sizeof(temp)-1] = 'x'; + + if (fgets(temp, sizeof(temp), fp) == NULL) + { + fseek(fp, 0, SEEK_SET); + if (globes != NULL) + { + fwrite(globes, globesize, 1, fp); + free(globes); + } + if (cdentry != NULL) + { + fwrite(cdentry, strlen(cdentry), 1, fp); + free(cdentry); + } + return; + } + + if (! strncmp(temp, "tracks ", 7)) + { + hit_cdent = 1; + if (curpos >= globesize) + break; + } + + if (! hit_cdent) + { + curpos += strlen(temp); + if (temp[sizeof(temp)-1] == '\0') + while ((c = getc(fp)) != '\n' && + c != EOF) + curpos++; + if (c == '\n') + curpos++; + + continue; + } + + wm_strmcat(&cdentry, temp); + curpos += strlen(temp); + while (temp[sizeof(temp)-1] == '\0') + { + temp[sizeof(temp)-1] = 'x'; + if (fgets(temp, sizeof(temp), fp) == NULL) + break; + wm_strmcat(&cdentry, temp); + curpos += strlen(temp); + } + } + + if (cdentry != NULL) + { + fseek(fp, 0, SEEK_END); + fwrite(cdentry, strlen(cdentry), 1, fp); + free(cdentry); + } + } + + if (globes != NULL) + { + fseek(fp, 0, SEEK_SET); + fwrite(globes, globesize, 1, fp); + free(globes); + } + + while (globesize++ < curpos) + putc('\n', fp); +} /* save_globals() */ + +/* + * save_entry() + * + * Save the CD information to one database. + * + * filename Database to save to. + * pref 0 for hard data, 1 for preferences. + * + * If an entry for this CD exists already, overwrite it with the new entry + * if the new entry is the same size or smaller, or with newlines if the new + * entry is larger (in which case the new entry is appended to the file.) + * + * Also, if the preference information is being updated, save it to the + * file while we've got it locked. Scoot stuff from the beginning of + * the file to the end as needed to facilitate this. + * + * XXX Preference-saving should probably be done elsewhere, like in an + * Apply button on the Goodies popup, and in any case needs to go to a + * different file (.Xdefaults?) + * + * Returns 0 on success. + */ +int +save_entry(char *filename, int pref) +{ + FILE *fp; + char *buf; + int len, i, locked = 0; + + + if( filename == NULL ) + return (-1); + + fp = open_rcfile(filename, "r+"); + if (fp == NULL) + { + if (errno == ENOENT) /* doesn't exist already */ + fp = open_rcfile(filename, "w"); + if (fp == NULL) + return (-1); + } + + if (lockit(fileno(fp), F_WRLCK)) + perror("Warning: Couldn't get write lock"); + else + locked = 1; + + buf = print_cdinfo(cd, pref); + len = strlen(buf); /* doesn't return if there's an error */ + + rcpos = -1; + search_db(fp, pref, 1, len); + if (rcpos != -1) /* XXX */ + { + /* + * Jump to the entry's position in the database file, if + * it was found. + */ + fseek(fp, rcpos, SEEK_SET); + + if (rclen >= len && holepos == -1) + { + /* + * If the new entry will fit in the space occupied by + * the old one, overwrite the old one and make a hole + * of the appropriate size at its end. + * + * No need to update the index file in this case, as + * the entry's position hasn't changed. + */ + fputs(buf, fp); + for (i = len; i < rclen; i++) + fputc('\n', fp); + } + else + { + /* + * Overwrite the old entry with a hole and delete + * its pointer in the index file. + */ + for (i = 0; i < rclen; i++) + fputc('\n', fp); + idx_delete_entry(filename, cd->trk[cd->ntracks-1].start, + 0, rcpos); + + rcpos = -1; + } + } + + /* + * Old entry wasn't found, or its new version wouldn't fit where + * the old one was. + */ + if (rcpos == -1) + { + /* + * Write the new entry in a hole, if there is one, + * or at the end of the file. + */ + if (holepos >= 0) + { + fseek(fp, holepos, SEEK_SET); + if (holepos < firstpos) + firstpos = holepos; + } + else + { + fseek(fp, 0, SEEK_END); + holepos = ftell(fp); + } + fputs(buf, fp); + + /* + * Write a new index entry for this CD. + */ + idx_write_entry(filename, cd->trk[cd->ntracks - 1].start, + holepos); + } + + if (pref) + save_globals(fp); + + fflush(fp); + + if (locked && lockit(fileno(fp), F_UNLCK)) + perror("Warning: Couldn't relinquish write lock"); + + fclose(fp); + + return (0); +} /* save_entry() */ + +/* + * save() + * + * Save CD information to the appropriate datafile (the first file in the + * list, unless the entry came from another database file) and to the + * personal prefs file. + */ +int +save( void ) +{ + + if( wm_db_save_disabled == FALSE ) + { + if (save_entry(rcfile, 1)) + return (0); + + if (cd->whichdb == NULL || access(cd->whichdb, W_OK)) + cd->whichdb = databases[0]; + + if (save_entry(cd->whichdb, 0)) + return (0); + + return( WM_DB_SAVE_ERROR ); + } else { + return( WM_DB_SAVE_DISABLED ); + } +} /* save() */ diff --git a/kscd/libwm/drv_sony.c b/kscd/libwm/drv_sony.c new file mode 100644 index 00000000..a9db5d73 --- /dev/null +++ b/kscd/libwm/drv_sony.c @@ -0,0 +1,166 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * Vendor-specific drive control routines for Sony CDU-8012 series. + */ + +#include <stdio.h> +#include <errno.h> +#include "include/wm_config.h" +#include "include/wm_struct.h" +#include "include/wm_scsi.h" + +#define PAGE_AUDIO 0x0e + +/* local prototypes */ +static int sony_init( struct wm_drive *d ); +static int sony_set_volume(struct wm_drive *d, int left, int right ); +static int sony_get_volume( struct wm_drive *d, int *left, int *right ); + + +extern int min_volume, max_volume; + +struct wm_drive_proto sony_proto = { + sony_init, /* functions... */ + gen_close, + gen_get_trackcount, + gen_get_cdlen, + gen_get_trackinfo, + gen_get_drive_status, + sony_get_volume, + sony_set_volume, + gen_pause, + gen_resume, + gen_stop, + gen_play, + gen_eject, + gen_closetray, + NULL /* gen_get_cdtext */ +}; + +/* + * Initialize the driver. + */ +static int sony_init( struct wm_drive *d ) { + +/* Sun use Sony drives as well */ +#if defined(SYSV) && defined(CODEC) + codec_init(); +#endif + min_volume = 128; + max_volume = 255; + return( 0 ); +} /* sony_init() */ + +/* + * On the Sony CDU-8012 drive, the amount of sound coming out the jack + * increases much faster toward the top end of the volume scale than it + * does at the bottom. To make up for this, we make the volume scale look + * sort of logarithmic (actually an upside-down inverse square curve) so + * that the volume value passed to the drive changes less and less as you + * approach the maximum slider setting. Additionally, only the top half + * of the volume scale is valid; the bottom half is all silent. The actual + * formula looks like + * + * max^2 - (max - vol)^2 max + * v = --------------------- + --- + * max * 2 2 + * + * Where "max" is the maximum value of the volume scale, usually 100. + */ +static int +scale_volume(vol, max) + int vol, max; +{ + vol = (max*max - (max - vol) * (max - vol)) / max; + return ((vol + max) / 2); +} + +/* + * Given a value between min_volume and max_volume, return the standard-scale + * volume value needed to achieve that hardware value. + * + * Rather than perform floating-point calculations to reverse the above + * formula, we simply do a binary search of scale_volume()'s return values. + */ +static int +unscale_volume(cd_vol, max) + int cd_vol, max; +{ + int vol = 0, top = max, bot = 0, scaled = 0; + + cd_vol = (cd_vol * 100 + (max_volume - 1)) / max_volume; + + while (bot <= top) + { + vol = (top + bot) / 2; + scaled = scale_volume(vol, max); + if (cd_vol <= scaled) + top = vol - 1; + else + bot = vol + 1; + } + + /* Might have looked down too far for repeated scaled values */ + if (cd_vol < scaled) + vol++; + + if (vol < 0) + vol = 0; + else if (vol > max) + vol = max; + + return (vol); +} + +/* + * Get the volume. Sun's CD-ROM driver doesn't support this operation, even + * though their drive does. Dumb. + */ +static int +sony_get_volume( struct wm_drive *d, int *left, int *right ) +{ + unsigned char mode[16]; + + /* Get the current audio parameters first. */ + if (wm_scsi_mode_sense(d, PAGE_AUDIO, mode)) + return (-1); + + *left = unscale_volume(mode[9], 100); + *right = unscale_volume(mode[11], 100); + + return (0); +} + +/* + * Set the volume using the wacky scale outlined above. The Sony drive + * responds to the standard set-volume command. + */ +static int +sony_set_volume(struct wm_drive *d, int left, int right ) +{ + left = scale_volume(left, 100); + right = scale_volume(right, 100); + return (gen_set_volume(d, left, right)); +} diff --git a/kscd/libwm/drv_toshiba.c b/kscd/libwm/drv_toshiba.c new file mode 100644 index 00000000..ef009867 --- /dev/null +++ b/kscd/libwm/drv_toshiba.c @@ -0,0 +1,149 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * Vendor-specific drive control routines for Toshiba XM-3401 series. + */ + +static char drv_toshiba_id[] = "$Id$"; + +#include <stdio.h> +#include <errno.h> +#include "include/wm_config.h" +#include "include/wm_struct.h" +#include "include/wm_scsi.h" + +#define SCMD_TOSH_EJECT 0xc4 + +/* local prototypes */ +static int tosh_init( struct wm_drive *d ); +static int tosh_eject( struct wm_drive *d ); +static int tosh_set_volume( struct wm_drive *d, int left, int right ); +static int tosh_get_volume( struct wm_drive *d, int *left, int *right ); + +struct wm_drive_proto toshiba_proto = { + tosh_init, /* functions... */ + gen_close, + gen_get_trackcount, + gen_get_cdlen, + gen_get_trackinfo, + gen_get_drive_status, + tosh_get_volume, + tosh_set_volume, + gen_pause, + gen_resume, + gen_stop, + gen_play, + tosh_eject, + gen_closetray, + NULL /* gen_get_cdtext */ +}; + +/* + * Initialize the driver. + */ +static int +tosh_init( struct wm_drive *d ) +{ + extern int min_volume; + +/* Sun use Toshiba drives as well */ +#if defined(SYSV) && defined(CODEC) + codec_init(); +#endif + min_volume = 0; + return ( 0 ); +} + +/* + * Send the Toshiba code to eject the CD. + */ +static int +tosh_eject( struct wm_drive *d ) +{ + return (sendscsi(d, NULL, 0, 0, SCMD_TOSH_EJECT, 1, 0,0,0,0,0,0,0,0,0,0)); +} + +/* + * Set the volume. The low end of the scale is more sensitive than the high + * end, so make up for that by transforming the volume parameters to a square + * curve. + */ +static int +tosh_set_volume( struct wm_drive *d, int left, int right ) +{ + left = (left * left * left) / 10000; + right = (right * right * right) / 10000; + return (gen_set_volume(d, left, right)); +} + +/* + * Undo the transformation above using a binary search (so no floating-point + * math is required.) + */ +static int +unscale_volume(cd_vol, max) + int cd_vol, max; +{ + int vol = 0, top = max, bot = 0, scaled = 0; + + /*cd_vol = (cd_vol * 100 + (max_volume - 1)) / max_volume;*/ + + while (bot <= top) + { + vol = (top + bot) / 2; + scaled = (vol * vol) / max; + if (cd_vol <= scaled) + top = vol - 1; + else + bot = vol + 1; + } + + /* Might have looked down too far for repeated scaled values */ + if (cd_vol < scaled) + vol++; + + if (vol < 0) + vol = 0; + else if (vol > max) + vol = max; + + return (vol); +} + +/* + * Get the volume. + */ +static int +tosh_get_volume( struct wm_drive *d, int *left, int *right ) +{ + int status; + + status = gen_get_volume(d, left, right); + if (status < 0) + return (status); + *left = unscale_volume(*left, 100); + *right = unscale_volume(*right, 100); + + return (0); +} diff --git a/kscd/libwm/include/wm_cdda.h b/kscd/libwm/include/wm_cdda.h new file mode 100644 index 00000000..11c8eb3e --- /dev/null +++ b/kscd/libwm/include/wm_cdda.h @@ -0,0 +1,203 @@ +#ifndef WM_CDDA_H +#define WM_CDDA_H +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* + * Information about a particular block of CDDA data. + */ +struct cdda_block { + unsigned char status; + unsigned char track; + unsigned char index; + unsigned char reserved; + + int frame; + char *buf; + long buflen; +}; + +struct cdda_device { + int fd; + const char *devname; + + unsigned char status; + unsigned char track; + unsigned char index; + unsigned char command; + + int frame; + int frames_at_once; + + /* Average volume levels, for level meters */ + unsigned char lev_chan0; + unsigned char lev_chan1; + + /* Current volume setting (0-255) */ + unsigned char volume; + + /* Current balance setting (0-255, 128 = balanced) */ + unsigned char balance; + + struct cdda_block *blocks; + int numblocks; +}; + +#include "wm_cdrom.h" +#include "wm_config.h" +#include "wm_struct.h" +/* + * cdda_block status codes. + */ + +/* + * Enable or disable CDDA building depending on platform capabilities, and + * determine endianness based on architecture. (Gross!) + * + * For header-comfort, the macros LITTLE_ENDIAN and BIG_ENDIAN had to be + * renamed. At least Linux does have bytesex.h and endian.h for easy + * byte-order examination. + */ + +#ifdef HAVE_MACHINE_ENDIAN_H + #include <machine/endian.h> + #if BYTE_ORDER == LITTLE_ENDIAN + #define WM_LITTLE_ENDIAN 1 + #define WM_BIG_ENDIAN 0 + #else + #define WM_LITTLE_ENDIAN 0 + #define WM_BIG_ENDIAN 1 + #endif +#elif defined(__sun) || defined(sun) +# ifdef SYSV +# include <sys/types.h> +# include <sys/cdio.h> +# ifndef CDROMCDDA +# undef BUILD_CDDA +# endif +# ifdef i386 +# define WM_LITTLE_ENDIAN 1 +# define WM_BIG_ENDIAN 0 +# else +# define WM_BIG_ENDIAN 1 +# define WM_LITTLE_ENDIAN 0 +# endif +# else +# undef BUILD_CDDA +# endif + +/* Linux only allows definition of endianness, because there's no + * standard interface for CDROM CDDA functions that aren't available + * if there is no support. + */ +#elif defined(__linux__) +/*# include <bytesex.h>*/ +# include <endian.h> +/* + * XXX could this be a problem? The results are only 0 and 1 because + * of the ! operator. How about other linux compilers than gcc ? + */ +# define WM_LITTLE_ENDIAN !(__BYTE_ORDER - __LITTLE_ENDIAN) +# define WM_BIG_ENDIAN !(__BYTE_ORDER - __BIG_ENDIAN) +#elif defined WORDS_BIGENDIAN + #define WM_LITTLE_ENDIAN 0 + #define WM_BIG_ENDIAN 1 +#else + #define WM_LITTLE_ENDIAN 1 + #define WM_BIG_ENDIAN 0 +#endif + +/* + * The following code shouldn't take effect now. + * In 1998, the WorkMan platforms don't support __PDP_ENDIAN + * architectures. + * + */ + +#if !defined(WM_LITTLE_ENDIAN) +# if !defined(WM_BIG_ENDIAN) +# error yet unsupported architecture + foo bar this is to stop the compiler. +# endif +#endif + +#if defined(BUILD_CDDA) +/* + * The following code support us by optimize cdda operations + */ +#define CDDARETURN(x) if(x && x->cdda == 1) return +#define IFCDDA(x) if(x && x->cdda == 1) +int cdda_get_drive_status(struct wm_drive *d, int oldmode, + int *mode, int *pos, int *track, int *ind); +int cdda_play(struct wm_drive *d, int start, int end, int realstart); +int cdda_pause(struct wm_drive *d); +int cdda_stop(struct wm_drive *d); +int cdda_eject(struct wm_drive *d); +int cdda_set_volume(struct wm_drive *d, int left, int right); +int cdda_get_volume(struct wm_drive *d, int *left, int *right); +void cdda_kill(struct wm_drive *d); +void cdda_save(struct wm_drive *d, char *filename); +int cdda_get_ack(int); +int gen_cdda_init(struct wm_drive *d ); + +void cdda_set_direction(struct wm_drive *d, int newdir); +void cdda_set_speed(struct wm_drive *d, int speed); +void cdda_set_loudness(struct wm_drive *d, int loud); + + +int wmcdda_init(struct cdda_device*); +int wmcdda_open(const char*); +int wmcdda_close(struct cdda_device*); +int wmcdda_setup(int start, int end, int realstart); +long wmcdda_read(struct cdda_device*, struct cdda_block *block); +void wmcdda_speed(int speed); +void wmcdda_direction(int newdir); + +#else + #define CDDARETURN(x) + #define IFCDDA(x) + #define cdda_get_drive_status + #define cdda_play + #define cdda_pause + #define cdda_resume + #define cdda_stop + #define cdda_eject + #define cdda_set_volume + #define cdda_get_volume + #define cdda_kill + #define cdda_save + #define cdda_get_ack +#endif /* defined(BUILD_CDDA) */ + +#include <stdio.h> + +#ifdef DEBUG + #define DEBUGLOG(fmt, args...) fprintf(stderr, fmt, ##args) +#else + #define DEBUGLOG(fmt, args...) +#endif +#define ERRORLOG(fmt, args...) fprintf(stderr, fmt, ##args) + +#endif /* WM_CDDA_H */ diff --git a/kscd/libwm/include/wm_cddb.h b/kscd/libwm/include/wm_cddb.h new file mode 100644 index 00000000..26a0c2d9 --- /dev/null +++ b/kscd/libwm/include/wm_cddb.h @@ -0,0 +1,36 @@ +#ifndef WM_CDDB_H +#define WM_CDDB_H +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +unsigned long cddb_discid(void); +void cddb_struct2cur(void); +void cddb_cur2struct(void); +void cddb_select(void); +void connect_cddb(void); +void update_cddbserver(void); +void cddb_request(void); + +#endif /* WM_CDDB_H */ diff --git a/kscd/libwm/include/wm_cdinfo.h b/kscd/libwm/include/wm_cdinfo.h new file mode 100644 index 00000000..dbb8e949 --- /dev/null +++ b/kscd/libwm/include/wm_cdinfo.h @@ -0,0 +1,76 @@ +#ifndef WM_CDINFO_H +#define WM_CDINFO_H +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Prototypes from cdinfo.c + * + * This is just one more step to a more modular and understandable code. + */ + +#include "wm_struct.h" +extern char *cur_trackname; /* Take a guess */ +extern int cur_index; /* Current index mark */ +extern int cur_frame; /* Current frame number */ +extern struct wm_play *playlist; /* = NULL */ + +/*extern int cur_track;*/ /* Current track number, starting at 1 */ +extern char *cur_artist; /* Name of current CD's artist */ +extern char cur_avoid; /* Avoid flag */ +extern char cur_contd; /* Continued flag */ +extern char *cur_cdname; /* Album name */ +extern int cur_nsections; /* Number of sections currently defined */ +extern int exit_on_eject; +extern int cur_pos_abs; +extern int cur_pos_rel; +extern int cur_cdlen; + +extern int cur_ntracks; +extern int cur_lasttrack; +extern int cur_firsttrack; +extern int cur_listno; +extern int cur_stopmode; + +void wipe_cdinfo( void ); +void play_next_entry( int forward ); +void make_playlist( int playmode, int starttrack ); +int get_autoplay( void ); +int get_playmode( void ); +void pl_find_track( int track ); +void play_prev_track( int forward ); +void play_next_track( int forward ); +int tracklen( int num ); +int get_default_volume( int track ); +int split_trackinfo( int pos ); +int remove_trackinfo( int num ); +void freeup( char **x ); +int get_runtime( void ); +const char *trackname( int num ); +void stash_cdinfo( char *artist, char *cdname, int autoplay, int playmode ); +void stash_trkinfo( int track, char *songname, int contd, int avoid ); +int get_avoid( int num ); +int get_contd( int num ); +void default_volume( int track, int vol ); +char *listentry( int num ); + +#endif /* WM_CDINFO_H */ diff --git a/kscd/libwm/include/wm_cdrom.h b/kscd/libwm/include/wm_cdrom.h new file mode 100644 index 00000000..d38f8b68 --- /dev/null +++ b/kscd/libwm/include/wm_cdrom.h @@ -0,0 +1,114 @@ +#ifndef WM_CDROM_H +#define WM_CDROM_H +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Prototypes from cdrom.c + * + * This is just one more step to a more modular and understandable code. + */ +#define WM_CDS_NO_DISC(status) (status == WM_CDM_UNKNOWN ||\ + status == WM_CDM_EJECTED ||\ + status == WM_CDM_NO_DISC) + +#define WM_CDS_DISC_READY(status)(status == WM_CDM_TRACK_DONE ||\ + status == WM_CDM_PLAYING ||\ + status == WM_CDM_FORWARD ||\ + status == WM_CDM_PAUSED ||\ + status == WM_CDM_STOPPED) + +#define WM_CDS_DISC_PLAYING(status)(status == WM_CDM_TRACK_DONE ||\ + status == WM_CDM_PLAYING ||\ + status == WM_CDM_FORWARD ||\ + status == WM_CDM_PAUSED) +#define WM_CDM_BACK 1 +#define WM_CDM_TRACK_DONE 1 +#define WM_CDM_PLAYING 2 +#define WM_CDM_FORWARD 3 +#define WM_CDM_PAUSED 4 +#define WM_CDM_STOPPED 5 +#define WM_CDM_EJECTED 6 +#define WM_CDM_DEVICECHANGED 9 /* deprecated */ +#define WM_CDM_NO_DISC 10 +#define WM_CDM_UNKNOWN 11 +#define WM_CDM_CDDAERROR 12 +#define WM_CDM_CDDAACK 0xF0 + +#define WM_CDIN 0 +#define WM_CDDA 1 + +#define WM_ENDTRACK 0 + +#define WM_BALANCE_SYMMETRED 0 +#define WM_BALANCE_ALL_LEFTS -10 +#define WM_BALANCE_ALL_RIGHTS 10 + +#define WM_VOLUME_MUTE 0 +#define WM_VOLUME_MAXIMAL 100 + +int wm_cd_init( int cdin, const char *cd_device, const char *soundsystem, + const char *sounddevice, const char *ctldevice ); +int wm_cd_destroy( void ); + +int wm_cd_status( void ); + +int wm_cd_getcurtrack( void ); +int wm_cd_getcurtracklen( void ); +int wm_cd_getcountoftracks( void ); + +int wm_cd_gettracklen( int track ); + +int wm_cd_play( int start, int pos, int end ); +int wm_cd_play_chunk( int start, int end, int realstart ); +int wm_cd_play_from_pos( int pos ); +int wm_cd_pause( void ); +int wm_cd_stop( void ); +int wm_cd_eject( void ); +int wm_cd_closetray( void ); + +int wm_find_trkind( int, int, int ); + +/* + * for vaild values see wm_helpers.h + */ +int wm_cd_set_verbosity( int ); + +const char * wm_drive_vendor( void ); +const char * wm_drive_model( void ); +const char * wm_drive_revision( void ); +const char * wm_drive_device( void ); + +/* + * volume is valid WM_VOLUME_MUTE <= vol <= WM_VOLUME_MAXIMAL, + * balance is valid WM_BALANCE_ALL_LEFTS <= balance <= WM_BALANCE_ALL_RIGHTS + */ +int wm_cd_volume( int volume, int balance); + +/* + * please notice, that more OSs don't allow to read balance and volume + * in this case you get -1 for volume and WM_BALANCE_SYMMETRED for balance + */ +int wm_cd_getvolume( void ); +int wm_cd_getbalance( void ); + +#endif /* WM_CDROM_H */ diff --git a/kscd/libwm/include/wm_cdtext.h b/kscd/libwm/include/wm_cdtext.h new file mode 100644 index 00000000..e843ee95 --- /dev/null +++ b/kscd/libwm/include/wm_cdtext.h @@ -0,0 +1,105 @@ +#ifndef WM_CDTEXT_H +#define WM_CDTEXT_H + +/*************************************************************************** + wm_cdtext.h - description + ------------------- + begin : Mon Feb 12 2001 + copyright : (C) 2001 by Alex Kern + email : alex.kern@gmx.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ + +/* + * cdtext base structure and defines + */ + +#define MAX_LENGHT_OF_CDTEXT_STRING 162 /* max 160 bytes + 2 * 0x00 by UNICODES */ +#define DATAFIELD_LENGHT_IN_PACK 12 +#define MAX_LANGUAGE_BLOCKS 8 + +struct cdtext_pack_data_header { + unsigned char header_field_id1_typ_of_pack; + unsigned char header_field_id2_tracknumber; + unsigned char header_field_id3_sequence; + unsigned char header_field_id4_block_no; + unsigned char text_data_field[DATAFIELD_LENGHT_IN_PACK]; + unsigned char crc_byte1; + unsigned char crc_byte2; +}; + +typedef unsigned char cdtext_string[MAX_LENGHT_OF_CDTEXT_STRING]; + +/* meke it more generic + it can be up to 8 blocks with different encoding */ + +struct cdtext_info_block { + /* management */ + unsigned char block_code; + unsigned char block_unicode; /* 0 - single chars, 1 - doublebytes */ + unsigned char block_encoding; /* orange book -? */ + cdtext_string* block_encoding_text; + + /* variable part of cdtext */ + cdtext_string* name; + cdtext_string* performer; + cdtext_string* songwriter; + cdtext_string* composer; + cdtext_string* arranger; + cdtext_string* message; + cdtext_string* UPC_EAN_ISRC_code; + + /* fix part of cdtext */ + unsigned char binary_disc_identification_info[DATAFIELD_LENGHT_IN_PACK]; + unsigned char binary_genreidentification_info[DATAFIELD_LENGHT_IN_PACK]; + unsigned char binary_size_information[DATAFIELD_LENGHT_IN_PACK]; +}; + +struct cdtext_info { + /* somethimes i get hunderts of bytes, without anyone valid pack + my CDU-561 for example */ + int count_of_entries; /* one more because album need one too */ + int count_of_valid_packs; + int count_of_invalid_packs; + int valid; + + struct cdtext_info_block *blocks[MAX_LANGUAGE_BLOCKS]; +}; + +#ifndef IGNORE_FEATURE_LIST + +struct feature_list_header { + unsigned char lenght_msb; + unsigned char lenght_1sb; + unsigned char lenght_2sb; + unsigned char lenght_lsb; + unsigned char reserved1; + unsigned char reserved2; + unsigned char profile_msb; + unsigned char profile_lsb; +}; + +struct feature_descriptor_cdread { + unsigned char feature_code_msb; + unsigned char feature_code_lsb; + unsigned char settings; + unsigned char add_lenght; + unsigned char add_settings; + unsigned char reserved1; + unsigned char reserved2; + unsigned char reserved3; +}; + +#endif /* IGNORE_FEATURE_LIST */ + +struct cdtext_info* wm_cd_get_cdtext( void ); + +#endif /* WM_CDTEXT_H */ diff --git a/kscd/libwm/include/wm_config.h b/kscd/libwm/include/wm_config.h new file mode 100644 index 00000000..b04027f4 --- /dev/null +++ b/kscd/libwm/include/wm_config.h @@ -0,0 +1,377 @@ +#ifndef WM_CONFIG_H +#define WM_CONFIG_H +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + ********************************************************************** + * + * This file consists of several parts. First, there's a generic, + * platform independent part. Set needed options there. + * The following parts are platform dependent. You may search for the + * names listed below and then set your OS specific options there. + * Don't be surprised, if there are no options for your OS. They aren't + * needed in any case. + * + * The default values should produce a functional WorkMan on every + * platform. + * + ********************* + * Current platforms: + ********************* + * BSD386 + * FreeBSD + * HP-UX + * Irix (SGI) + * Linux + * News (Sony NewsOS) + * OpenBSD + * OSF1 + * Sun (SunOS/Solaris, Sparc or x86) + * SVR4 + * Ultrix + * AIX + * + * The above order corresponds with the order of the platform specific + * options below. + */ + +#include <config.h> +/****************************************************************** + * generic options + ****************************************************************** + ** ** *** **** ** **** ** * ** ** ** * ** + * * * *** **** * * *** * ** ** *** * * * * * * ** + * * *** **** ** *** ** ** ** * * ** * * ** + * * * *** **** **** *** * ** ** *** * * * * *** ** + * * * * ** **** * * ** ** **** ** * * *** ** + ******************************************************************/ + +/* + * This option is obvious. But please do not forget the original + * WorkMan version string if you need support. + */ + +#define WORKMAN_NAME "LibWorkMan" +#define WORKMAN_VERSION "1.4.0" + +/* + * If your CD-ROM drive closes its tray if the device is opened, then + * the next define can make WorkMans "Eject" button an "open/close" + * button. If it disturbs you, just comment it out. + * + * ### this is preliminary. It may have no effect for you ### + */ +#define CAN_CLOSE 1 + +/* + * Define the following if you want the balance slider to + * decrease one channel's volume while increasing the other's + */ +/* #define SYMETRIC_BALANCE 1 */ + + +/* + * Define this if you want CDDA support. Supported systems are: + * + * - Solaris (2.4 or newer) + * --> Linux is on the way. Don't define it now. It would lead to errors only. + */ +/*#define BUILD_CDDA 1*/ + + + +/****************************************************************** + * BSD386 + ****************************************************************** + *** **** *** ******* ** **** **** ************ + *** ** ** ****** * ***** ****** ** ** ** *************** + *** ****** **** ** *** ***** ***** *** ************ + *** ** ****** ** * *** ******** ** ** ** ** *********** + *** **** *** *** ****** **** **** ************ + ******************************************************************/ +#if defined(__bsdi__) || defined(__bsdi) + +/* + * This lets you use the SoundBlaster Mixer on BSD/386 + */ +#define SOUNDBLASTER 1 + +#define DEFAULT_CD_DEVICE "/dev/rsr2c" + +#endif /* __bsdi__ (BSD/386) */ + +/****************************************************************** + * FreeBSD + ****************************************************************** + *** ** *** ** ** **** *** *********** + *** ****** ** ** ****** ****** ** ** ****** * ********** + *** **** *** **** **** ****** **** ** ********* + *** ****** ** ** ****** ****** ** ****** ** * ********** + *** ****** ** ** ** ** **** *** *********** + ******************************************************************/ +#if defined(__FreeBSD__) || defined(__FreeBSD) + +#if __FreeBSD_version >= 500100 +#define DEFAULT_CD_DEVICE "/dev/acd0" +#else +#define DEFAULT_CD_DEVICE "/dev/acd0c" +#endif + +#endif /* freebsd */ + +/* DragonFly */ +#if defined(__DragonFly__) +#define DEFAULT_CD_DEVICE "/dev/acd0c" +#endif + +/****************************************************************** + * NetBSD + ****************************************************************** + *** *** ** ** ** **** *** ***************** + *** ** ** ******** **** ** ** ****** * **************** + *** * * ** ****** **** ****** **** ** *************** + *** ** ** ******** **** ** ****** ** * **************** + *** *** ** **** **** **** *** ***************** + ******************************************************************/ +#if defined(__NetBSD__) || defined(__NetBSD) + +#if defined(__i386__) + #define DEFAULT_CD_DEVICE "/dev/rcd0d" +#else + #define DEFAULT_CD_DEVICE "/dev/rcd0c" +#endif + +#endif /* netbsd */ + +/****************************************************************** + * HP-UX + ****************************************************************** + *** ** ** ********* ** ** ** *************************** + *** ** ** ** ******** ** *** **************************** + *** ** *** ** ** **** ***************************** + *** ** ** ************ ** *** **************************** + *** ** ** ************* *** ** *************************** + ******************************************************************/ +#if defined(hpux) || defined (__hpux) + +#define DEFAULT_CD_DEVICE "/dev/rscsi" + +#endif /* hpux */ + +/****************************************************************** + * Irix + ****************************************************************** + *** ** *** ** ** ********************************* + ***** **** ** **** ***** ********************************** + ***** **** ***** ****** *********************************** + ***** **** ** **** ***** ********************************** + *** ** ** ** ** ** ********************************* + ******************************************************************/ +#if defined(sgi) || defined(__sgi) + +#define DEFAULT_CD_DEVICE "/dev/scsi/sc0d6l0" + +#endif /* sgi IRIX */ + +/****************************************************************** + * Linux + ****************************************************************** + *** ****** ** *** ** ** ** ** *********************** + *** ******** **** ** ** ** *** ************************ + *** ******** **** * * ** ** **** ************************* + *** ******** **** ** ** ** *** ************************ + *** ** ** *** *** *** ** *********************** + ******************************************************************/ +#if defined(__linux__) + +/* + * Uncomment the following line to have WorkMan send SCSI commands + * directly to the CD-ROM drive. If you have a SCSI drive you + * probably want this, but it will cause WorkMan to not work on IDE + * drives. + */ +/*#define LINUX_SCSI_PASSTHROUGH 1*/ + +/* + * Which device should be opened by WorkMan at default? + */ +#define DEFAULT_CD_DEVICE "/dev/cdrom" + +/* + * Uncomment the following if you use the sbpcd or mcdx device driver. + * It shouldn't hurt if you use it on other devices. It'll be nice to + * hear from non-sbpcd (or mcdx) users if this is right. + */ +/*#define SBPCD_HACK 1*/ + +/* + * Linux Soundcard support + * Disabled by default, because some people rely on it + */ +/* #define OSS_SUPPORT 1 */ + +/* + * This has nothing to do with the above. + */ + +/* #define CURVED_VOLUME */ + +/* + * Uncomment the following if you want to try out a better responding + * WorkMan, especially with IDE drives. This may work with non-IDE + * drives as well. But it may be possible, that it doesn't work at all. + * If your drive/driver combination cannot handle the faster access, + * the driver will usually hang and you have to reboot your machine. + */ +/* #define FAST_IDE 1 */ + +/* + * There are two alternative ways of checking a device containing a + * mounted filesystem. Define BSD_MOUNTTEST for the test using + * getmntent(). Undefine it for using the SVR4 ustat(). + * I built in the choice, because it's not clear which method should + * be used in Linux. The ustat manpage tells us since 1995, that + * fstat() should be used, but I'm too dumb to do so. + */ + +#define BSD_MOUNTTEST + +#endif /* __linux */ + +/****************************************************************** + * Sony NewsOS + ****************************************************************** + *** *** ** ** ***** *** ***************************** + *** ** ** ****** ***** ** ******************************** + *** * * ** **** ** ** **** ****************************** + *** ** ** ****** * * ****** **************************** + *** *** ** ** * *** ***************************** + ******************************************************************/ +#if defined(__sony_news) || defined(sony_news) + +#define DEFAULT_CD_DEVICE "/dev/rsd/b0i6u0p2\0" + +#endif + +/****************************************************************** + * OSF1 + ****************************************************************** + **** **** *** *** *** ******************************* + *** ** ** ****** ****** ** ******************************* + *** ** **** **** *** ***** ******************************* + *** ** ****** ** **** ****** ******************************* + **** **** *** *** ***** ***************************** + ******************************************************************/ +#if defined(__osf__) || defined(__osf) + +/* not needed here, it's figured out by plat_osf1.c */ +/* #define DEFAULT_CD_DEVICE "/dev/rcdrom/cd0" */ + +#endif + +/****************************************************************** + * SunOS/Solaris + ****************************************************************** + **** *** ** ** *** *************************************** + *** ****** ** ** ** *************************************** + ***** **** ** ** * * *************************************** + ******* ** ** ** ** *************************************** + **** **** *** *** *************************************** + ******************************************************************/ +#if defined(sun) || defined(__sun) + +/* + * Define the following for Solaris 2.x + * If you don't want WorkMan to try to activate the SPARCstation 5 + * internal audio input so you get sound from the workstation, comment + * out the CODEC define. + */ + +#define SYSV 1 +#define CODEC 1 +#define DEFAULT_CD_DEVICE "/vol/dev/aliases/cdrom0" + +/* + * set the following to "SUNW,CS4231" for Sun and to "SUNW,sb16" + * for PC (with SoundBlaster 16) running Solaris x86 + * (only important if you define CODEC above) + */ +#define SUN_AUD_DEV "SUNW,CS4231" +/*#define SUN_AUD_DEV "SUNW,sbpro"*/ + + +#endif + +/****************************************************************** + * SVR4 + ****************************************************************** + **** *** **** ** *** * ******************************** + *** ****** **** ** ** ** * ******************************** + ***** ***** ** *** *** ******************************* + ******* *** ** *** ** ***** ******************************** + **** ***** **** ** ***** ******************************** + ******************************************************************/ +#if (defined(SVR4) || defined(__SVR4)) && !defined(sun) && !defined(__sun) && !defined(sony_news) && !defined(__sony_news) + +#define DEFAULT_CD_DEVICE "/dev/rcdrom/cd0" + +#endif + +/****************************************************************** + * Ultrix + ****************************************************************** + *** ** ** ***** ** *** ** ** ****************** + *** ** ** ******* **** ** **** ***** ******************* + *** ** ** ******* **** ***** ****** ******************** + *** ** ** ******* **** ** **** ***** ******************* + **** *** *** **** ** ** ** ** ****************** + ******************************************************************/ +#if defined(ultrix) || defined(__ultrix) + +#endif + +/****************************************************************** + * IBM AIX + ****************************************************************** + **** *** ** ** ***************************************** + *** ** **** ***** ****************************************** + *** **** ****** ******************************************* + *** ** **** ***** ****************************************** + *** ** ** ** ** ***************************************** + ******************************************************************/ +#if defined(AIXV3) || defined(__AIXV3) + +#define DEFAULT_CD_DEVICE "/dev/cd0" + +#endif /* IBM AIX */ + +/******************************************************************/ +#endif /* WM_CONFIG_H */ + + + + + + + + diff --git a/kscd/libwm/include/wm_database.h b/kscd/libwm/include/wm_database.h new file mode 100644 index 00000000..401f12bc --- /dev/null +++ b/kscd/libwm/include/wm_database.h @@ -0,0 +1,42 @@ +#ifndef WM_DATABASE_H +#define WM_DATABASE_H +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Prototypes for WorkMan database + * + * This is just one more step to a more modular and understandable code. + */ + + +#define WM_DB_SAVE_ERROR 1 +#define WM_DB_SAVE_DISABLED 2 + +int wm_db_get_playnew( void ); +void split_workmandb( void ); +int save( void ); +void load( void ); +void load_settings( void ); + + +#endif /* WM_DATABASE_H */ diff --git a/kscd/libwm/include/wm_helpers.h b/kscd/libwm/include/wm_helpers.h new file mode 100644 index 00000000..ad98a365 --- /dev/null +++ b/kscd/libwm/include/wm_helpers.h @@ -0,0 +1,109 @@ +#ifndef WM_HELPERS_H +#define WM_HELPERS_H +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Here to be found: Prototypes. Including variable names to be easier + * to read. + * This is just one more step to a more modular and understandable code. + * + */ + +/* + * LibWorkMan message levels. I'm not sure how to call them all and which + * use they should fulfill. This is not very urgent now, because there + * aren't many messages in LibWorkMan now. + */ +#define WM_MSG_LEVEL_NONE 0 /**/ +#define WM_MSG_LEVEL_ERROR 1 /**/ +#define WM_MSG_LEVEL_TWO 2 +#define WM_MSG_LEVEL_THREE 3 +#define WM_MSG_LEVEL_FOUR 4 +#define WM_MSG_LEVEL_INFO 5 /**/ +#define WM_MSG_LEVEL_SIX 6 +#define WM_MSG_LEVEL_VERB 7 /**/ +#define WM_MSG_LEVEL_EIGHT 8 +#define WM_MSG_LEVEL_DEBUG 9 /**/ + +/* + * Message classes. This is somehow a definition of + * the message's source. + */ + +#define WM_MSG_CLASS_PLATFORM 0x010 +#define WM_MSG_CLASS_SCSI 0x020 +#define WM_MSG_CLASS_CDROM 0x040 +#define WM_MSG_CLASS_DB 0x080 +#define WM_MSG_CLASS_MISC 0x100 + +#define WM_MSG_CLASS_ALL 0xff0 + +extern int wm_lib_verbosity; + +/* + * I did not know any better place... + */ +#ifdef DEBUG +#define CHECKPOINT(t) fprintf(stderr, "%s (%d): %s\n", __FILE__, __LINE__, t ); +#else +#define CHECKPOINT(t) +#endif + +#ifndef TRUE +#define TRUE 1 +#endif + +#ifndef FALSE +#define FALSE 0 +#endif + +#ifdef __linux__ +#include <signal.h> +/* Linux doesn't have a SIGEMT */ +#if !defined( SIGEMT ) +# define SIGEMT SIGUNUSED +#endif +#endif /* linux */ + +void freeup( char **x ); +void wm_strmcat( char **t, const char *s); +void wm_strmcpy( char **t, const char *s ); +char * wm_strdup( char *s ); +/* Somebody's version query unsatisfied? */ +int wm_libver_major( void ); /* return major internal version number */ +int wm_libver_minor( void ); /* return minor internal version number */ +int wm_libver_pl( void ); /* return internal patchlevel number */ +char * wm_libver_name( void ); /* return internal name (LibWorkMan) */ +char * wm_libver_number( void ); /* returns string: "<major>.<minor>.<pl>" */ +char * wm_libver_string( void ); /* returns string: "<name> <number>" */ +char * wm_libver_date( void ); /* returns string: date of compilation */ +void wm_lib_set_verbosity( int level ); /* set verbosity level */ +int wm_lib_get_verbosity( void ); /* get verbosity level */ +void wm_lib_message( unsigned int level, const char *format, ... ) +#ifdef __GNUC__ + __attribute__ ((format(printf,2,3))) +#endif + ; /* put out a message on stderr */ +int wm_susleep( int usec ); + +#endif /* WM_HELPERS_H */ diff --git a/kscd/libwm/include/wm_index.h b/kscd/libwm/include/wm_index.h new file mode 100644 index 00000000..7c348b75 --- /dev/null +++ b/kscd/libwm/include/wm_index.h @@ -0,0 +1,36 @@ +#ifndef WM_INDEX_H +#define WM_INDEX_H +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Prototypes for wm_index.c + * + * This is just one more step to a more modular and understandable code. + */ + +int idx_find_entry( char *file, int ntracks, int *tracks, + int len, int fuzz, unsigned long *pos ); +int idx_delete_entry(char *file, int track, int fuzz, unsigned long pos ); +int idx_write_entry( char *file, int track, unsigned long pos ); + +#endif /* WM_INDEX_H */ diff --git a/kscd/libwm/include/wm_platform.h b/kscd/libwm/include/wm_platform.h new file mode 100644 index 00000000..edce8119 --- /dev/null +++ b/kscd/libwm/include/wm_platform.h @@ -0,0 +1,51 @@ +#ifndef WM_PLATFORM_H +#define WM_PLATFORM_H +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * The platform interface + * + * This is just one more step to a more modular and understandable code. + */ + +#include "wm_struct.h" + +int wmcd_open( struct wm_drive *d ); +int wmcd_reopen( struct wm_drive *d ); + +/* + * void keep_cd_open( void ); + */ +int wm_scsi( struct wm_drive *d, unsigned char *cdb, int cdblen, + void *retbuf, int retbuflen, int getreply ); + +/**************************************** + * + * The drive prototypes. + * + */ +extern struct wm_drive_proto generic_proto; +extern struct wm_drive_proto sony_proto; +extern struct wm_drive_proto toshiba_proto; + +#endif /* WM_PLATFORM_H */ diff --git a/kscd/libwm/include/wm_scsi.h b/kscd/libwm/include/wm_scsi.h new file mode 100644 index 00000000..0acc62ef --- /dev/null +++ b/kscd/libwm/include/wm_scsi.h @@ -0,0 +1,50 @@ +#ifndef WM_SCSI_H +#define WM_SCSI_H +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * SCSI prototypes (scsi.c) + * + * This is just one more step to a more modular and understandable code. + */ + +#include "wm_struct.h" + +#define WM_ERR_SCSI_INQUIRY_FAILED -1 + +int wm_scsi_mode_sense( struct wm_drive *d, unsigned char page, + unsigned char *buf ); +int sendscsi( struct wm_drive *d, void *buf, + unsigned int len, int dir, + unsigned char a0, unsigned char a1, + unsigned char a2, unsigned char a3, + unsigned char a4, unsigned char a5, + unsigned char a6, unsigned char a7, + unsigned char a8, unsigned char a9, + unsigned char a10, unsigned char a11 ); + int wm_scsi_get_drive_type( struct wm_drive *d, char *vendor, + char *model, char *rev ); +int wm_scsi_get_cdtext( struct wm_drive *d, + unsigned char **pp_buffer, int *p_buffer_length ); + +#endif /* WM_SCSI_H */ diff --git a/kscd/libwm/include/wm_struct.h b/kscd/libwm/include/wm_struct.h new file mode 100644 index 00000000..790de3b0 --- /dev/null +++ b/kscd/libwm/include/wm_struct.h @@ -0,0 +1,198 @@ +#ifndef WM_STRUCT_H +#define WM_STRUCT_H +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + + + +/* + * Structure for a single track. This is pretty much self-explanatory -- + * one of these exists for each track on the current CD. + */ +struct wm_trackinfo +{ + char *songname; /* Name of song, dynamically allocated */ + char *otherdb; /* Unrecognized info for this track */ + char *otherrc; + int length; /* Length of track in seconds or Kbytes */ + int start; /* Starting position (f+s*75+m*60*75) */ + int volume; /* Per-track volume (1-32, 0 to disable) */ + int track; /* Physical track number */ + int section; /* Section number (0 if track not split) */ + int contd; /* Flag: continuation of previous track */ + int avoid; /* Flag: don't play this track. */ + int data; /* Flag: data track */ +}; + +/* + * Structure for internal playlist management. The internal playlist is + * simply the list of track ranges that are being played currently. This + * is built whenever the CD starts playing; it's used in normal and shuffle + * modes as well as playlist mode. + * + * The "starttime" element represents how much time has elapsed by the time + * we get to this entry. For instance, if the list begins with a 5-minute + * track and a 3-minute track, the third entry would have a starttime of 8 + * minutes. This is used so that the elapsed play time can be displayed + * even in shuffle or playlist modes. + * + * The last member of the list has a start track of 0, and its starttime is + * the total playing time of the playlist (which will usually be overestimated, + * since we don't play leadouts in some cases.) + */ +struct wm_play +{ + int start; /* Start track, or 0 if end of list */ + int end; /* last track plus 1 */ + int starttime; /* Number of seconds elapsed previously */ +}; + +/* + * Structure for playlists (as seen by the user.) This is simply a name + * followed by a zero-terminated list of track numbers to play. The list + * is terminated by a NULL name. + */ +struct wm_playlist +{ + char *name; /* Name of this playlist */ + int *list; /* List of tracks */ +}; + +struct wm_cdinfo +{ + char artist[84]; /* Artist's name */ + char cdname[84]; /* Disc's name */ + int ntracks; /* Number of tracks on the disc */ + int curtrack; + int curtracklen; + int length; /* Total running time in seconds */ + int autoplay; /* Start playing CD immediately */ + int playmode; /* How to play the CD */ + int volume; /* Default volume (1-32, 0 for none) */ + struct wm_trackinfo *trk; /* struct wm_trackinfo[ntracks] */ + struct wm_playlist *lists; /* User-specified playlists */ + char *whichdb; /* Which database is this entry from? */ + char *otherdb; /* Unrecognized lines from this entry */ + char *otherrc; + char *user; /* Name of originating user */ + unsigned int cddbid; /* CDDB-ID of the current disc */ + struct cdinfo *next; /* For browsers, etc. */ +}; + +/* The global variable "cd" points to the struct for the CD that's playing. */ +extern struct wm_cdinfo *cd; + +extern struct wm_playlist *new_playlist(); + +#define WM_STR_GENVENDOR "Generic" +#define WM_STR_GENMODEL "drive" +#define WM_STR_GENREV "type" + + +/* + * Drive descriptor structure. Used for access to low-level routines. + */ +struct wm_drive_proto +{ + int (*gen_init)(); + int (*gen_close)(); + int (*gen_get_trackcount)(); + int (*gen_get_cdlen)(); + int (*gen_get_trackinfo)(); + int (*gen_get_drive_status)(); + int (*gen_get_volume)(); + int (*gen_set_volume)(); + int (*gen_pause)(); + int (*gen_resume)(); + int (*gen_stop)(); + int (*gen_play)(); + int (*gen_eject)(); + int (*gen_closetray)(); + int (*gen_get_cdtext)(); +}; + +struct wm_drive +{ + int cdda; /* cdda 1, cdin 0 */ + const char *cd_device; + char *soundsystem; + char *sounddevice; + char *ctldevice; + int fd; /* File descriptor, if used by platform */ + int cdda_slave; /* File descriptor for CDDA */ + + char *vendor; /* Vendor name */ + char *model; /* Drive model */ + char *revision; /* Revision of the drive */ + void *aux; /* Pointer to optional platform-specific info */ + void *daux; /* Pointer to optional drive-specific info */ + + struct wm_drive_proto *proto; +}; + +/* + * Structure for information of the usage of cddb. + */ +struct wm_cddb { + int protocol; /* 0-off, 1-cddbp, 2-http, 3-htproxy */ + char cddb_server[84]; /* host.domain.name:port */ + char mail_adress[84]; /* user@domain.name */ + char path_to_cgi[84]; /* (/)path/to/cddb.cgi */ + char proxy_server[84]; /* host.domain.name:port */ +}; +extern struct wm_cddb cddb; + + +/* + * Each platform has to define generic functions, so may as well declare + * them all here to save space. + * These functions should never be seen outside libworkman. So I don't care + * about the wm_ naming convention here. + */ +int gen_init( struct wm_drive *d ); +int gen_close( struct wm_drive *d ); +int gen_get_trackcount(struct wm_drive *d, int *tracks); +int gen_get_cdlen(struct wm_drive *d, int *frames); +int gen_get_trackinfo(struct wm_drive *d, int track, int *data, int *startframe); +int gen_get_drive_status( struct wm_drive *d, int oldmode, + int *mode, int *pos, int *track, int *ind ); +int gen_set_volume( struct wm_drive *d, int left, int right ); +int gen_get_volume( struct wm_drive *d, int *left, int *right ); +int gen_pause(struct wm_drive *d); +int gen_resume(struct wm_drive *d); +int gen_stop(struct wm_drive *d); +int gen_play(struct wm_drive *d, int start, int end, int realstart); +int gen_eject(struct wm_drive *d); +int gen_closetray(struct wm_drive *d); +int gen_get_cdtext(struct wm_drive *d, unsigned char **pp_buffer, int *p_buffer_lenght); + +int find_drive_struct(const char *vendor, const char *model, const char *rev); + + +struct cdtext_info* get_glob_cdtext(struct wm_drive*, int); +void free_cdtext(void); +const char* gen_status(int); + +#endif /* WM_STRUCT_H */ diff --git a/kscd/libwm/include/wm_version.h b/kscd/libwm/include/wm_version.h new file mode 100644 index 00000000..82e500c5 --- /dev/null +++ b/kscd/libwm/include/wm_version.h @@ -0,0 +1,35 @@ +#ifndef WM_VERSION_H +#define WM_VERSION_H +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Version information + * + */ + +#define WM_LIBVER_MAJOR 1 +#define WM_LIBVER_MINOR 4 +#define WM_LIBVER_PL 3 +#define WM_LIBVER_NAME "LibWorkMan" + +#endif /* WM_VERSION_H */ diff --git a/kscd/libwm/include/workman.h b/kscd/libwm/include/workman.h new file mode 100644 index 00000000..e7c3807d --- /dev/null +++ b/kscd/libwm/include/workman.h @@ -0,0 +1,52 @@ +#ifndef WORKMAN_H +#define WORKMAN_H +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * all-in-one libworkman include file. + * + */ + + +/* + * wm_config should always be included first + */ +#include "wm_config.h" + +#include "workman_defs.h" +#ifdef BUILD_CDDA +#include "wm_cdda.h" +#endif +#include "wm_cddb.h" +#include "wm_cdinfo.h" +#include "wm_cdrom.h" +#include "wm_database.h" +#include "wm_helpers.h" +#include "wm_index.h" +#include "wm_platform.h" +#include "wm_scsi.h" +#include "wm_struct.h" +#include "wm_cdtext.h" + +#endif /* WORKMAN_H */ + diff --git a/kscd/libwm/include/workman_defs.h b/kscd/libwm/include/workman_defs.h new file mode 100644 index 00000000..9da47f8f --- /dev/null +++ b/kscd/libwm/include/workman_defs.h @@ -0,0 +1,30 @@ +#ifndef WORKMAN_DEFS_H +#define WORKMAN_DEFS_H +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player program + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * #defined CONSTANTS + * + * Too bad this file seems to be so empty... + * + */ + +#include "wm_version.h" + +#endif /* WORKMAN_DEFS_H */ diff --git a/kscd/libwm/index.c b/kscd/libwm/index.c new file mode 100644 index 00000000..e15312b7 --- /dev/null +++ b/kscd/libwm/index.c @@ -0,0 +1,383 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * Maintain an external index file for a WorkMan CD database. + * Uses the Berkeley libdb library, available from ftp.cs.berkeley.edu. + */ + +#ifdef LIBDB + +#include <stdio.h> +#include <stdlib.h> +#include <db.h> +#include <fcntl.h> +#include <string.h> +#include <netinet/in.h> /* for htonl() */ +#include "include/wm_config.h" +#include "include/wm_index.h" + +extern int suppress_locking; + +/* + * idx_find_entry() + * + * Find an entry in the index file. + * + * Input: + * file Name of database file (text version). + * ntracks Number of tracks on the CD we're looking for. + * tracks Array of track start times. + * len CD length in frames. + * fuzz Fuzz factor (tolerance value). + * pos Pointer to return value. + * + * Output: + * 1 No matching record found. + * 0 Record found; *pos contains offset into text file. + * -1 Index file out of date or inaccessible, or another error. + */ +int +idx_find_entry( char *file, int ntracks, int *tracks, + int len, int fuzz, unsigned long *pos ) +{ + unsigned long dbpos; + char *indexname = NULL, keyval[8]; + int c; + FILE *text; + DB *index; + DBT key, data; + BTREEINFO bti; + + /* + * First, see if the text file is accessible. Lock it if so. + */ + text = fopen(file, "r"); + if (text == NULL) + return (-1); + if ((c = getc(text)) == EOF) + { + fclose(text); + return (-1); + } + if (! suppress_locking) + if (lockit(fileno(text), F_RDLCK)) + { + fclose(text); + return (-1); + } + + /* + * Open the index file. + */ + indexname = malloc(strlen(file) + sizeof(".ind")); + if (indexname == NULL) + { + fclose(text); + return (-1); + } + strcpy(indexname, file); + strcat(indexname, ".ind"); + bti.flags = 0; + bti.cachesize = 0; + bti.minkeypage = bti.maxkeypage = 0; + bti.psize = bti.lorder = 0; + bti.compare = NULL; + bti.prefix = NULL; + index = dbopen(indexname, O_RDONLY, 0666, DB_BTREE, &bti); + free(indexname); + if (index == NULL) + { + fclose(text); + return (-1); + } + + /* + * Search for the first matching entry. + */ + sprintf(keyval, "%07d", tracks[ntracks - 1] - fuzz); + key.data = keyval; + key.size = 7; + if (c = (index->seq)(index, &key, &data, R_CURSOR)) + { + (index->close)(index); + fclose(text); + return (c); + } + + /* + * Now loop through all the possible matches, collecting them into + * memory. + */ + do { + char tracksline[750], *s; + int i, val; + + /* Hit the end of the valid entries? */ + sscanf(key.data, "%d", &val); + if (val > tracks[ntracks - 1] + fuzz) + break; + + dbpos = ntohl(*((unsigned long *) data.data)); + if (fseek(text, dbpos, 0)) + break; + + fgets(tracksline, sizeof(tracksline), text); + if (strncmp(tracksline, "tracks ", 7)) + break; + (void) strtok(tracksline, " \t"); + + /* Got a valid tracks line. See if it matches the CD. */ + s = strtok(NULL, " \t"); + if (s == NULL) + break; + if (atoi(s) != ntracks) + continue; + + for (i = 0; i < ntracks; i++) + { + s = strtok(NULL, " \t"); + if (s == NULL) + break; + val = atoi(s); + if (val + fuzz < tracks[i] || val - fuzz > tracks[i]) + break; + } + if (i != ntracks) + continue; + + s = strtok(NULL, " \t"); + if (s == NULL) + continue; + val = atoi(s); + if (val + fuzz / 75 < len / 75 || val + fuzz / 75 > len / 75) + continue; + + /* XXX - add to sorted list! */ + *pos = dbpos; + (index->close)(index); + fclose(text); + return (0); + } while ((c = (index->seq)(index, &key, &data, R_NEXT)) == 0); + + if (c == 0) + { + /* An error. */ + (index->close)(index); + fclose(text); + return (-1); + } + + (index->close)(index); + fclose(text); + return (1); +} + +/* + * idx_delete_entry() + * + * Delete an entry from the index file. + * + * Input: + * file Name of database file (text version). + * track Last track's start time (database key). + * fuzz Fuzz factor (tolerance value). + * pos Position of CD in database file. + * + * Output: + * 1 No matching record found. + * 0 Record deleted. + * -1 Index file out of date or inaccessible, or another error. + * + * Note: it is the caller's responsibility to do locking, as it's assumed + * that this operation will accompany a modification of the main database + * file and will need to be atomic with that modification. + */ +int +idx_delete_entry(char *file, int track, int fuzz, unsigned long pos ) +{ + unsigned long dbpos; + char *indexname = NULL, keyval[8]; + int c, status; + DB *index; + DBT key, data; + BTREEINFO bti; + + /* + * Open the index file. + */ + indexname = malloc(strlen(file) + sizeof(".ind")); + if (indexname == NULL) + return (-1); + + strcpy(indexname, file); + strcat(indexname, ".ind"); + + bti.flags = 0; + bti.cachesize = 0; + bti.minkeypage = bti.maxkeypage = 0; + bti.psize = bti.lorder = 0; + bti.compare = NULL; + bti.prefix = NULL; + index = dbopen(indexname, O_RDWR, 0666, DB_BTREE, &bti); + free(indexname); + if (index == NULL) + return (-1); + + /* + * Search for the first matching entry. + */ + sprintf(keyval, "%07d", track - fuzz); + key.data = keyval; + key.size = 7; + if (c = (index->seq)(index, &key, &data, R_CURSOR)) + { + /* + * Nothing matched! + */ + (index->close)(index); + return (c); + } + + /* + * Look for the entry the user wants to delete. + */ + do { + int val; + + /* Hit the end of the valid entries? */ + sscanf(key.data, "%d", &val); + if (val > track + fuzz) + break; + + /* Is this the entry we want? */ + if (pos == ntohl(*((unsigned long *) data.data))) + { + /* + * Yep! Delete it. + */ + status = (index->del)(index, &key, R_CURSOR); + (index->close)(index); + return (status); + } + } while ((c = (index->seq)(index, &key, &data, R_NEXT)) == 0); + + if (c == 0) + { + /* An error. */ + (index->close)(index); + return (-1); + } + + (index->close)(index); + return (1); +} + +/* + * idx_write_entry() + * + * Write out an index file entry. + * + * Input: + * file Name of database file (text version). + * track Start time of last track (database key). + * pos Position of entry in text file. + * + * Output: + * 0 Record written. + * -1 Index file inaccessible, or another error. + * + * Note: it is the caller's responsibility to do locking, as it's assumed + * that this operation will accompany a modification of the main database + * file and will need to be atomic with that modification. + */ +int +idx_write_entry( char *file, int track, unsigned long pos ) +{ + char *indexname, keyval[8]; + int status; + DB *index; + DBT key, data; + BTREEINFO bti; + + /* + * Open the index file. + */ + indexname = malloc(strlen(file) + sizeof(".ind")); + if (indexname == NULL) + return (-1); + + strcpy(indexname, file); + strcat(indexname, ".ind"); + + bti.flags = R_DUP; + bti.cachesize = 0; + bti.minkeypage = 0; + bti.maxkeypage = 0; + bti.psize = 0; + bti.lorder = 4321; /* network byte order */ + bti.compare = NULL; + bti.prefix = NULL; + index = dbopen(indexname, O_RDWR, 0666, DB_BTREE, &bti); + free(indexname); + if (index == NULL) + return (-1); + + /* + * Create a new key and value. + */ + pos = htonl(pos); + data.data = &pos; + data.size = sizeof(pos); + key.data = keyval; + key.size = 7; + + sprintf(keyval, "%07d", track); + + status = (index->put)(index, &key, &data, 0); + + (index->close)(index); + return (status); +} + +#else /* LIBDB */ + +int +idx_find_entry() +{ + return (1); /* no record found; text file will be searched. */ +} + +int +idx_delete_entry() +{ + return (0); +} + +int +idx_write_entry() +{ + return (0); +} + +#endif /* LIBDB */ diff --git a/kscd/libwm/plat_aix.c b/kscd/libwm/plat_aix.c new file mode 100644 index 00000000..93b596a1 --- /dev/null +++ b/kscd/libwm/plat_aix.c @@ -0,0 +1,489 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * plat_aix - AIX 4.x IDE and SCSI support 16 Dec 1998 + * + * AIX 4.x Port: Erik O'Shaughnessy + * Original AIX IDE Code: Cloyce Spradling (xmcd libdi_d/aixioc.c ) + * + * Taken from the ascd distribution. + * + */ + + +#if defined(AIXV3) || defined(__AIXV3) + +#include <stdio.h> +#include <errno.h> +#include <fcntl.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <sys/cdrom.h> +#include <sys/devinfo.h> +#include <sys/scsi.h> +#include <sys/scdisk.h> + +#include "include/wm_config.h" +#include "include/wm_struct.h" +#include "include/wm_cdtext.h" + +#define WM_MSG_CLASS WM_MSG_CLASS_PLATFORM + +#define LEADOUT 0xaa + +int min_volume = 128; +int max_volume = 255; + + + +/* NAME: gen_init + * + * FUNCTION: + * + * RETURNS: + */ +int +gen_init(struct wm_drive *d) +{ + return 0; +} /* gen_init() */ + + +/* NAME: wmcd_open + * + * FUNCTION: + * + * RETURNS: + */ +int +wmcd_open(struct wm_drive *d) +{ + char vendor[32] = WM_STR_GENVENDOR; + char model[32] = WM_STR_GENMODEL; + char rev[32] = WM_STR_GENREV; + + int fd; + + if( ! d ) + { + errno = EFAULT; + return -1; + } + + if(d->fd > -1) /* device already open? */ + { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_open(): [device is open (fd=%d)]\n", d->fd); + return 0; + } + + if( d->cd_device == (char *)NULL ) + d->cd_device = DEFAULT_CD_DEVICE; + + if( (fd = openx(d->cd_device,O_RDONLY,NULL,SC_SINGLE)) < 0 ) + { + perror("openx"); + return -6; + /* return 1 */ + } + + find_drive_struct(vendor, model, rev); + + d->fd = fd; + d->init(d); + return 0; +} /* wmcd_open() */ + +/* + * Re-Open the device if it is open. + */ +int +wmcd_reopen( struct wm_drive *d ) +{ + int status; + + do { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_reopen\n"); + status = gen_close( d ); + wm_susleep( 1000 ); + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "calling wmcd_open()\n"); + status = wmcd_open( d ); /* open it as usual */ + wm_susleep( 1000 ); + } while ( status != 0 ); + return status; +} /* wmcd_reopen() */ + +/* NAME: wm_scsi + * + * FUNCTION: + * + * RETURNS: + */ +int +wm_scsi(struct wm_drive *d, + uchar_t *cdb, int cdblen, + void *retbuf, int retbuflen, + int getreply) +{ + return 0; +} /* wm_scsi() */ + +int +gen_close( struct wm_drive *d ) +{ + if(d->fd != -1) { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "closing the device\n"); + close(d->fd); + d->fd = -1; + } + return 0; +} + +/* NAME: gen_get_drive_status + * + * FUNCTION: + * + * RETURNS: + */ +int +gen_get_drive_status(struct wm_drive *d, + int oldmode, + int *mode, + int *pos, + int *track, + int *index) +{ + struct cd_audio_cmd cmd; + + *mode = WM_CDM_EJECTED; + + if(d->fd < 0) + switch( wmcd_open(d) ) + { + case -1: + return -1; + case 1: + return 0; + } + + cmd.audio_cmds = CD_INFO_AUDIO; + + if( ioctl(d->fd,DKAUDIO,&cmd) < 0) + return -1; + + switch(cmd.status) + { + case CD_PLAY_AUDIO: + *mode = WM_CDM_PLAYING; + *track = cmd.indexing.info_audio.current_track; + *index = cmd.indexing.info_audio.current_index; + *pos = cmd.indexing.info_audio.current_mins * 60 * 75 + + cmd.indexing.info_audio.current_secs * 75 + + cmd.indexing.info_audio.current_frames; + break; + + case CD_PAUSE_AUDIO: + *mode = WM_CDM_PAUSED; + *track = cmd.indexing.info_audio.current_track; + *index = cmd.indexing.info_audio.current_index; + *pos = cmd.indexing.info_audio.current_mins * 60 * 75 + + cmd.indexing.info_audio.current_secs * 75 + + cmd.indexing.info_audio.current_frames; + + break; + case CD_NO_AUDIO: /* no play audio in progress */ + case CD_COMPLETED: /* play operation completed successfully */ + case CD_STATUS_ERROR: /* invalid status or play stopped due to err */ + case CD_NOT_VALID: /* audio status is invalid or not supported */ + *mode = WM_CDM_STOPPED; + break; + default: + *mode = WM_CDM_UNKNOWN; + break; + } + + return 0; +} /* gen_get_drive_status() */ + + + +/* NAME: gen_get_trackcount + * + * FUNCTION: + * + * RETURNS: + */ +int +gen_get_trackcount(struct wm_drive *d,int *tracks) +{ + struct cd_audio_cmd cmd; + + cmd.audio_cmds = CD_TRK_INFO_AUDIO; + cmd.msf_flag = 0; + + if( ioctl(d->fd,DKAUDIO,&cmd) < 0) + { + perror("DKAUDIO"); + return -1; + } + + *tracks = cmd.indexing.track_index.last_track; + + return 0; +} /* gen_get_trackcount() */ + +/* NAME: gen_get_trackinfo + * + * FUNCTION: + * + * RETURNS: + */ +int +gen_get_trackinfo(struct wm_drive *d,int track,int *data,int *startframe) +{ + struct cd_audio_cmd cmd; + + cmd.audio_cmds = CD_GET_TRK_MSF; + cmd.msf_flag = 1; + + cmd.indexing.track_msf.track = track; + + if( ioctl(d->fd,DKAUDIO,&cmd) < 0) + return -1; + + *startframe = cmd.indexing.track_msf.mins * 60 * 75 + + cmd.indexing.track_msf.secs * 75 + + cmd.indexing.track_msf.frames; + + *data = 0; + + return 0; +} /* gen_get_trackinfo() */ + +/* NAME: gen_get_cdlen + * + * FUNCTION: + * + * RETURNS: + */ +int +gen_get_cdlen(struct wm_drive *d,int *frames) +{ + int tmp; + + return gen_get_trackinfo(d,LEADOUT,&tmp,frames); +} /* gen_get_cdlen() */ + + +/* NAME: gen_play + * + * FUNCTION: + * + * RETURNS: + */ +int +gen_play(struct wm_drive *d,int start,int end) +{ + struct cd_audio_cmd cmd; + + cmd.audio_cmds = CD_PLAY_AUDIO; + cmd.msf_flag = 1; + + cmd.indexing.msf.first_mins = start / (60*75); + cmd.indexing.msf.first_secs = (start % (60*75)) / 75; + cmd.indexing.msf.first_frames = start % 75; + + cmd.indexing.msf.last_mins = end / (60*75); + cmd.indexing.msf.last_secs = (end % (60*75)) / 75; + cmd.indexing.msf.last_frames = end % 75; + + if( ioctl(d->fd,DKAUDIO,&cmd) < 0) + { + perror("DKAUDIO:CD_PLAY_AUDIO"); + return -1; + } + return 0; +} /* gen_play() */ + +/* NAME: gen_pause + * + * FUNCTION: + * + * RETURNS: + */ +int +gen_pause(struct wm_drive *d) +{ + struct cd_audio_cmd cmd; + + cmd.audio_cmds = CD_PAUSE_AUDIO; + + return ioctl(d->fd,DKAUDIO,&cmd); +} /* gen_pause() */ + + +/* NAME: gen_resume + * + * FUNCTION: + * + * RETURNS: + */ +int +gen_resume(struct wm_drive *d) +{ + struct cd_audio_cmd cmd; + + cmd.audio_cmds = CD_RESUME_AUDIO; + return ioctl(d->fd,DKAUDIO,&cmd); +} /* gen_resume() */ + +/* NAME: gen_stop + * + * FUNCTION: + * + * RETURNS: + */ +int +gen_stop(struct wm_drive *d) +{ + struct cd_audio_cmd cmd; + + cmd.audio_cmds = CD_STOP_AUDIO; + return ioctl(d->fd,DKAUDIO,&cmd); +} /* gen_stop() */ + +/* NAME: gen_eject + * + * FUNCTION: + * + * RETURNS: + */ +int +gen_eject(struct wm_drive *d) +{ + return ioctl(d->fd,DKEJECT,NULL); +} + +/*----------------------------------------* + * Close the CD tray + *----------------------------------------*/ +int +gen_closetray(struct wm_drive *d) +{ +#ifdef CAN_CLOSE + if(!close(d->fd)) + { + d->fd=-1; + return(wmcd_reopen(d)); + } else { + return(-1); + } +#else + /* Always succeed if the drive can't close */ + return(0); +#endif /* CAN_CLOSE */ +} /* gen_closetray() */ + + +int +scale_volume(int vol,int max) +{ + return ((vol * (max_volume - min_volume)) / max + min_volume); +} + +int +unscale_volume(int vol,int max) +{ + int n; + n = ( vol - min_volume ) * max_volume / (max - min_volume); + return (n <0)?0:n; +} + +/* NAME: gen_set_volume + * + * FUNCTION: + * + * RETURNS: + */ +int +gen_set_volume(struct wm_drive *d,int left,int right) +{ + struct cd_audio_cmd cmd; + + cmd.audio_cmds = CD_SET_VOLUME; + cmd.volume_type = CD_VOLUME_CHNLS; + + cmd.out_port_0_vol = scale_volume(left,100); + cmd.out_port_1_vol = scale_volume(right,100); + + if( ioctl(d->fd,DKAUDIO,&cmd) < 0) + { + perror("CD_SET_VOLUME"); + return -1; + } + + return 0; +} /* gen_set_volume() */ + +/* NAME: gen_get_volume + * + * FUNCTION: + * + * RETURNS: + */ +int +gen_get_volume(struct wm_drive *d,int *left,int *right) +{ + struct cd_audio_cmd cmd; + int l,r; + + fprintf(stderr,"gen_get_volume\n"); + + cmd.audio_cmds = CD_INFO_AUDIO; + if( ioctl(d->fd,DKAUDIO,&cmd) < 0) + return -1; + + *left = unscale_volume(cmd.out_port_0_vol,100); + *right = unscale_volume(cmd.out_port_1_vol,100); + + return 0; +} /* gen_get_volume() */ + +/*------------------------------------------------------------------------* + * gen_get_cdtext(drive, buffer, lenght) + *------------------------------------------------------------------------*/ + +int +gen_get_cdtext(struct wm_drive *d, unsigned char **pp_buffer, int *p_buffer_lenght) +{ + return -1; /* no SCSI, no CDTEXT */ +} /* gen_get_cdtext() */ + + + +#endif /* _AIX */ + + + + + diff --git a/kscd/libwm/plat_bsd386.c b/kscd/libwm/plat_bsd386.c new file mode 100644 index 00000000..492d394c --- /dev/null +++ b/kscd/libwm/plat_bsd386.c @@ -0,0 +1,510 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * BSD/386-specific drive control routines. + */ + +static char plat_bsd386_id[] = "$Id$"; + +#if defined(__bsdi__) || defined(__bsdi) + +#include <errno.h> +#include <stdio.h> +#include <sys/types.h> +#include <fcntl.h> +#include <unistd.h> +#include <sys/param.h> +#include <sys/stat.h> + +#include "include/wm_config.h" + +/* + * The following is included from the Linux module. However, I didn't + * see a check here if the CD to be ejected is mounted... + */ +#if defined(BSD_MOUNTTEST) + #include <mntent.h> +#endif + + +#include <sys/time.h> +#include <string.h> +#include <cdrom.h> +#ifdef SOUNDBLASTER +# include <sys/soundcard.h> +#endif + +#include "include/wm_struct.h" +#include "include/wm_helpers.h" +#include "include/wm_cdtext.h" + +#define WM_MSG_CLASS WM_MSG_CLASS_PLATFORM + + +/* + * Since we can't sense the drive type with libcdrom anyway, and since the + * library doesn't provide "pause" or "resume" functions, use the daux field + * to point to the frame number at which we paused. + */ +struct pause_info +{ + int frame; + int endframe; +}; + +#define PAUSE_FRAME (((struct pause_info *) d->daux)->frame) +#define END_FRAME (((struct pause_info *) d->daux)->endframe) +#define CUR_CD ((struct cdinfo *) d->aux) + +void *malloc(); + +#ifdef SOUNDBLASTER + int min_volume = 0; + int max_volume = 100; + int min_volume_drive = 10; /* Toshiba drive does low values. */ + int max_volume_drive = 255; +#else + int min_volume = 10; + int max_volume = 255; +#endif + +/*--------------------------------------------------------* + * Initialize the drive. A no-op for the generic driver. + *--------------------------------------------------------*/ +int +gen_init(struct wm_drive *d) +{ + return (0); +} /* gen_init() */ + +/*-----------------------------------------------------------------------* + * Open the CD device. We can't determine the drive type under BSD/386. + *-----------------------------------------------------------------------*/ +int +wmcd_open(struct wm_drvie *d) +{ + void *aux = NULL, *daux = NULL; + int fd = -1; + + if (d->aux) /* Device already open? */ + { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_open(): [device is open (aux=%d)]\n", d->aux); + return (0); + } + + if ((aux = cdopen(d->cd_device)) == NULL) + { + fprintf(stderr, "No cdrom found by libcdrom\n"); + return (-6); + } + + if ((daux = malloc(sizeof(struct pause_info))) == NULL) + return (-1); + +#ifdef SOUNDBLASTER + fd = open("/dev/mixer", O_RDWR, 0); +#endif + + /* Now fill in the relevant parts of the wm_drive structure. */ + find_drive_struct("", "", ""); + d->aux = aux; + d->daux = daux; + d->fd = fd; + PAUSE_FRAME = 0; + END_FRAME = 0; + + (d->init)(d); + + return (0); +} /* wmcd_open() */ + +/* + * Re-Open the device if it is open. + */ +int +wmcd_reopen( struct wm_drive *d ) +{ + int status; + int tries = 0; + + do { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_reopen\n"); + status = gen_close( d ); + wm_susleep( 1000 ); + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "calling wmcd_open()\n"); + status = wmcd_open( d ); /* open it as usual */ + wm_susleep( 1000 ); + tries++; + } while ( (status != 0) && (tries < 10) ); + return status; +} /* wmcd_reopen() */ + + +/*---------------------------------------------* + * Send an arbitrary SCSI command to a device. + *---------------------------------------------*/ +int +wm_scsi(struct wm_drive *d, unsigned char *cdb, int cdblen, + void *retbuf, int retbuflen, int getreply) +{ + /* Don't know how to do SCSI passthrough... */ + return (-1); +} /* wm_scsi() */ + +int +gen_close( struct wm_drive *d ) +{ + if(d->fd != -1) { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "closing the device\n"); + close(d->fd); /* close mixer if open */ + d->fd = -1; + cdclose( d->aux ); /* close the cdrom drive! */ + d->aux = NULL; + free(d->daux); + d->daux = NULL; + } + return 0; +} + +/*--------------------------------------------------------------------------* + * Get the current status of the drive: the current play mode, the absolute + * position from start of disc (in frames), and the current track and index + * numbers if the CD is playing or paused. + *--------------------------------------------------------------------------*/ +#define DOPOS \ + *pos = status.abs_frame; \ +*track = status.track_num; \ +*index = status.index_num + +int +gen_get_drive_status(struct wm_drive *d, int oldmode, + int *mode, int *pos, int *track, int *index) +{ + struct cdstatus status; + extern enum wm_cd_modes cur_cdmode; + + /* If we can't get status, the CD is ejected, so default to that. */ + *mode = WM_CDM_EJECTED; + + /* Is the device open? */ + if (d->aux == NULL) + { + switch (wmcd_open(d)) + { + case -1: /* error */ + return (-1); + + case 1: /* retry */ + return (0); + } + } + + if (cdstatus (CUR_CD, &status) < 0) + { + *mode = WM_CDM_TRACK_DONE; /* waiting for next track. */ + return (0); + } + + switch (status.state) + { + case cdstate_playing: + *mode = WM_CDM_PLAYING; + DOPOS; + break; + + case cdstate_stopped: + /* the MITSUMI drive doesn't have a "paused" state, + so it always comes here and not to the paused section. + The PAUSE_FRAME stuff below (in gen_pause()) + fakes out the paused state. */ + if (oldmode == WM_CDM_PLAYING) + { + *mode = WM_CDM_TRACK_DONE; + break; + } else if (cur_cdmode != WM_CDM_PAUSED) { + *mode = WM_CDM_STOPPED; + DOPOS; + break; + } + /* fall through if paused */ + + case cdstate_paused: + /* the SCSI2 code in the cdrom library only pauses with + cdstop(); it never truly stops a disc (until an in-progress + play reaches the end). So it always comes here. */ + if (cur_cdmode == WM_CDM_STOPPED) + { + *mode = WM_CDM_STOPPED; + DOPOS; + break; + } + if (oldmode == WM_CDM_PLAYING || oldmode == WM_CDM_PAUSED) + { + *mode = WM_CDM_PAUSED; + DOPOS; + } else { + *mode = WM_CDM_STOPPED; + DOPOS; + } + break; + + default: + *mode = WM_CDM_STOPPED; + } + + return (0); +} /* gen_get_drive_status() */ + + +/*-------------------------------------* + * Get the number of tracks on the CD. + *-------------------------------------*/ +int +gen_get_trackcount(struct wm_drive *d, int *tracks) +{ + *tracks = CUR_CD->ntracks; + + return (0); +} /* gen_get_trackcount() */ + +/*---------------------------------------------------------* + * Get the start time and mode (data or audio) of a track. + *---------------------------------------------------------*/ +int +gen_get_trackinfo(struct wm_drive *d, int track, int *data, int *startframe) +{ + *data = (CUR_CD->tracks[track - 1].control & 4) ? 1 : 0; + *startframe = CUR_CD->tracks[track - 1].start_frame; + + return (0); +} /* gen_get_trackinfo() */ + +/*-------------------------------------* + * Get the number of frames on the CD. + *-------------------------------------*/ +int +gen_get_cdlen(struct wm_drive *d, int *frames) +{ + *frames = CUR_CD->total_frames; + + return (0); +} /* gen_get_cdlen() */ + +/*------------------------------------------------------------* + * Play the CD from one position to another (both in frames.) + *------------------------------------------------------------*/ +int +gen_play(struct wm_drive *d, int start, int end) +{ + END_FRAME = end; + if (cdplay(d->aux, start, end) < 0) + return (-1); + else + return (0); +} /* gen_play() */ + +/*--------------------------------------------------------------------* + * Pause the CD. This is a bit of a trick since there's no cdpause() + * function in the library. We fake it by saving the frame number + * and stopping. + *--------------------------------------------------------------------*/ +int +gen_pause(struct wm_drive *d) +{ + struct cdstatus status; + + if (cdstatus(d->aux, &status) < 0) + return (-1); + if (status.state != cdstate_playing) + PAUSE_FRAME = CUR_CD->tracks[0].start_frame; + else + PAUSE_FRAME = status.abs_frame; + if (cdstop(d->aux) < 0) + return (-1); + + return (0); +} /* gen_pause() */ + +/*-------------------------------------------------* + * Resume playing the CD (assuming it was paused.) + *-------------------------------------------------*/ +int +gen_resume(struct wm_drive *d) +{ + int status; + + status = (d->play)(d, PAUSE_FRAME, END_FRAME); + PAUSE_FRAME = 0; + return (status); +} /* gen_resume() */ + +/*--------------* + * Stop the CD. + *--------------*/ +int +gen_stop(struct wm_drive *d) +{ + return cdstop(d->aux); +} /* gen_stop() */ + +/*----------------------------------------* + * Eject the current CD, if there is one. + *----------------------------------------*/ +int +gen_eject(struct wm_drive *d) +{ + cdeject(d->aux); + cdclose(d->aux); + d->aux = NULL; + free(d->daux); + d->daux = NULL; + + if (d->fd >= 0) + close(d->fd); /* close mixer */ + d->fd = -1; + return (0); +} /* gen_eject() */ + +/*----------------------------------------* + * Close the CD tray + *----------------------------------------*/ +int +gen_closetray(struct wm_drive *d) +{ +#ifdef CAN_CLOSE + if (!cdload(d->aux)) + return(0); + return(-1); +#else + /* Always succeed if the drive can't close */ + return(0); +#endif /* CAN_CLOSE */ +} /* gen_closetray() */ + + +/*------------------------------------------------------------------------* + * Return a volume value suitable for passing to the CD-ROM drive. "vol" + * is a volume slider setting; "max" is the slider's maximum value. + *------------------------------------------------------------------------*/ +static int +scale_volume(int vol, int max) +{ + /* on Toshiba XM-3401B drive, and on soundblaster, this works fine. */ + return ((vol * (max_volume - min_volume)) / max + min_volume); +} /* scale_volume() */ + +/*---------------------------------------------------------------------------* + * unscale_volume(cd_vol, max) + * + * Given a value between min_volume and max_volume, return the volume slider + * value needed to achieve that value. + * + * Rather than perform floating-point calculations to reverse the above + * formula, we simply do a binary search of scale_volume()'s return values. + *--------------------------------------------------------------------------*/ +static int +unscale_volume(int cd_vol, int max) +{ + int vol = 0, top = max, bot = 0, scaled; + + while (bot <= top) + { + vol = (top + bot) / 2; + scaled = scale_volume(vol, max); + if (cd_vol == scaled) + break; + if (cd_vol < scaled) + top = vol - 1; + else + bot = vol + 1; + } + + if (vol < 0) + vol = 0; + else if (vol > max) + vol = max; + + return (vol); +} /* unscale_volume() */ + +/*---------------------------------------------------------------------* + * Set the volume level for the left and right channels. Their values + * range from 0 to 100. + *---------------------------------------------------------------------*/ +int +gen_set_volume(struct wm_drive *d, int left, int right) +{ + int level; + + left = scale_volume(left, 100); + right = scale_volume(right, 100); + level = right << 8 | left; + + /* Send a Mixer IOCTL */ + if (d->fd >= 0) + (void) ioctl(d->fd, MIXER_WRITE(SOUND_MIXER_VOLUME), &level); +#ifdef notnow + /* NOTE: the cdvolume2() call is an addition to the cdrom library. + Pick it up from the archives on bsdi.com */ + cdvolume2 (CUR_CD, left < 0 ? 0 : left > 255 ? 255 : left, + right < 0 ? 0 : right > 255 ? 255 : right); + +#endif + return (0); +} + +/*---------------------------------------------------------------------* + * Read the initial volume from the drive, if available. Each channel + * ranges from 0 to 100, with -1 indicating data not available. + *---------------------------------------------------------------------*/ +int +gen_get_volume(struct wm_drive *d, int *left, int *right) +{ + int level; + + /* Most systems can't seem to do this... */ + *left = *right = -1; + + /* Send a Mixer IOCTL */ + if (d->fd >= 0) { + if (ioctl(d->fd, MIXER_READ(SOUND_MIXER_VOLUME), &level) == 0) { + *left = unscale_volume((level & 0xff) & 0xff, 100); + *right = unscale_volume((level >> 8) & 0xff, 100); + } + } + return (0); +} + +/*------------------------------------------------------------------------* + * gen_get_cdtext(drive, buffer, lenght) + *------------------------------------------------------------------------*/ + +int +gen_get_cdtext(struct wm_drive *d, unsigned char **pp_buffer, int *p_buffer_lenght) +{ + return -1; /* no SCSI, no CDTEXT */ +} /* gen_get_cdtext() */ + + +#endif /* __bsdi__ */ diff --git a/kscd/libwm/plat_freebsd.c b/kscd/libwm/plat_freebsd.c new file mode 100644 index 00000000..b1028a75 --- /dev/null +++ b/kscd/libwm/plat_freebsd.c @@ -0,0 +1,560 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * plat_freebsd.c + * + * FreeBSD-specific drive control routines. + * + * Todd Pfaff, 3/20/94 + * + */ + +#if defined(__FreeBSD__) || defined(__FreeBSD) || defined(__NetBSD__) || defined (__NetBSD) || defined(__DragonFly__) + +#include <errno.h> +#include <stdio.h> +#include <fcntl.h> +#include <string.h> +#include <unistd.h> +#include <sys/types.h> +#include <sys/param.h> +#include <sys/mount.h> +#include <sys/stat.h> + +#include "include/wm_config.h" + +#include <sys/time.h> +#include <sys/ioctl.h> +#include <sys/cdio.h> + +#if defined(__OpenBSD__) +# define MSF_MINUTES 1 +# define MSF_SECONDS 2 +# define MSF_FRAMES 3 +# include <sys/scsiio.h> +# include "/sys/scsi/scsi_all.h" +# include "/sys/scsi/scsi_cd.h" +#elif defined(__NetBSD__) +#include <sys/scsiio.h> +#include <dev/scsipi/scsipi_cd.h> +#else +# define LEFT_PORT 0 +# define RIGHT_PORT 1 +# if defined(__FreeBSD_version) && __FreeBSD_version < 300000 +# include <scsi.h> +# endif +#endif + +#include "include/wm_struct.h" +#include "include/wm_platform.h" +#include "include/wm_cdrom.h" +#include "include/wm_scsi.h" +#include "include/wm_helpers.h" +#include "include/wm_cdtext.h" + +#define WM_MSG_CLASS WM_MSG_CLASS_PLATFORM + +void *malloc(); + +int min_volume = 10; +int max_volume = 255; + + +/*--------------------------------------------------------* + * Initialize the drive. A no-op for the generic driver. + *--------------------------------------------------------*/ +int +gen_init(struct wm_drive *d) +{ + return (0); +} /* gen_init() */ + + +/*-------------------------------------------------------------------* + * Open the CD device and figure out what kind of drive is attached. + *-------------------------------------------------------------------*/ +int +wmcd_open( struct wm_drive *d ) +{ + int fd; + static int warned = 0; + char vendor[32] = WM_STR_GENVENDOR; + char model[32] = WM_STR_GENMODEL; + char rev[32] = WM_STR_GENREV; + + if (d->fd >= 0) /* Device already open? */ + { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_open(): [device is open (fd=%d)]\n", d->fd); + return (0); + } + + if (d->cd_device == NULL) + d->cd_device = DEFAULT_CD_DEVICE; + + d->fd = open(d->cd_device, 0); + if (d->fd < 0) + { + if (errno == EACCES) + { + return -EACCES; + } + + /* No CD in drive. */ + return (1); + } + + /* Now fill in the relevant parts of the wm_drive structure. */ + fd = d->fd; + + find_drive_struct(vendor, model, rev); + + /*(d->init)(d); */ + + d->fd = fd; + + return (0); +} /* wmcd_open() */ + +/* + * Re-Open the device if it is open. + */ +int +wmcd_reopen( struct wm_drive *d ) +{ + int status; + + do { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_reopen\n"); + status = gen_close( d ); + wm_susleep( 1000 ); + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "calling wmcd_open()\n"); + status = wmcd_open( d ); /* open it as usual */ + wm_susleep( 1000 ); + if(status == -EACCES || status == 1) + return status; + } while ( status != 0 ); + return status; +} /* wmcd_reopen() */ + +/*---------------------------------------------* + * Send an arbitrary SCSI command to a device. + * + *---------------------------------------------*/ +int +wm_scsi(struct wm_drive *d, unsigned char *cdb, int cdblen, + void *retbuf, int retbuflen, int getreply) +{ + return (-1); +} /* wm_scsi() */ + +int +gen_close( struct wm_drive *d ) +{ + if(d->fd != -1) { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "closing the device\n"); + close(d->fd); + d->fd = -1; + } + return 0; +} + +/*--------------------------------------------------------------------------* + * Get the current status of the drive: the current play mode, the absolute + * position from start of disc (in frames), and the current track and index + * numbers if the CD is playing or paused. + *--------------------------------------------------------------------------*/ +int +gen_get_drive_status(struct wm_drive *d, int oldmode, + int *mode, int *pos, int *track, int *index) +{ + struct ioc_read_subchannel sc; + struct cd_sub_channel_info scd; + + /* If we can't get status, the CD is ejected, so default to that. */ + *mode = WM_CDM_EJECTED; + + sc.address_format = CD_MSF_FORMAT; + sc.data_format = CD_CURRENT_POSITION; + sc.track = 0; + sc.data_len = sizeof(scd); + sc.data = (struct cd_sub_channel_info *)&scd; + + /* Is the device open? */ + if (d->fd < 0) + { + switch (wmcd_open(d)) + { + case -1: /* error */ + return (-1); + + case 1: /* retry */ + return (0); + } + } + + if (ioctl(d->fd, CDIOCREADSUBCHANNEL, &sc)) + { + /* + * #ifdef __NetBSD__ + * + * Denis Bourez <denis@rsn.fdn.fr> told me, that closing the + * device is mandatory for FreeBSD, too. + */ + /* we need to release the device so the kernel will notice + reloaded media */ + (void) close(d->fd); + d->fd = -1; + /* + * #endif + */ + return (0); /* ejected */ + } + + switch (scd.header.audio_status) + { + case CD_AS_PLAY_IN_PROGRESS: + *mode = WM_CDM_PLAYING; + dopos: + *pos = scd.what.position.absaddr.msf.minute * 60 * 75 + + scd.what.position.absaddr.msf.second * 75 + + scd.what.position.absaddr.msf.frame; + *track = scd.what.position.track_number; + *index = scd.what.position.index_number; + break; + + case CD_AS_PLAY_PAUSED: + if (oldmode == WM_CDM_PLAYING || oldmode == WM_CDM_PAUSED) + { + *mode = WM_CDM_PAUSED; + goto dopos; + } + else + *mode = WM_CDM_STOPPED; + break; + + case CD_AS_PLAY_COMPLETED: + *mode = WM_CDM_TRACK_DONE; /* waiting for next track. */ + break; + + case CD_AS_NO_STATUS: + case 0: + *mode = WM_CDM_STOPPED; + break; + } + + return (0); +} /* gen_get_drive_status() */ + + +/*-------------------------------------* + * Get the number of tracks on the CD. + *-------------------------------------*/ +int +gen_get_trackcount(struct wm_drive *d, int *tracks) +{ + struct ioc_toc_header hdr; + + if (ioctl(d->fd, CDIOREADTOCHEADER, &hdr) == -1) + return (-1); + + *tracks = hdr.ending_track - hdr.starting_track + 1; + + return (0); +} /* gen_get_trackcount() */ + +/*-----------------------------------------------------------------------* + * Get the start time and mode (data or audio) of a track. + * + * XXX - this should get cached, but that means keeping track of ejects. + *-----------------------------------------------------------------------*/ +int +gen_get_trackinfo(struct wm_drive *d, int track, int *data, int *startframe) +{ + struct ioc_read_toc_entry toc; + struct cd_toc_entry toc_buffer; + + bzero((char *)&toc_buffer, sizeof(toc_buffer)); + toc.address_format = CD_MSF_FORMAT; + toc.starting_track = track; + toc.data_len = sizeof(toc_buffer); + toc.data = &toc_buffer; + + if (ioctl(d->fd, CDIOREADTOCENTRYS, &toc)) + return (-1); + + *data = ((toc_buffer.control & 0x4) != 0); + + *startframe = toc_buffer.addr.msf.minute*60*75 + + toc_buffer.addr.msf.second * 75 + + toc_buffer.addr.msf.frame; + + return (0); +} /* gen_get_trackinfo() */ + +/*-------------------------------------* + * Get the number of frames on the CD. + *-------------------------------------*/ +int +gen_get_cdlen(struct wm_drive *d, int *frames) +{ + int tmp; + struct ioc_toc_header hdr; + int status; + +#define LEADOUT 0xaa /* see scsi.c. what a hack! */ + return gen_get_trackinfo(d, LEADOUT, &tmp, frames); +} /* gen_get_cdlen() */ + + +/*------------------------------------------------------------* + * Play the CD from one position to another (both in frames.) + *------------------------------------------------------------*/ +int +gen_play(struct wm_drive *d, int start, int end, int realstart) +{ + struct ioc_play_msf msf; + + msf.start_m = start / (60*75); + msf.start_s = (start % (60*75)) / 75; + msf.start_f = start % 75; + msf.end_m = end / (60*75); + msf.end_s = (end % (60*75)) / 75; + msf.end_f = end % 75; + + if (ioctl(d->fd, CDIOCSTART)) + return (-1); + + if (ioctl(d->fd, CDIOCPLAYMSF, &msf)) + return (-2); + + return (0); +} /* gen_play() */ + +/*---------------* + * Pause the CD. + *---------------*/ +int +gen_pause( struct wm_drive *d ) +{ + return (ioctl(d->fd, CDIOCPAUSE)); +} /* gen_pause() */ + +/*-------------------------------------------------* + * Resume playing the CD (assuming it was paused.) + *-------------------------------------------------*/ +int +gen_resume( struct wm_drive *d ) +{ + return (ioctl(d->fd, CDIOCRESUME)); +} /* gen_resume() */ + +/*--------------* + * Stop the CD. + *--------------*/ +int +gen_stop( struct wm_drive *d) +{ + return (ioctl(d->fd, CDIOCSTOP)); +} /* gen_stop() */ + +/*----------------------------------------* + * Eject the current CD, if there is one. + *----------------------------------------*/ +int +gen_eject( struct wm_drive *d ) +{ + /* On some systems, we can check to see if the CD is mounted. */ + struct stat stbuf; + struct statfs buf; + int rval; + + if (fstat(d->fd, &stbuf) != 0) + return (-2); + + /* Is this a mounted filesystem? */ + if (fstatfs(stbuf.st_rdev, &buf) == 0) + return (-3); + + rval = ioctl(d->fd, CDIOCALLOW); + + if (rval == 0) + rval = ioctl(d->fd, CDIOCEJECT); + + if (rval == 0) + rval = ioctl(d->fd, CDIOCPREVENT); + + (void) close(d->fd); + + return rval; +} /* gen_eject() */ + +/*----------------------------------------* + * Close the CD tray + *----------------------------------------*/ + +int +gen_closetray(struct wm_drive *d) +{ +#ifdef CAN_CLOSE + if(!close(d->fd)) + { + d->fd=-1; + return(wmcd_reopen(d)); + } else { + return(-1); + } +#else + /* Always succeed if the drive can't close */ + return(0); +#endif /* CAN_CLOSE */ +} /* gen_closetray() */ + + +/*---------------------------------------------------------------------------* + * scale_volume(vol, max) + * + * Return a volume value suitable for passing to the CD-ROM drive. "vol" + * is a volume slider setting; "max" is the slider's maximum value. + * + * On Sun and DEC CD-ROM drives, the amount of sound coming out the jack + * increases much faster toward the top end of the volume scale than it + * does at the bottom. To make up for this, we make the volume scale look + * sort of logarithmic (actually an upside-down inverse square curve) so + * that the volume value passed to the drive changes less and less as you + * approach the maximum slider setting. The actual formula looks like + * + * (max^2 - (max - vol)^2) * (max_volume - min_volume) + * v = --------------------------------------------------- + min_volume + * max^2 + * + * If your system's volume settings aren't broken in this way, something + * like the following should work: + * + * return ((vol * (max_volume - min_volume)) / max + min_volume); + *---------------------------------------------------------------------------*/ +static int +scale_volume(int vol, int max) +{ + return ((vol * (max_volume - min_volume)) / max + min_volume); +} /* scale_volume() */ + +/*---------------------------------------------------------------------------* + * unscale_volume(cd_vol, max) + * + * Given a value between min_volume and max_volume, return the volume slider + * value needed to achieve that value. + * + * Rather than perform floating-point calculations to reverse the above + * formula, we simply do a binary search of scale_volume()'s return values. + *--------------------------------------------------------------------------*/ +static int +unscale_volume( int cd_vol, int max ) +{ + int vol = 0, top = max, bot = 0, scaled; + + while (bot <= top) + { + vol = (top + bot) / 2; + scaled = scale_volume(vol, max); + if (cd_vol == scaled) + break; + if (cd_vol < scaled) + top = vol - 1; + else + bot = vol + 1; + } + + if (vol < 0) + vol = 0; + else if (vol > max) + vol = max; + + return (vol); +} /* unscale_volume() */ + +/*---------------------------------------------------------------------* + * Set the volume level for the left and right channels. Their values + * range from 0 to 100. + *---------------------------------------------------------------------*/ +int +gen_set_volume(struct wm_drive *d, int left, int right) +{ + struct ioc_vol vol; + + if (left < 0) /* don't laugh, I saw this happen once! */ + left = 0; + if (right < 0) + right = 0; + left = scale_volume(left, 100); + right = scale_volume(right, 100); + + bzero((char *)&vol, sizeof(vol)); + + vol.vol[LEFT_PORT] = left; + vol.vol[RIGHT_PORT] = right; + + if (ioctl(d->fd, CDIOCSETVOL, &vol)) + return (-1); + + return (0); +} /* gen_set_volume() */ + +/*---------------------------------------------------------------------* + * Read the initial volume from the drive, if available. Each channel + * ranges from 0 to 100, with -1 indicating data not available. + *---------------------------------------------------------------------*/ +int +gen_get_volume( struct wm_drive *d, int *left, int *right ) +{ + struct ioc_vol vol; + + if (d->fd >= 0) + { + bzero((char *)&vol, sizeof(vol)); + + if (ioctl(d->fd, CDIOCGETVOL, &vol)) + *left = *right = -1; + else + { + *left = unscale_volume(vol.vol[LEFT_PORT], 100); + *right = unscale_volume(vol.vol[RIGHT_PORT], 100); + } + } else { + *left = *right = -1; + } + return (0); +} /* gen_get_volume() */ + +/*------------------------------------------------------------------------* + * gen_get_cdtext(drive, buffer, lenght) + *------------------------------------------------------------------------*/ + +int +gen_get_cdtext(struct wm_drive *d, unsigned char **pp_buffer, int *p_buffer_lenght) +{ + return -1; /* no SCSI, no CDTEXT */ +} /* gen_get_cdtext() */ + + +#endif diff --git a/kscd/libwm/plat_hpux.c b/kscd/libwm/plat_hpux.c new file mode 100644 index 00000000..53aaee40 --- /dev/null +++ b/kscd/libwm/plat_hpux.c @@ -0,0 +1,358 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * HP/UX-specific drive control routines. + */ + +#if defined(hpux) || defined(__hpux) + +#include <errno.h> +#include <stdio.h> +#include <fcntl.h> +#include <ustat.h> +#include <unistd.h> +#include <sys/types.h> +#include <sys/param.h> +#include <sys/stat.h> + +#include "include/wm_config.h" + +/* + * this is for glibc 2.x which the ust structure in + * ustat.h not stat.h + */ +#ifdef __GLIBC__ +#include <sys/ustat.h> +#endif + +#include <sys/time.h> +#include <sys/scsi.h> + +#include "include/wm_struct.h" +#include "include/wm_helpers.h" +#include "include/wm_cdtext.h" + +#define WM_MSG_CLASS WM_MSG_CLASS_PLATFORM + +void *malloc(); +char *strchr(); + +int min_volume = 0; +int max_volume = 255; + +/*--------------------------------------------------------* + * Initialize the drive. A no-op for the generic driver. + *--------------------------------------------------------*/ +int +gen_init( struct wm_drive *d ) +{ + return (0); +} /* gen_init() */ + + +/*-------------------------------------------------------------* + * Open the CD and figure out which kind of drive is attached. + *-------------------------------------------------------------*/ +int +wmcd_open( struct wm_drive *d ) +{ + int fd, flag = 1; + static int warned = 0; + /* unsigned ? */ + char vendor[32], model[32], rev[32]; + + if (d->fd >= 0) /* Device already open? */ + { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_open(): [device is open (fd=%d)]\n", d->fd); + return (0); + } + + if (d->cd_device == NULL) + d->cd_device = DEFAULT_CD_DEVICE; + + d->fd = open(d->cd_device, O_RDWR); + if (d->fd < 0) + { + if (errno == EACCES) + { + return -EACCES; + } + else if (errno != EINTR) + { + return (-6); + } + + /* No CD in drive. */ + return (1); + } + + /* Prepare the device to receive raw SCSI commands. */ + if (ioctl(d->fd, SIOC_CMD_MODE, &flag) < 0) + { + fprintf(stderr, "%s: SIOC_CMD_MODE: true: %s\n", + d->cd_device, strerror(errno)); + /*exit(1);*/ + } + + /* Now fill in the relevant parts of the wm_drive structure. */ + fd = d->fd; + + /* Default drive is the HP one, which might not respond to INQUIRY */ + strcpy(&vendor, "TOSHIBA"); + strcpy(&model, "XM-3301"); + rev[0] = '\0'; + wm_scsi_get_drive_type(d, vendor, model, rev); + find_drive_struct(vendor, model, rev); + + d->fd = fd; + + (d->init)(d); + + return (0); +} /* wmcd_open() */ + +/* + * Re-Open the device if it is open. + */ +int +wmcd_reopen( struct wm_drive *d ) +{ + int status; + + do { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_reopen\n"); + status = gen_close( d ); + wm_susleep( 1000 ); + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "calling wmcd_open()\n"); + status = wmcd_open( d ); /* open it as usual */ + wm_susleep( 1000 ); + } while ( status != 0 ); + return status; +} /* wmcd_reopen() */ + +/*----------------------------------* + * Send a SCSI command out the bus. + *----------------------------------*/ +int +wm_scsi( struct wm_drive *d, unsigned char *cdb, int cdblen, + void *retbuf, int retbuflen, int getreply ) +{ +#ifdef SIOC_IO + struct sctl_io cmd; + + memset(&cmd, 0, sizeof(cmd)); + cmd.cdb_length = cdblen; + cmd.data = retbuf; + cmd.data_length = retbuflen; + cmd.max_msecs = 1000; + cmd.flags = getreply ? SCTL_READ : 0; + memcpy(cmd.cdb, cdb, cdblen); + + return (ioctl(d->fd, SIOC_IO, &cmd)); +#else + /* this code, for pre-9.0, is BROKEN! ugh. */ + char reply_buf[12]; + struct scsi_cmd_parms cmd; + + memset(&cmd, 0, sizeof(cmd)); + cmd.clock_ticks = 500; + cmd.cmd_mode = 1; + cmd.cmd_type = cdblen; + memcpy(cmd.command, cdb, cdblen); + if (ioctl(d->fd, SIOC_SET_CMD, &cmd) < 0) + return (-1); + + if (! retbuf || ! retbuflen) + (void) read(d->fd, reply_buf, sizeof(reply_buf)); + else if (getreply) + { + if (read(d->fd, retbuf, retbuflen) < 0) + return (-1); + } + else + if (write(d->fd, retbuf, retbuflen) < 0) + return (-1); + + return (0); +#endif +} /* wm_scsi() */ + +int +gen_close( struct wm_drive *d ) +{ + if(d->fd != -1) { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "closing the device\n"); + close(d->fd); + d->fd = -1; + } + return 0; +} + +/*--------------------------------------------------------------------------* + * Get the current status of the drive: the current play mode, the absolute + * position from start of disc (in frames), and the current track and index + * numbers if the CD is playing or paused. + *--------------------------------------------------------------------------*/ +int +gen_get_drive_status( struct wm_drive *d, int oldmode, int *mode, + int *pos, int *track, int *index ) +{ + return (wm_scsi2_get_drive_status(d, oldmode, mode, pos, track, index)); +} /* gen_get_drive_status() */ + +/*-------------------------------------* + * Get the number of tracks on the CD. + *-------------------------------------*/ +int +gen_get_trackcount(struct wm_drive *d, int *tracks ) +{ + return (wm_scsi2_get_trackcount(d, tracks)); +} /* gen_get_trackcount() */ + +/*---------------------------------------------------------* + * Get the start time and mode (data or audio) of a track. + *---------------------------------------------------------*/ +int +gen_get_trackinfo( struct wm_drive *d, int *track, int *data, int *startframe) +{ + return (wm_scsi2_get_trackinfo(d, track, data, startframe)); +} /* gen_get_trackinfo() */ + +/*-------------------------------------* + * Get the number of frames on the CD. + *-------------------------------------*/ +int +gen_get_cdlen(struct wm_drive *d, int *frames) +{ + int tmp; + + return (wm_scsi2_get_cdlen(d, frames)); +} /* gen_get_cdlen() */ + +/*------------------------------------------------------------* + * Play the CD from one position to another (both in frames.) + *------------------------------------------------------------*/ +int +gen_play( struct wm_drive *d, int start, int end ) +{ + return (wm_scsi2_play(d, start, end)); +} /* gen_play() */ + +/*---------------* + * Pause the CD. + *---------------*/ +int +gen_pause( struct wm_drive *d ) +{ + return (wm_scsi2_pause(d)); +} /* gen_pause() */ + +/*-------------------------------------------------* + * Resume playing the CD (assuming it was paused.) + *-------------------------------------------------*/ +int +gen_resume( struct wm_drive *d ) +{ + return (wm_scsi2_resume(d)); +} /* gen_resume() */ + +/*--------------* + * Stop the CD. + *--------------*/ +int +gen_stop( struct wm_drive *d ) +{ + return (wm_scsi2_stop(d)); +} /* gen_stop() */ + + +/*----------------------------------------* + * Eject the current CD, if there is one. + *----------------------------------------*/ +int +gen_eject( struct wm_drive *d ) +{ + struct stat stbuf; + struct ustat ust; + + if (fstat(d->fd, &stbuf) != 0) + return (-2); + + /* Is this a mounted filesystem? */ + if (ustat(stbuf.st_rdev, &ust) == 0) + return (-3); + + return (wm_scsi2_eject(d)); +} /* gen_eject() */ + +/*----------------------------------------* + * Close the CD tray + *----------------------------------------*/ +int +gen_closetray(struct wm_drive *d) +{ +#ifdef CAN_CLOSE + return (wm_scsi2_closetray(d)); +#else + /* Always succeed if the drive can't close */ + return(0); +#endif /* CAN_CLOSE */ +} /* gen_closetray() */ + + +/*---------------------------------------------------------------------* + * Set the volume level for the left and right channels. Their values + * range from 0 to 100. + *---------------------------------------------------------------------*/ +int +gen_set_volume( struct wm_drive *d, int left, int right ) +{ + return (wm_scsi2_set_volume(d, left, right)); +} /* gen_set_volume() */ + +/*---------------------------------------------------------------------* + * Read the initial volume from the drive, if available. Each channel + * ranges from 0 to 100, with -1 indicating data not available. + *---------------------------------------------------------------------*/ +int +gen_get_volume( struct wm_drive *d, int *left, int *right ) +{ + return (wm_scsi2_get_volume(d, left, right)); +} /* gen_get_volume() */ + +/*------------------------------------------------------------------------* + * gen_get_cdtext(drive, buffer, lenght) + *------------------------------------------------------------------------*/ + +int +gen_get_cdtext(struct wm_drive *d, unsigned char **pp_buffer, int *p_buffer_lenght) +{ + /* This needs to be tested ! */ + return wm_scsi_get_cdtext(d, pp_buffer, p_buffer_lenght); +} /* gen_get_cdtext() */ + + +#endif + + diff --git a/kscd/libwm/plat_irix.c b/kscd/libwm/plat_irix.c new file mode 100644 index 00000000..7f1e3fc7 --- /dev/null +++ b/kscd/libwm/plat_irix.c @@ -0,0 +1,474 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * IRIX specific. + * + * Taken from the kscd distribution + * + * Paul Kendall + * paul@orion.co.nz, or + * paul@kcbbs.gen.nz + */ + +#if defined(sgi) || defined(__sgi) + +#include "include/wm_config.h" + +/* + * Yes, it was designed for WorkMan 1.4b3 + * Because I did start over from 1.3a, I disable it here. + * There is no guarantee of getting working code by defining + * CDDA yourself. + * + */ +#undef CDDA +/*#define CDDA*/ + +#include <sys/types.h> +#include <sys/time.h> +#include <stdio.h> +#include <ctype.h> +#include <string.h> +#include <fcntl.h> +#include <stdlib.h> +#include <unistd.h> +#include <signal.h> +#include <sigfpe.h> +#include <dmedia/cdaudio.h> +#include <dmedia/audio.h> +#include <errno.h> + +#include "include/wm_struct.h" +#include "include/wm_cdtext.h" + +#define WM_MSG_CLASS WM_MSG_CLASS_PLATFORM + +void *malloc(); +char *strchr(); + +int min_volume = 0; +int max_volume = 255; + +#ifdef CDDA +static int playing = STOPPED; +static CDPLAYER *icd; +static CDPARSER *icdp; +static CDFRAME cdbuf[12]; +static ALport audioport; +static ALconfig aconfig; +static struct itimerval audiotimer = { {0,0}, {0,25000} }; +static int cdtrack=0; +static int cdframe=0; +static int cdstopframe=0; + +/* + * Platform specific internal functions for CDDA + */ +void +cbprognum(void *arg, CDDATATYPES type, CDPROGNUM* prognum) +{ + cdtrack = prognum->value; +} /* cbprognum() */ + +void +cbabstime(void *arg, CDDATATYPES type, struct cdtimecode* atime) +{ + cdframe = CDtctoframe(atime); + if( cdframe == cdstopframe ) + playing = STOPPED; +} /* cbabstime() */ + +void +cbplayaudio(void *arg, CDDATATYPES type, short* audio) +{ + if(playing != PLAYING) return; + ALwritesamps(audioport, audio, CDDA_NUMSAMPLES); +} /* cbplayaudio() */ + +static void +alarmsignal() +{ + int n, i; + if(playing != PLAYING) return; + if( ALgetfilled(audioport) < CDDA_NUMSAMPLES*8 ) + { + /* Only get more samples and play them if we're getting low + * this ensures that the CD stays close to the sound + */ + n = CDreadda(icd, cdbuf, 12); + if( n == 0 ) return; + for( i=0 ; i<12 ; i++ ) + CDparseframe(icdp, &cdbuf[i]); + } + signal(SIGALRM, alarmsignal); + setitimer(ITIMER_REAL, &audiotimer, NULL); +} /* alarmsignal() */ +#endif + +/*--------------------------------------------------------* + * Initialize the drive. A no-op for the generic driver. + *--------------------------------------------------------*/ +int +gen_init( struct wm_drive *d ) +{ +#ifdef CDDA + long Param[4]; + /* Set the audio rate to 44100Hz 16bit 2s-comp stereo */ + aconfig = ALnewconfig(); + ALsetwidth(aconfig, AL_SAMPLE_16); + ALsetsampfmt(aconfig, AL_SAMPFMT_TWOSCOMP); + ALsetchannels(aconfig, 2); + Param[0] = AL_OUTPUT_RATE; Param[1] = AL_RATE_44100; + Param[2] = AL_CHANNEL_MODE; Param[3] = AL_STEREO; + ALsetparams(AL_DEFAULT_DEVICE, Param, 4); + audioport = ALopenport("KDE KSCD Audio", "w", aconfig); + + /* setup cdparser */ + icdp = CDcreateparser(); + CDaddcallback(icdp, cd_audio, (CDCALLBACKFUNC)cbplayaudio, 0); + CDaddcallback(icdp, cd_pnum, (CDCALLBACKFUNC)cbprognum, 0); + CDaddcallback(icdp, cd_atime, (CDCALLBACKFUNC)cbabstime, 0); + + /* Lets handle those floating point exceptions expeditiously. */ + sigfpe_[_UNDERFL].repls = _ZERO; + handle_sigfpes(_ON, _EN_UNDERFL, NULL, _ABORT_ON_ERROR, NULL); +#endif + return 0; +} /* gen_init() */ + +/*-------------------------------------------------------------* + * Open the CD and figure out which kind of drive is attached. + *-------------------------------------------------------------*/ +int +wmcd_open( struct wm_drive *d ) +{ + int fd; + CDSTATUS s; + + if (d->fd < 0) /* Device already open? */ + { + if (d->cd_device == NULL) + d->cd_device = DEFAULT_CD_DEVICE; + + d->fd = 1; + + /* Now fill in the relevant parts of the wm_drive structure. */ + fd = d->fd; + find_drive_struct("", "", ""); + d->fd = fd; + (d->init)(d); + + d->daux = CDopen(d->cd_device,"r"); + if (d->daux == 0) + { + return (-6); + } +#ifdef CDDA + icd = d->daux; +#endif + } else { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_open(): [device is open (fd=%d)]\n", d->fd); + } + + CDgetstatus(d->daux, &s); + if( s.state==CD_NODISC || s.state==CD_ERROR ) + return 1; + + return (0); +} /* wmcd_open() */ + +/* + * Re-Open the device if it is open. + */ +int +wmcd_reopen( struct wm_drive *d ) +{ + int status; + + do { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_reopen\n"); + status = gen_close( d ); + wm_susleep( 1000 ); + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "calling wmcd_open()\n"); + status = wmcd_open( d ); /* open it as usual */ + wm_susleep( 1000 ); + } while ( status != 0 ); + return status; +} /* wmcd_reopen() */ + + +/*----------------------------------* + * Send a SCSI command out the bus. + *----------------------------------*/ +int +wm_scsi( struct wm_drive *d, unsigned char *xcdb, int cdblen, + char *retbuf, int retbuflen, int getreply) +{ + return -1; +} /* wm_scsi() */ + +int +gen_close( struct wm_drive *d ) +{ + if(d->fd != -1) { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "closing the device\n"); + close(d->fd); + d->fd = -1; + } + return 0; +} + +/*--------------------------------------------------------------------------* + * Get the current status of the drive: the current play mode, the absolute + * position from start of disc (in frames), and the current track and index + * numbers if the CD is playing or paused. + *--------------------------------------------------------------------------*/ +int +gen_get_drive_status( struct wm_drive *d, int oldmode, + int *mode, int *pos, int *track, + int *index ) +{ +#ifdef CDDA + *mode = playing; + *track = cdtrack; + *pos = cdframe; + *index = 0; +#else + CDSTATUS s; + if( CDgetstatus(d->daux, &s)==0 ) + return -1; + *pos = CDmsftoframe(s.min,s.sec,s.frame); + *track = s.track; + *index = 0; + switch( s.state ) + { + case CD_READY: *mode = WM_CDM_STOPPED; + break; + case CD_STILL: + case CD_PAUSED: *mode = WM_CDM_PAUSED; + break; + case CD_PLAYING: *mode = WM_CDM_PLAYING; + break; + default: *mode = WM_CDM_UNKNOWN; + } +#endif + return 0; +} /* gen_get_drive_status() */ + +/*-------------------------------------* + * Get the number of tracks on the CD. + *-------------------------------------*/ +int +gen_get_trackcount( struct wm_drive *d, int *tracks ) +{ + CDSTATUS s; + if( CDgetstatus(d->daux, &s)==0 ) + return -1; + *tracks = s.last; + return 0; +} /* gen_get_trackcount() */ + +/*---------------------------------------------------------* + * Get the start time and mode (data or audio) of a track. + *---------------------------------------------------------*/ +int +gen_get_trackinfo( struct wm_drive *d, int track, int *data, int *startframe) +{ + CDTRACKINFO i; + int ret = CDgettrackinfo(d->daux, track, &i); + if( ret == 0 ) + return -1; + *data = 0; + *startframe = CDmsftoframe(i.start_min,i.start_sec,i.start_frame); + return 0; +} /* gen_get_trackinfo() */ + +/*-------------------------------------* + * Get the number of frames on the CD. + *-------------------------------------*/ +int +gen_get_cdlen( struct wm_drive *d, int *frames ) +{ + CDSTATUS s; + if( CDgetstatus(d->daux, &s)==0 ) + return -1; + *frames = CDmsftoframe(s.total_min,s.total_sec,s.total_frame); + return 0; +} /* gen_get_cdlen() */ + +/*------------------------------------------------------------* + * Play the CD from one position to another (both in frames.) + *------------------------------------------------------------*/ +int +gen_play( struct wm_drive *d, int start, int end ) +{ +#ifdef CDDA + int m, s, f; + CDframetomsf(start, &m, &s, &f); + CDseek(icd, m, s, f); + cdstopframe = end; + playing = PLAYING; + signal(SIGALRM, alarmsignal); + setitimer(ITIMER_REAL, &audiotimer, NULL); +#else + int m, s, f; + CDframetomsf(start, &m, &s, &f); + CDplayabs(d->daux, m, s, f, 1); +#endif + return 0; +} /* gen_play() */ + +/*---------------* + * Pause the CD. + *---------------*/ +int +gen_pause( struct wm_drive *d ) +{ +#ifdef CDDA + playing = WM_CDM_PAUSED; +#else + CDSTATUS s; + if( CDgetstatus(d->daux, &s)==0 ) + return -1; + if(s.state == CD_PLAYING) + CDtogglepause(d->daux); +#endif + return 0; +} /* gen_pause() */ + +/*-------------------------------------------------* + * Resume playing the CD (assuming it was paused.) + *-------------------------------------------------*/ +int +gen_resume( struct wm_drive *d ) +{ +#ifdef CDDA + playing = WM_CDM_PLAYING; + signal(SIGALRM, alarmsignal); + setitimer(ITIMER_REAL, &audiotimer, NULL); +#else + CDSTATUS s; + if( CDgetstatus(d->daux, &s)==0 ) + return -1; + if(s.state == CD_PAUSED) + CDtogglepause(d->daux); +#endif + return 0; +} /* gen_resume() */ + +/*--------------* + * Stop the CD. + *--------------*/ +int +gen_stop( struct wm_drive *d ) +{ +#ifdef CDDA + playing = WM_CDM_STOPPED; +#else + CDstop(d->daux); +#endif + return 0; +} /* gen_stop() */ + +/*----------------------------------------* + * Eject the current CD, if there is one. + *----------------------------------------*/ +int +gen_eject( struct wm_drive *d ) +{ +#ifdef CDDA + playing = WM_CDM_STOPPED; +#endif + CDeject(d->daux); + return 0; +} /* gen_eject() */ + +/*----------------------------------------* + * Close the CD tray + * + * Please edit and send changes to + * milliByte@Deathsdoor.com + *----------------------------------------*/ + +int +gen_closetray(struct wm_drive *d) +{ +#ifdef CAN_CLOSE + if(!close(d->fd)) + { + d->fd=-1; + return(wmcd_reopen(d)); + } else { + return(-1); + } +#else + /* Always succeed if the drive can't close */ + return(0); +#endif /* CAN_CLOSE */ +} /* gen_closetray() */ + +/*---------------------------------------------------------------------* + * Set the volume level for the left and right channels. Their values + * range from 0 to 100. + *---------------------------------------------------------------------*/ +int +gen_set_volume( struct wm_drive *d, int left, int right ) +{ + long Param[4]; + Param[0] = AL_LEFT_SPEAKER_GAIN; Param[1] = left*255/100; + Param[2] = AL_RIGHT_SPEAKER_GAIN; Param[3] = right*255/100; + ALsetparams(AL_DEFAULT_DEVICE, Param, 4); + return 0; +} /* gen_set_volume() */ + +/*---------------------------------------------------------------------* + * Read the initial volume from the drive, if available. Each channel + * ranges from 0 to 100, with -1 indicating data not available. + *---------------------------------------------------------------------*/ +int +gen_get_volume( struct wm_drive *d, int *left, int *right ) +{ + long Param[4]; + Param[0] = AL_LEFT_SPEAKER_GAIN; Param[1] = 0; + Param[2] = AL_RIGHT_SPEAKER_GAIN; Param[3] = 0; + ALgetparams(AL_DEFAULT_DEVICE, Param, 4); + *left = Param[1] * 100 / 255; + *right = Param[3] * 100 / 255; + return 0; +} /* gen_get_volume() */ + + +/*------------------------------------------------------------------------* + * gen_get_cdtext(drive, buffer, lenght) + *------------------------------------------------------------------------*/ + +int +gen_get_cdtext(struct wm_drive *d, unsigned char **pp_buffer, int *p_buffer_lenght) +{ + return -1; /* no SCSI, no CDTEXT */ +} /* gen_get_cdtext() */ + + +#endif + diff --git a/kscd/libwm/plat_linux.c b/kscd/libwm/plat_linux.c new file mode 100644 index 00000000..58768a40 --- /dev/null +++ b/kscd/libwm/plat_linux.c @@ -0,0 +1,803 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * Linux-specific drive control routines. Very similar to the Sun module. + */ + +#if defined(__linux__) + +#include <errno.h> +#include <stdio.h> +#include <stdlib.h> +#include <fcntl.h> +#include <unistd.h> +#include <string.h> +#include <sys/types.h> +#include <sys/param.h> +#include <sys/socket.h> +#include <sys/stat.h> +#include <sys/wait.h> +/* Try to get around bug #29274 */ +#include <linux/version.h> +#if 0 +/* this breaks the build on ia64 and s390 for example. + sys/types.h is already included and should provide __u64. + please tell where we really need this and let's try to find + a working #if case for everyone ... adrian@suse.de */ +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,50)) || (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,21) && LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) +#undef __GNUC__ +typedef unsigned long long __u64; +#endif +#endif + +#include "include/wm_config.h" +#include "include/wm_struct.h" +#include "include/wm_cdtext.h" + +#if defined(BSD_MOUNTTEST) + #include <mntent.h> +#else + /* + * this is for glibc 2.x which defines ust structure in + * ustat.h not stat.h + */ + #ifdef __GLIBC__ + #include <sys/ustat.h> + #endif +#endif + + +#include <sys/time.h> +#include <sys/ioctl.h> + +#ifndef __GNUC__ +#define __GNUC__ 1 +#endif +/* needed for vanilla kernel headers, which do provide __u64 only + for ansi */ +#undef __STRICT_ANSI__ +/* needed for non-ansi kernel headers */ +#define asm __asm__ +#define inline __inline__ +#include <asm/types.h> +#include <linux/cdrom.h> +#undef asm +#undef inline + +#include "include/wm_cdda.h" +#include "include/wm_struct.h" +#include "include/wm_platform.h" +#include "include/wm_cdrom.h" +#include "include/wm_scsi.h" +#include "include/wm_helpers.h" + +#ifdef OSS_SUPPORT +#include <linux/soundcard.h> +#define CD_CHANNEL SOUND_MIXER_CD +#endif + +#define WM_MSG_CLASS WM_MSG_CLASS_PLATFORM + +#define max(a,b) ((a) > (b) ? (a) : (b)) + +#ifdef LINUX_SCSI_PASSTHROUGH +/* this is from <scsi/scsi_ioctl.h> */ +# define SCSI_IOCTL_SEND_COMMAND 1 +#endif + +#ifdef BUILD_CDDA +int gen_cdda_init( struct wm_drive *d ); +#endif + +int min_volume = 0; +int max_volume = 255; + +#ifdef OSS_SUPPORT +int mixer; +char mixer_dev_name[20] = "/dev/mixer"; +#endif + +/*-------------------------------------------------------* + * + * + * CD-ROM drive functions. + * + * + *-------------------------------------------------------*/ + +/*--------------------------------------------------------* + * Initialize the drive. A no-op for the generic driver. + *--------------------------------------------------------*/ +int +gen_init( struct wm_drive *d ) +{ + return (0); +} /* gen_init() */ + +/*---------------------------------------------------------------------------* + * Open the CD device and figure out what kind of drive is attached. + *---------------------------------------------------------------------------*/ +int +wmcd_open( struct wm_drive *d ) +{ + int fd; + char vendor[32], model[32], rev[32]; + + if (d->cd_device == NULL) + d->cd_device = DEFAULT_CD_DEVICE; + + + if (d->fd >= 0) { /* Device already open? */ +/* wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_open(): [device is open (fd=%d)]\n", d->fd);*/ + return (0); + } + + fd = open(d->cd_device, O_RDONLY | O_NONBLOCK); + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_open(): device=%s fd=%d\n", d->cd_device, fd); + + if (fd < 0) + return -errno; + + /* Now fill in the relevant parts of the wm_drive structure. */ + d->fd = fd; + + /* + * See if we can do digital audio. + */ +#if defined(BUILD_CDDA) + if(d->cdda && gen_cdda_init(d)) { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_open(): failed in gen_cdda_init\n"); + gen_close(d); + return -1; + } +#endif + + /* Can we figure out the drive type? */ + if (wm_scsi_get_drive_type(d, vendor, model, rev)) { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_open(): inquiry failed\n"); + strcpy(vendor, "Generic"); + strcpy(model, "drive type"); + strcpy(rev, ""); + } + + if(find_drive_struct(vendor, model, rev) < 0) { + gen_close(d); + return -1; + } + + if(d->proto->gen_init) + return (d->proto->gen_init)(d); + + return 0; +} /* wmcd_open() */ + +/* + * Re-Open the device if it is open. + */ +int +wmcd_reopen( struct wm_drive *d ) +{ + int status; + int tries = 0; + + do { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_reopen\n"); + gen_close(d); + wm_susleep( 1000 ); + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "calls wmcd_open()\n"); + status = wmcd_open( d ); /* open it as usual */ + wm_susleep( 1000 ); + tries++; + } while ( (status != 0) && (tries < 10) ); + return status; +} /* wmcd_reopen() */ + +/*---------------------------------------------* + * Send an arbitrary SCSI command to a device. + *---------------------------------------------*/ +int +wm_scsi( struct wm_drive *d, unsigned char *cdb, int cdblen, + void *retbuf, int retbuflen, int getreply ) +{ +#ifdef LINUX_SCSI_PASSTHROUGH + + char *cmd; + int cmdsize; + + cmdsize = 2 * sizeof(int); + if (retbuf) + { + if (getreply) cmdsize += max(cdblen, retbuflen); + else cmdsize += (cdblen + retbuflen); + } + else cmdsize += cdblen; + + cmd = malloc(cmdsize); + if (cmd == NULL) + return (-1); + + ((int*)cmd)[0] = cdblen + ((retbuf && !getreply) ? retbuflen : 0); + ((int*)cmd)[1] = ((retbuf && getreply) ? retbuflen : 0); + + memcpy(cmd + 2*sizeof(int), cdb, cdblen); + if (retbuf && !getreply) + memcpy(cmd + 2*sizeof(int) + cdblen, retbuf, retbuflen); + + if (ioctl(d->fd, SCSI_IOCTL_SEND_COMMAND, cmd)) + { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "%s: ioctl() failure\n", __FILE__); + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "command buffer is:\n"); + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "%02x %02x %02x %02x %02x %02x\n", + cmd[0], cmd[1], cmd[2], cmd[3], cmd[4], cmd[5]); + free(cmd); + return (-1); + } + + if (retbuf && getreply) + memcpy(retbuf, cmd + 2*sizeof(int), retbuflen); + + free(cmd); + return 0; + +#else /* Linux SCSI passthrough*/ +/*----------------------------------------* + * send packet over cdrom interface + * kernel >= 2.2.16 + *----------------------------------------*/ +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,2,15)) + + struct cdrom_generic_command cdc; + struct request_sense sense; + int capability; + + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wm_scsi over CDROM_SEND_PACKET entered\n"); + + capability = ioctl(d->fd, CDROM_GET_CAPABILITY); + + if(!(capability & CDC_GENERIC_PACKET)) + { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "your CDROM or/and kernel don't support CDC_GENERIC_PACKET ...\n"); + return -1; + } + + memset(&cdc, 0, sizeof(struct cdrom_generic_command)); + memset(&sense, 0, sizeof(struct request_sense)); + + memcpy(cdc.cmd, cdb, cdblen); + + cdc.buffer = retbuf; + cdc.buflen = retbuflen; + cdc.stat = 0; + cdc.sense = &sense; + cdc.data_direction = getreply?CGC_DATA_READ:CGC_DATA_WRITE; + + /* sendpacket_over_cdrom_interface() */ + return ioctl(d->fd, CDROM_SEND_PACKET, &cdc); +#endif /* CDROM_SEND_PACKET */ + printf("ERROR: this binary was compiled without CDROM GENERIC PACKET SUPPORT. kernel version < 2.2.16?\n"); + printf("ERROR: if you have a SCSI CDROM, rebuild it with a #define LINUX_SCSI_PASSTHROUGH\n"); + return (-1); +#endif +} /* wm_scsi */ + +int +gen_close( struct wm_drive *d ) +{ + if(d->fd != -1) { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "closing the device\n"); + close(d->fd); + d->fd = -1; + } + return 0; +} + +/*--------------------------------* + * Keep the CD open all the time. + * disabled, analogous to 1.4b3 + *--------------------------------* +void +keep_cd_open( void ) +{ + int fd; + struct flock fl; + extern end; + + + for (fd = 0; fd < 256; fd++) + close(fd); + + if (fork()) + exit(0); + +#if defined(O_NOFOLLOW) + if ((fd = open("/tmp/cd.lock", O_RDWR | O_CREAT | O_NOFOLLOW, 0666)) < 0) +#else + if ((fd = open("/tmp/cd.lock", O_RDWR | O_CREAT, 0666)) < 0) +#endif + exit(0); + fl.l_type = F_WRLCK; + fl.l_whence = 0; + fl.l_start = 0; + fl.l_len = 0; + if (fcntl(fd, F_SETLK, &fl) < 0) + exit(0); + + if (open(cd_device, 0) >= 0) + { + brk(&end); + pause(); + } + + exit(0); +} +*/ + +/*--------------------------------------------------------------------------* + * Get the current status of the drive: the current play mode, the absolute + * position from start of disc (in frames), and the current track and index + * numbers if the CD is playing or paused. + *--------------------------------------------------------------------------*/ +int +gen_get_drive_status( struct wm_drive *d, int oldmode, + int *mode, int *pos, int *track, int *ind ) +{ + struct cdrom_subchnl sc; + int ret; + +#ifdef SBPCD_HACK + static int prevpos = 0; +#endif + + + /* Is the device open? */ + if (d->fd < 0) { + ret = wmcd_open(d); + if(ret < 0) /* error */ + return ret; + + if(ret == 1) { + /* retry */ + *mode = WM_CDM_UNKNOWN; + return 0; + } + } + + /* Try to get rid of the door locking */ + /* Don't care about return value. If it */ + /* works - fine. If not - ... */ + ioctl(d->fd, CDROM_LOCKDOOR, 0); + + *mode = WM_CDM_UNKNOWN; + + sc.cdsc_format = CDROM_MSF; + +#if defined(BUILD_CDDA) + IFCDDA(d) { + if(!cdda_get_drive_status(d, oldmode, mode, pos, track, ind)) { + if(*mode == WM_CDM_STOPPED) + *mode = WM_CDM_UNKNOWN; /* dont believe */ + } + } else +#endif + if(!ioctl(d->fd, CDROMSUBCHNL, &sc)) { + switch (sc.cdsc_audiostatus) { + case CDROM_AUDIO_PLAY: + *mode = WM_CDM_PLAYING; + *track = sc.cdsc_trk; + *ind = sc.cdsc_ind; + *pos = sc.cdsc_absaddr.msf.minute * 60 * 75 + + sc.cdsc_absaddr.msf.second * 75 + + sc.cdsc_absaddr.msf.frame; +#ifdef SBPCD_HACK + if( *pos < prevpos ) { + if( (prevpos - *pos) < 75 ) { + *mode = WM_CDM_TRACK_DONE; + } + } + + prevpos = *pos; +#endif + break; + + case CDROM_AUDIO_PAUSED: + if (oldmode == WM_CDM_PLAYING || oldmode == WM_CDM_PAUSED) { + *mode = WM_CDM_PAUSED; + *track = sc.cdsc_trk; + *ind = sc.cdsc_ind; + *pos = sc.cdsc_absaddr.msf.minute * 60 * 75 + + sc.cdsc_absaddr.msf.second * 75 + + sc.cdsc_absaddr.msf.frame; + } else + *mode = WM_CDM_STOPPED; + break; + + case CDROM_AUDIO_NO_STATUS: + *mode = WM_CDM_STOPPED; + break; + + case CDROM_AUDIO_COMPLETED: + *mode = WM_CDM_TRACK_DONE; /* waiting for next track. */ + break; + + case CDROM_AUDIO_INVALID: /**/ + default: + *mode = WM_CDM_UNKNOWN; + break; + } + } + + if(WM_CDS_NO_DISC(*mode)) { + /* verify status of drive */ + ret = ioctl(d->fd, CDROM_DRIVE_STATUS, 0/* slot */); + if(ret == CDS_DISC_OK) + ret = ioctl(d->fd, CDROM_DISC_STATUS, 0); + switch(ret) { + case CDS_NO_DISC: + *mode = WM_CDM_NO_DISC; + break; + case CDS_TRAY_OPEN: + *mode = WM_CDM_EJECTED; + break; + case CDS_AUDIO: + case CDS_MIXED: + *mode = WM_CDM_STOPPED; + break; + case CDS_DRIVE_NOT_READY: + case CDS_NO_INFO: + case CDS_DATA_1: + case CDS_DATA_2: + case CDS_XA_2_1: + case CDS_XA_2_2: + default: + *mode = WM_CDM_UNKNOWN; + } + } + + return (0); +} /* gen_get_drive_status */ + +/*-------------------------------------* + * Get the number of tracks on the CD. + *-------------------------------------*/ +int +gen_get_trackcount(struct wm_drive *d, int *tracks) +{ + struct cdrom_tochdr hdr; + + if (ioctl(d->fd, CDROMREADTOCHDR, &hdr)) + return (-1); + + *tracks = hdr.cdth_trk1; + return (0); +} /* gen_get_trackcount() */ + +/*---------------------------------------------------------* + * Get the start time and mode (data or audio) of a track. + *---------------------------------------------------------*/ +int +gen_get_trackinfo(struct wm_drive *d, int track, int *data, int *startframe) +{ + struct cdrom_tocentry entry; + + entry.cdte_track = track; + entry.cdte_format = CDROM_MSF; + + if (ioctl(d->fd, CDROMREADTOCENTRY, &entry)) + return (-1); + + *startframe = entry.cdte_addr.msf.minute * 60 * 75 + + entry.cdte_addr.msf.second * 75 + + entry.cdte_addr.msf.frame; + *data = entry.cdte_ctrl & CDROM_DATA_TRACK ? 1 : 0; + + return (0); +} + +/*-------------------------------------* + * Get the number of frames on the CD. + *-------------------------------------*/ +int +gen_get_cdlen(struct wm_drive *d, int *frames) +{ + int tmp; + + return gen_get_trackinfo( d, CDROM_LEADOUT, &tmp, frames); +} /* gen_get_cdlen() */ + + +/*------------------------------------------------------------* + * Play the CD from one position to another (both in frames.) + *------------------------------------------------------------*/ +int +gen_play(struct wm_drive *d, int start, int end, int realstart) +{ + struct cdrom_msf msf; + + CDDARETURN(d) cdda_play(d, start, end, realstart); + + msf.cdmsf_min0 = start / (60*75); + msf.cdmsf_sec0 = (start % (60*75)) / 75; + msf.cdmsf_frame0 = start % 75; + msf.cdmsf_min1 = end / (60*75); + msf.cdmsf_sec1 = (end % (60*75)) / 75; + msf.cdmsf_frame1 = end % 75; + + if (ioctl(d->fd, CDROMPLAYMSF, &msf)) { + if (ioctl(d->fd, CDROMSTART)) + return (-1); + if (ioctl(d->fd, CDROMPLAYMSF, &msf)) + return (-2); + } + + /* + * I hope no drive gets really confused after CDROMSTART + * If so, I need to make this run-time configurable. + * +#ifndef FAST_IDE + if (ioctl( d->fd, CDROMSTART)) + return (-1); +#endif + if (ioctl( d->fd, CDROMPLAYMSF, &msf )) + return (-2); + */ + + return (0); +} /* gen_play() */ + +/*---------------* + * Pause the CD. + *---------------*/ +int +gen_pause(struct wm_drive *d) +{ + CDDARETURN(d) cdda_pause(d); + return (ioctl(d->fd, CDROMPAUSE)); +} + +/*-------------------------------------------------* + * Resume playing the CD (assuming it was paused.) + *-------------------------------------------------*/ +int +gen_resume(struct wm_drive *d) +{ + CDDARETURN(d) cdda_pause(d); + return (ioctl(d->fd, CDROMRESUME)); +} + +/*--------------* + * Stop the CD. + *--------------*/ +int +gen_stop(struct wm_drive *d) +{ + CDDARETURN(d) cdda_stop(d); + return (ioctl(d->fd, CDROMSTOP)); +} + + +/*----------------------------------------* + * Eject the current CD, if there is one. + *----------------------------------------*/ +int +gen_eject(struct wm_drive *d) +{ + struct stat stbuf; +#if !defined(BSD_MOUNTTEST) + struct ustat ust; +#else + struct mntent *mnt; + FILE *fp; +#endif + + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "ejecting?\n"); + + if (fstat(d->fd, &stbuf) != 0) { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "that weird fstat() thingy\n"); + return (-2); + } + + /* Is this a mounted filesystem? */ +#if !defined(BSD_MOUNTTEST) + if (ustat(stbuf.st_rdev, &ust) == 0) + return (-3); +#else + /* + * This is the same test as in the WorkBone interface. + * I should eliminate it there, because there is no need + * for it in the UI + */ + /* check if drive is mounted (from Mark Buckaway's cdplayer code) */ + /* Changed it again (look at XPLAYCD from ???? */ + /* It's better to check the device name rather than one device is */ + /* mounted as iso9660. That prevents "no playing" if you have more*/ + /* than one CD-ROM, and one of them is mounted, but it's not the */ + /* audio CD -dirk */ + if ((fp = setmntent (MOUNTED, "r")) == NULL) + { + wm_lib_message(WM_MSG_LEVEL_ERROR|WM_MSG_CLASS, "Could not open %s: %s\n", MOUNTED, strerror (errno)); + return(-3); + } + while ((mnt = getmntent (fp)) != NULL) + { + if (strcmp (mnt->mnt_fsname, d->cd_device) == 0) + { + wm_lib_message(WM_MSG_LEVEL_ERROR|WM_MSG_CLASS, "CDROM already mounted (according to mtab). Operation aborted.\n"); + endmntent (fp); + return(-3); + } + } + endmntent (fp); +#endif /* BSD_MOUNTTEST */ + + IFCDDA(d) { + cdda_eject(d); + } + + ioctl( d->fd, CDROM_LOCKDOOR, 0 ); + + if (ioctl(d->fd, CDROMEJECT)) + { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "eject failed (%s).\n", strerror(errno)); + return (-1); + } + + /*------------------ + * Things in "foobar_one" are left over from 1.4b3 + * I put them here for further observation. In 1.4b3, however, + * that workaround didn't help at least for /dev/sbpcd + * (The tray closed just after ejecting because re-opening the + * device causes the tray to close) + *------------------*/ +#ifdef foobar_one + extern int intermittent_dev + /* + * Some drives (drivers?) won't recognize a new CD if we leave the + * device open. + */ + if (intermittent_dev) + gen_close(d); +#endif + + return (0); +} /* gen_eject() */ + +/*----------------------------------------* + * Close the CD tray + *----------------------------------------*/ + +int +gen_closetray(struct wm_drive *d) +{ +#ifdef CAN_CLOSE +#ifdef CDROMCLOSETRAY + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "CDROMCLOSETRAY closing tray...\n"); + if (ioctl(d->fd, CDROMCLOSETRAY)) + return (-1); +#else + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_reopen() closing tray...\n"); + if(!gen_close(d)) + { + return(wmcd_reopen(d)); + } else { + return(-1); + } +#endif /* CDROMCLOSETRAY */ +#endif /* CAN_CLOSE */ + /* Always succeed if the drive can't close. */ + return(0); +} /* gen_closetray() */ + + +/*------------------------------------------------------------------------* + * scale_volume(vol, max) + * + * Return a volume value suitable for passing to the CD-ROM drive. "vol" + * is a volume slider setting; "max" is the slider's maximum value. + * This is not used if sound card support is enabled. + * + *------------------------------------------------------------------------*/ +static int +scale_volume( int vol, int max ) +{ +#ifdef CURVED_VOLUME + return ((max * max - (max - vol) * (max - vol)) * + (max_volume - min_volume) / (max * max) + min_volume); +#else + return ((vol * (max_volume - min_volume)) / max + min_volume); +#endif +} /* scale_volume() */ + +static int +unscale_volume( int vol, int max ) +{ +#ifdef CURVED_VOLUME + /* FIXME do it simpler */ + int tmp = (((max_volume - min_volume - vol) * max * max) - (vol + min_volume)); + return max - sqrt((tmp/(max_volume - min_volume))); +#else + return (((vol - min_volume) * max) / (max_volume - min_volume)); +#endif +} /* unscale_volume() */ + +/*---------------------------------------------------------------------* + * Set the volume level for the left and right channels. Their values + * range from 0 to 100. + *---------------------------------------------------------------------*/ +int +gen_set_volume( struct wm_drive *d, int left, int right ) +{ + struct cdrom_volctrl v; + + CDDARETURN(d) cdda_set_volume(d, left, right); + + /* Adjust the volume to make up for the CD-ROM drive's weirdness. */ + left = scale_volume(left, 100); + right = scale_volume(right, 100); + + v.channel0 = v.channel2 = left < 0 ? 0 : left > 255 ? 255 : left; + v.channel1 = v.channel3 = right < 0 ? 0 : right > 255 ? 255 : right; + + return (ioctl(d->fd, CDROMVOLCTRL, &v)); +} /* gen_set_volume() */ + +/*---------------------------------------------------------------------* + * Read the volume from the drive, if available. Each channel + * ranges from 0 to 100, with -1 indicating data not available. + *---------------------------------------------------------------------*/ +int +gen_get_volume( struct wm_drive *d, int *left, int *right ) +{ + struct cdrom_volctrl v; + + CDDARETURN(d) cdda_get_volume(d, left, right); + +#if defined(CDROMVOLREAD) + if(!ioctl(d->fd, CDROMVOLREAD, &v)) { + *left = unscale_volume((v.channel0 + v.channel2)/2, 100); + *right = unscale_volume((v.channel1 + v.channel3)/2, 100); + } else +#endif + /* Suns, HPs, Linux, NEWS can't read the volume; oh well */ + *left = *right = -1; + + return 0; +} /* gen_get_volume() */ + +/*------------------------------------------------------------------------* + * gen_get_cdtext(drive, buffer, lenght) + * + * Return a buffer with cdtext-stream. buffer will be allocated and filled + * + * needs send packet interface -> for IDE, linux at 2.2.16 + * depends on scsi.c which depends on wm_scsi defined in here + * (which also takes care of IDE drives) + *------------------------------------------------------------------------*/ + +int +gen_get_cdtext(struct wm_drive *d, unsigned char **pp_buffer, int *p_buffer_lenght) +{ + return wm_scsi_get_cdtext(d, pp_buffer, p_buffer_lenght); +} /* gen_get_cdtext() */ + +#endif /* __linux__ */ diff --git a/kscd/libwm/plat_linux_audio.c b/kscd/libwm/plat_linux_audio.c new file mode 100644 index 00000000..7316a691 --- /dev/null +++ b/kscd/libwm/plat_linux_audio.c @@ -0,0 +1,489 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * Linux digital audio functions. + */ + +#include "include/wm_config.h" + +static char plat_linux_audio_id[] = "$Id$"; + +#if defined(__linux__) && defined(BUILD_CDDA) /* { */ + +#include "include/wm_cdda.h" + +/* types.h included by wm_cdda.h */ + +#include <stdio.h> +#include <sys/ioctl.h> +#include <sys/audioio.h> +#include <sys/stropts.h> +#include <sys/time.h> +#include <errno.h> +#include <fcntl.h> +#include <signal.h> + +#define WM_MSG_CLASS WM_MSG_CLASS_PLATFORM + +/* + * Since there's a lag time between writing audio to the audio device and + * hearing it, we need to make sure the status indicators correlate to what's + * playing out the speaker. Luckily, Solaris gives us some audio + * synchronization facilities that make this pretty easy. + * + * We maintain a circular queue of status information. When we write some + * sound to the audio device, we put its status info into the queue. We write + * a marker into the audio stream; when the audio device driver encounters the + * marker, it increments a field in a status structure. When we see that + * field go up, we grab the next status structure from the queue and send it + * to the parent process. + * + * The minimum size of the queue depends on the latency of the audio stream. + */ +#define QSIZE 500 + +struct cdda_block queue[QSIZE]; +int qtail; +int qstart; + +/* + * We only send WMCDDA_PLAYED status messages upstream when the CD is supposed + * to be playing; this is used to keep track. + */ +extern int playing; + +static int aufd, aucfd; +static int raw_audio = 1; /* Can /dev/audio take 44.1KHz stereo? */ + +/* + * For fast linear-to-ulaw mapping, we use a lookup table that's generated + * at startup. + */ +unsigned char *ulawmap, linear_to_ulaw(); + +char *getenv(); + +/* + * Dummy signal handler so writes to /dev/audio will interrupt. + */ +static void +dummy( void ) +{ + signal(SIGALRM, dummy); +} + +/* + * Initialize the audio device. + */ +void +wmaudio_init( void ) +{ + audio_info_t info; + char *audiodev, *acdev; + int linval; + + audiodev = getenv("AUDIODEV"); + if (audiodev == NULL) + audiodev = "/dev/audio"; + + acdev = malloc(strlen(audiodev) + 4); + if (acdev == NULL) + { + perror("Can't allocate audio control filename"); + exit(1); + } + strcpy(acdev, audiodev); + strcat(acdev, "ctl"); + + aucfd = open(acdev, O_WRONLY, 0); + if (aucfd < 0) + { + perror(acdev); + exit(1); + } + free(acdev); + + aufd = open(audiodev, O_WRONLY, 0); + if (aufd < 0) + { + perror(audiodev); + exit(1); + } + + signal(SIGALRM, dummy); + + /* + * Try to set the device to CD-style audio; we can process it + * with the least CPU overhead. + */ + AUDIO_INITINFO(&info); + info.play.sample_rate = 44100; + info.play.channels = 2; + info.play.precision = 16; + info.play.encoding = AUDIO_ENCODING_LINEAR; + info.play.pause = 0; + info.record.pause = 0; + info.monitor_gain = 0; + + if (ioctl(aufd, AUDIO_SETINFO, &info) < 0) + if (errno == EINVAL) + { + /* + * Oh well, so much for that idea. + */ + AUDIO_INITINFO(&info); + info.play.sample_rate = 8000; + info.play.channels = 1; + info.play.precision = 8; + info.play.encoding = AUDIO_ENCODING_ULAW; + info.play.pause = 0; + info.record.pause = 0; + info.monitor_gain = 0; + if (ioctl(aufd, AUDIO_SETINFO, &info) < 0) + { + perror("Can't set up audio device"); + exit(1); + } + + /* + * Initialize the linear-to-ulaw mapping table. + */ + if (ulawmap == NULL) + ulawmap = malloc(65536); + if (ulawmap == NULL) + { + perror("malloc"); + exit(1); + } + for (linval = 0; linval < 65536; linval++) + ulawmap[linval] = linear_to_ulaw(linval-32768); + ulawmap += 32768; + raw_audio = 0; + } + else + { + perror(audiodev); + exit(1); + } +} + +/* + * Get ready to play some sound. + */ +void +wmaudio_ready( void ) +{ + audio_info_t info; + + /* + * Start at the correct queue position. + */ + if (ioctl(aucfd, AUDIO_GETINFO, &info) < 0) perror("AUDIO_GETINFO"); + qtail = info.play.eof % QSIZE; + qstart = qtail; + + queue[qtail].status = WMCDDA_OK; +} + +/* + * Stop the audio immediately. + */ +void +wmaudio_stop( void ) +{ + if (ioctl(aufd, I_FLUSH, FLUSHRW) < 0) + perror("flush"); +} + +/* + * Close the audio device. + */ +void +wmaudio_close( void ) +{ + wmaudio_stop(); + close(aufd); + close(aucfd); +} + +/* + * Set the volume level. + */ +void +wmaudio_volume(int level) +{ + audio_info_t info; + + AUDIO_INITINFO(&info); + if (ioctl(aucfd, AUDIO_GETINFO, &info) < 0) perror("AUDIO_GETINFO"); + info.play.gain = level; + if (ioctl(aucfd, AUDIO_SETINFO, &info) < 0) perror("AUDIO_SETINFO"); +} + +/* + * Set the balance level. + */ +void +wmaudio_balance(int level) +{ + audio_info_t info; + + AUDIO_INITINFO(&info); + if (ioctl(aucfd, AUDIO_GETINFO, &info) < 0) perror("AUDIO_GETINFO"); + level *= AUDIO_RIGHT_BALANCE; + info.play.balance = level / 255; + if (ioctl(aucfd, AUDIO_SETINFO, &info) < 0) perror("AUDIO_SETINFO"); +} + +/* + * Mark the most recent audio block on the queue as the last one. + */ +void +wmaudio_mark_last( void ) +{ + queue[qtail].status = WMCDDA_DONE; +} + +/* + * Figure out the most recent status information and send it upstream. + */ +int +wmaudio_send_status( void ) +{ + audio_info_t info; + int qhead; + + /* + * Now send the most current status information to our parent. + */ + if (ioctl(aucfd, AUDIO_GETINFO, &info) < 0) + perror("AUDIO_GETINFO"); + qhead = info.play.eof % QSIZE; + + if (qhead != qstart && playing) + { + int balance; + + if (queue[qhead].status != WMCDDA_DONE) + queue[qhead].status = WMCDDA_PLAYED; + queue[qhead].volume = info.play.gain; + queue[qhead].balance = (info.play.balance * 255) / + AUDIO_RIGHT_BALANCE; + + send_status(queue + qhead); + qstart = -1; + } + + return (queue[qhead].status == WMCDDA_DONE); +} + +/* + * Play some audio and pass a status message upstream, if applicable. + * Returns 0 on success. + */ +int +wmaudio_play(unsigned char *rawbuf, long buflen, struct cdda_block *blk) +{ + int i; + short *buf16; + int alarmcount = 0; + struct itimerval it; + + alarm(1); + + while (write(aufd, rawbuf, buflen) <= 0) + if (errno == EINTR) + { + if (! raw_audio && alarmcount++ < 5) + { + /* + * 8KHz /dev/audio blocks for several seconds + * waiting for its queue to drop below a low + * water mark. + */ + wmaudio_send_status(); + timerclear(&it.it_interval); + timerclear(&it.it_value); + it.it_value.tv_usec = 500000; + setitimer(ITIMER_REAL, &it, NULL); + continue; + } + +/* close(aufd); + close(aucfd); + wmaudio_init(); +*/ wmaudio_stop( void ); + alarm(2); + continue; + } + else + { + blk->status = WMCDDA_ERROR; + return (-1); + } + alarm(0); + + /* + * Mark this spot in the audio stream. + * + * Marks don't always succeed (if the audio buffer is empty + * this call will block forever) so do it asynchronously. + */ + fcntl(aufd, F_SETFL, O_NONBLOCK); + if (write(aufd, rawbuf, 0) < 0) + { + if (errno != EAGAIN) + perror("audio mark"); + } + else + qtail = (qtail + 1) % QSIZE; + + fcntl(aufd, F_SETFL, 0); + + queue[qtail] = *blk; + + if (wmaudio_send_status() < 0) + return (-1); + else + return (0); +} + +/* + * Get the current audio state. + */ +void +wmaudio_state(struct cdda_block *blk) +{ + audio_info_t info; + int balance; + + if (ioctl(aucfd, AUDIO_GETINFO, &info) < 0) + perror("AUDIO_GETINFO"); + blk->volume = info.play.gain; + blk->balance = (info.play.balance * 255) / AUDIO_RIGHT_BALANCE; +} + +/* +** This routine converts from linear to ulaw. +** +** Craig Reese: IDA/Supercomputing Research Center +** Joe Campbell: Department of Defense +** 29 September 1989 +** +** References: +** 1) CCITT Recommendation G.711 (very difficult to follow) +** 2) "A New Digital Technique for Implementation of Any +** Continuous PCM Companding Law," Villeret, Michel, +** et al. 1973 IEEE Int. Conf. on Communications, Vol 1, +** 1973, pg. 11.12-11.17 +** 3) MIL-STD-188-113,"Interoperability and Performance Standards +** for Analog-to_Digital Conversion Techniques," +** 17 February 1987 +** +** Input: Signed 16 bit linear sample +** Output: 8 bit ulaw sample +*/ +#define ZEROTRAP /* turn on the trap as per the MIL-STD */ +#define BIAS 0x84 /* define the add-in bias for 16 bit samples */ +#define CLIP 32635 + +unsigned char +linear_to_ulaw( sample ) +int sample; +{ + static int exp_lut[256] = {0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3, + 4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4, + 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5, + 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5, + 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, + 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, + 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, + 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7}; + int sign, exponent, mantissa; + unsigned char ulawbyte; + + /* Get the sample into sign-magnitude. */ + sign = (sample >> 8) & 0x80; /* set aside the sign */ + if ( sign != 0 ) sample = -sample; /* get magnitude */ + if ( sample > CLIP ) sample = CLIP; /* clip the magnitude */ + + /* Convert from 16 bit linear to ulaw. */ + sample = sample + BIAS; + exponent = exp_lut[( sample >> 7 ) & 0xFF]; + mantissa = ( sample >> ( exponent + 3 ) ) & 0x0F; + ulawbyte = ~ ( sign | ( exponent << 4 ) | mantissa ); +#ifdef ZEROTRAP + if ( ulawbyte == 0 ) ulawbyte = 0x02; /* optional CCITT trap */ +#endif + + return ulawbyte; +} + +/* + * Downsample a block of CDDA data, if necessary, for playing out an old-style + * audio device. + */ +long +wmaudio_convert(unsigned char *rawbuf, long buflen, struct cdda_block *blk) +{ + short *buf16 = (short *)rawbuf; + int i, j, samples; + int mono_value; + unsigned char *rbend = rawbuf + buflen; + + /* Don't do anything if the audio device can take the raw values. */ + if (raw_audio) + return (buflen); + + for (i = 0; buf16 < (short *)(rbend); i++) + { + /* Downsampling to 8KHz is a little irregular. */ + samples = (i & 1) ? ((i % 20) ? 10 : 12) : 12; + + /* And unfortunately, we don't always end on a nice boundary. */ + if (buf16 + samples > (short *)(rbend)) + samples = ((short *)rbend) - buf16; + + /* + * No need to average all the values; taking the first one + * is sufficient and less CPU-intensive. But we do need to + * do both channels. + */ + mono_value = (buf16[0] + buf16[1]) / 2; + buf16 += samples; + rawbuf[i] = ulawmap[mono_value]; + } + + return (i); +} + +#endif /* ... && BUILD_CDDA */ diff --git a/kscd/libwm/plat_linux_cdda.c b/kscd/libwm/plat_linux_cdda.c new file mode 100644 index 00000000..6456e10a --- /dev/null +++ b/kscd/libwm/plat_linux_cdda.c @@ -0,0 +1,253 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Fďż˝sterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * Linux CDDA functions. Derived from the SUN module. + */ + +#include "include/wm_cdda.h" + +#if defined(__linux__) && defined(BUILD_CDDA) + +#ifndef __GNUC__ +#define __GNUC__ 1 +#endif +/* needed for vanilla kernel headers, which do provide __u64 only + for ansi */ +#undef __STRICT_ANSI__ +/* needed for non-ansi kernel headers */ +#define asm __asm__ +#define inline __inline__ +#include <asm/types.h> +#include <linux/cdrom.h> +#undef asm +#undef inline + +#include <stdio.h> +#include <math.h> +#include <sys/ioctl.h> +#include <sys/types.h> +#include <fcntl.h> +#include <unistd.h> +#include <errno.h> +#include <string.h> + +#include "include/wm_struct.h" +#include "include/wm_cdda.h" + +#define WM_MSG_CLASS WM_MSG_CLASS_PLATFORM + +#define CDDABLKSIZE 2352 + +/* Address of next block to read. */ +static int current_position; + +/* Address of last block to read. */ +static int ending_position; + +static struct cdrom_read_audio cdda; +static long wmcdda_normalize(struct cdda_block *block); + + +/* + * Initialize the CDDA data buffer and open the appropriate device. + * + */ +int +wmcdda_init(struct cdda_device* pdev) +{ + int i; + + if (pdev->fd > -1) + return -1; + + if(!pdev->devname) + return -1; + + for (i = 0; i < pdev->numblocks; i++) { + /* in Linux const */ + pdev->blocks[i].buflen = pdev->frames_at_once * CDDABLKSIZE; + pdev->blocks[i].buf = malloc(pdev->blocks[i].buflen); + if (!pdev->blocks[i].buf) { + ERRORLOG("wmcdda_init ENOMEM\n"); + return -ENOMEM; + } + } + + pdev->fd = open(pdev->devname, O_RDONLY | O_NONBLOCK); + + if (pdev->fd > -1) { + cdda.addr_format = CDROM_LBA; + cdda.addr.lba = 200; + cdda.nframes = 1; + cdda.buf = (unsigned char*)pdev->blocks[0].buf; + + pdev->status = WM_CDM_STOPPED; + if((ioctl(pdev->fd, CDROMREADAUDIO, &cdda) < 0)) { + if (errno == ENXIO) { + /* CD ejected! */ + pdev->status = WM_CDM_EJECTED; + return 0; + } else { + /* Sometimes it fails once, dunno why */ + pdev->status = WM_CDM_CDDAERROR; + return 0; + } + } + } else { + ERRORLOG("canot open device, errno %i\n", errno); + pdev->status = WM_CDM_UNKNOWN; + return -1; + } + + pdev->status = WM_CDM_UNKNOWN; + return 0; +} + +/* + * Close the CD-ROM device in preparation for exiting. + */ +int +wmcdda_close(struct cdda_device* pdev) +{ + int i; + + if(-1 == pdev->fd) + return -1; + + close(pdev->fd); + pdev->fd = -1; + + for (i = 0; i < pdev->numblocks; i++) { + free(pdev->blocks[i].buf); + pdev->blocks[i].buf = 0; + pdev->blocks[i].buflen = 0; + } + + return 0; +} + +/* + * Set up for playing the CD. Actually this doesn't play a thing, just sets a + * couple variables so we'll know what to do when we're called. + */ +int +wmcdda_setup(int start, int end, int realstart) +{ + current_position = start; + ending_position = end; + + return 0; +} + +/* + * Read some blocks from the CD. Stop if we hit the end of the current region. + * + * Returns number of bytes read, -1 on error, 0 if stopped for a benign reason. + */ +long +wmcdda_read(struct cdda_device* pdev, struct cdda_block *block) +{ + if (pdev->fd < 0 && wmcdda_init(pdev)) { + return -1; + } + + /* Hit the end of the CD, probably. */ + if (current_position >= ending_position) { + block->status = WM_CDM_TRACK_DONE; + return 0; + } + + cdda.addr_format = CDROM_LBA; + cdda.addr.lba = current_position - CD_MSF_OFFSET; + if (ending_position && current_position + pdev->frames_at_once > ending_position) + cdda.nframes = ending_position - current_position; + else + cdda.nframes = pdev->frames_at_once; + + cdda.buf = (unsigned char*)block->buf; + + if (ioctl(pdev->fd, CDROMREADAUDIO, &cdda) < 0) { + if (errno == ENXIO) { + /* CD ejected! */ + block->status = WM_CDM_EJECTED; + return 0; + } else { + /* Sometimes it fails once, dunno why */ + block->status = WM_CDM_CDDAERROR; + return 0; + } + } + + block->track = -1; + block->index = 0; + block->frame = current_position; + block->status = WM_CDM_PLAYING; + block->buflen = cdda.nframes * CDDABLKSIZE; + + current_position = current_position + cdda.nframes; + + return wmcdda_normalize(block); +} + +/* + * Normalize a bunch of CDDA data. Basically this means doing byte-swapping, since the CD audio is in + * littleendian format. + */ +long +wmcdda_normalize(struct cdda_block *block) +{ +#if WM_BIG_ENDIAN + int i; + int blocks = block->buflen / CDDABLKSIZE; + char *rawbuf = block->buf; + char *dest = block->buf; + + while (blocks--) { + for (i = 0; i < CDDABLKSIZE / 2; i++) { + *dest++ = rawbuf[1]; + *dest++ = rawbuf[0]; + rawbuf += 2; + } + } +#endif + return block->buflen; +} + +/* + * Set the playback direction. + */ +void +wmcdda_direction(int newdir) +{ +} + +/* + * Do system-specific stuff to get ready to play at a particular speed. + */ +void +wmcdda_speed(int speed) +{ +} + +#endif diff --git a/kscd/libwm/plat_news.c b/kscd/libwm/plat_news.c new file mode 100644 index 00000000..0e95b01d --- /dev/null +++ b/kscd/libwm/plat_news.c @@ -0,0 +1,442 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * Sony NEWS-specific drive control routines. + */ + +static char plat_news_id[] = "$Id$"; + +#if defined( __sony_news) || defined(sony_news) + +#include <errno.h> +#include <stdio.h> +#include <fcntl.h> +#include <ustat.h> +#include <CD.h> +#include <sys/types.h> +#include <sys/param.h> +#include <sys/stat.h> +#include <sys/time.h> + +#include "include/wm_config.h" +#include "include/wm_struct.h" +#include "include/wm_cdtext.h" + +#define WM_MSG_CLASS WM_MSG_CLASS_PLATFORM + +void *malloc(); +char *strchr(); + +extern int intermittent_dev; + +int min_volume = 128; +int max_volume = 255; + +/* + * Initialize the drive. A no-op for the generic driver. + */ +int +gen_init( struct wm_drive *d ) +{ + return (0); +} /* gen_init() */ + +/* + * Open the CD device and figure out what kind of drive is attached. + */ +int +wmcd_open( struct wm_drive *d ) +{ + int fd; + static int warned = 0; + char vendor[32] = WM_STR_GENVENDOR; + char model[32] = WM_STR_GENMODEL; + char rev[32] = WM_STR_GENREV; + + if (d->fd >= 0) /* Device already open? */ + { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_open(): [device is open (fd=%d)]\n", d->fd); + return (0); + } + + intermittent_dev = 1; + if (d->cd_device == NULL) + d->cd_device = DEFAULT_CD_DEVICE; + + if ((d->fd = CD_Open(d->cd_device, 0)) < 0) + { + /* Solaris 2.2 volume manager moves links around */ + if (errno == ENOENT && intermittent_dev) + return (0); + + if (errno == EACCES) + { + if (!warned) + { + /* + char realname[MAXPATHLEN]; + + if (realpath(cd_device, realname) == NULL) + { + perror("realpath"); + return 1; + } + */ + return -EACCES; + } + } + else if (errno != EIO) /* defined at top */ + { + return (-6); + } + + /* No CD in drive. */ + return (1); + } + + /* Now fill in the relevant parts of the wm_drive structure. */ + fd = d->fd; + + /* Figure out the drive type, if possible */ + wm_scsi_get_drive_type(d, vendor, model, rev); + find_drive_struct(vendor, model, rev); + + d->fd = fd; + + (d->init)(d); + + return (0); +} /* wmcd_open() */ + +/* + * Re-Open the device if it is open. + */ +int +wmcd_reopen( struct wm_drive *d ) +{ + int status; + + do { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_reopen\n"); + status = gen_close( d ); + wm_susleep( 1000 ); + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "calling wmcd_open()\n"); + status = wmcd_open( d ); /* open it as usual */ + wm_susleep( 1000 ); + } while ( status != 0 ); + return status; +} /* wmcd_reopen() */ + +/* + * Pass SCSI commands to the device. + */ +int +wm_scsi(struct wm_drive *d, unsigned char *cdb, int cdblen, + unsigned char *buf, int buflen, int getreply) +{ + /* NEWS can't do SCSI passthrough... or can it? */ + return (-1); +} /* wm_scsi() */ + +int +gen_close( struct wm_drive *d ) +{ + int ret = 0; + if(d->fd != -1) { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "closing the device.\n"); + ret = CD_Close(d->fd); + d->fd = -1; + wm_susleep(3000000); + } + return (ret); +} + +/* + * Get the current status of the drive: the current play mode, the absolute + * position from start of disc (in frames), and the current track and index + * numbers if the CD is playing or paused. + */ +int +gen_get_drive_status( struct wm_drive *d, int oldmode, + int *mode, int *pos, int *track, int *index) +{ + struct CD_Status sc; + + /* If we can't get status, the CD is ejected, so default to that. */ + *mode = WM_CDM_EJECTED; + + /* Is the device open? */ + if (d->fd < 0) + { + switch (wmcd_open(d)) { + case -1: /* error */ + return (-1); + + case 1: /* retry */ + return (0); + } + } + + /* Disc is ejected. Close the device. */ + if (CD_GetStatus(d->fd, &sc)) + { + gen_close(d); + return (0); + } + + switch (sc.status) { + case CDSTAT_PLAY: + *mode = PLAYING; + *track = sc.tno; + *index = sc.index; + *pos = sc.baddr; + break; + + case CDSTAT_PAUSE: + if (oldmode == WM_CDM_PLAYING || oldmode == WM_CDM_PAUSED) + { + *mode = WM_CDM_PAUSED; + *track = sc.tno; + *index = sc.index; + *pos = sc.baddr; + } + else + *mode = WM_CDM_STOPPED; + break; + + case CDSTAT_STOP: + if (oldmode == WM_CDM_PLAYING) + { + *mode = WM_CDM_TRACK_DONE; /* waiting for next track. */ + break; + } + /* fall through */ + + default: + *mode = WM_CDM_STOPPED; + break; + } + + return (0); +} /* gen_get_drive_status() */ + +/* + * Get the number of tracks on the CD. + */ +int +gen_get_trackcount(struct wm_drive *d, int *tracks) +{ + struct CD_Capacity cc; + + if (CD_GetCapacity(d->fd, &cc)) + return (-1); + + *tracks = cc.etrack - 1; + return (0); +} /* gen_get_trackcount() */ + +/* + * Get the start time and mode (data or audio) of a track. + */ +int +gen_get_trackinfo( struct wm_drive *d, int track, int *data, int *startframe ) +{ + struct CD_TOCinfo hdr; + struct CD_TOCdata ent; + + hdr.strack = track; + hdr.ntrack = 1; + hdr.data = &ent; + if (CD_ReadTOC(d->fd, &hdr)) + return (-1); + + *data = (ent.control & 4) ? 1 : 0; + *startframe = ent.baddr; + + return (0); +} /* gen_get_trackinfo */ + +/* + * Get the number of frames on the CD. + */ +int +gen_get_cdlen( struct wm_drive *d, int *frames ) +{ + int tmp; + + if ((d->get_trackcount)(d, &tmp)) + return (-1); + + return (gen_get_trackinfo(d, tmp + 1, &tmp, frames)); +} /* gen_get_cdlen() */ + + +/* + * Play the CD from one position to another (both in frames.) + */ +int +gen_play( struct wm_drive *d, int start, int end ) +{ + struct CD_PlayAddr msf; + + msf.addrmode = CD_MSF; + msf.addr.msf.startmsf.min = start / (60*75); + msf.addr.msf.startmsf.sec = (start % (60*75)) / 75; + msf.addr.msf.startmsf.frame = start % 75; + msf.addr.msf.endmsf.min = end / (60*75); + msf.addr.msf.endmsf.sec = (end % (60*75)) / 75; + msf.addr.msf.endmsf.frame = end % 75; + + if (CD_Play(d->fd, &msf)) + { + printf("wm_cd_play_chunk(%d,%d)\n",start,end); + printf("msf = %d:%d:%d %d:%d:%d\n", + msf.addr.msf.startmsf.min, + msf.addr.msf.startmsf.sec, + msf.addr.msf.startmsf.frame, + msf.addr.msf.endmsf.min, + msf.addr.msf.endmsf.sec, + msf.addr.msf.endmsf.frame); + perror("CD_Play"); + return (-1); + } + + return (0); +} /* gen_play() */ + +/* + * Pause the CD. + */ +int +gen_pause( struct wm_drive *d ) +{ + CD_Pause(d->fd); + return (0); +} /* gen_pause() */ + +/* + * Resume playing the CD (assuming it was paused.) + */ +int +gen_resume( struct wm_drive *d ) +{ + CD_Restart(d->fd); + return (0); +} /* gen_resume() */ + +/* + * Stop the CD. + */ +int +gen_stop( struct wm_drive *d ) +{ + CD_Stop(d->fd); + return (0); +} /* gen_stop() */ + +/* + * Eject the current CD, if there is one. + */ +int +gen_eject( struct wm_drive *d ) +{ + struct stat stbuf; + struct ustat ust; + + if (fstat(d->fd, &stbuf) != 0) + return (-2); + + /* Is this a mounted filesystem? */ + if (ustat(stbuf.st_rdev, &ust) == 0) + return (-3); + + if (CD_AutoEject(d->fd)) + return (-1); + + /* Close the device if it needs to vanish. */ + if (intermittent_dev) + { + gen_close(d); + } + + return (0); +} /* gen_eject() */ + +/*----------------------------------------* + * Close the CD tray + * + * Please edit and send changes to + * milliByte@DeathsDoor.com + *----------------------------------------*/ +int +gen_closetray(struct wm_drive *d) +{ +#ifdef CAN_CLOSE + if(!gen_close(d)) + { + return(wmcd_reopen(d)); + } else { + return(-1); + } +#else + /* Always succeed if the drive can't close */ + return(0); +#endif /* CAN_CLOSE */ +} /* gen_closetray() */ + + +/* + * Set the volume level for the left and right channels. Their values + * range from 0 to 100. + */ +int +gen_set_volume( struct wm_drive *d, int left, int right) +{ + /* NEWS can't adjust volume! */ + return (0); +} + +/* + * Read the initial volume from the drive, if available. Each channel + * ranges from 0 to 100, with -1 indicating data not available. + */ +int +gen_get_volume( struct wm_drive *d, omt *left, int *right) +{ + /* Suns, HPs, Linux, NEWS can't read the volume; oh well */ + *left = *right = -1; + return (0); +} /* gen_get_volume() */ + +/*------------------------------------------------------------------------* + * gen_get_cdtext(drive, buffer, lenght) + *------------------------------------------------------------------------*/ + +int +gen_get_cdtext(struct wm_drive *d, unsigned char **pp_buffer, int *p_buffer_lenght) +{ + return -1; /* no SCSI, no CDTEXT */ +} /* gen_get_cdtext() */ + +#endif diff --git a/kscd/libwm/plat_openbsd.c b/kscd/libwm/plat_openbsd.c new file mode 100644 index 00000000..a3b0fd47 --- /dev/null +++ b/kscd/libwm/plat_openbsd.c @@ -0,0 +1,545 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * OpenBSD-specific drive control routines. (Based on plat_freebsd.c) + * + * Michael Shalayeff, 7/24/96 + * Todd Pfaff, 3/20/94 + * + */ + +#if defined(__OpenBSD__) || defined(__OpenBSD) + + +#include <errno.h> +#include <stdio.h> +#include <sys/types.h> +#include <sys/param.h> +#include <sys/mount.h> +#include <fcntl.h> +#include <sys/param.h> +#include <sys/stat.h> + +#include "include/wm_config.h" +#include "include/wm_cdrom.h" +#include "include/wm_helpers.h" + +/* this is for glibc 2.x which defines the ust structure in ustat.h not stat.h */ +#ifdef __GLIBC__ +#include <sys/ustat.h> +#endif + +#include <sys/time.h> +#include <string.h> +#include <sys/ioctl.h> +#include <sys/cdio.h> +#include <sys/scsiio.h> +#include <scsi/scsi_all.h> +#include <scsi/cd.h> +#include <scsi/scsi_cd.h> + +#include "include/wm_struct.h" +#include "include/wm_cdtext.h" + +#define WM_MSG_CLASS WM_MSG_CLASS_PLATFORM + +void *malloc(); + +int min_volume = 10; +int max_volume = 255; + +/* + * Initialize the drive. A no-op for the generic driver. + */ +int +gen_init(struct wm_drive *d) +{ + return (0); +} /* gen_init() */ + + +char *cds[] = {"/dev/rcd0c", "/dev/rcd1c", "/dev/acd0c", NULL}; + + +/* + * Open the CD device and figure out what kind of drive is attached. + */ +int +wmcd_open(struct wm_drive *d) +{ + int fd; + static int warned = 0; + char vendor[32] = WM_STR_GENVENDOR; + char model[32] = WM_STR_GENMODEL; + char rev[32] = WM_STR_GENREV; + int i; + + if (d->fd >= 0) /* Device already open? */ + { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_open(): [device is open (fd=%d)]\n", d->fd); + return (0); + } + + if (d->cd_device == NULL) + { + for (i = 0; cds[i] != NULL; i++) + { + d->cd_device = cds[i]; + d->fd = open(d->cd_device, O_RDONLY); + if (d->fd >= 0) + break; + } + } + else + d->fd = open(d->cd_device, O_RDONLY); + if (d->fd < 0) + { + if (errno == EIO) + /* No CD in drive. */ + return 1; + else + return -errno; + } + + /* Now fill in the relevant parts of the wm_drive structure. */ + fd = d->fd; + + find_drive_struct(vendor, model, rev); + + (d->init)(d); + + d->fd = fd; + + return (0); +} /* wmcd_open() */ + +/* + * Re-Open the device if it is open. + */ +int +wmcd_reopen( struct wm_drive *d ) +{ + int status; + + do { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_reopen\n"); + status = gen_close( d ); + wm_susleep( 1000 ); + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "calling wmcd_open()\n"); + status = wmcd_open( d ); /* open it as usual */ + wm_susleep( 1000 ); + } while ( status != 0 ); + return status; +} /* wmcd_reopen() */ + +/* + * Send an arbitrary SCSI command to a device. + * + */ +int +wm_scsi(struct wm_drive *d, unsigned char *cdb, + int cdblen, void *retbuf, int retbuflen, int getreply) +{ + return (-1); +} /* wm_scsi() */ + +int +gen_close( struct wm_drive *d ) +{ + if(d->fd != -1) { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "closing the device\n"); + close(d->fd); + } + d->fd = -1; + return 0; +} + +/* + * Get the current status of the drive: the current play mode, the absolute + * position from start of disc (in frames), and the current track and index + * numbers if the CD is playing or paused. + */ +int +gen_get_drive_status(struct wm_drive *d, int oldmode, + int *mode, int *pos, int *track, int *index) +{ + struct ioc_read_subchannel sc; + struct cd_sub_channel_info scd; + + /* If we can't get status, the CD is ejected, so default to that. */ + *mode = WM_CDM_EJECTED; + + sc.address_format = CD_MSF_FORMAT; + sc.data_format = CD_CURRENT_POSITION; + sc.track = 0; + sc.data_len = sizeof(scd); + sc.data = (struct cd_sub_channel_info *)&scd; + + /* Is the device open? */ + if (d->fd < 0) + { + switch (wmcd_open(d)) { + case -1: /* error */ + return (-1); + + case 1: /* retry */ + return (0); + } + } + + if (ioctl(d->fd, CDIOCREADSUBCHANNEL, &sc)) + { + /* we need to release the device so the kernel will notice + reloaded media */ + (void) close(d->fd); + d->fd = -1; + return (0); /* ejected */ + } + + switch (scd.header.audio_status) + { + case CD_AS_PLAY_IN_PROGRESS: + *mode = WM_CDM_PLAYING; + dopos: + *pos = scd.what.position.absaddr.msf.minute * 60 * 75 + + scd.what.position.absaddr.msf.second * 75 + + scd.what.position.absaddr.msf.frame; + *track = scd.what.position.track_number; + *index = scd.what.position.index_number; + break; + + case CD_AS_PLAY_PAUSED: + if (oldmode == WM_CDM_PLAYING || oldmode == WM_CDM_PAUSED) + { + *mode = WM_CDM_PAUSED; + goto dopos; + } + else + *mode = WM_CDM_STOPPED; + break; + + case CD_AS_PLAY_COMPLETED: + *mode = WM_CDM_TRACK_DONE; /* waiting for next track. */ + break; + + case CD_AS_NO_STATUS: + case 0: + *mode = WM_CDM_STOPPED; + break; + } + + return (0); +} /* gen_get_drive_status() */ + +/* + * Get the number of tracks on the CD. + */ +int +gen_get_trackcount(struct wm_drive *d, int *tracks) +{ + struct ioc_toc_header hdr; + + if (ioctl(d->fd, CDIOREADTOCHEADER, &hdr) == -1) + return (-1); + + *tracks = hdr.ending_track - hdr.starting_track + 1; + return (0); +} /* gen_get_trackcount() */ + +/* + * Get the start time and mode (data or audio) of a track. + * + * XXX - this should get cached, but that means keeping track of ejects. + */ +int +gen_get_trackinfo(struct wm_drive *d, int track, int *data, int *startframe) +{ + struct ioc_read_toc_entry toc; + struct cd_toc_entry toc_buffer; + + bzero((char *)&toc_buffer, sizeof(toc_buffer)); + toc.address_format = CD_MSF_FORMAT; + toc.starting_track = track; + toc.data_len = sizeof(toc_buffer); + toc.data = &toc_buffer; + + if (ioctl(d->fd, CDIOREADTOCENTRYS, &toc)) + return (-1); + + *data = ((toc_buffer.control & 0x4) != 0); + + *startframe = toc_buffer.addr.msf.minute*60*75 + + toc_buffer.addr.msf.second * 75 + + toc_buffer.addr.msf.frame; + + return (0); +} /* gen_get_trackinfo() */ + +/* + * Get the number of frames on the CD. + */ +int +gen_get_cdlen(struct wm_drive *d, int *frames) +{ + int tmp; + struct ioc_toc_header hdr; + int status; + +#define LEADOUT 0xaa /* see scsi.c. what a hack! */ + return gen_get_trackinfo(d, LEADOUT, &tmp, frames); +} /* gen_get_cdlen() */ + +/* + * Play the CD from one position to another (both in frames.) + */ +int +gen_play(struct wm_drive *d, int start, int end) +{ + struct ioc_play_msf msf; + + msf.start_m = start / (60*75); + msf.start_s = (start % (60*75)) / 75; + msf.start_f = start % 75; + msf.end_m = end / (60*75); + msf.end_s = (end % (60*75)) / 75; + msf.end_f = end % 75; + + if (ioctl(d->fd, CDIOCSTART)) + return (-1); + + if (ioctl(d->fd, CDIOCPLAYMSF, &msf)) + return (-2); + + return (0); +} /* gen_play() */ + +/* + * Pause the CD. + */ +int +gen_pause(struct wm_drive *d) +{ + return (ioctl(d->fd, CDIOCPAUSE)); +} /* gen_pause() */ + +/* + * Resume playing the CD (assuming it was paused.) + */ +int +gen_resume(struct wm_drive *d) +{ + return (ioctl(d->fd, CDIOCRESUME)); +} /* gen_resume() */ + +/* + * Stop the CD. + */ +int +gen_stop(struct wm_drive *d) +{ + return (ioctl(d->fd, CDIOCSTOP)); +} /* gen_stop() */ + +/* + * Eject the current CD, if there is one. + */ +int +gen_eject(struct wm_drive *d) +{ + /* On some systems, we can check to see if the CD is mounted. */ + struct stat stbuf; + struct statfs buf; + int rval; + + if (fstat(d->fd, &stbuf) != 0) + return (-2); + + /* Is this a mounted filesystem? */ + if (fstatfs(stbuf.st_rdev, &buf) == 0) + return (-3); + + rval = ioctl(d->fd, CDIOCALLOW); + if (rval == 0) + rval = ioctl(d->fd, CDIOCEJECT); + if (rval == 0) + rval = ioctl(d->fd, CDIOCPREVENT); + if (rval == 0) + rval = close(d->fd); + if (rval == 0) + d->fd = -1; + return rval; +} /* gen_eject() */ + +/*----------------------------------------* + * Close the CD tray + * + * Please edit and send changes to + * milliByte@DeathsDoor.com + *----------------------------------------*/ + +int +gen_closetray(struct wm_drive *d) +{ +#ifdef CAN_CLOSE + if(!close(d->fd)) + { + d->fd=-1; + return(wmcd_reopen(d)); + } else { + return(-1); + } +#else + /* Always succeed if the drive can't close */ + return(0); +#endif /* CAN_CLOSE */ +} /* gen_closetray() */ + +/* + * scale_volume(vol, max) + * + * Return a volume value suitable for passing to the CD-ROM drive. "vol" + * is a volume slider setting; "max" is the slider's maximum value. + * + * On Sun and DEC CD-ROM drives, the amount of sound coming out the jack + * increases much faster toward the top end of the volume scale than it + * does at the bottom. To make up for this, we make the volume scale look + * sort of logarithmic (actually an upside-down inverse square curve) so + * that the volume value passed to the drive changes less and less as you + * approach the maximum slider setting. The actual formula looks like + * + * (max^2 - (max - vol)^2) * (max_volume - min_volume) + * v = --------------------------------------------------- + min_volume + * max^2 + * + * If your system's volume settings aren't broken in this way, something + * like the following should work: + * + * return ((vol * (max_volume - min_volume)) / max + min_volume); + */ +static int +scale_volume(int vol, int max) +{ + return ((vol * (max_volume - min_volume)) / max + min_volume); +} /* scale_volume() */ + +/* + * unscale_volume(cd_vol, max) + * + * Given a value between min_volume and max_volume, return the volume slider + * value needed to achieve that value. + * + * Rather than perform floating-point calculations to reverse the above + * formula, we simply do a binary search of scale_volume()'s return values. + */ +static int +unscale_volume(int cd_vol, int max) +{ + int vol = 0, top = max, bot = 0, scaled; + + while (bot <= top) + { + vol = (top + bot) / 2; + scaled = scale_volume(vol, max); + if (cd_vol == scaled) + break; + if (cd_vol < scaled) + top = vol - 1; + else + bot = vol + 1; + } + + if (vol < 0) + vol = 0; + else if (vol > max) + vol = max; + + return (vol); +} /* unscale_volume() */ + +/* + * Set the volume level for the left and right channels. Their values + * range from 0 to 100. + */ +int +gen_set_volume(struct wm_drive *d, int left, int right) +{ + struct ioc_vol vol; + + if (left < 0) /* don't laugh, I saw this happen once! */ + left = 0; + if (right < 0) + right = 0; + left = scale_volume(left, 100); + right = scale_volume(right, 100); + + bzero((char *)&vol, sizeof(vol)); + + vol.vol[LEFT_PORT] = left; + vol.vol[RIGHT_PORT] = right; + + if (ioctl(d->fd, CDIOCSETVOL, &vol)) + return (-1); + + return (0); +} /* gen_set_volume() */ + + +/* + * Read the initial volume from the drive, if available. Each channel + * ranges from 0 to 100, with -1 indicating data not available. + */ +int +gen_get_volume(struct wm_drive *d, int *left, int *right) +{ + struct ioc_vol vol; + + if (d->fd >= 0) + { + bzero((char *)&vol, sizeof(vol)); + + if (ioctl(d->fd, CDIOCGETVOL, &vol)) + *left = *right = -1; + else + { + *left = unscale_volume(vol.vol[LEFT_PORT], 100); + *right = unscale_volume(vol.vol[RIGHT_PORT], 100); + } + } + else + *left = *right = -1; + + return (0); +} /* gen_get_volume() */ + +/*------------------------------------------------------------------------* + * gen_get_cdtext(drive, buffer, lenght) + *------------------------------------------------------------------------*/ + +int +gen_get_cdtext(struct wm_drive *d, unsigned char **pp_buffer, int *p_buffer_lenght) +{ + return -1; /* no SCSI, no CDTEXT */ +} /* gen_get_cdtext() */ + +#endif diff --git a/kscd/libwm/plat_osf1.c b/kscd/libwm/plat_osf1.c new file mode 100644 index 00000000..a2cc0afb --- /dev/null +++ b/kscd/libwm/plat_osf1.c @@ -0,0 +1,674 @@ +/* + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * OSF drive control routines. + */ + + +#if defined(__osf__) || defined(__osf) + + +#include <errno.h> +#include <stdio.h> +#include <sys/types.h> +#include <fcntl.h> +#include <sys/param.h> +#include <sys/stat.h> +#include <sys/time.h> +#include <ustat.h> +#include <string.h> +/* #include <sys/rzdisk.h> +#include <sys/cdrom.h> */ +#include <io/cam/rzdisk.h> +#include <io/cam/cdrom.h> + +#include "include/wm_config.h" +#include "include/wm_struct.h" +#include "include/wm_helpers.h" +#include "include/wm_cdtext.h" + + +#define WM_MSG_CLASS WM_MSG_CLASS_PLATFORM + +/* + * This structure will be filled with the TOC header and all entries. + * Ultrix doesn't seem to allow getting single TOC entries. + * - Chris Ross (cross@eng.umd.edu) + */ +struct cd_toc_header_and_entries +{ + struct cd_toc_header cdth; + struct cd_toc_entry cdte[CDROM_MAX_TRACK+1]; +}; + +void *malloc(); +char *strchr(); + +int min_volume = 128; +int max_volume = 255; +static char* osf_cd_device = NULL; + +/* + * fgetline() + * + * Simulate fgets, but joining continued lines in the output of uerf. + * + * platform specific internal function + * + */ + +#define BUF_SIZE 85 /* Max length of a (real) line */ + +char * +fgetline( FILE *fp ) +{ + static char *retval = NULL; + static char holdbuf[BUF_SIZE + 1]; + char tmp[BUF_SIZE + 1]; + char *stmp; + + if (!retval) + { + retval = malloc(BUF_SIZE * 3); /* 3 lines can be joined */ + if (!retval) + return(NULL); + else + *retval = '\0'; + } + + if (*holdbuf) + { + strcpy(retval, holdbuf); + retval[strlen(retval)-1] = '\0'; + memset(holdbuf, 0, BUF_SIZE+1); + } + + while (fgets(tmp, BUF_SIZE, fp)) + { + stmp = tmp + strspn(tmp, " \t"); + if (*stmp == '_') { /* Continuation line */ + retval[strlen(retval)-1] = '\0'; /* Trim off C/R */ + strcat(retval, stmp+1); + } else { + if (*retval) + { + strcpy(holdbuf, tmp); + holdbuf[strlen(holdbuf)-1] = -1; + return retval; + } else { /* First line read, keep reading */ + strcat(retval, stmp); + retval[strlen(retval)-1] = '\0'; + } + } + } + return NULL; +} /* fgetline() */ + + +/* + * find_cdrom + * + * Determine the name of the CD-ROM device. + * + * Read through the boot records (via a call to uerf) and find the SCSI + * address of the CD-ROM. + */ +const char* +find_cdrom() +{ + char *data; + FILE *uerf; + int fds[2]; + int pid; + extern char *getenv(); + const char *device = NULL; + + pipe(fds); + + device = getenv("CDROM"); + /* + ** the path of the device has to start w/ /dev + ** otherwise we are vulnerable to race conditions + ** Thomas Biege <thomas@suse.de> + */ + if ( device == NULL || + strncmp("/dev/", device, 5) || + strstr(device, "/../") + ) + return NULL; + + if ((pid = fork()) == 0) + { + close(fds[0]); + dup2(fds[1], 1); + execl("/etc/uerf", "uerf", "-R", "-r", "300", (void *)0); + execl("/usr/sbin/uerf", "uerf", "-R", "-r", "300", (void *)0); + return NULL; /* _exit(1); */ + } else if (pid < 0) { + perror("fork"); + return NULL; + } + + close(fds[1]); + uerf = fdopen(fds[0], "r"); + + while (data = fgetline(uerf)) + if (strstr(data, "RRD42")) + { + char *device_p; + + osf_cd_device = (char *)malloc(sizeof("/dev/rrz##c")); + strcpy(osf_cd_device, "/dev/r"); + device_p = strstr(data, "rz"); + device_p[(int)(strchr(device_p, ' ') - device_p)] = '\0'; + strcat(osf_cd_device, device_p); + strcat(osf_cd_device, "c"); + device = osf_cd_device; + break; + } + + fclose(uerf); + + if (device == NULL) + { + fprintf(stderr, + "No cdrom (RRD42) is installed on this system\n"); + return NULL; + } + + kill(pid, 15); + (void)wait((int *)NULL); + return device; +} /* find_cdrom() */ + +/* + * Initialize the drive. A no-op for the generic driver. + */ +int +gen_init( struct wm_drive *d ) +{ + return (0); +} /* gen_init() */ + +/* + * Open the CD device and figure out what kind of drive is attached. + */ +int +wmcd_open( struct wm_drive *d ) +{ + int fd; + static int warned = 0; + + if (d->fd >= 0) /* Device already open? */ + { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_open(): [device is open (fd=%d)]\n", d->fd); + return (0); + } + + if (d->cd_device == NULL) + d->cd_device = find_cdrom(); + + d->fd = open(d->cd_device, O_RDWR); + if (d->fd < 0) + { + if (errno == EACCES) + { + return -EACCES; + } + else if (errno != EINTR) + { + return (-6); + } + + /* No CD in drive. */ + return (1); + } + + /* Now fill in the relevant parts of the wm_drive structure. */ + find_drive_struct("", "", ""); + d->fd = fd; + + (d->init)(d); + + return (0); +} /* wmcd_open() */ + +/* + * Re-Open the device if it is open. + */ +int +wmcd_reopen( struct wm_drive *d ) +{ + int status; + + do { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_reopen\n"); + status = gen_close( d ); + wm_susleep( 1000 ); + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "calling wmcd_open()\n"); + status = wmcd_open( d ); /* open it as usual */ + wm_susleep( 1000 ); + } while ( status != 0 ); + return status; +} /* wmcd_reopen() */ + +/* + * Send an arbitrary SCSI command to a device. + */ +int +wm_scsi(struct wm_drive *d, unsigned char *cdb, int cdblen, + void *retbuf, int retbuflen, int getreply) +{ + /* OSF1 doesn't have a SCSI passthrough interface, does it? */ + return (-1); +} /* wm_scsi() */ + +int +gen_close( struct wm_drive *d ) +{ + if(d->fd != -1) { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "closing the device\n"); + close(d->fd); + d->fd = -1; + } + return 0; +} + +/* + * Get the current status of the drive: the current play mode, the absolute + * position from start of disc (in frames), and the current track and index + * numbers if the CD is playing or paused. + */ +int +gen_get_drive_status(struct wm_drive *d, int oldmode, + int *mode, int *pos, int *track, int *index) +{ + struct cd_sub_channel sc; + struct cd_subc_channel_data scd; + + /* If we can't get status, the CD is ejected, so default to that. */ + *mode = WM_CDM_EJECTED; + + sc.sch_address_format = CDROM_MSF_FORMAT; + sc.sch_data_format = CDROM_CURRENT_POSITION; + sc.sch_track_number = 0; + sc.sch_alloc_length = sizeof(scd); + sc.sch_buffer = (caddr_t)&scd; + + /* Is the device open? */ + if (d->fd < 0) + { + switch (wmcd_open(d)) + { + case -1: /* error */ + return (-1); + + case 1: /* retry */ + return (0); + } + } + + if (ioctl(d->fd, CDROM_READ_SUBCHANNEL, &sc)) + return (0); /* ejected */ + + switch (scd.scd_header.sh_audio_status) + { + case AS_PLAY_IN_PROGRESS: + *mode = WM_CDM_PLAYING; + dopos: + *pos = scd.scd_position_data.scp_absaddr.msf.m_units * 60 * 75 + + scd.scd_position_data.scp_absaddr.msf.s_units * 75 + + scd.scd_position_data.scp_absaddr.msf.f_units; + *track = scd.scd_position_data.scp_track_number; + *index = scd.scd_position_data.scp_index_number; + break; + + case AS_PLAY_PAUSED: + if (oldmode == WM_CDM_PLAYING || oldmode == WM_CDM_PAUSED) + { + *mode = WM_CDM_PAUSED; + goto dopos; + } + else + *mode = WM_CDM_STOPPED; + break; + + case AS_PLAY_COMPLETED: + *mode = WM_CDM_TRACK_DONE; /* waiting for next track. */ + break; + + case AS_NO_STATUS: + *mode = WM_CDM_STOPPED; + break; + default: + abort(); + } + + return (0); +} /* gen_get_drive_status() */ + +/* + * Play the CD from one position to another (both in frames.) + */ +int +gen_play( struct wm_drive *d, int start, int end ) +{ + struct cd_play_audio_msf msf; + + msf.msf_starting_M_unit = start / (60*75); + msf.msf_starting_S_unit = (start % (60*75)) / 75; + msf.msf_starting_F_unit = start % 75; + msf.msf_ending_M_unit = end / (60*75); + msf.msf_ending_S_unit = (end % (60*75)) / 75; + msf.msf_ending_F_unit = end % 75; + + if (ioctl(d->fd, SCSI_START_UNIT)) + return (-1); + if (ioctl(d->fd, CDROM_PLAY_AUDIO_MSF, &msf)) + return (-2); + + return (0); +} /* gen_play() */ + +/* + * Pause the CD. + */ +int +gen_pause( struct wm_drive *d ) +{ + return (ioctl(d->fd, CDROM_PAUSE_PLAY, 0)); +} /* gen_pause() */ + +/* + * Resume playing the CD (assuming it was paused.) + */ +int +gen_resume( struct wm_drive *d ) +{ + return (ioctl(d->fd, CDROM_RESUME_PLAY, 0)); +} /* gen_resume() */ + +/* + * Stop the CD. + */ +int +gen_stop( struct wm_drive *d ) +{ + return (ioctl(d->fd, SCSI_STOP_UNIT, 0)); +} /* gen_stop() */ + +/* + * Eject the current CD, if there is one. + */ +int +gen_eject(struct wm_drive *d) +{ + /* On some systems, we can check to see if the CD is mounted. */ + struct stat stbuf; + struct ustat ust; + + if (fstat(d->fd, &stbuf) != 0) + return (-2); + + /* Is this a mounted filesystem? */ + if (ustat(stbuf.st_rdev, &ust) == 0) + return (-3); + + return (ioctl(d->fd, CDROM_EJECT_CADDY, 0)); +} /* gen_eject() */ + +/*----------------------------------------* + * Close the CD tray + * + * Please edit and send changes to + * milliByte@DeathsDoor.com + *----------------------------------------*/ + +int +gen_closetray(struct wm_drive *d) +{ +#ifdef CAN_CLOSE + if(!close(d->fd)) + { + d->fd=-1; + return(wmcd_reopen(d)); + } else { + return(-1); + } +#else + /* Always succeed if the drive can't close */ + return(0); +#endif /* CAN_CLOSE */ +} /* gen_closetray() */ + +/* + * Get the number of tracks on the CD. + */ +int +gen_get_trackcount(struct wm_drive *d, int *tracks) +{ + struct cd_toc_header hdr; + + if (ioctl(d->fd, CDROM_TOC_HEADER, &hdr)) + return (-1); + + *tracks = hdr.th_ending_track; + + return (0); +} /* gen_get_trackcount() */ + +/* + * Get the start time and mode (data or audio) of a track. + * + * XXX - this should get cached, but that means keeping track of ejects. + */ +int +gen_get_trackinfo(struct wm_drive *d, int track, int *data, int *startframe) +{ + struct cd_toc toc; + struct cd_toc_header hdr; + struct cd_toc_header_and_entries toc_buffer; + + if (ioctl(d->fd, CDROM_TOC_HEADER, &hdr)) + return (-1); + + bzero((char *)&toc_buffer, sizeof(toc_buffer)); + toc.toc_address_format = CDROM_MSF_FORMAT; + toc.toc_starting_track = 0; + toc.toc_alloc_length = (u_short)(((hdr.th_data_len1 << 8) + + hdr.th_data_len0) & 0xfff) + 2; + toc.toc_buffer = (caddr_t)&toc_buffer; + + if (ioctl(d->fd, CDROM_TOC_ENTRYS, &toc)) + return (-1); + + if (track == 0) + track = hdr.th_ending_track + 1; + + *data = (toc_buffer.cdte[track-1].te_control & CDROM_DATA_TRACK) ? 1:0; + *startframe = toc_buffer.cdte[track - 1].te_absaddr.msf.m_units*60*75 + + toc_buffer.cdte[track - 1].te_absaddr.msf.s_units * 75 + + toc_buffer.cdte[track - 1].te_absaddr.msf.f_units; + + return (0); +} /* gen_get_trackinfo() */ + +/* + * Get the number of frames on the CD. + */ +int +gen_get_cdlen( struct wm_drive *d, int *frames ) +{ + int tmp; + + return (gen_get_trackinfo(d, 0, &tmp, frames)); +} /* gen_get_cdlen() */ + +/* + * scale_volume(vol, max) + * + * Return a volume value suitable for passing to the CD-ROM drive. "vol" + * is a volume slider setting; "max" is the slider's maximum value. + * + * On Sun and DEC CD-ROM drives, the amount of sound coming out the jack + * increases much faster toward the top end of the volume scale than it + * does at the bottom. To make up for this, we make the volume scale look + * sort of logarithmic (actually an upside-down inverse square curve) so + * that the volume value passed to the drive changes less and less as you + * approach the maximum slider setting. The actual formula looks like + * + * (max^2 - (max - vol)^2) * (max_volume - min_volume) + * v = --------------------------------------------------- + min_volume + * max^2 + * + * If your system's volume settings aren't broken in this way, something + * like the following should work: + * + * return ((vol * (max_volume - min_volume)) / max + min_volume); + */ +scale_volume(int vol, int max) +{ + return ((max * max - (max - vol) * (max - vol)) * + (max_volume - min_volume) / (max * max) + min_volume); +} /* scale_volume() */ + +/* + * unscale_volume(cd_vol, max) + * + * Given a value between min_volume and max_volume, return the volume slider + * value needed to achieve that value. + * + * Rather than perform floating-point calculations to reverse the above + * formula, we simply do a binary search of scale_volume()'s return values. + */ +static int +unscale_volume( int cd_vol, int max ) +{ + int vol = 0, top = max, bot = 0, scaled; + + while (bot <= top) + { + vol = (top + bot) / 2; + scaled = scale_volume(vol, max); + if (cd_vol == scaled) + break; + if (cd_vol < scaled) + top = vol - 1; + else + bot = vol + 1; + } + + if (vol < 0) + vol = 0; + else if (vol > max) + vol = max; + + return (vol); +} /* unscale_volume() */ + +/* + * Set the volume level for the left and right channels. Their values + * range from 0 to 100. + */ +int +gen_set_volume(struct wm_drive *d, int left, int right) +{ + struct cd_playback pb; + struct cd_playback_status ps; + struct cd_playback_control pc; + + left = scale_volume(left, 100); + right = scale_volume(right, 100); + + bzero((char *)&pb, sizeof(pb)); + bzero((char *)&ps, sizeof(ps)); + bzero((char *)&pc, sizeof(pc)); + + pb.pb_alloc_length = sizeof(ps); + pb.pb_buffer = (caddr_t)&ps; + + if (ioctl(d->fd, CDROM_PLAYBACK_STATUS, &pb)) + return (-1); + + pc.pc_chan0_select = ps.ps_chan0_select; + pc.pc_chan0_volume = (left < CDROM_MIN_VOLUME) ? + CDROM_MIN_VOLUME : (left > CDROM_MAX_VOLUME) ? + CDROM_MAX_VOLUME : left; + pc.pc_chan1_select = ps.ps_chan1_select; + pc.pc_chan1_volume = (right < CDROM_MIN_VOLUME) ? + CDROM_MIN_VOLUME : (right > CDROM_MAX_VOLUME) ? + CDROM_MAX_VOLUME : right; + + pb.pb_alloc_length = sizeof(pc); + pb.pb_buffer = (caddr_t)&pc; + + if (ioctl(d->fd, CDROM_PLAYBACK_CONTROL, &pb)) + return (-1); + + return (0); +} /* gen_set_volume() */ + + +/* + * Read the initial volume from the drive, if available. Each channel + * ranges from 0 to 100, with -1 indicating data not available. + */ +int +gen_get_volume( struct wm_drive *d, int *left, int *right ) +{ + struct cd_playback pb; + struct cd_playback_status ps; + + bzero((char *)&pb, sizeof(pb)); + bzero((char *)&ps, sizeof(ps)); + + pb.pb_alloc_length = sizeof(ps); + pb.pb_buffer = (caddr_t)&ps; + + if (d->fd >= 0) + { + if (ioctl(d->fd, CDROM_PLAYBACK_STATUS, &pb)) + *left = *right = -1; + else + { + *left = unscale_volume(ps.ps_chan0_volume, 100); + *right = unscale_volume(ps.ps_chan1_volume, 100); + } + } + else + *left = *right = -1; + + return (0); +} /* gen_get_volume() */ + +/*------------------------------------------------------------------------* + * gen_get_cdtext(drive, buffer, lenght) + *------------------------------------------------------------------------*/ + +int +gen_get_cdtext(struct wm_drive *d, unsigned char **pp_buffer, int *p_buffer_lenght) +{ + return -1; /* no SCSI, no CDTEXT */ +} /* gen_get_cdtext() */ + + +#endif diff --git a/kscd/libwm/plat_scor5.c b/kscd/libwm/plat_scor5.c new file mode 100644 index 00000000..1e5be6e2 --- /dev/null +++ b/kscd/libwm/plat_scor5.c @@ -0,0 +1,426 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * SCO Openserver R5 specific. Derived from the KSCD plat_scor5.c + * + */ + + +static char plat_linux_id[] = "$Id$"; + +#if defined(M_UNIX) || defined(__M_UNIX) + + +#include "include/wm_config.h" + +#include <sys/types.h> +#include <stdio.h> +#include <ctype.h> +#include <string.h> +#include <fcntl.h> +#include <stdlib.h> +#include <unistd.h> +#include <signal.h> +#include <sys/stat.h> +#include <sys/scsi.h> +#include <sys/scsicmd.h> +#include <errno.h> +#include <macros.h> + +#include "include/wm_struct.h" +#include "include/wm_scsi.h" +#include "include/wm_cdtext.h" + +#define WM_MSG_CLASS WM_MSG_CLASS_PLATFORM + +#define SENSE_SZ EXTD_SENSE_LEN + +void *malloc(); +char *strchr(); + +int min_volume = 0; +int max_volume = 255; + +/* + * platformspecific internal function + */ +static int +create_cdrom_node(char *dev_name) +{ + char pass_through[100]; + int file_des; + struct stat sbuf; + int err; + int ccode; + + + strncpy(pass_through, dev_name, sizeof(pass_through)-2); + strcat(pass_through, "p" ); + + if (setreuid(-1,0) < 0) + { + perror("setregid/setreuid/access"); + return -1; + } + + ccode = access(pass_through, F_OK); + + if (ccode < 0) + { + + if (stat(dev_name, &sbuf) < 0) + { + perror("Call to get pass-through device number failed"); + return -1; + } + + if (mknod(pass_through, (S_IFCHR | S_IREAD | S_IWRITE), + sbuf.st_rdev) < 0) + { + perror("Unable to make pass-through node"); + return -1; + } + + if (chown(pass_through, 0 , 0) < 0) + { + perror("chown"); + return -1; + } + + if (chmod(pass_through, 0660 ) < 0) + { + perror("chmod"); + return -1; + } + } + + file_des = open( pass_through, O_RDONLY); + err = errno; + + /* + if ( (setreuid(-1,getuid()) < 0) || (setregid(-1,getgid()) < 0) ) + { + perror("setreuid/setregid"); + exit(1); + } + + */ + + errno = err; + return file_des; +} /* create_cdrom_node() */ + + +/* + * Initialize the drive. A no-op for the generic driver. + */ +int +gen_init( struct wm_drive *d ) +{ + return (0); +} /* gen_init() */ + +/* + * Open the CD and figure out which kind of drive is attached. + */ +int +wmcd_open( struct wm_drive *d) +{ + int fd; + static int warned = 0; + char vendor[9], model[17], rev[5]; + + if (d->fd >= 0) /* Device already open? */ + { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_open(): [device is open (fd=%d)]\n", d->fd); + return (0); + } + + if (d->cd_device == NULL) + { + fprintf(stderr,"cd_device string empty\n"); + return (-1); + } + + + d->fd = create_cdrom_node(d->cd_device); /* this will do open */ + + if (d->fd < 0) + { + if (errno == EACCES) + { + if (! warned) + { + fprintf(stderr,"Cannot access %s\n",d->cd_device); + warned++; + } + } + else if (errno != EINTR) + { + perror(d->cd_device); + return( -6 ); + } + + /* can not acces CDROM device */ + return (-1); + } + + if (warned) + { + warned = 0; + fprintf(stderr, "Thank you.\n"); + } + + /* Now fill in the relevant parts of the wm_drive structure. */ + + fd = d->fd; + + if (wm_scsi_get_drive_type(d, vendor, model, rev) < 0) + { + perror("Cannot inquiry drive for it's type"); + return (-1); + } + find_drive_struct(vendor, model, rev); + + d->fd = fd; + + return (0); +} /* wmcd_open */ + +/* + * Re-Open the device + */ +wmcd_reopen( struct wm_drive *d ) +{ + int status; + int tries = 0; + do { + gen_close(d); + susleep( 1000 ); + status = wmcd_open( d ); + susleep( 1000 ); + tries++; + } while ( (status != 0) && (tries < 10) ); + return status; +} /* wmcd_reopen() */ + +/* + * Send a SCSI command out the bus. + */ +int +wm_scsi(struct wm_drive *d, unsigned char *xcdb, int cdblen, + char *retbuf, int retbuflen, int getreply) +{ + int ccode; + int file_des = d->fd; + unsigned char sense_buffer[ SENSE_SZ ]; + + /* getreply == 1 is read, == 0 is write */ + + struct scsicmd2 sb; /* Use command with automatic sense */ + + if (cdblen > SCSICMDLEN) + { + fprintf(stderr,"Cannot handle longer commands than %d bytes.\n", SCSICMDLEN); + exit(-1); + } + + /* Get the command */ + memcpy(sb.cmd.cdb, xcdb, cdblen); + sb.cmd.cdb_len = cdblen; + + /* Point to data buffer */ + sb.cmd.data_ptr = retbuf; + sb.cmd.data_len = retbuflen; + + /* Is this write or read ? */ + sb.cmd.is_write = (getreply==1) ? 0 : 1; + + /* Zero out return status fields */ + sb.cmd.host_sts = 0; + sb.cmd.target_sts = 0; + + /* Set up for possible sense info */ + + sb.sense_ptr = sense_buffer; + sb.sense_len = sizeof(sense_buffer); + + ccode = ioctl(file_des, SCSIUSERCMD2, &sb); + + if ( sb.cmd.target_sts != 02 ) + return ccode; + + return 0; +} /* wm_scsi() */ + +int +gen_close( struct wm_drive *d ) +{ + if(d->fd != -1) { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "closing the device\n"); + close(d->fd); + d->fd = -1; + } + return 0; +} + +void +keep_cd_open() { } + +/* + * Get the current status of the drive: the current play mode, the absolute + * position from start of disc (in frames), and the current track and index + * numbers if the CD is playing or paused. + */ +int +gen_get_drive_status(wm_drive *d, int oldmode, int *mode, + int *pos, int *track, int *index) +{ + return (wm_scsi2_get_drive_status(d, oldmode, mode, pos, track, index)); +} /* gen_get_drive_status() */ + +/* + * Get the number of tracks on the CD. + */ +int +gen_get_trackcount(struct wm_drive *d, int *tracks) +{ + return (wm_scsi2_get_trackcount(d, tracks)); +} /* gen_get_trackcount() */ + + +/* + * Get the start time and mode (data or audio) of a track. + */ +int +gen_get_trackinfo(struct wm_drive *d, int track, int *data, int *startframe) +{ + return (wm_scsi2_get_trackinfo(d, track, data, startframe)); +} /* gen_get_trackinfo() */ + +/* + * Get the number of frames on the CD. + */ +int +gen_get_cdlen(struct wm_drive *d, int *frames) +{ + return (wm_scsi2_get_cdlen(d, frames)); +} /* gen_get_cdlen() */ + + +/* + * Play the CD from one position to another (both in frames.) + */ +int +gen_play(struct wm_drive *d, int start, int end) +{ + return (wm_scsi2_play(d, start, end)); +} /* gen_play() */ + +/* + * Pause the CD. + */ +int +gen_pause( struct wm_drive *d ) +{ + return (wm_scsi2_pause(d)); +} /* gen_pause() */ + +/* + * Resume playing the CD (assuming it was paused.) + */ +int +gen_resume( struct wm_drive *d ) +{ + return (wm_scsi2_resume(d)); +} /* gen_resume() */ + +/* + * Stop the CD. + */ +int +gen_stop(struct wm_drive *d) +{ + return (wm_scsi2_stop(d)); +} /* gen_stop() */ + +/* + * Eject the current CD, if there is one. + */ +int +gen_eject(struct wm_drive *d) +{ + int stat; + + stat = wm_scsi2_eject(d); + sleep(2); + return (stat); +} /* gen_eject() */ + + +int +gen_closetray(struct wm_drive *d) +{ + return(wm_scsi2_closetray(d)); +} /* gen_closetray() */ + + +/* + * Set the volume level for the left and right channels. Their values + * range from 0 to 100. + */ +int +gen_set_volume(struct wm_drive *d, int left, int right) +{ + return (wm_scsi2_set_volume(d, left, right)); +} /* gen_set_volume() */ + +/* + * Read the initial volume from the drive, if available. Each channel + * ranges from 0 to 100, with -1 indicating data not available. + */ +int +gen_get_volume(struct wm_drive *d, int *left, int *right) +{ + return (wm_scsi2_get_volume(d, left, right)); +} /* gen_get_volume() */ + +/*------------------------------------------------------------------------* + * gen_get_cdtext(drive, buffer, lenght) + *------------------------------------------------------------------------*/ + +int +gen_get_cdtext(struct wm_drive *d, unsigned char **pp_buffer, int *p_buffer_lenght) +{ + /* This needs to be tested! */ + return wm_scsi_get_cdtext(d, pp_buffer, p_buffer_lenght); +} /* gen_get_cdtext() */ + + + +#endif /* M_UNIX */ + + + + diff --git a/kscd/libwm/plat_sun.c b/kscd/libwm/plat_sun.c new file mode 100644 index 00000000..f83a6cd8 --- /dev/null +++ b/kscd/libwm/plat_sun.c @@ -0,0 +1,972 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * Sun-specific drive control routines. + */ + +static char plat_sun_id[] = "$Id$"; + +#if defined(sun) || defined(__sun) + +#include <errno.h> +#include <stdio.h> +#include <sys/types.h> +#include <fcntl.h> +#include <string.h> +#include <sys/param.h> +#include <sys/stat.h> +#include <sys/time.h> +#include <sys/ioctl.h> + +#include "include/wm_config.h" +#include "include/wm_helpers.h" +#include "include/wm_cdrom.h" +#include "include/wm_cdtext.h" + +#include <ustat.h> +#include <unistd.h> +#include <signal.h> +#ifdef solbourne +# include <mfg/dklabel.h> +# include <mfg/dkio.h> +# include <sys/unistd.h> +# include <dev/srvar.h> +#else /* A real Sun */ +# ifdef SYSV +# include <poll.h> +# include <stdlib.h> +# include <sys/cdio.h> +# include <sys/socket.h> +# include <sys/scsi/impl/uscsi.h> +# include "include/wm_cdda.h" +# else +# include <sys/buf.h> +# include <sun/dkio.h> +# include <scsi/targets/srdef.h> +# include <scsi/impl/uscsi.h> +# include <scsi/generic/commands.h> +# endif +#endif + +#include "include/wm_struct.h" + +#define WM_MSG_CLASS WM_MSG_CLASS_PLATFORM + +int min_volume = 0; +int max_volume = 255; + +static const char *sun_cd_device = NULL; +extern int intermittent_dev; + +int current_end; + +#if defined(SYSV) && defined(SIGTHAW) +#ifdef __GNUC__ +void sigthawinit(void) __attribute__ ((constructor)); +#else +#pragma init(sigthawinit) +#endif /* GNUC */ + +static int last_left, last_right; +static struct wm_drive *thecd = NULL; + +/* + * Handling for Sun's Suspend functionality + */ +static void +thawme(int sig) +{ +// Just leave this line in as a reminder for a missing +// functionality in the GUI. +// change_mode(NULL, WM_CDM_STOPPED, NULL); + codec_init(); + if( thecd ) + gen_set_volume(thecd, last_left, last_right); +} /* thawme() */ + +void +sigthawinit( void ) +{ + struct sigaction sa; + + sa.sa_handler = thawme; + sigemptyset(&sa.sa_mask); + sa.sa_flags = 0; + + sigaction(SIGTHAW, &sa, NULL); +} /* sigthawinit() */ + +#endif /* SYSV && SIGTHAW */ + +/* + * find_cdrom + * + * Determine the name of the CD-ROM device. + * + * Use the first of /vol/dev/aliases/cdrom0, /dev/rdsk/c0t6d0s2, and /dev/rsr0 + * that exists. (Check for /vol/dev/aliases, not cdrom0, since it won't be + * there if there's no CD in the drive.) This is done so a single SunOS 4.x + * binary can be used on any 4.x or higher Sun system. + */ +const char* +find_cdrom( void ) +{ + if (access("/vol/dev/aliases", X_OK) == 0) + { + /* Volume manager. Device might not be there. */ + intermittent_dev = 1; + + /* If vold is running us, it'll tell us the device name. */ + sun_cd_device = getenv("VOLUME_DEVICE"); + /* + ** the path of the device has to include /dev + ** otherwise we are vulnerable to race conditions + ** Thomas Biege <thomas@suse.de> + */ + if (sun_cd_device == NULL || + strncmp("/vol/dev/", sun_cd_device, 9) || + strstr(sun_cd_device, "/../") ) + return "/vol/dev/aliases/cdrom0"; + else + return sun_cd_device; + } + else if (access("/dev/rdsk/c0t6d0s2", F_OK) == 0) + { + /* Solaris 2.x w/o volume manager. */ + return "/dev/rdsk/c0t6d0s2"; + } + else if (access("/dev/rcd0", F_OK) == 0) + { + return "/dev/rcd0"; + } + else if (access("/dev/rsr0", F_OK) == 0) + return "/dev/rsr0"; + else + { + fprintf(stderr, "Couldn't find a CD device!\n"); + return NULL; + } +} /* find_cdrom() */ + +/* + * Initialize the drive. A no-op for the generic driver. + */ +int +gen_init( struct wm_drive *d ) +{ + codec_init(); + return (0); +} /* gen_init() */ + + +/* + * Open the CD device and figure out what kind of drive is attached. + */ +int +wmcd_open( struct wm_drive *d ) +{ + static int warned = 0; + char vendor[32] = WM_STR_GENVENDOR; + char model[32] = WM_STR_GENMODEL; + char rev[32] = WM_STR_GENREV; + + if (d->fd >= 0) /* Device already open? */ + { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_open(): [device is open (fd=%d)]\n", d->fd); + return (0); + } + + if (d->cd_device == NULL) + d->cd_device = find_cdrom(); + + d->fd = open(d->cd_device, 0); + if (d->fd < 0) + { + /* Solaris 2.2 volume manager moves links around */ + if (errno == ENOENT && intermittent_dev) + return (1); + + if (errno == EACCES) + { + if (!warned) + { + /* + char realname[MAXPATHLEN]; + + if (realpath(cd_device, realname) == NULL) + { + perror("realpath"); + return (1); + } + */ + return -EACCES; + } + } + else if (errno != ENXIO) + { + return( -6 ); + } + + /* No CD in drive. */ + return (1); + } + + /* + * See if we can do digital audio. + */ +#if defined(BUILD_CDDA) + if(d->cdda) { + if (!gen_cdda_init(d)) + /* WARNING: Old GUI call. How could this survive? */ + enable_cdda_controls(1); + else { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_open(): failed in gen_cdda_init\n"); + gen_close(d); + return -1; + } +#endif + + /* Can we figure out the drive type? */ + if (wm_scsi_get_drive_type(d, vendor, model, rev)) + { + if (errno == EPERM) + { + /* + * Solaris 2.4 seems to refuse to do USCSICMD ioctls + * when not running as root. SunOS 4.x allows it + * as an unprivileged user, though. + */ + fprintf(stderr, "Warning: WorkMan can't adapt itself to your drive unless it runs as root.\n"); + } else { + fprintf(stderr, "Warning: WorkMan couldn't determine drive type\n"); + } + strcpy(vendor, "Generic"); + strcpy(model, "drive type"); + strcpy(rev, ""); + } + + find_drive_struct(vendor, model, rev); + + (d->proto->gen_init)(d); + thecd = d; + + return (0); +} /* wmcd_open() */ + +/* + * Re-Open the device if it is open. + */ +int +wmcd_reopen( struct wm_drive *d ) +{ + int status; + + do { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_reopen\n"); + gen_close(d); + wm_susleep( 1000 ); + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "calling wmcd_open()\n"); + status = wmcd_open( d ); /* open it as usual */ + wm_susleep( 1000 ); + } while ( status != 0 ); + return status; +} /* wmcd_reopen() */ + + +#ifndef solbourne +/* + * Send an arbitrary SCSI command out the bus and optionally wait for + * a reply if "retbuf" isn't NULL. + */ +int +wm_scsi( struct wm_drive *d, + unsigned char *cdb, + int cdblen, void *retbuf, + int retbuflen, int getreply ) +{ + char x; + struct uscsi_cmd cmd; + + memset(&cmd, 0, sizeof(cmd)); + cmd.uscsi_cdb = (void *) cdb; + cmd.uscsi_cdblen = cdblen; + cmd.uscsi_bufaddr = retbuf ? retbuf : (void *)&x; + cmd.uscsi_buflen = retbuf ? retbuflen : 0; + cmd.uscsi_flags = USCSI_ISOLATE | USCSI_SILENT; + if (getreply) + cmd.uscsi_flags |= USCSI_READ; + + if (ioctl(d->fd, USCSICMD, &cmd)) + return (-1); + + if (cmd.uscsi_status) + return (-1); + + return (0); +} +#else +int wm_scsi() { return (-1); } +#endif + +int +gen_close( struct wm_drive *d ) +{ + if(d->fd != -1) { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "closing the device\n"); + close(d->fd); + d->fd = -1; + } + return 0; +} + +/* Alarm signal handler. */ +static void do_nothing( int x ) { x++; } + +/* + * Get the current status of the drive: the current play mode, the absolute + * position from start of disc (in frames), and the current track and index + * numbers if the CD is playing or paused. + */ +int +gen_get_drive_status( struct wm_drive *d, + int oldmode, + int *mode, + int *pos, int *track, int *index ) +{ + struct cdrom_subchnl sc; + struct itimerval old_timer, new_timer; + struct sigaction old_sig, new_sig; + + /* If we can't get status, the CD is ejected, so default to that. */ + *mode = WM_CDM_EJECTED; + + /* Is the device open? */ + if (d->fd < 0) + { + switch (wmcd_open(d)) + { + case -1: /* error */ + return (-1); + + case 1: /* retry */ + return (0); + } + } + +#if defined(BUILD_CDDA) + if (oldmode == WM_CDM_PAUSED || oldmode == WM_CDM_PLAYING || oldmode == WM_CDM_STOPPED) { + CDDARETURN(d) cdda_get_drive_status(d, oldmode, mode, pos, track, index); + } +#endif + + /* + * Solaris 2.2 hangs on this ioctl if someone else ejects the CD. + * So we schedule a signal to break out of the hang if the call + * takes an unreasonable amount of time. The signal handler and + * timer are restored immediately to avoid interfering with XView. + */ + if (intermittent_dev) + { + /* + * First clear out the timer so XView's signal doesn't happen + * while we're diddling with the signal handler. + */ + timerclear(&new_timer.it_interval); + timerclear(&new_timer.it_value); + setitimer(ITIMER_REAL, &new_timer, &old_timer); + + /* + * Now install the no-op signal handler. + */ + new_sig.sa_handler = do_nothing; + memset(&new_sig.sa_mask, 0, sizeof(new_sig.sa_mask)); + new_sig.sa_flags = 0; + if (sigaction(SIGALRM, &new_sig, &old_sig)) + perror("sigaction"); + + /* + * And finally, set the timer. + */ + new_timer.it_value.tv_sec = 2; + setitimer(ITIMER_REAL, &new_timer, NULL); + } + + sc.cdsc_format = CDROM_MSF; + + if (ioctl(d->fd, CDROMSUBCHNL, &sc)) + { + if (intermittent_dev) + { + sigaction(SIGALRM, &old_sig, NULL); + setitimer(ITIMER_REAL, &old_timer, NULL); + + /* If the device can disappear, let it do so. */ + close(d->fd); + d->fd = -1; + } + + return (0); + } + + if (intermittent_dev) + { + sigaction(SIGALRM, &old_sig, NULL); + setitimer(ITIMER_REAL, &old_timer, NULL); + } + + switch (sc.cdsc_audiostatus) { + case CDROM_AUDIO_PLAY: + *mode = WM_CDM_PLAYING; + *track = sc.cdsc_trk; + *index = sc.cdsc_ind; + *pos = sc.cdsc_absaddr.msf.minute * 60 * 75 + + sc.cdsc_absaddr.msf.second * 75 + + sc.cdsc_absaddr.msf.frame; + break; + + case CDROM_AUDIO_PAUSED: + case CDROM_AUDIO_INVALID: + case CDROM_AUDIO_NO_STATUS: + if (oldmode == WM_CDM_PLAYING || oldmode == WM_CDM_PAUSED) + { + *mode = WM_CDM_PAUSED; + *track = sc.cdsc_trk; + *index = sc.cdsc_ind; + *pos = sc.cdsc_absaddr.msf.minute * 60 * 75 + + sc.cdsc_absaddr.msf.second * 75 + + sc.cdsc_absaddr.msf.frame; + } + else + *mode = WM_CDM_STOPPED; + break; + + /* CD ejected manually during play. */ + case CDROM_AUDIO_ERROR: + break; + + case CDROM_AUDIO_COMPLETED: + *mode = WM_CDM_TRACK_DONE; /* waiting for next track. */ + break; + + default: + *mode = WM_CDM_UNKNOWN; + break; + } + + return (0); +} /* gen_get_drive_status() */ + +/* + * Get the number of tracks on the CD. + */ +int +gen_get_trackcount( struct wm_drive *d, int *tracks ) +{ + struct cdrom_tochdr hdr; + + if (ioctl(d->fd, CDROMREADTOCHDR, &hdr)) + return (-1); + + *tracks = hdr.cdth_trk1; + return (0); +} /* gen_get_trackcount() */ + +/* + * Get the start time and mode (data or audio) of a track. + */ +int +gen_get_trackinfo( struct wm_drive *d, int track, int *data, int *startframe) +{ + struct cdrom_tocentry entry; + + entry.cdte_track = track; + entry.cdte_format = CDROM_MSF; + + if (ioctl(d->fd, CDROMREADTOCENTRY, &entry)) + return (-1); + + *startframe = entry.cdte_addr.msf.minute * 60 * 75 + + entry.cdte_addr.msf.second * 75 + + entry.cdte_addr.msf.frame; + *data = entry.cdte_ctrl & CDROM_DATA_TRACK ? 1 : 0; + + return (0); +} /* gen_get_trackinfo() */ + +/* + * Get the number of frames on the CD. + */ +int +gen_get_cdlen(struct wm_drive *d, int *frames ) +{ + int tmp; + + return (gen_get_trackinfo(d, CDROM_LEADOUT, &tmp, frames)); +} /* gen_get_cdlen() */ + +/* + * Play the CD from one position to another. + * + * d Drive structure. + * start Frame to start playing at. + * end End of this chunk. + * realstart Beginning of this chunk (<= start) + */ +int +gen_play( struct wm_drive *d, int start, int end, int realstart) +{ + struct cdrom_msf msf; + unsigned char cmdbuf[10]; + + current_end = end; + + CDDARETURN(d) cdda_play(d, start, end, realstart); + + msf.cdmsf_min0 = start / (60*75); + msf.cdmsf_sec0 = (start % (60*75)) / 75; + msf.cdmsf_frame0 = start % 75; + msf.cdmsf_min1 = end / (60*75); + msf.cdmsf_sec1 = (end % (60*75)) / 75; + msf.cdmsf_frame1 = end % 75; + + codec_start(); + if (ioctl(d->fd, CDROMSTART)) + return (-1); + if (ioctl(d->fd, CDROMPLAYMSF, &msf)) + return (-2); + + return (0); +} /* gen_play() */ + +/* + * Pause the CD. + */ +int +gen_pause( struct wm_drive *d ) +{ + CDDARETURN(d) cdda_pause(d); + + codec_stop(); + return (ioctl(d->fd, CDROMPAUSE)); +} /* gen_pause() */ + +/* + * Resume playing the CD (assuming it was paused.) + */ +int +gen_resume( struct wm_drive *d ) +{ + CDDARETURN(d) cdda_pause(d); + + codec_start(); + return (ioctl(d->fd, CDROMRESUME)); +} /* gen_resume() */ + +/* + * Stop the CD. + */ +int +gen_stop( struct wm_drive *d ) +{ + CDDARETURN(d) cdda_stop(d); + + codec_stop(); + return (ioctl(d->fd, CDROMSTOP)); +} /* gen_stop() */ + +/* + * Eject the current CD, if there is one. + */ +int +gen_eject( struct wm_drive *d ) +{ + struct stat stbuf; + struct ustat ust; + + if (fstat(d->fd, &stbuf) != 0) + return (-2); + + /* Is this a mounted filesystem? */ + if (ustat(stbuf.st_rdev, &ust) == 0) + return (-3); + + IFCDDA(d) { + cdda_eject(d); + } + + if (ioctl(d->fd, CDROMEJECT)) + return (-1); + + /* Close the device if it needs to vanish. */ + if (intermittent_dev) + { + close(d->fd); + d->fd = -1; + /* Also remember to tell the cddaslave since volume + manager switches links around on us */ + if (d->cdda_slave > -1) + { + write(d->cdda_slave, "E", 1); + cdda_get_ack(d->cdda_slave); + } + } + + return (0); +} /* gen_eject() */ + +/*----------------------------------------* + * Close the CD tray + * + * Please edit and send changes to + * milliByte@DeathsDoor.com + *----------------------------------------*/ + +int +gen_closetray(struct wm_drive *d) +{ +#ifdef CAN_CLOSE + if(!close(d->fd)) + { + d->fd=-1; + return(wmcd_reopen(d)); + } else { + return(-1); + } +#else + /* Always succeed if the drive can't close */ + return(0); +#endif /* CAN_CLOSE */ +} /* gen_closetray() */ + +/* + * Set the volume level for the left and right channels. Their values + * range from 0 to 100. + */ +int +gen_set_volume( struct wm_drive *d, int left, int right ) +{ + struct cdrom_volctrl v; + +#if defined(SIGTHAW) && defined(SYSV) + last_left = left; + last_right = right; + thecd = d; +#endif + + CDDARETURN(d) cdda_set_volume(d, left, right); + + left = (left * (max_volume - min_volume)) / 100 + min_volume; + right = (right * (max_volume - min_volume)) / 100 + min_volume; + + v.channel0 = left < 0 ? 0 : left > 255 ? 255 : left; + v.channel1 = right < 0 ? 0 : right > 255 ? 255 : right; + + return (ioctl(d->fd, CDROMVOLCTRL, &v)); +} /* gen_set_volume() */ + +/* + * Read the volume from the drive, if available. Each channel + * ranges from 0 to 100, with -1 indicating data not available. + */ +int +gen_get_volume( struct wm_drive *d, int *left, int *right ) +{ + CDDARETURN(d) cdda_get_volume(d, left, right); + + *left = *right = -1; + + return (wm_scsi2_get_volume(d, left, right)); +} /* gen_get_volume() */ + +#ifdef BUILD_CDDA + +/* + * Try to initialize the CDDA slave. Returns 0 on success. + */ +int +gen_cdda_init( struct wm_drive *d ) +{ + int slavefds[2]; + + if (d->cdda_slave > -1) + return (0); + + if (socketpair(AF_UNIX, SOCK_STREAM, 0, slavefds)) + { + perror("socketpair"); + return (-1); + } + + switch (fork()) + { + case 0: + close(slavefds[0]); + dup2(slavefds[1], 1); + dup2(slavefds[1], 0); + close(slavefds[1]); + close(d->fd); + /* Try the default path first. */ + execl(cddaslave_path, cddaslave_path, d->cd_device, (void *)0); + /* Search $PATH if that didn't work. */ + execlp("cddaslave", "cddaslave", d->cd_device, (void *)0); + perror(cddaslave_path); + exit(1); + + case -1: + close(slavefds[0]); + close(slavefds[1]); + perror("fork"); + return (-2); + } + + close(slavefds[1]); + d->cdda_slave = slavefds[0]; + + if (!cdda_get_ack(d->cdda_slave)) + { + d->cdda_slave = -1; + codec_start(); + return (-3); + } + + return (0); +} + +#endif /* BUILD_CDDA */ + +/* + * The following code activates the internal CD audio passthrough on + * SPARCstation 5 systems (and possibly others.) + * + * Thanks to <stevep@ctc.ih.att.com>, Roger Oscarsson <roger@cs.umu.se> + * and Steve McKinty <> + * + * Most CD drives have a headphone socket on the front, but it + * is often more convenient to route the audio though the + * built-in audio device. That way the user can leave their + * headphones plugged-in to the base system, for use with + * other audio stuff like ShowMeTV + */ + +#ifdef CODEC /* { */ +#ifdef SYSV /* { */ + +# include <sys/ioctl.h> +# include <sys/audioio.h> +# include <stdlib.h> + +#else /* } { */ + +# include <sun/audioio.h> +# define AUDIO_DEV_SS5STYLE 5 +typedef int audio_device_t; + +#endif /* } */ +#endif /* } */ + +/* + * Don't do anything with /dev/audio if we can't set it to high quality. + * Also, don't do anything real if it's not Solaris. + */ +#if !defined(AUDIO_ENCODING_LINEAR) || !defined(CODEC) || !defined(SYSV) /* { */ +codec_init() { return 0; } +codec_start() { return 0; } +codec_stop() { return 0; } +#else + +#ifndef AUDIO_INTERNAL_CD_IN +#define AUDIO_INTERNAL_CD_IN 0x4 +#endif + +static char* devname = 0; +static char* ctlname = 0; +static int ctl_fd = -1; +static int port = AUDIO_LINE_IN; +int internal_audio = 1; + +codec_init( void ) +{ + register int i; + char* ctlname; + audio_info_t foo; + audio_device_t aud_dev; + + if (internal_audio == 0) + { + ctl_fd = -1; + return(0); + } + + if (!(devname = getenv("AUDIODEV"))) devname = "/dev/audio"; + ctlname = strcat(strcpy(malloc(strlen(devname) + 4), devname), "ctl"); + if ((ctl_fd = open(ctlname, O_WRONLY, 0)) < 0) + { + perror(ctlname); + return -1; + } + if (ioctl(ctl_fd, AUDIO_GETDEV, &aud_dev) < 0) + { + close(ctl_fd); + ctl_fd = -1; + return -1; + } + /* + * Instead of filtering the "OLD_SUN_AUDIO", try to find the new ones. + * Not sure if this is all correct. + */ +#ifdef SYSV + if (strcmp(aud_dev.name, "SUNW,CS4231") && + strcmp(aud_dev.name, "SUNW,sb16") && + strcmp(aud_dev.name, "SUNW,sbpro")) +#else + if (aud_dev != AUDIO_DEV_SS5STYLE) +#endif + { + close(ctl_fd); + ctl_fd = -1; + return 0; /* but it's okay */ + } + + /* + * Does the chosen device have an internal CD port? + * If so, use it. If not then try and use the + * Line In port. + */ + if (ioctl(ctl_fd, AUDIO_GETINFO, &foo) < 0) + { + perror("AUDIO_GETINFO"); + close(ctl_fd); + ctl_fd = -1; + return(-1); + } + if (foo.record.avail_ports & AUDIO_INTERNAL_CD_IN) + port = AUDIO_INTERNAL_CD_IN; + else + port = AUDIO_LINE_IN; + + /* + * now set it up to use it. See audio(7I) + */ + + AUDIO_INITINFO(&foo); + foo.record.port = port; + foo.record.balance = foo.play.balance = AUDIO_MID_BALANCE; +#ifdef BUILD_CDDA + if (d->cdda_slave > -1) + foo.monitor_gain = 0; + else +#endif + foo.monitor_gain = AUDIO_MAX_GAIN; + /* + * These next ones are tricky. The voulme will depend on the CD drive + * volume (set by the knob on the drive and/or by workman's volume + * control), the audio device record gain and the audio device + * play gain. For simplicity we set the latter two to something + * reasonable, but we don't force them to be reset if the user + * wants to change them. + */ + foo.record.gain = (AUDIO_MAX_GAIN * 80) / 100; + foo.play.gain = (AUDIO_MAX_GAIN * 40) / 100; + + ioctl(ctl_fd, AUDIO_SETINFO, &foo); + return 0; +} + +static int +kick_codec( void ) +{ + audio_info_t foo; + int dev_fd; + int retval = 0; + + /* + * Open the audio device, not the control device. This + * will fail if someone else has taken it. + */ + + if ((dev_fd = open(devname, O_WRONLY|O_NDELAY, 0)) < 0) + { + perror(devname); + return -1; + } + + AUDIO_INITINFO(&foo); + foo.record.port = port; + foo.monitor_gain = AUDIO_MAX_GAIN; + + /* These can only be set on the real device */ + foo.play.sample_rate = 44100; + foo.play.channels = 2; + foo.play.precision = 16; + foo.play.encoding = AUDIO_ENCODING_LINEAR; + + if ((retval = ioctl(dev_fd, AUDIO_SETINFO, &foo)) < 0) + perror(devname); + + close(dev_fd); + return retval; +} /* kick_codec() */ + +codec_start( void ) +{ + audio_info_t foo; + + if (ctl_fd < 0) + return 0; + + if (ioctl(ctl_fd, AUDIO_GETINFO, &foo) < 0) + return -1; + + if (foo.play.channels != 2) return kick_codec(); + if (foo.play.encoding != AUDIO_ENCODING_LINEAR) return kick_codec(); + if (foo.play.precision != 16) return kick_codec(); + if (foo.play.sample_rate != 44100) return kick_codec(); + + if (foo.record.channels != 2) return kick_codec(); + if (foo.record.encoding != AUDIO_ENCODING_LINEAR) return kick_codec(); + if (foo.record.precision != 16) return kick_codec(); + if (foo.record.sample_rate != 44100) return kick_codec(); + + if (foo.monitor_gain != AUDIO_MAX_GAIN) return kick_codec(); + if (foo.record.port != port) return kick_codec(); + + return 0; +} /* codec_start() */ + +codec_stop( void ) { return 0; } + +#endif /* CODEC } */ + +/*------------------------------------------------------------------------* + * gen_get_cdtext(drive, buffer, lenght) + *------------------------------------------------------------------------*/ + +int +gen_get_cdtext(struct wm_drive *d, unsigned char **pp_buffer, int *p_buffer_lenght) +{ + /* This needs to be tested */ + return wm_scsi_get_cdtext(d, pp_buffer, p_buffer_lenght); +} /* gen_get_cdtext() */ + +#endif /* sun */ diff --git a/kscd/libwm/plat_sun_audio.c b/kscd/libwm/plat_sun_audio.c new file mode 100644 index 00000000..da9fe12f --- /dev/null +++ b/kscd/libwm/plat_sun_audio.c @@ -0,0 +1,493 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * Sun (really Solaris) digital audio functions. + */ + +#include "include/wm_config.h" + +static char plat_sun_audio_id[] = "$Id$"; + +#if defined(sun) || defined(__sun) && defined(SYSV) && defined(BUILD_CDDA) && defined(WMCDDA_DONE) + + +#include "include/wm_cdda.h" + +/* types.h included by wmcdda.h */ + +#include <stdio.h> +#include <malloc.h> +#include <sys/ioctl.h> +#include <sys/audioio.h> +#include <sys/stropts.h> +#include <sys/time.h> +#include <errno.h> +#include <fcntl.h> +#include <signal.h> + +#define WM_MSG_CLASS WM_MSG_CLASS_PLATFORM + +/* + * Since there's a lag time between writing audio to the audio device and + * hearing it, we need to make sure the status indicators correlate to what's + * playing out the speaker. Luckily, Solaris gives us some audio + * synchronization facilities that make this pretty easy. + * + * We maintain a circular queue of status information. When we write some + * sound to the audio device, we put its status info into the queue. We write + * a marker into the audio stream; when the audio device driver encounters the + * marker, it increments a field in a status structure. When we see that + * field go up, we grab the next status structure from the queue and send it + * to the parent process. + * + * The minimum size of the queue depends on the latency of the audio stream. + */ +#define QSIZE 500 + +struct cdda_block queue[QSIZE]; +int qtail; +int qstart; + +/* + * We only send WMCDDA_PLAYED status messages upstream when the CD is supposed + * to be playing; this is used to keep track. + */ +extern int playing; + +static int aufd, aucfd; +static int raw_audio = 1; /* Can /dev/audio take 44.1KHz stereo? */ + +/* + * For fast linear-to-ulaw mapping, we use a lookup table that's generated + * at startup. + */ +unsigned char *ulawmap, linear_to_ulaw(); + +char *getenv(); + +/* + * Dummy signal handler so writes to /dev/audio will interrupt. + */ +static void +dummy( void ) +{ + signal(SIGALRM, dummy); +} + +/* + * Initialize the audio device. + */ +void +wmaudio_init( void ) +{ + audio_info_t info; + char *audiodev, *acdev; + int linval; + + audiodev = getenv("AUDIODEV"); + if (audiodev == NULL || + strncmp("/dev/", audiodev, 5) || + strstr(audiodev, "/../") ) + audiodev = "/dev/audio"; + + acdev = malloc(strlen(audiodev) + 4); + if (acdev == NULL) + { + perror("Can't allocate audio control filename"); + exit(1); + } + strcpy(acdev, audiodev); + strcat(acdev, "ctl"); + + aucfd = open(acdev, O_WRONLY, 0); + if (aucfd < 0) + { + perror(acdev); + exit(1); + } + free(acdev); + + aufd = open(audiodev, O_WRONLY, 0); + if (aufd < 0) + { + perror(audiodev); + exit(1); + } + + signal(SIGALRM, dummy); + + /* + * Try to set the device to CD-style audio; we can process it + * with the least CPU overhead. + */ + AUDIO_INITINFO(&info); + info.play.sample_rate = 44100; + info.play.channels = 2; + info.play.precision = 16; + info.play.encoding = AUDIO_ENCODING_LINEAR; + info.play.pause = 0; + info.record.pause = 0; + info.monitor_gain = 0; + + if (ioctl(aufd, AUDIO_SETINFO, &info) < 0) + if (errno == EINVAL) + { + /* + * Oh well, so much for that idea. + */ + AUDIO_INITINFO(&info); + info.play.sample_rate = 8000; + info.play.channels = 1; + info.play.precision = 8; + info.play.encoding = AUDIO_ENCODING_ULAW; + info.play.pause = 0; + info.record.pause = 0; + info.monitor_gain = 0; + if (ioctl(aufd, AUDIO_SETINFO, &info) < 0) + { + perror("Can't set up audio device"); + exit(1); + } + + /* + * Initialize the linear-to-ulaw mapping table. + */ + if (ulawmap == NULL) + ulawmap = malloc(65536); + if (ulawmap == NULL) + { + perror("malloc"); + exit(1); + } + for (linval = 0; linval < 65536; linval++) + ulawmap[linval] = linear_to_ulaw(linval-32768); + ulawmap += 32768; + raw_audio = 0; + } + else + { + perror(audiodev); + exit(1); + } +} + +/* + * Get ready to play some sound. + */ +void +wmaudio_ready( void ) +{ + audio_info_t info; + + /* + * Start at the correct queue position. + */ + if (ioctl(aucfd, AUDIO_GETINFO, &info) < 0) perror("AUDIO_GETINFO"); + qtail = info.play.eof % QSIZE; + qstart = qtail; + + queue[qtail].status = WMCDDA_OK; +} + +/* + * Stop the audio immediately. + */ +void +wmaudio_stop( void ) +{ + if (ioctl(aufd, I_FLUSH, FLUSHRW) < 0) + perror("flush"); +} + +/* + * Close the audio device. + */ +void +wmaudio_close( void ) +{ + wmaudio_stop(); + close(aufd); + close(aucfd); +} + +/* + * Set the volume level. + */ +void +wmaudio_volume(int level) +{ + audio_info_t info; + + AUDIO_INITINFO(&info); + if (ioctl(aucfd, AUDIO_GETINFO, &info) < 0) perror("AUDIO_GETINFO"); + info.play.gain = level; + if (ioctl(aucfd, AUDIO_SETINFO, &info) < 0) perror("AUDIO_SETINFO"); +} + +/* + * Set the balance level. + */ +void +wmaudio_balance(int level) +{ + audio_info_t info; + + AUDIO_INITINFO(&info); + if (ioctl(aucfd, AUDIO_GETINFO, &info) < 0) perror("AUDIO_GETINFO"); + level *= AUDIO_RIGHT_BALANCE; + info.play.balance = level / 255; + if (ioctl(aucfd, AUDIO_SETINFO, &info) < 0) perror("AUDIO_SETINFO"); +} + +/* + * Mark the most recent audio block on the queue as the last one. + */ +void +wmaudio_mark_last( void ) +{ + queue[qtail].status = WMCDDA_DONE; +} + +/* + * Figure out the most recent status information and send it upstream. + */ +int +wmaudio_send_status( void ) +{ + audio_info_t info; + int qhead; + + /* + * Now send the most current status information to our parent. + */ + if (ioctl(aucfd, AUDIO_GETINFO, &info) < 0) + perror("AUDIO_GETINFO"); + qhead = info.play.eof % QSIZE; + + if (qhead != qstart && playing) + { + int balance; + + if (queue[qhead].status != WMCDDA_DONE) + queue[qhead].status = WMCDDA_PLAYED; + queue[qhead].volume = info.play.gain; + queue[qhead].balance = (info.play.balance * 255) / + AUDIO_RIGHT_BALANCE; + + send_status(queue + qhead); + qstart = -1; + } + + return (queue[qhead].status == WMCDDA_DONE); +} + +/* + * Play some audio and pass a status message upstream, if applicable. + * Returns 0 on success. + */ +int +wmaudio_play(unsigned char *rawbuf, long buflen, struct cdda_block *blk) +{ + int i; + short *buf16; + int alarmcount = 0; + struct itimerval it; + + alarm(1); + + while (write(aufd, rawbuf, buflen) <= 0) + if (errno == EINTR) + { + if (! raw_audio && alarmcount++ < 5) + { + /* + * 8KHz /dev/audio blocks for several seconds + * waiting for its queue to drop below a low + * water mark. + */ + wmaudio_send_status(); + timerclear(&it.it_interval); + timerclear(&it.it_value); + it.it_value.tv_usec = 500000; + setitimer(ITIMER_REAL, &it, NULL); + continue; + } + +/* close(aufd); + close(aucfd); + wmaudio_init(); +*/ wmaudio_stop(); + alarm(2); + continue; + } + else + { + blk->status = WMCDDA_ERROR; + return (-1); + } + alarm(0); + + /* + * Mark this spot in the audio stream. + * + * Marks don't always succeed (if the audio buffer is empty + * this call will block forever) so do it asynchronously. + */ + fcntl(aufd, F_SETFL, O_NONBLOCK); + if (write(aufd, rawbuf, 0) < 0) + { + if (errno != EAGAIN) + perror("audio mark"); + } + else + qtail = (qtail + 1) % QSIZE; + + fcntl(aufd, F_SETFL, 0); + + queue[qtail] = *blk; + + if (wmaudio_send_status() < 0) + return (-1); + else + return (0); +} + +/* + * Get the current audio state. + */ +void +wmaudio_state(struct cdda_block *blk) +{ + audio_info_t info; + int balance; + + if (ioctl(aucfd, AUDIO_GETINFO, &info) < 0) + perror("AUDIO_GETINFO"); + blk->volume = info.play.gain; + blk->balance = (info.play.balance * 255) / AUDIO_RIGHT_BALANCE; +} + +/* +** This routine converts from linear to ulaw. +** +** Craig Reese: IDA/Supercomputing Research Center +** Joe Campbell: Department of Defense +** 29 September 1989 +** +** References: +** 1) CCITT Recommendation G.711 (very difficult to follow) +** 2) "A New Digital Technique for Implementation of Any +** Continuous PCM Companding Law," Villeret, Michel, +** et al. 1973 IEEE Int. Conf. on Communications, Vol 1, +** 1973, pg. 11.12-11.17 +** 3) MIL-STD-188-113,"Interoperability and Performance Standards +** for Analog-to_Digital Conversion Techniques," +** 17 February 1987 +** +** Input: Signed 16 bit linear sample +** Output: 8 bit ulaw sample +*/ +#define ZEROTRAP /* turn on the trap as per the MIL-STD */ +#define BIAS 0x84 /* define the add-in bias for 16 bit samples */ +#define CLIP 32635 + +unsigned char +linear_to_ulaw( sample ) +int sample; +{ + static int exp_lut[256] = {0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3, + 4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4, + 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5, + 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5, + 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, + 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, + 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, + 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7}; + int sign, exponent, mantissa; + unsigned char ulawbyte; + + /* Get the sample into sign-magnitude. */ + sign = (sample >> 8) & 0x80; /* set aside the sign */ + if ( sign != 0 ) sample = -sample; /* get magnitude */ + if ( sample > CLIP ) sample = CLIP; /* clip the magnitude */ + + /* Convert from 16 bit linear to ulaw. */ + sample = sample + BIAS; + exponent = exp_lut[( sample >> 7 ) & 0xFF]; + mantissa = ( sample >> ( exponent + 3 ) ) & 0x0F; + ulawbyte = ~ ( sign | ( exponent << 4 ) | mantissa ); +#ifdef ZEROTRAP + if ( ulawbyte == 0 ) ulawbyte = 0x02; /* optional CCITT trap */ +#endif + + return ulawbyte; +} + +/* + * Downsample a block of CDDA data, if necessary, for playing out an old-style + * audio device. + */ +long +wmaudio_convert(unsigned char *rawbuf, long buflen, struct cdda_block *blk) +{ + short *buf16 = (short *)rawbuf; + int i, j, samples; + int mono_value; + unsigned char *rbend = rawbuf + buflen; + + /* Don't do anything if the audio device can take the raw values. */ + if (raw_audio) + return (buflen); + + for (i = 0; buf16 < (short *)(rbend); i++) + { + /* Downsampling to 8KHz is a little irregular. */ + samples = (i & 1) ? ((i % 20) ? 10 : 12) : 12; + + /* And unfortunately, we don't always end on a nice boundary. */ + if (buf16 + samples > (short *)(rbend)) + samples = ((short *)rbend) - buf16; + + /* + * No need to average all the values; taking the first one + * is sufficient and less CPU-intensive. But we do need to + * do both channels. + */ + mono_value = (buf16[0] + buf16[1]) / 2; + buf16 += samples; + rawbuf[i] = ulawmap[mono_value]; + } + + return (i); +} + +#endif /* ... && BUILD_CDDA */ diff --git a/kscd/libwm/plat_sun_cdda.c b/kscd/libwm/plat_sun_cdda.c new file mode 100644 index 00000000..3f669a8b --- /dev/null +++ b/kscd/libwm/plat_sun_cdda.c @@ -0,0 +1,380 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * Sun (really Solaris) CDDA functions. + */ + +#include "include/wm_cdda.h" + +#if defined(sun) || defined(__sun__) && defined(SYSV) && defined(BUILD_CDDA) + + +#include "include/wm_struct.h" +#include "include/wm_cdda.h" +/* types.h and cdio.h are included by wm_cdda.h */ + +#include <stdio.h> +#include <math.h> +#include <sys/ioctl.h> +#include <malloc.h> +#include <errno.h> + +#define WM_MSG_CLASS WM_MSG_CLASS_PLATFORM + +#define CDDABLKSIZE 2368 +#define SAMPLES_PER_BLK 588 + +/* Address of next block to read. */ +int current_position = 0; + +/* Address of first and last blocks to read. */ +int starting_position = 0; +int ending_position = 0; + +/* Playback direction. */ +int direction = 1; + +/* Number of blocks to read at once; initialize to the maximum. */ +/* (was 30. Set to 15 for INTeL. Maybe config option? */ +int numblocks = 15; + +/* + * This is the fastest way to convert from BCD to 8-bit. + */ +unsigned char unbcd[256] = { + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,0,0,0,0,0, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 0,0,0,0,0,0, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 0,0,0,0,0,0, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 0,0,0,0,0,0, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 0,0,0,0,0,0, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 0,0,0,0,0,0, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 0,0,0,0,0,0, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 0,0,0,0,0,0, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 0,0,0,0,0,0, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 +}; + +static long wmcdda_normalize(struct cdda_block *block); + +/* + * Initialize the CDDA data buffer and open the appropriate device. + * + * NOTE: We allocate twice as much space as we need to actually read a block; + * this lets us do audio manipulations without bothering to malloc a second + * buffer. + * + * Also, test to see if we can actually *do* CDDA on this drive; if not, we + * need to exit right away so the UI doesn't show the user any CDDA controls. + */ +int +wmcdda_init(struct cdda_device* pdev, struct cdda_block *block) +{ + struct cdrom_cdda cdda; + int i; + + if (pdev->fd > -1) + return -1; + + for (i = 0; i < pdev->numblocks; i++) { + /* in Linux const */ + pdev->blocks[i].buflen = pdev->frames_at_once * CDDABLKSIZE; + pdev->blocks[i].buf = malloc(pdev->blocks[i].buflen); + if (!pdev->blocks[i].buf) + return -ENOMEM; + } + + pdev->fd = open(pdev->devname, 0); + if (pdev->fd == -1) + pdev->fd = open("/dev/rdsk/c0t6d0s2", 0); + + if (pdev->fd > -1) + { + cdda.cdda_addr = 200; + cdda.cdda_length = 1; + cdda.cdda_data = pdev->blocks[0].buf; + cdda.cdda_subcode = CDROM_DA_SUBQ; + + if (ioctl(pdev->fd, CDROMCDDA, &cdda) < 0) + { + block->status = WM_CDM_STOPPED; + return -1; + } else { + block->status = WM_CDM_STOPPED; + return 0; + } + } else { + block->status = WM_CDM_EJECTED; + return -1; + } +} + +/* + * Close the CD-ROM device in preparation for exiting. + */ +int +wmcdda_close(struct cdda_device* pdev) +{ + int i; + + if(-1 == pdev->fd) + return -1; + + close(pdev->fd); + pdev->fd = -1; + + for (i = 0; i < pdev->numblocks; i++) { + free(pdev->blocks[i].buf); + pdev->blocks[i].buf = 0; + pdev->blocks[i].buflen = 0; + } + + return 0; +} + +/* + * Set up for playing the CD. Actually this doesn't play a thing, just sets a + * couple variables so we'll know what to do when we're called. + */ +int +wmcdda_setup(int start, int end, int realstart) +{ + current_position = start - 150; + ending_position = end - 150; + starting_position = realstart - 150; + + /* + * Special case: don't start at the "end" of a track if we're + * playing backwards! + */ + if (direction == -1 && start == realstart) + current_position = ending_position - numblocks; + return 0; +} + +/* + * Read some blocks from the CD. Stop if we hit the end of the current region. + * + * Returns number of bytes read, -1 on error, 0 if stopped for a benign reason. + */ +long +wmcdda_read(struct cdda_device* pdev, struct cdda_block *block) +{ + struct cdrom_cdda cdda; + int blk; + unsigned char *q; + extern int speed; + unsigned char* rawbuf = block->buf; + + if(pdev->fd < 0 && (wmcdda_init(pdev, block) < 0)) { + return -1; + } + + /* + * Hit the end of the CD, probably. + */ + if ((direction > 0 && current_position >= ending_position) || + (direction < 0 && current_position < starting_position)) + { + block->status = WM_CDM_TRACK_DONE; + return (0); + } + + cdda.cdda_addr = current_position; + if (ending_position && current_position + pdev->frames_at_once > ending_position) + cdda.cdda_length = ending_position - current_position; + else + cdda.cdda_length = pdev->frames_at_once; + cdda.cdda_data = (unsigned char*)block->buf; + cdda.cdda_subcode = CDROM_DA_SUBQ; + + if (ioctl(pdev->fd, CDROMCDDA, &cdda) < 0) + { + if (errno == ENXIO) /* CD ejected! */ + { + block->status = WM_CDM_EJECTED; + return (-1); + } + + /* Sometimes it fails once, dunno why */ + if (ioctl(pdev->fd, CDROMCDDA, &cdda) < 0) + { + if (ioctl(pdev->fd, CDROMCDDA, &cdda) < 0) + { + if (ioctl(pdev->fd, CDROMCDDA, &cdda) < 0) + { + perror("CDROMCDDA"); + block->status = WM_CDM_CDDAERROR; + return (-1); + } + } + } + } + + if (speed > 148) + { + /* + * We want speed=148 to advance by cdda_length, but + * speed=256 to advance cdda_length * 4. + */ + current_position = current_position + + (cdda.cdda_length * direction * (speed - 112)) / 36; + } + else + current_position = current_position + cdda.cdda_length * direction; + + for (blk = 0; blk < numblocks; blk++) + { + /* + * New valid Q-subchannel information? Update the block + * status. + */ + q = &rawbuf[blk * CDDABLKSIZE + SAMPLES_PER_BLK * 4]; + if (*q == 1) + { + block->track = unbcd[q[1]]; + block->index = unbcd[q[2]]; + /*block->minute = unbcd[q[7]]; + block->second = unbcd[q[8]];*/ + block->frame = unbcd[q[9]]; + block->status = WM_CDM_PLAYING; + block->buflen = cdda.cdda_length; + } + } + + return wmcdda_normalize(block); +} + +/* + * Normalize a bunch of CDDA data. Basically this means ripping out the + * Q subchannel data and doing byte-swapping, since the CD audio is in + * littleendian format. + * + * Scanning is handled here too. + * + * XXX - do byte swapping on Intel boxes? + */ +long +wmcdda_normalize(struct cdda_block *block) +{ + int i, nextq; + long buflen = block->buflen; + int blocks = buflen / CDDABLKSIZE; + unsigned char *rawbuf = block->buf; + unsigned char *dest = rawbuf; + unsigned char tmp; + long *buf32 = (long *)rawbuf, tmp32; + +/* + * this was #ifndef LITTLEENDIAN + * in wmcdda it was called LITTLE_ENDIAN. Was this a flaw? + */ +#if WM_BIG_ENDIAN + if (blocks--) + for (i = 0; i < SAMPLES_PER_BLK * 2; i++) + { + /* Only need to use temp buffer on first block. */ + tmp = *rawbuf++; + *dest++ = *rawbuf++; + *dest++ = tmp; + } +#endif + + while (blocks--) + { + /* Skip over Q data. */ + rawbuf += 16; + + for (i = 0; i < SAMPLES_PER_BLK * 2; i++) + { +#if WM_LITTLE_ENDIAN + *dest++ = *rawbuf++; + *dest++ = *rawbuf++; +#else + *dest++ = rawbuf[1]; + *dest++ = rawbuf[0]; + rawbuf += 2; +#endif + } + } + + buflen -= ((buflen / CDDABLKSIZE) * 16); + + /* + * Reverse the data here if we're playing backwards. + * XXX - ideally this should be done above. + */ + if (direction < 0) + { + buflen /= 4; /* we can move 32 bits at a time. */ + + for (i = 0; i < buflen / 2; i++) + { + tmp32 = buf32[i]; + buf32[i] = buf32[buflen - i - 1]; + buf32[buflen - i - 1] = tmp32; + } + + buflen *= 4; + } + + return (buflen); +} + +/* + * Set the playback direction. + */ +void +wmcdda_direction(int newdir) +{ + if (newdir == 0) + { + numblocks = 20; + direction = 1; + } + else + { + numblocks = 30; + direction = -1; + } +} + +/* + * Do system-specific stuff to get ready to play at a particular speed. + */ +void +wmcdda_speed(int speed) +{ + if (speed > 128) + numblocks = 12; + else + numblocks = direction > 0 ? 20 : 30; +} + +#endif /* } */ diff --git a/kscd/libwm/plat_svr4.c b/kscd/libwm/plat_svr4.c new file mode 100644 index 00000000..ad6e488c --- /dev/null +++ b/kscd/libwm/plat_svr4.c @@ -0,0 +1,482 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * SVR4 specific. Much of this is similar to plat_hpux.c. + */ + +static char plat_svr4_id[] = "$Id$"; + +#if (defined(SVR4) || defined(__SVR4)) && !defined(sun) && !defined(__sun) && !defined(sony_news) && !defined(__sony_news) + + +#include <sys/types.h> +#include <stdio.h> +#include <ctype.h> +#include <string.h> +#include <fcntl.h> +#include <stdlib.h> +#include <unistd.h> +#include <signal.h> +#include <sys/mkdev.h> +#include <sys/stat.h> +#include <sys/sdi.h> +#include <sys/sdi_edt.h> +#include <sys/scsi.h> +#include <errno.h> + +#include "include/wm_config.h" +#include "include/wm_struct.h" +#include "include/wm_cdtext.h" + +#define WM_MSG_CLASS WM_MSG_CLASS_PLATFORM + + +void *malloc(); +char *strchr(); + +int min_volume = 0; +int max_volume = 255; + +static int +create_cdrom_node(char *dev_name) +{ + char pass_through[100]; + int file_des; + dev_t pass_thru_device; + int err; + int ccode; + + + strncpy(pass_through, dev_name, sizeof(pass_through) - 2); + strcat(pass_through, "p" ); + + if (setreuid(-1,0) < 0) + { + perror("setregid/setreuid/access"); + return -1; + } + + ccode = access(pass_through, F_OK); + + if (ccode < 0) + { + if ((file_des = open(dev_name, O_RDONLY)) < 0) + { + perror("open cdrom devices failed"); + return -1; + } + + if (ioctl(file_des, B_GETDEV, &pass_thru_device) < 0) + { + perror("Call to get pass-through device number failed"); + return -1; + } + + (void)close(file_des); + + if (mknod(pass_through, (S_IFCHR | S_IREAD | S_IWRITE), + pass_thru_device) < 0) + { + perror("Unable to make pass-through node"); + return -1; + } + + if (chown(pass_through, 0 , 0) < 0) + { + perror("chown"); + return -1; + } + + if (chmod(pass_through, 0660 ) < 0) + { + perror("chmod"); + return -1; + } + } + + file_des = open( pass_through, O_RDWR); + err = errno; + + if ( (setreuid(-1,getuid()) < 0) || (setregid(-1,getgid()) < 0) ) + { + perror("setreuid/setregid"); + return -1; + } + errno = err; + return file_des; +} /* create_cdrom_node() */ + +const char* +find_cdrom() +{ + /* + ** the path of the device has to start w/ /dev + ** otherwise we are vulnerable to race conditions + ** Thomas Biege <thomas@suse.de> + */ + const char* device = NULL; + + device = getenv("CDROM"); + if ( (device != NULL) && + !(strncmp("/dev/", device, 5) || + strstr(_device, "/../") )) + return device; + + if (access("/dev/cdrom/cdrom1", F_OK) == 0) + { + return "/dev/cdrom/cdrom1"; + } + else if (access("/dev/cdrom/cdrom2", F_OK) == 0) + { + return "/dev/cdrom/cdrom2"; + } + else + { + fprintf(stderr, "Couldn't find a CD device!\n"); + return NULL; + } +} /* find_cdrom() */ + +/* + * Initialize the drive. A no-op for the generic driver. + */ +int +gen_init(struct wm_drive *d) +{ + return (0); +} /* gen_init() */ + +/* + * Open the CD and figure out which kind of drive is attached. + */ +int +wmcd_open(struct wm_drive *d) +{ + int fd, flag = 1; + static int warned = 0; + char vendor[32] = WM_STR_GENVENDOR; + char model[32] = WM_STR_GENMODEL; + char rev[32] = WM_STR_GENREV; + + if (d->fd >= 0) /* Device already open? */ + { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_open(): [device is open (fd=%d)]\n", d->fd); + return (0); + } + + if (d->cd_device == NULL) + d->cd_device = DEFAULT_CD_DEVICE; + + d->fd = create_cdrom_node(d->cd_device); /* this will do open */ + + if (d->fd < 0) + { + if (errno == EACCES) + { + if (! warned) + { + fprintf(stderr,"Cannot access %s\n",d->cd_device); + warned++; + } + } + else if (errno != EINTR) + { + return ( -6 ); + } + + /* No CD in drive. (Is this true also for svr4 ? XXX ) */ + return (1); + } + + if (warned) + { + warned = 0; + fprintf(stderr, "Thank you.\n"); + } + + /* Now fill in the relevant parts of the wm_drive structure. */ + + fd = d->fd; + + if (wm_scsi_get_drive_type(d, vendor, model, rev) < 0) + { + perror("Cannot inquiry drive for it's type"); + exit(1); + } + find_drive_struct(vendor, model, rev); + + d->fd = fd; + + return (0); +} /* wmcd_open() */ + +/* + * Re-Open the device if it is open. + */ +int +wmcd_reopen( struct wm_drive *d ) +{ + int status; + + do { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_reopen\n"); + status = gen_close( d ); + wm_susleep( 1000 ); + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "calling wmcd_open()\n"); + status = wmcd_open( d ); /* open it as usual */ + wm_susleep( 1000 ); + } while ( status != 0 ); + return status; +} /* wmcd_reopen() */ + + +/* + * Send a SCSI command out the bus. + */ +int +wm_scsi( struct wm_drive *d, unsigned char *xcdb, int cdblen, + char *retbuf, int retbuflen, int getreply) +{ + int ccode; + int file_des = d->fd; + int i,j; + unsigned char sense_buffer[ SENSE_SZ ]; + int errno_save; + + /* getreply == 1 is read, == 0 is write */ + + struct sb sb; + struct scs scs; + + sb.sb_type = ISCB_TYPE; + + sb.SCB.sc_comp_code = SDI_PROGRES; + sb.SCB.sc_int = NULL; + sb.SCB.sc_wd = 0; + sb.SCB.sc_dev.sa_major = 0; + sb.SCB.sc_dev.sa_minor = 0; + sb.SCB.sc_dev.sa_lun = 0; + sb.SCB.sc_dev.sa_exlun = 0; + sb.SCB.sc_status = 0; + sb.SCB.sc_link = (struct sb *) NULL; + sb.SCB.sc_resid = 0; + + sb.SCB.sc_cmdpt = (void *)xcdb; + sb.SCB.sc_cmdsz = cdblen; + + sb.SCB.sc_datapt = retbuf ; + sb.SCB.sc_datasz = retbuflen ; + + if (getreply == 1) + sb.SCB.sc_mode = SCB_READ; + else + sb.SCB.sc_mode = SCB_WRITE; + + sb.SCB.sc_time = 500; + + ccode = ioctl(file_des, SDI_SEND, &sb); + + if ( (sb.SCB.sc_comp_code != 0xd000000e ) || + ( sb.SCB.sc_status != 02) ) + return ccode; + + errno_save = errno; + + sb.SCB.sc_comp_code = SDI_PROGRES; + sb.SCB.sc_int = NULL; + sb.SCB.sc_wd = 0; + sb.SCB.sc_dev.sa_major = 0; + sb.SCB.sc_dev.sa_minor = 0; + sb.SCB.sc_dev.sa_lun = 0; + sb.SCB.sc_dev.sa_exlun = 0; + sb.SCB.sc_status = 0; + sb.SCB.sc_link = (struct sb *) NULL; + sb.SCB.sc_resid = 0; + + scs.ss_op = SS_REQSEN; + scs.ss_lun = 0; + scs.ss_addr1 = 0; + scs.ss_addr = 0; + scs.ss_len = SENSE_SZ; + scs.ss_cont = 0; + + sb.SCB.sc_cmdpt = SCS_AD(&scs); + sb.SCB.sc_cmdsz = SCS_SZ; + sb.SCB.sc_datapt = sense_buffer; + sb.SCB.sc_datasz = 18; + sb.SCB.sc_mode = SCB_READ; + sb.SCB.sc_time = 5000; + + if (ioctl(file_des, SDI_SEND, &sb) < 0) + { + fprintf(stderr,"Cannot read sense.\n"); + exit(-1); + } + + errno=errno_save; + return -1; +} /* wm_scsi() */ + +int +gen_close( struct wm_drive *d ) +{ + if(d->fd != -1) { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "closing the device\n"); + close(d->fd); + d->fd = -1; + } + return 0; +} + +/* + * Get the current status of the drive: the current play mode, the absolute + * position from start of disc (in frames), and the current track and index + * numbers if the CD is playing or paused. + */ +int +gen_get_drive_status(struct wm_drive *d, int oldmode, + int *mode, int *pos, int *track, int *index) +{ + return (wm_scsi2_get_drive_status(d, oldmode, mode, pos, track, index)); +} /* gen_get_drive_status() */ + +/* + * Get the number of tracks on the CD. + */ +int +gen_get_trackcount(struct wm_drive *d, int *tracks) +{ + return (wm_scsi2_get_trackcount(d, tracks)); +} /* gen_get_trackcount() */ + +/* + * Get the start time and mode (data or audio) of a track. + */ +int +gen_get_trackinfo(struct wm_drive *d, int track, int *data, int *startframe) +{ + return (wm_scsi2_get_trackinfo(d, track, data, startframe)); +} /* gen_get_trackinfo() */ + +/* + * Get the number of frames on the CD. + */ +int +gen_get_cdlen(struct wm_drive *d, int *frames) +{ + int tmp; + + return (wm_scsi2_get_cdlen(d, frames)); +} /* gen_get_cdlen() */ + +/* + * Play the CD from one position to another (both in frames.) + */ +int +gen_play(struct wm_drive *d, int start, int end) +{ + return (wm_scsi2_play(d, start, end)); +} /* gen_play() */ + +/* + * Pause the CD. + */ +int +gen_pause(struct wm_drive *d) +{ + return (wm_scsi2_pause(d)); +} /* gen_pause() */ + +/* + * Resume playing the CD (assuming it was paused.) + */ +int +gen_resume(struct wm_drive *d) +{ + return (wm_scsi2_resume(d)); +} /* gen_resume() */ + +/* + * Stop the CD. + */ +int +gen_stop(struct wm_drive *d) +{ + return (wm_scsi2_stop(d)); +} /* gen_stop() */ + + +/* + * Eject the current CD, if there is one. + */ +int +gen_eject(struct wm_drive *d) +{ + return (wm_scsi2_eject(d)); +} /* gen_eject() */ + +/* + * Close the tray. + * please review scsi.c / wm_scsi2_closetray() + * and send changes to milliByte@DeathsDoor.com + */ +int +gen_closetray( struct wm_drive *d ) +{ + return(wm_scsi2_closetray(d)); +} /* gen_closetray() */ + + +/* + * Set the volume level for the left and right channels. Their values + * range from 0 to 100. + */ +int +gen_set_volume(struct wm_drive *d, int left, int right) +{ + return (wm_scsi2_set_volume(d, left, right)); +} /* gen_set_volume() */ + +/* + * Read the initial volume from the drive, if available. Each channel + * ranges from 0 to 100, with -1 indicating data not available. + */ +int +gen_get_volume(struct wm_drive *d, int *left, int *right) +{ + return (wm_scsi2_get_volume(d, left, right)); +} /* gen_get_volume() */ + +/*------------------------------------------------------------------------* + * gen_get_cdtext(drive, buffer, lenght) + *------------------------------------------------------------------------*/ + +int +gen_get_cdtext(struct wm_drive *d, unsigned char **pp_buffer, int *p_buffer_lenght) +{ + /* This needs to be tested */ + return wm_scsi_get_cdtext(d, pp_buffer, p_buffer_lenght); +} /* gen_get_cdtext() */ + +#endif diff --git a/kscd/libwm/plat_template.c b/kscd/libwm/plat_template.c new file mode 100644 index 00000000..bd47c20b --- /dev/null +++ b/kscd/libwm/plat_template.c @@ -0,0 +1,295 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * This file surely contains nonsense. It's the porter's part to fill + * the gaps and assure that the resulting code makes sense. + * + */ + + +static char plat_template_id[] = "$Id$" + +#if [TEMPLATESYSTEM] + + +#include "include/wm_config.h" +#include "include/wm_struct.h" +#include "include/wm_cdtext.h" + +#define WM_MSG_CLASS WM_MSG_CLASS_PLATFORM + +/* + * gen_init(); + * + */ +int +gen_init(struct wm_drive *d) +{ + return (0); +} /* gen_init() */ + +/* + * wmcd_open() + * + */ +int +wmcd_open(struct wm_drive *d) +{ + char vendor[32] = WM_STR_GENVENDOR; + char model[32] = WM_STR_GENMODEL; + char rev[32] = WM_STR_GENREV; + + if( ! d ) + { + errno = EFAULT; + return -1; + } + + if(d->fd > -1) /* device already open? */ + { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_open(): [device is open (fd=%d)]\n", d->fd); + return 0; + } + + if( d->cd_device == (char *)NULL ) + d->cd_device = DEFAULT_CD_DEVICE; + + /* open() goes here */ + + if(find_drive_struct(vendor, model, rev)) { + gen_close(d); + return -1; + } + + d->init(d); + + return (0); +} /* wmcd_open() */ + +/* + * Re-Open the device if it is open. + */ +int +wmcd_reopen( struct wm_drive *d ) +{ + int status; + + do { + wm_lib_message(WM_MSG_LEVEL_DEBUG, "wmcd_reopen\n"); + status = gen_close( d ); + wm_susleep( 1000 ); + wm_lib_message(WM_MSG_LEVEL_DEBUG, "calling wmcd_open()\n"); + status = wmcd_open( d ); /* open it as usual */ + wm_susleep( 1000 ); + } while ( status != 0 ); + return status; +} /* wmcd_reopen() */ + +/* + * wm_scsi() + * + */ +int +wm_scsi(struct wm_drive *d, + uchar_t *cdb, int cdblen,void *retbuf,int retbuflen,int getreply) +{ + return (0); +} /* wm_scsi() */ + +/* + * close the CD device + */ + +int +gen_close(struct wm_drive *d) +{ + if(d->fd != -1) { + wm_lib_message(WM_MSG_LEVEL_DEBUG, "closing the device\n"); + close(d->fd); + d->fd = -1; + } + return 0; +} /* gen_close() */ + +/* + * gen_get_drive_status() + * + */ +int +gen_get_drive_status(struct wm_drive *d, + int oldmode, + int *mode, + int *pos, + int *track, + int *index) +{ + return (0); +} /* gen_get_drive_status() */ + +/* + * gen_get_trackcount() + * + */ +int +gen_get_trackcount(struct wm_drive *d,int *tracks) +{ + return (0); +} /* gen_get_trackcount() */ + +/* + * gen_get_trackinfo() + * + */ +int +gen_get_trackinfo(struct wm_drive *d,int track,int *data,int *startframe) +{ + return (0); +} /* gen_get_trackinfo() */ + +/* + * gen_get_cdlen() + * + */ +int +gen_get_cdlen(struct wm_drive *d,int *frames) +{ + return (0); +} /* gen_get_cdlen() */ + +/* + * gen_play() + * + */ +int +gen_play(struct wm_drive *d,int start,int end) +{ + return (0); +} /* gen_play() */ + +/* + * gen_pause() + * + */ +int +gen_pause(struct wm_drive *d) +{ + return ioctl( 0 ); +} /* gen_pause() */ + +/* + * gen_resume + * + */ +int +gen_resume(struct wm_drive *d) +{ + return (0); +} /* gen_resume() */ + +/* + * gen_stop() + * + */ +int +gen_stop(struct wm_drive *d) +{ + return (0); +} /* gen_stop() */ + +/* + * gen_eject() + * + */ +int +gen_eject(struct wm_drive *d) +{ + return (0); +} /* gen_eject() */ + +/*----------------------------------------* + * Close the CD tray + *----------------------------------------*/ +int gen_closetray(struct wm_drive *d) +{ +#ifdef CAN_CLOSE + if(!wmcd_close(d->fd)) + { + d->fd=-1; + return(wmcd_reopen(d)); + } else { + return(-1); + } +#else + /* Always succeed if the drive can't close */ + return(0); +#endif /* CAN_CLOSE */ +} /* gen_closetray() */ + +int +scale_volume(int vol,int max) +{ + return ((vol * (max_volume - min_volume)) / max + min_volume); +} /* scale_volume() */ + +int +unscale_volume(int vol,int max) +{ + int n; + n = ( vol - min_volume ) * max_volume / (max - min_volume); + return (n <0)?0:n; +} /* unscale_volume() */ + +/* + * gen_set_volume() + * + */ +int +gen_set_volume(struct wm_drive *d,int left,int right) +{ + return (0); +} /* gen_set_volume() */ + +/* + * gen_get_volume() + * + */ +int +gen_get_volume(struct wm_drive *d,int *left,int *right) +{ + return (0); +} /* gen_get_volume() */ + +/*------------------------------------------------------------------------* + * gen_get_cdtext(drive, buffer, lenght) + * + * For systems without working wm_scsi(), this should return -1 + *------------------------------------------------------------------------*/ + +int +gen_get_cdtext(struct wm_drive *d, unsigned char **pp_buffer, int *p_buffer_lenght) +{ + return wm_scsi_get_cdtext(d, pp_buffer, p_buffer_lenght); +} /* gen_get_cdtext() */ + +#endif /* TEMPLATESYSTEM */ diff --git a/kscd/libwm/plat_ultrix.c b/kscd/libwm/plat_ultrix.c new file mode 100644 index 00000000..2685b0f5 --- /dev/null +++ b/kscd/libwm/plat_ultrix.c @@ -0,0 +1,663 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * ULTRIX 4.2 drive control routines. + */ + +static char plat_ultrix_id[] = "$Id$"; + +#if defined(ultrix) || defined(__ultrix) + + +#include <errno.h> +#include <stdio.h> +#include <sys/types.h> +#include <fcntl.h> +#include <sys/param.h> +#include <sys/stat.h> +#include <sys/time.h> +#include <ustat.h> +#include <string.h> +#include <sys/rzdisk.h> +#include <sys/cdrom.h> + +#include "include/wm_config.h" +#include "include/wm_cdtext.h" +#include "include/wm_struct.h" + +#define WM_MSG_CLASS WM_MSG_CLASS_PLATFORM + +/* + * This structure will be filled with the TOC header and all entries. + * Ultrix doesn't seem to allow getting single TOC entries. + * - Chris Ross (cross@eng.umd.edu) + */ +struct cd_toc_header_and_entries +{ + struct cd_toc_header cdth; + struct cd_toc_entry cdte[CDROM_MAX_TRACK+1]; +}; + +void *malloc(); +char *strchr(); + +int min_volume = 128; +int max_volume = 255; + +char * ultrix_cd_device = NULL; +/* + * fgetline() + * + * Simulate fgets, but joining continued lines in the output of uerf. + */ + +#define BUF_SIZE 85 /* Max length of a (real) line */ + +char * +fgetline( FILE *fp ) +{ + static char *retval = NULL; + static char holdbuf[BUF_SIZE + 1]; + char tmp[BUF_SIZE + 1]; + char *stmp; + + if (!retval) + { + retval = malloc(BUF_SIZE * 3); /* 3 lines can be joined */ + if (!retval) + return(NULL); + else + *retval = '\0'; + } + + if (*holdbuf) + { + strcpy(retval, holdbuf); + retval[strlen(retval)-1] = '\0'; + memset(holdbuf, 0, BUF_SIZE+1); + } + + while (fgets(tmp, BUF_SIZE, fp)) + { + stmp = tmp + strspn(tmp, " \t"); + if (*stmp == '_') + { /* Continuation line */ + retval[strlen(retval)-1] = '\0'; /* Trim off C/R */ + strcat(retval, stmp+1); + } else { + if (*retval) + { + strcpy(holdbuf, tmp); + holdbuf[strlen(holdbuf)-1] = -1; + return retval; + } else { /* First line read, keep reading */ + strcat(retval, stmp); + retval[strlen(retval)-1] = '\0'; + } + } + } + return NULL; +} /* fgetline() */ + +/* + * find_cdrom + * + * Determine the name of the CD-ROM device. + * + * Read through the boot records (via a call to uerf) and find the SCSI + * address of the CD-ROM. If the "CDROM" environment variable is set, + * use that instead. + */ +const char* +find_cdrom() +{ + char *data; + FILE *uerf; + int fds[2]; + int pid; + const char* device = NULL; + + device = getenv("CDROM"); + + if (device != NULL) + { + if(strncmp("/dev/", device, 5) || strstr(device, "/../")) + return NULL; + } + + pipe(fds); + + if ((pid = fork()) == 0) + { + close(fds[0]); + dup2(fds[1], 1); + execl("/etc/uerf", "uerf", "-R", "-r", "300", (void *)0); + execl("/usr/sbin/uerf", "uerf", "-R", "-r", "300", (void *)0); + return NULL; /* _exit(1); */ + } else if (pid < 0) { + perror("fork"); + return NULL; /* exit(1); */ + } + + close(fds[1]); + uerf = fdopen(fds[0], "r"); + + while (data = fgetline(uerf)) + if (strstr(data, "RRD42")) + { + char *device_p; + + ultrix_cd_device = (char *)malloc(sizeof("/dev/rrz##c")); + strcpy(ultrix_cd_device, "/dev/r"); + device_p = strstr(data, "rz"); + device_p[(int)(strchr(device_p, ' ') - device_p)] = '\0'; + strcat(ultrix_cd_device, device_p); + strcat(ultrix_cd_device, "c"); + device = ultrix_cd_device; + break; + } + + fclose(uerf); + + if (device == NULL) + { + fprintf(stderr, "No cdrom (RRD42) is installed on this system\n"); + return NULL; /* exit(1); */ + } + + kill(pid, 15); + (void)wait((int *)NULL); + return device; +} /* find_cdrom() */ + +/* + * initialize the drive. a no-op for the generic driver. + */ +int +gen_init( struct wm_drive *d ) +{ + return (0); +} /* gen_init() */ + + +/* + * Open the CD device and figure out what kind of drive is attached. + */ +int +wmcd_open( struct wm_drive *d ) +{ + int fd; + static int warned = 0; + + if (d->fd >= 0) /* Device already open? */ + { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_open(): [device is open (fd=%d)]\n", d->fd); + return (0); + } + + if (d->cd_device == NULL) + d->cd_device = find_cdrom(); + + d->fd = open(d->cd_device, 0); + if (d->fd < 0) + { + if (errno == EACCES) + { + return -EACCES; + } + else if (errno != EINTR) + { + return( -6 ); + } + + /* No CD in drive. */ + return (1); + } + + /* Now fill in the relevant parts of the wm_drive structure. */ + find_drive_struct("", "", ""); + d->fd = fd; + + (d->init)(d); + + return (0); +} /* wmcd_open() */ + +/* + * Re-Open the device if it is open. + */ +int +wmcd_reopen( struct wm_drive *d ) +{ + int status; + + do { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wmcd_reopen\n"); + status = gen_close( d ); + wm_susleep( 1000 ); + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "calling wmcd_open()\n"); + status = wmcd_open( d ); /* open it as usual */ + wm_susleep( 1000 ); + } while ( status != 0 ); + return status; +} /* wmcd_reopen() */ + +/* + * Send an arbitrary SCSI command to a device. + */ +int +wm_scsi( struct wm_drive *d, unsigned char *cdb, int cdblen, + void *retbuf, int retbuflen, int getreply ) +{ + /* ULTRIX doesn't have a SCSI passthrough interface, does it? */ + return (-1); +} /* wm_scsi() */ + +int +gen_close( struct wm_drive *d ) +{ + if(d->fd != -1) { + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "closing the device\n"); + close(d->fd); + d->fd = -1; + } + return 0; +} + +/* + * Get the current status of the drive: the current play mode, the absolute + * position from start of disc (in frames), and the current track and index + * numbers if the CD is playing or paused. + */ +int +gen_get_drive_status( struct wm_drive *d, int oldmode, + int *mode, int *pos, int *track, int *index) +{ + struct cd_sub_channel sc; + struct cd_subc_channel_data scd; + + /* If we can't get status, the CD is ejected, so default to that. */ + *mode = WM_CDM_EJECTED; + + sc.sch_address_format = CDROM_MSF_FORMAT; + sc.sch_data_format = CDROM_CURRENT_POSITION; + sc.sch_track_number = 0; + sc.sch_alloc_length = sizeof(scd); + sc.sch_buffer = (caddr_t)&scd; + + /* Is the device open? */ + if (d->fd < 0) + { + switch (wmcd_open(d)) + { + case -1: /* error */ + return (-1); + + case 1: /* retry */ + return (0); + } + } + + if (ioctl(d->fd, CDROM_READ_SUBCHANNEL, &sc)) + return (0); /* ejected */ + + switch (scd.scd_header.sh_audio_status) + { + case AS_PLAY_IN_PROGRESS: + *mode = WM_CDM_PLAYING; +dopos: + *pos = scd.scd_position_data.scp_absaddr.msf.m_units * 60 * 75 + + scd.scd_position_data.scp_absaddr.msf.s_units * 75 + + scd.scd_position_data.scp_absaddr.msf.f_units; + *track = scd.scd_position_data.scp_track_number; + *index = scd.scd_position_data.scp_index_number; + break; + + case AS_PLAY_PAUSED: + if (oldmode == WM_CDM_PLAYING || oldmode == WM_CDM_PAUSED) + { + *mode = WM_CDM_PAUSED; + goto dopos; + } + else + *mode = WM_CDM_STOPPED; + break; + + case AS_PLAY_COMPLETED: + *mode = WM_CDM_TRACK_DONE; /* waiting for next track. */ + break; + + case AS_NO_STATUS: + *mode = WM_CDM_STOPPED; + break; + } + return (0); +} /* gen_get_drive_status() */ + +/* + * Get the number of tracks on the CD. + */ +int +gen_get_trackcount( struct wm_drive *d, int *tracks ) +{ + struct cd_toc_header hdr; + + if (ioctl(d->fd, CDROM_TOC_HEADER, &hdr)) + return (-1); + + *tracks = hdr.th_ending_track; + + return (0); +} /* gen_get_trackcount() */ + +/* + * Get the start time and mode (data or audio) of a track. + * + * XXX - this should get cached, but that means keeping track of ejects. + */ +int +gen_get_trackinfo(struct wm_drive *d, int track, int *data, int *startframe) +{ + struct cd_toc toc; + struct cd_toc_header hdr; + struct cd_toc_header_and_entries toc_buffer; + + if (ioctl(d->fd, CDROM_TOC_HEADER, &hdr)) + return (-1); + + bzero((char *)&toc_buffer, sizeof(toc_buffer)); + toc.toc_address_format = CDROM_MSF_FORMAT; + toc.toc_starting_track = 0; + toc.toc_alloc_length = (u_short)(((hdr.th_data_len1 << 8) + + hdr.th_data_len0) & 0xfff) + 2; + toc.toc_buffer = (caddr_t)&toc_buffer; + + if (ioctl(d->fd, CDROM_TOC_ENTRYS, &toc)) + return (-1); + + if (track == 0) + track = hdr.th_ending_track + 1; + + *data = (toc_buffer.cdte[track-1].te_control & CDROM_DATA_TRACK) ? 1:0; + *startframe = toc_buffer.cdte[track - 1].te_absaddr.msf.m_units*60*75 + + toc_buffer.cdte[track - 1].te_absaddr.msf.s_units * 75 + + toc_buffer.cdte[track - 1].te_absaddr.msf.f_units; + + return (0); +} /* gen_get_trackinfo() */ + +/* + * Get the number of frames on the CD. + */ +int +gen_get_cdlen(struct wm_drive *d, int *frames) +{ + int tmp; + return (gen_get_trackinfo(d, 0, &tmp, frames)); +} /* gen_get_cdlen() */ + +/* + * Play the CD from one position to another (both in frames.) + */ +int +gen_play( struct wm_drive *d, int start, int end ) +{ + struct cd_play_audio_msf msf; + + msf.msf_starting_M_unit = start / (60*75); + msf.msf_starting_S_unit = (start % (60*75)) / 75; + msf.msf_starting_F_unit = start % 75; + msf.msf_ending_M_unit = end / (60*75); + msf.msf_ending_S_unit = (end % (60*75)) / 75; + msf.msf_ending_F_unit = end % 75; + + if (ioctl(d->fd, SCSI_START_UNIT)) + return (-1); + if (ioctl(d->fd, CDROM_PLAY_MSF, &msf)) + return (-2); + + return (0); +} /* gen_play() */ + +/* + * Pause the CD. + */ +int +gen_pause( struct wm_drive *d ) +{ + return (ioctl(d->fd, CDROM_PAUSE_PLAY)); +} /* gen_pause() */ + +/* + * Resume playing the CD (assuming it was paused.) + */ +int +gen_resume( struct wm_drive *d ) +{ + return (ioctl(d->fd, CDROM_RESUME_PLAY)); +} /* gen_resume() */ + +/* + * Stop the CD. + */ +int +gen_stop( struct wm_drive *d ) +{ + return (ioctl(d->fd, SCSI_STOP_UNIT)); +} /* gen_stop() */ + +/* + * Eject the current CD, if there is one. + */ +int +gen_eject(struct wm_drive *d) +{ + /* On some systems, we can check to see if the CD is mounted. */ + struct stat stbuf; + struct ustat ust; + + if (fstat(d->fd, &stbuf) != 0) + return (-2); + + /* Is this a mounted filesystem? */ + if (ustat(stbuf.st_rdev, &ust) == 0) + return (-3); + + return (ioctl(d->fd, CDROM_EJECT_CADDY)); +} /* gen_eject() */ + +/*----------------------------------------* + * Close the CD tray + * + * Please edit and send changes to + * milliByte@DeathsDoor.com + *----------------------------------------*/ + +int +gen_closetray(struct wm_drive *d) +{ +#ifdef CAN_CLOSE + if(!close(d->fd)) + { + d->fd=-1; + return(wmcd_reopen(d)); + } else { + return(-1); + } +#else + /* Always succeed if the drive can't close */ + return(0); +#endif /* CAN_CLOSE */ +} /* gen_closetray() */ + + +/* + * scale_volume(vol, max) + * + * Return a volume value suitable for passing to the CD-ROM drive. "vol" + * is a volume slider setting; "max" is the slider's maximum value. + * + * On Sun and DEC CD-ROM drives, the amount of sound coming out the jack + * increases much faster toward the top end of the volume scale than it + * does at the bottom. To make up for this, we make the volume scale look + * sort of logarithmic (actually an upside-down inverse square curve) so + * that the volume value passed to the drive changes less and less as you + * approach the maximum slider setting. The actual formula looks like + * + * (max^2 - (max - vol)^2) * (max_volume - min_volume) + * v = --------------------------------------------------- + min_volume + * max^2 + * + * If your system's volume settings aren't broken in this way, something + * like the following should work: + * + * return ((vol * (max_volume - min_volume)) / max + min_volume); + */ +scale_volume( int vol, int max ) +{ + return ((max * max - (max - vol) * (max - vol)) * + (max_volume - min_volume) / (max * max) + min_volume); +} /* scale_volume() */ + + +/* + * unscale_volume(cd_vol, max) + * + * Given a value between min_volume and max_volume, return the volume slider + * value needed to achieve that value. + * + * Rather than perform floating-point calculations to reverse the above + * formula, we simply do a binary search of scale_volume()'s return values. + */ +static int +unscale_volume( int cd_vol, int max ) +{ + int vol = 0, top = max, bot = 0, scaled; + + while (bot <= top) + { + vol = (top + bot) / 2; + scaled = scale_volume(vol, max); + if (cd_vol == scaled) + break; + if (cd_vol < scaled) + top = vol - 1; + else + bot = vol + 1; + } + + if (vol < 0) + vol = 0; + else if (vol > max) + vol = max; + + return (vol); +} /* unscale_volume() */ + +/* + * Set the volume level for the left and right channels. Their values + * range from 0 to 100. + */ +int +gen_set_volume( struct wm_drive *d, int left, int right ) +{ + struct cd_playback pb; + struct cd_playback_status ps; + struct cd_playback_control pc; + + left = scale_volume(left, 100); + right = scale_volume(right, 100); + + bzero((char *)&pb, sizeof(pb)); + bzero((char *)&ps, sizeof(ps)); + bzero((char *)&pc, sizeof(pc)); + + pb.pb_alloc_length = sizeof(ps); + pb.pb_buffer = (caddr_t)&ps; + + if (ioctl(d->fd, CDROM_PLAYBACK_STATUS, &pb)) + return (-1); + + pc.pc_chan0_select = ps.ps_chan0_select; + pc.pc_chan0_volume = (left < CDROM_MIN_VOLUME) ? + CDROM_MIN_VOLUME : (left > CDROM_MAX_VOLUME) ? + CDROM_MAX_VOLUME : left; + pc.pc_chan1_select = ps.ps_chan1_select; + pc.pc_chan1_volume = (right < CDROM_MIN_VOLUME) ? + CDROM_MIN_VOLUME : (right > CDROM_MAX_VOLUME) ? + CDROM_MAX_VOLUME : right; + + pb.pb_alloc_length = sizeof(pc); + pb.pb_buffer = (caddr_t)&pc; + + if (ioctl(d->fd, CDROM_PLAYBACK_CONTROL, &pb)) + return (-1); + + return (0); +} /* gen_set_volume() */ + +/* + * Read the initial volume from the drive, if available. Each channel + * ranges from 0 to 100, with -1 indicating data not available. + */ +int +gen_get_volume(struct wm_drive *d, int *left, int *right) +{ + struct cd_playback pb; + struct cd_playback_status ps; + + bzero((char *)&pb, sizeof(pb)); + bzero((char *)&ps, sizeof(ps)); + + pb.pb_alloc_length = sizeof(ps); + pb.pb_buffer = (caddr_t)&ps; + + if (d->fd >= 0) + { + if (ioctl(d->fd, CDROM_PLAYBACK_STATUS, &pb)) + *left = *right = -1; + else + { + *left = unscale_volume(ps.ps_chan0_volume, 100); + *right = unscale_volume(ps.ps_chan1_volume, 100); + } + } + else + *left = *right = -1; + + return (0); +} /* gen_get_volume() */ + +/*------------------------------------------------------------------------* + * gen_get_cdtext(drive, buffer, lenght) + *------------------------------------------------------------------------*/ + +int +gen_get_cdtext(struct wm_drive *d, unsigned char **pp_buffer, int *p_buffer_lenght) +{ + return -1; /* No SCSI, no CDTEXT */ +} /* gen_get_cdtext() */ + + +#endif diff --git a/kscd/libwm/scsi.c b/kscd/libwm/scsi.c new file mode 100644 index 00000000..4e0dd759 --- /dev/null +++ b/kscd/libwm/scsi.c @@ -0,0 +1,667 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * Frontend functions for sending raw SCSI commands to the CD-ROM drive. + * These depend on wm_scsi(), which should be defined in each platform + * module. + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include "include/wm_config.h" +#include "include/wm_struct.h" +#include "include/wm_scsi.h" +#include "include/wm_platform.h" +#include "include/wm_helpers.h" +#include "include/wm_cdrom.h" +#include "include/wm_cdtext.h" + +#define SCMD_INQUIRY 0x12 +#define SCMD_MODE_SELECT 0x15 +#define SCMD_MODE_SENSE 0x1a +#define SCMD_START_STOP 0x1b +#define SCMD_PREVENT 0x1e +#define SCMD_READ_SUBCHANNEL 0x42 +#define SCMD_READ_TOC 0x43 +#define SCMD_PLAY_AUDIO_MSF 0x47 +#define SCMD_PAUSE_RESUME 0x4b + +#define SUBQ_STATUS_INVALID 0x00 +#define SUBQ_STATUS_PLAY 0x11 +#define SUBQ_STATUS_PAUSE 0x12 +#define SUBQ_STATUS_DONE 0x13 +#define SUBQ_STATUS_ERROR 0x14 +#define SUBQ_STATUS_NONE 0x15 +#define SUBQ_STATUS_NO_DISC 0x17 /* Illegal, but Toshiba returns it. */ +#define SUBQ_ILLEGAL 0xff + +#define PAGE_AUDIO 0x0e +#define LEADOUT 0xaa + +#define WM_MSG_CLASS WM_MSG_CLASS_SCSI + +/* local prototypes */ +int wm_scsi_mode_select( struct wm_drive *d, unsigned char *buf, unsigned char len ); +int wm_scsi2_pause_resume(struct wm_drive *d, int resume); +int wm_scsi2_prevent(struct wm_drive *d, int prevent); +int wm_scsi2_play(struct wm_drive *d, int sframe, int eframe); +int wm_scsi2_get_trackinfo(struct wm_drive *d, int track, int *data, int *startframe); +int wm_scsi2_get_cdlen(struct wm_drive *d, int frames); +int wm_scsi2_get_drive_status(struct wm_drive *d, int oldmode, + int *mode, int *pos, int *track, int *ind); +int wm_scsi2_get_trackcount(struct wm_drive *d, int *tracks); +int wm_scsi2_pause(struct wm_drive *d); +int wm_scsi2_resume(struct wm_drive *d); +int wm_scsi2_stop(struct wm_drive *d); +int wm_scsi2_eject(struct wm_drive *d); +int wm_scsi2_closetray(struct wm_drive *d); +int wm_scsi2_get_volume(struct wm_drive *d, int *left, int *right); +int wm_scsi2_set_volume(struct wm_drive *d, int left, int right); +/* local prototypes END */ + +/* + * Send a SCSI command over the bus, with all the CDB bytes specified + * as unsigned char parameters. This doesn't use varargs because some + * systems have stdargs instead and the number of bytes in a CDB is + * limited to 12 anyway. + * + * d Drive structure + * buf Buffer for data, both sending and receiving + * len Size of buffer + * dir TRUE if the command expects data to be returned in the buffer. + * a0- CDB bytes. Either 6, 10, or 12 of them, depending on the command. + */ +/*VARARGS4*/ +int +sendscsi( struct wm_drive *d, void *buf, + unsigned int len, int dir, + unsigned char a0, unsigned char a1, + unsigned char a2, unsigned char a3, + unsigned char a4, unsigned char a5, + unsigned char a6, unsigned char a7, + unsigned char a8, unsigned char a9, + unsigned char a10, unsigned char a11 ) + +{ + int cdblen = 0; + unsigned char cdb[12]; + + cdb[0] = a0; + cdb[1] = a1; + cdb[2] = a2; + cdb[3] = a3; + cdb[4] = a4; + cdb[5] = a5; + + switch ((a0 >> 5) & 7) { + case 0: + cdblen = 6; + break; + + case 5: + cdb[10] = a10; + cdb[11] = a11; + cdblen = 12; + + case 1: + case 2: + case 6: /* assume 10-byte vendor-specific codes for now */ + cdb[6] = a6; + cdb[7] = a7; + cdb[8] = a8; + cdb[9] = a9; + if (! cdblen) + cdblen = 10; + break; + } + + return (wm_scsi(d, cdb, cdblen, buf, len, dir)); +} + +/* + * Send a MODE SENSE command and return the results (minus header cruft) + * in a user buffer. + * + * d Drive structure + * page Number of page to query (plus page control bits, if any) + * buf Result buffer + */ +int +wm_scsi_mode_sense( struct wm_drive *d, unsigned char page, unsigned char *buf ) +{ + unsigned char pagebuf[255]; + int status, i, len, offset; + + status = sendscsi(d, pagebuf, sizeof(pagebuf), 1, SCMD_MODE_SENSE, 0, + page, 0, sizeof(pagebuf), 0,0,0,0,0,0,0); + if (status < 0) + return (status); + + /* + * The first byte of the returned data is the transfer length. Then + * two more bytes and the length of whatever header blocks are in + * front of the page we want. + */ + len = pagebuf[0] - pagebuf[3] - 3; + offset = pagebuf[3] + 4; + for (i = 0; i < len; i++) + buf[i] = pagebuf[offset + i]; + + return (0); +} + +/* + * Send a MODE SELECT command. + * + * d Drive structure + * buf Page buffer (no need to put on block descriptors) + * len Size of page + */ +int +wm_scsi_mode_select( struct wm_drive *d, unsigned char *buf, unsigned char len ) +{ + unsigned char pagebuf[255]; + int i; + + pagebuf[0] = pagebuf[1] = pagebuf[2] = pagebuf[3] = 0; + for (i = 0; i < (int) len; i++) + pagebuf[i + 4] = buf[i]; + + return (sendscsi(d, pagebuf, len + 4, 0, SCMD_MODE_SELECT, 0x10, 0, + 0, len + 4, 0,0,0,0,0,0,0)); +} + +/* + * Send an INQUIRY command to get the drive type. + * + * d Drive structure + * vendor Buffer for vendor name (8 bytes + null) + * model Buffer for model name (16 bytes + null) + * rev Buffer for revision level (4 bytes + null) + * + * The above string lengths apply to the SCSI INQUIRY command. The + * actual WorkMan drive structure reserves 31 bytes + NULL per entry. + * + * If the model name begins with "CD-ROM" and zero or more spaces, that will + * all be stripped off since it's just extra junk to WorkMan. + */ +int +wm_scsi_get_drive_type( struct wm_drive *d, char *vendor, + char *model, char *rev ) +{ +/* removed unsigned*/ + char *s, *t, buf[36]; + memset(buf, 0, 36); + + wm_lib_message(WM_MSG_CLASS_SCSI | WM_MSG_LEVEL_INFO, "Sending SCSI inquiry command...\n"); + if (sendscsi(d, buf, 36, 1, SCMD_INQUIRY, 0, 0, 0, 36, 0,0,0,0,0,0,0)) + { + sprintf( vendor, WM_STR_GENVENDOR); + sprintf( model, WM_STR_GENMODEL); + sprintf( rev, WM_STR_GENREV); + wm_lib_message(WM_MSG_CLASS_SCSI | WM_MSG_LEVEL_ERROR, "SCSI Inquiry command not supported in this context\n"); + return -1; + } + + wm_lib_message(WM_MSG_CLASS_SCSI | WM_MSG_LEVEL_DEBUG, "sent.\n"); + + memcpy(vendor, buf + 8, 8); + vendor[8] = '\0'; + memcpy(model, buf + 16, 16); + model[16] = '\0'; + memcpy(rev, buf + 32, 4); + rev[4] = '\0'; + wm_lib_message(WM_MSG_CLASS_SCSI | WM_MSG_LEVEL_VERB, "SCSI Inquiry result: [%s|%s|%s]\n", vendor, model, rev); + + + /* Remove "CD-ROM " from the model. */ + if (! strncmp(model, "CD-ROM", 6)) + { + s = model + 6; + t = model; + while (*s == ' ' || *s == '\t') + s++; + while( (*t++ = *s++) ) + ; + } + wm_lib_message(WM_MSG_CLASS_SCSI | WM_MSG_LEVEL_INFO, "scsi: Cooked data: %s %s rev. %s\n", vendor, model,rev); + return (0); +} /* wm_scsi_get_drive_type() */ + +/* + * Send a SCSI-2 PAUSE/RESUME command. "resume" is 1 to resume, 0 to pause. + */ +int +wm_scsi2_pause_resume(struct wm_drive *d, int resume) +{ + return (sendscsi(d, NULL, 0, 0, SCMD_PAUSE_RESUME, 0, 0, 0, 0, 0, 0, + 0, resume ? 1 : 0, 0,0,0)); +} + +/* + * Send a SCSI-2 "prevent media removal" command. "prevent" is 1 to lock + * caddy in. + */ +int +wm_scsi2_prevent(struct wm_drive *d, int prevent) +{ + return (sendscsi(d, NULL, 0, 0, SCMD_PREVENT, 0, 0, 0, 0, 0, 0, + 0, prevent ? 1 : 0, 0,0,0)); +} + +/* + * Send a SCSI-2 PLAY AUDIO MSF command. Pass the starting and ending + * frame numbers. + */ +int +wm_scsi2_play(struct wm_drive *d, int sframe, int eframe) +{ + return (sendscsi(d, NULL, 0, 0, SCMD_PLAY_AUDIO_MSF, 0, 0, + sframe / (60 * 75), (sframe / 75) % 60, sframe % 75, + eframe / (60 * 75), (eframe / 75) % 60, eframe % 75, + 0,0,0)); +} + +/* + * Send a SCSI-2 READ TOC command to get the data for a particular track. + * Fill in track information from the returned data. + */ +int +wm_scsi2_get_trackinfo(struct wm_drive *d, int track, + int *data, int *startframe) +{ + unsigned char buf[12]; /* one track's worth of info */ + + if (sendscsi(d, buf, sizeof(buf), 1, SCMD_READ_TOC, 2, + 0, 0, 0, 0, track, sizeof(buf) / 256, + sizeof(buf) % 256, 0,0,0)) + return (-1); + + *data = buf[5] & 4 ? 1 : 0; + *startframe = buf[9] * 60 * 75 + buf[10] * 75 + buf[11]; + + return (0); +} + +/* + * Get the starting frame for the leadout area (which should be the same as + * the length of the disc as far as WorkMan is concerned). + */ +int +wm_scsi2_get_cdlen(struct wm_drive *d, int frames) +{ + int tmp; + return (wm_scsi2_get_trackinfo(d, LEADOUT, &tmp, &frames)); +} + +/* + * Get the current status of the drive by sending the appropriate SCSI-2 + * READ SUB-CHANNEL command. + */ +int +wm_scsi2_get_drive_status(struct wm_drive *d, int oldmode, + int *mode, int *pos, int *track, int *ind) +{ + unsigned char buf[48]; + + /* If we can't get status, the CD is ejected, so default to that. */ + *mode = WM_CDM_EJECTED; + + /* Is the device open? */ + if (d->fd < 0) + { +/* + * stupid somehow, but necessary this time + */ + switch( wmcd_open( d ) ) { + + case -1: /* error */ + return (-1); + + case 1: /* retry */ + return (0); + } + } + + /* If we can't read status, the CD has been ejected. */ + buf[1] = SUBQ_ILLEGAL; + if (sendscsi(d, buf, sizeof(buf), 1, SCMD_READ_SUBCHANNEL, 2, 64, 1, + 0, 0, 0, sizeof(buf) / 256, sizeof(buf) % 256, 0,0,0)) + return (0); + + switch (buf[1]) { + case SUBQ_STATUS_PLAY: + *mode = WM_CDM_PLAYING; + *track = buf[6]; + *ind = buf[7]; + *pos = buf[9] * 60 * 75 + buf[10] * 75 + buf[11]; + break; + + case SUBQ_STATUS_PAUSE: + if (oldmode == WM_CDM_PLAYING || oldmode == WM_CDM_PAUSED) + { + *mode = WM_CDM_PAUSED; + *track = buf[6]; + *ind = buf[7]; + *pos = buf[9] * 60 * 75 + + buf[10] * 75 + + buf[11]; + } + else + *mode = WM_CDM_STOPPED; + break; + + /* + * SUBQ_STATUS_DONE is sometimes returned when the CD is idle, + * even though the spec says it should only be returned when an + * audio play operation finishes. + */ + case SUBQ_STATUS_DONE: + case SUBQ_STATUS_NONE: + case SUBQ_STATUS_INVALID: + if (oldmode == WM_CDM_PLAYING) + *mode = WM_CDM_TRACK_DONE; + else + *mode = WM_CDM_STOPPED; + break; + + /* + * This usually means there's no disc in the drive. + */ + case SUBQ_STATUS_NO_DISC: + break; + + /* + * This usually means the user ejected the CD manually. + */ + case SUBQ_STATUS_ERROR: + break; + + case SUBQ_ILLEGAL: /* call didn't really succeed */ + break; + + default: + *mode = WM_CDM_UNKNOWN; +#ifndef NDEBUG + if( getenv( "WORKMAN_DEBUG" ) != NULL ) + printf("wm_scsi2_get_drive_status: status is 0x%x\n", + buf[1]); +#endif + break; + } + + return (0); +} + +/* + * Get the number of tracks on the CD using the SCSI-2 READ TOC command. + */ +int +wm_scsi2_get_trackcount(struct wm_drive *d, int *tracks) +{ + unsigned char buf[4]; + + if (sendscsi(d, buf, sizeof(buf), 1, SCMD_READ_TOC, 0, + 0, 0, 0, 0, 0, sizeof(buf) / 256, + sizeof(buf) % 256, 0,0,0)) + return (-1); + + *tracks = buf[3] - buf[2] + 1; + return (0); +} + +/* + * Pause the CD. + */ +int +wm_scsi2_pause(struct wm_drive *d) +{ + return (wm_scsi2_pause_resume(d, 0)); +} + +/* + * Resume playing after a pause. + */ +int +wm_scsi2_resume(struct wm_drive *d) +{ + return (wm_scsi2_pause_resume(d, 1)); +} + +/* + * Stop playing the CD by sending a START STOP UNIT command. + */ +int +wm_scsi2_stop(struct wm_drive *d) +{ + return (sendscsi(d, NULL, 0, 0, SCMD_START_STOP, 0, 0,0,0,0,0,0,0,0,0,0)); +} + +/* + * Eject the CD by sending a START STOP UNIT command. + */ +int +wm_scsi2_eject(struct wm_drive *d) +{ + /* Unlock the disc (possibly unnecessary). */ + if (wm_scsi2_prevent(d, 0)) + return (-1); + wm_lib_message(WM_MSG_CLASS_SCSI | WM_MSG_LEVEL_VERB, "Issuing START_STOP for ejecting...\n"); + return (sendscsi(d, NULL, 0, 0, SCMD_START_STOP, 2, 0,0,0,0,0,0,0,0,0,0)); +} + +/* + * Something like a dummy. The SCSI-2 specs are too hard for me to + * understand here... + * + * If you have the correct command handy, please send the code to + * milliByte@DeathsDoor.com + */ +int +wm_scsi2_closetray(struct wm_drive *d) +{ + wm_lib_message(WM_MSG_CLASS_SCSI | WM_MSG_LEVEL_VERB, "Issuing START_STOP for closing...\n"); + return (sendscsi(d, NULL, 0,0, SCMD_START_STOP, 2, 0,0,0,0,0,0,0,0,0,0)); +} + +/* + * Get the volume by doing a MODE SENSE command. + */ +int +wm_scsi2_get_volume(struct wm_drive *d, int *left, int *right) +{ + unsigned char mode[16]; + + *left = *right = -1; + + /* Get the current audio parameters first. */ + if (wm_scsi_mode_sense(d, PAGE_AUDIO, mode)) + return (-1); + + *left = ((int) mode[9] * 100) / 255; + *right = ((int) mode[11] * 100) / 255; + + return (0); +} + +/* + * Set the volume by doing a MODE SELECT command. + */ +int +wm_scsi2_set_volume(struct wm_drive *d, int left, int right) +{ + unsigned char mode[16]; + + /* Get the current audio parameters first. */ + if (wm_scsi_mode_sense(d, PAGE_AUDIO, mode)) + return (-1); + + /* Tweak the volume part of the parameters. */ + mode[9] = (left * 255) / 100; + mode[11] = (right * 255) / 100; + + /* And send them back to the drive. */ + return (wm_scsi_mode_select(d, mode, sizeof(mode))); +} + +/*------------------------------------------------------------------------* + * wm_scsi_get_cdtext(drive, buffer, lenght) + * + * Return a buffer with cdtext-stream. buffer mus be allocated and filled + * + * + *------------------------------------------------------------------------*/ + +int +wm_scsi_get_cdtext(struct wm_drive *d, unsigned char **pp_buffer, int *p_buffer_length) +{ + int ret; + unsigned char temp[8]; + unsigned char *dynamic_temp; + int cdtext_possible; + unsigned short cdtext_data_length; + unsigned long feature_list_length; +#define IGNORE_FEATURE_LIST +#ifndef IGNORE_FEATURE_LIST + struct feature_list_header *pHeader; + struct feature_descriptor_cdread *pDescriptor; +#endif /* IGNORE_FEATURE_LIST */ + + dynamic_temp = NULL; + cdtext_possible = 0; + wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "wm_scsi_get_cdtext entered\n"); + + wm_lib_message(WM_MSG_LEVEL_INFO|WM_MSG_CLASS, "CDTEXT INFO: use GET_FEATURY_LIST(0x46)...\n"); + ret = sendscsi(d, temp, 8, 1, + 0x46, 0x02, 0x00, 0x1E, 0, + 0, 0, 0, 8, 0, 0, 0); + + if(ret) + { + wm_lib_message(WM_MSG_LEVEL_INFO|WM_MSG_CLASS, "CDTEXT ERROR: GET_FEATURY_LIST(0x46) not implemented or broken. ret = %i!\n", ret); +#ifndef IGNORE_FEATURE_LIST + wm_lib_message(WM_MSG_LEVEL_INFO|WM_MSG_CLASS, "CDTEXT ERROR: Try #define IGNORE_FEATURE_LIST in libwm/scsi.c\n"); +#else + cdtext_possible = 1; + wm_lib_message(WM_MSG_LEVEL_INFO|WM_MSG_CLASS, "CDTEXT INFO: GET_FEATURY_LIST(0x46) ignored. It's OK, because many CDROMS don't implement this feature\n"); +#endif /* IGNORE_FEATURE_LIST */ + } + else + { + feature_list_length = temp[0]*0xFFFFFF + temp[1]*0xFFFF + temp[2]*0xFF + temp[3] + 4; + + dynamic_temp = malloc(feature_list_length); + + if(!dynamic_temp) + return -1; + + memset(dynamic_temp, 0, feature_list_length); + ret = sendscsi(d, dynamic_temp, feature_list_length, 1, + 0x46, 0x02, 0x00, 0x1E, 0, 0, + 0, (feature_list_length>>8) & 0xFF, feature_list_length & 0xFF, 0, 0, 0); + + +#ifndef IGNORE_FEATURE_LIST + if(!ret) + { + pHeader = (struct feature_list_header*)dynamic_temp; +/* printf("length = %i, profile = 0x%02X%02X\n", pHeader->lenght_lsb, pHeader->profile_msb, pHeader->profile_lsb);*/ + pDescriptor = (struct feature_descriptor_cdread*)(dynamic_temp + sizeof(struct feature_list_header)); +/* printf("code = 0x%02X%02X, settings = 0x%02X, add_length = %i, add_settings = 0x%02X \n", + pDescriptor->feature_code_msb, pDescriptor->feature_code_lsb, pDescriptor->settings, + pDescriptor->add_lenght, pDescriptor->add_settings);*/ + + cdtext_possible = pDescriptor->add_settings & 0x01; + } + else + { + cdtext_possible = 0; + } + +#else + cdtext_possible = 1; +#endif /* IGNORE_FEATURE_LIST */ + + free (dynamic_temp); + dynamic_temp = 0; + } + + if(!cdtext_possible) + { + wm_lib_message(WM_MSG_LEVEL_INFO|WM_MSG_CLASS, "CDTEXT INFO: GET_FEATURY_LIST(0x46) says, CDTEXT is not present!\n"); + return EXIT_SUCCESS; + } + + wm_lib_message(WM_MSG_LEVEL_INFO|WM_MSG_CLASS, "CDTEXT INFO: try to read, how long CDTEXT is?\n"); + ret = sendscsi(d, temp, 4, 1, + SCMD_READ_TOC, 0x00, 0x05, 0, 0, 0, + 0, 0, 4, 0, 0, 0); + + if(ret) + { + wm_lib_message(WM_MSG_LEVEL_INFO|WM_MSG_CLASS, + "CDTEXT ERROR: READ_TOC(0x43) with format code 0x05 not implemented or broken. ret = %i!\n", ret); + } + else + { + cdtext_data_length = temp[0]*0xFF + temp[1] + 4 + 1; /* divide by 18 + 4 ? */ + /* cdtext_data_length%18 == 0;? */ + wm_lib_message(WM_MSG_LEVEL_INFO|WM_MSG_CLASS, "CDTEXT INFO: CDTEXT is %i byte(s) long\n", cdtext_data_length); + /* cdc_buffer[2]; cdc_buffer[3]; reserwed */ + dynamic_temp = malloc(cdtext_data_length); + if(!dynamic_temp) + return -1; + + memset(dynamic_temp, 0, cdtext_data_length); + wm_lib_message(WM_MSG_LEVEL_INFO|WM_MSG_CLASS, "CDTEXT INFO: try to read CDTEXT\n"); + ret = sendscsi(d, dynamic_temp, cdtext_data_length, 1, + SCMD_READ_TOC, 0x00, 0x05, 0, 0, 0, + 0, (cdtext_data_length>>8) & 0xFF, cdtext_data_length & 0xFF, 0, 0, 0); + + if(ret) + { + wm_lib_message(WM_MSG_LEVEL_INFO|WM_MSG_CLASS, + "CDTEXT ERROR: READ_TOC(0x43) with format code 0x05 not implemented or broken. ret = %i!\n", ret); + } + else + { + cdtext_data_length = temp[0]*0xFF + temp[1] + 4 + 1; /* divide by 18 + 4 ? */ + wm_lib_message(WM_MSG_LEVEL_INFO|WM_MSG_CLASS, "CDTEXT INFO: read %i byte(s) of CDTEXT\n", cdtext_data_length); + + /* send cdtext only 18 bytes packs * ? */ + *(p_buffer_length) = cdtext_data_length - 4; + *pp_buffer = malloc(*p_buffer_length); + if(!(*pp_buffer)) + { + return -1; + } + memcpy(*pp_buffer, dynamic_temp + 4, *p_buffer_length); + } + free(dynamic_temp); + dynamic_temp = 0; + } + + return ret; +} /* wm_scsi_get_cdtext() */ diff --git a/kscd/libwm/wm_helpers.c b/kscd/libwm/wm_helpers.c new file mode 100644 index 00000000..109efe1b --- /dev/null +++ b/kscd/libwm/wm_helpers.c @@ -0,0 +1,238 @@ +/* + * $Id$ + * + * This file is part of WorkMan, the civilized CD player library + * (c) 1991-1997 by Steven Grimm (original author) + * (c) by Dirk Försterling (current 'author' = maintainer) + * The maintainer can be contacted by his e-mail address: + * milliByte@DeathsDoor.com + * + * 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 this library; if not, write to the Free + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * Some helpful functions... + * + */ + +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <errno.h> +#include <stdarg.h> +#include <sys/time.h> +#include "include/workman_defs.h" +#include "include/wm_config.h" +#include "include/wm_helpers.h" +#include "include/wm_struct.h" + +#define WM_MSG_CLASS WM_MSG_CLASS_MISC + +int wm_lib_verbosity = WM_MSG_LEVEL_NONE; + +/* + * Some seleced functions of version reporting follow... + */ + +int wm_libver_major( void ){return WM_LIBVER_MAJOR;} +int wm_libver_minor( void ){return WM_LIBVER_MINOR;} +int wm_libver_pl( void ){return WM_LIBVER_PL;} + +char *wm_libver_name( void ) +{ + char *s = NULL; + + wm_strmcat(&s, WM_LIBVER_NAME); + return s; +} /* wm_libver_name() */ + +char *wm_libver_number( void ) +{ + char *s = NULL; + + s = malloc(10); + /* this is not used very often, so don't care about speed...*/ + sprintf(s, "%d.%d.%d", wm_libver_major(), wm_libver_minor(), wm_libver_pl()); + return s; +} /* wm_libver_number() */ + +char *wm_libver_date( void ) +{ + char *s = NULL; + wm_strmcat(&s, __DATE__); + return s; +} /* wm_libver_date() */ + +char *wm_libver_string( void ) +{ + char *s = NULL; + + wm_strmcat( &s, wm_libver_name() ); + wm_strmcat( &s, " " ); + wm_strmcat( &s, wm_libver_number() ); + return s; +} /* wm_libver_string() */ + + +/* + * + * Now for some memory management... + * + */ + +/* Free some memory and set a pointer to null. */ +void freeup( char **x ) +{ + if (*x != NULL) + { + free(*x); + *x = NULL; + } +} /* freeup() */ + +/* Copy into a malloced string. */ +void +wm_strmcpy( char **t, const char *s ) +{ + wm_lib_message(WM_MSG_CLASS_MISC | WM_MSG_LEVEL_DEBUG, "wm_strmcpy(%s, '%s')\n", *t, s); + if (*t != NULL) + { + wm_lib_message(WM_MSG_CLASS_MISC | WM_MSG_LEVEL_DEBUG, "wm_strmcpy freeing pointer %p\n", *t); + free(*t); + } + + *t = malloc(strlen(s) + 1); + if (*t == NULL) + { + perror("wm_strmcpy"); + exit(1); + } + + wm_lib_message(WM_MSG_CLASS_MISC | WM_MSG_LEVEL_DEBUG, "wm_strmcpy finally copying (%p, '%s')\n", *t, s); + strncpy(*t, s, strlen(s)); +} /* wm_strmcpy() */ + +/* Add to a malloced string. */ +void +wm_strmcat( char **t, const char *s) +{ + int len = strlen(s) + 1; + + wm_lib_message(WM_MSG_CLASS_MISC | WM_MSG_LEVEL_DEBUG, "wm_strmcat(%s, %s)\n", *t, s); + + if (*s == '\0') + return; + + if (*t != NULL) + { + len += strlen(*t); + *t = realloc(*t, len); + if (*t == NULL) + { + perror("wm_strmcat"); + exit(1); + } + strcat(*t, s); + } + else + wm_strmcpy(t, s); +} /* wm_strmcat() */ + +/* Duplicate a string. Some systems have this in libc, but not all. */ +char * +wm_strdup( char *s ) +{ + char *new; + + new = malloc(strlen(s) + 1); + if (new) + strcpy(new, s); + return (new); +} /* wm_strdup() */ + + +/* + * set and get verbosity level. + */ +void wm_lib_set_verbosity( int level ) +{ + if( WM_MSG_LEVEL_NONE <= level && level <= WM_MSG_LEVEL_DEBUG ) + { + wm_lib_verbosity = level; + wm_lib_message(WM_MSG_CLASS_MISC | WM_MSG_LEVEL_DEBUG, "Verbosity set to %d|%d\n", WM_MSG_LEVEL_DEBUG, level & WM_MSG_CLASS_ALL); + } +} /* wm_lib_set_verbosity */ + +int wm_lib_get_verbosity( void ) +{ + return wm_lib_verbosity; +} + +/* + * wm_lib_message(). + * + * any message that falls into allowed classes and has at least + * verbosity level wm_lib_verbosity & 0xf will be printed. + * + * Usage: + * + * wm_lib_message( WM_MSG_LEVEL | WM_MSG_CLASS, "format", contents); + * + * To simplify the usage, you may simply use WM_MSG_CLASS. It should be + * defined in each module to reflect the correct message class. + * + */ +void wm_lib_message( unsigned int level, const char *fmt, ... ) +{ + va_list ap; + /* verbosity level */ + unsigned int vlevel = wm_lib_verbosity & 0xf; + /* allowed classes */ + unsigned int vclass = (level & WM_MSG_CLASS_ALL) & (wm_lib_verbosity & WM_MSG_CLASS_ALL); + + /* + * just give me the level + */ + level &= 0xf; + if(level <= WM_MSG_LEVEL_NONE) + { + fprintf(stderr, "LibWorkMan warning: A LibWorkMan programmer specified an invalid message level.\n"); + } + /* + * print it only if level and class are allowed. + */ + if( (level <= vlevel) && (vclass != 0) ) + { + fprintf(stderr, "libWorkMan: "); + va_start(ap, fmt); + vfprintf(stderr, fmt, ap); + va_end(ap); + } +} /* wm_lib_message() */ + +/* + * Simulate usleep() using select(). + */ +int +wm_susleep( int usec ) +{ + struct timeval tv; + + timerclear(&tv); + tv.tv_sec = usec / 1000000; + tv.tv_usec = usec % 1000000; + return (select(0, NULL, NULL, NULL, &tv)); +} /* wm_susleep() */ + + |