From e2de64d6f1beb9e492daf5b886e19933c1fa41dd Mon Sep 17 00:00:00 2001 From: toma Date: Wed, 25 Nov 2009 17:56:58 +0000 Subject: Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features. BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdemultimedia@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- kscd/libwm/plat_ultrix.c | 663 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 663 insertions(+) create mode 100644 kscd/libwm/plat_ultrix.c (limited to 'kscd/libwm/plat_ultrix.c') 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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 -- cgit v1.2.1