From a855d6202536ff28e5aae4f22a0f31d8f5b325d0 Mon Sep 17 00:00:00 2001 From: Franklin Wei Date: Sat, 21 Jan 2017 15:18:31 -0500 Subject: Port of Duke Nukem 3D This ports Fabien Sanglard's Chocolate Duke to run on a version of SDL for Rockbox. Change-Id: I8f2c4c78af19de10c1633ed7bb7a997b43256dd9 --- apps/plugins/sdl/src/cdrom/aix/SDL_syscdrom.c | 660 ++++++++++++++++++++++++++ 1 file changed, 660 insertions(+) create mode 100644 apps/plugins/sdl/src/cdrom/aix/SDL_syscdrom.c (limited to 'apps/plugins/sdl/src/cdrom/aix') diff --git a/apps/plugins/sdl/src/cdrom/aix/SDL_syscdrom.c b/apps/plugins/sdl/src/cdrom/aix/SDL_syscdrom.c new file mode 100644 index 0000000000..e7e05585e3 --- /dev/null +++ b/apps/plugins/sdl/src/cdrom/aix/SDL_syscdrom.c @@ -0,0 +1,660 @@ +/* + SDL - Simple DirectMedia Layer + Copyright (C) 1997-2012 Sam Lantinga + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Carsten Griwodz + griff@kom.tu-darmstadt.de + + based on linux/SDL_syscdrom.c by Sam Lantinga +*/ +#include "SDL_config.h" + +#ifdef SDL_CDROM_AIX + +/* Functions for system-level CD-ROM audio control */ + +/*#define DEBUG_CDROM 1*/ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "SDL_cdrom.h" +#include "../SDL_syscdrom.h" + +/* The maximum number of CD-ROM drives we'll detect */ +#define MAX_DRIVES 16 + +/* A list of available CD-ROM drives */ +static char *SDL_cdlist[MAX_DRIVES]; +static dev_t SDL_cdmode[MAX_DRIVES]; + +/* The system-dependent CD control functions */ +static const char *SDL_SYS_CDName(int drive); +static int SDL_SYS_CDOpen(int drive); +static int SDL_SYS_CDGetTOC(SDL_CD *cdrom); +static CDstatus SDL_SYS_CDStatus(SDL_CD *cdrom, int *position); +static int SDL_SYS_CDPlay(SDL_CD *cdrom, int start, int length); +static int SDL_SYS_CDPause(SDL_CD *cdrom); +static int SDL_SYS_CDResume(SDL_CD *cdrom); +static int SDL_SYS_CDStop(SDL_CD *cdrom); +static int SDL_SYS_CDEject(SDL_CD *cdrom); +static void SDL_SYS_CDClose(SDL_CD *cdrom); +static int SDL_SYS_CDioctl(int id, int command, void *arg); + +/* Check a drive to see if it is a CD-ROM */ +static int CheckDrive(char *drive, struct stat *stbuf) +{ + int is_cd; + int cdfd; + int ret; + struct devinfo info; + + /* If it doesn't exist, return -1 */ + if ( stat(drive, stbuf) < 0 ) { + return -1; + } + + /* If it does exist, verify that it's an available CD-ROM */ + is_cd = 0; + if ( S_ISCHR(stbuf->st_mode) || S_ISBLK(stbuf->st_mode) ) { + cdfd = open(drive, (O_RDONLY|O_EXCL|O_NONBLOCK), 0); + if ( cdfd >= 0 ) { + ret = SDL_SYS_CDioctl( cdfd, IOCINFO, &info ); + if ( ret < 0 ) { + /* Some kind of error */ + is_cd = 0; + } else { + if ( info.devtype == DD_CDROM ) { + is_cd = 1; + } else { + is_cd = 0; + } + } + close(cdfd); + } +#ifdef DEBUG_CDROM + else + { + fprintf(stderr, "Could not open drive %s (%s)\n", drive, strerror(errno)); + } +#endif + } + return is_cd; +} + +/* Add a CD-ROM drive to our list of valid drives */ +static void AddDrive(char *drive, struct stat *stbuf) +{ + int i; + + if ( SDL_numcds < MAX_DRIVES ) { + /* Check to make sure it's not already in our list. + This can happen when we see a drive via symbolic link. + */ + for ( i=0; ist_rdev == SDL_cdmode[i] ) { +#ifdef DEBUG_CDROM + fprintf(stderr, "Duplicate drive detected: %s == %s\n", drive, SDL_cdlist[i]); +#endif + return; + } + } + + /* Add this drive to our list */ + i = SDL_numcds; + SDL_cdlist[i] = SDL_strdup(drive); + if ( SDL_cdlist[i] == NULL ) { + SDL_OutOfMemory(); + return; + } + SDL_cdmode[i] = stbuf->st_rdev; + ++SDL_numcds; +#ifdef DEBUG_CDROM + fprintf(stderr, "Added CD-ROM drive: %s\n", drive); +#endif + } +} + +static void CheckMounts() +{ + char* buffer; + int bufsz; + struct vmount* ptr; + int ret; + + buffer = (char*)SDL_malloc(10); + bufsz = 10; + if ( buffer==NULL ) + { + fprintf(stderr, "Could not allocate 10 bytes in aix/SDL_syscdrom.c:CheckMounts\n" ); + exit ( -10 ); + } + + do + { + /* mntctrl() returns an array of all mounted filesystems */ + ret = mntctl ( MCTL_QUERY, bufsz, buffer ); + if ( ret == 0 ) + { + /* Buffer was too small, realloc. */ + bufsz = *(int*)buffer; /* Required size is in first word. */ + /* (whatever a word is in AIX 4.3.3) */ + /* int seems to be OK in 32bit mode. */ + SDL_free(buffer); + buffer = (char*)SDL_malloc(bufsz); + if ( buffer==NULL ) + { + fprintf(stderr, + "Could not allocate %d bytes in aix/SDL_syscdrom.c:CheckMounts\n", + bufsz ); + exit ( -10 ); + } + } + else if ( ret < 0 ) + { +#ifdef DEBUG_CDROM + fprintf(stderr, "Error reading vmount structures\n"); +#endif + return; + } + } + while ( ret == 0 ); + +#ifdef DEBUG_CDROM + fprintf ( stderr, "Read %d vmount structures\n",ret ); +#endif + ptr = (struct vmount*)buffer; + do + { + switch(ptr->vmt_gfstype) + { + case MNT_CDROM : + { + struct stat stbuf; + char* text; + + text = (char*)ptr + ptr->vmt_data[VMT_OBJECT].vmt_off; +#ifdef DEBUG_CDROM + fprintf(stderr, "Checking mount path: %s mounted on %s\n", + text, (char*)ptr + ptr->vmt_data[VMT_STUB].vmt_off ); +#endif + if ( CheckDrive( text, &stbuf) > 0) + { + AddDrive( text, &stbuf); + } + } + break; + default : + break; + } + ptr = (struct vmount*)((char*)ptr + ptr->vmt_length); + ret--; + } + while ( ret > 0 ); + + free ( buffer ); +} + +static int CheckNonmounts() +{ +#ifdef _THREAD_SAFE + AFILE_t fsFile = NULL; + int passNo = 0; + int ret; + struct fstab entry; + struct stat stbuf; + + ret = setfsent_r( &fsFile, &passNo ); + if ( ret != 0 ) return -1; + do + { + ret = getfsent_r ( &entry, &fsFile, &passNo ); + if ( ret == 0 ) { + char* l = SDL_strrchr(entry.fs_spec,'/'); + if ( l != NULL ) { + if ( !SDL_strncmp("cd",++l,2) ) { +#ifdef DEBUG_CDROM + fprintf(stderr, + "Found unmounted CD ROM drive with device name %s\n", + entry.fs_spec); +#endif + if ( CheckDrive( entry.fs_spec, &stbuf) > 0) + { + AddDrive( entry.fs_spec, &stbuf); + } + } + } + } + } + while ( ret == 0 ); + ret = endfsent_r ( &fsFile ); + if ( ret != 0 ) return -1; + return 0; +#else + struct fstab* entry; + struct stat stbuf; + + setfsent(); + do + { + entry = getfsent(); + if ( entry != NULL ) { + char* l = SDL_strrchr(entry->fs_spec,'/'); + if ( l != NULL ) { + if ( !SDL_strncmp("cd",++l,2) ) { +#ifdef DEBUG_CDROM + fprintf(stderr,"Found unmounted CD ROM drive with device name %s", entry->fs_spec); +#endif + if ( CheckDrive( entry->fs_spec, &stbuf) > 0) + { + AddDrive( entry->fs_spec, &stbuf); + } + } + } + } + } + while ( entry != NULL ); + endfsent(); +#endif +} + +int SDL_SYS_CDInit(void) +{ + char *SDLcdrom; + struct stat stbuf; + + /* Fill in our driver capabilities */ + SDL_CDcaps.Name = SDL_SYS_CDName; + SDL_CDcaps.Open = SDL_SYS_CDOpen; + SDL_CDcaps.GetTOC = SDL_SYS_CDGetTOC; + SDL_CDcaps.Status = SDL_SYS_CDStatus; + SDL_CDcaps.Play = SDL_SYS_CDPlay; + SDL_CDcaps.Pause = SDL_SYS_CDPause; + SDL_CDcaps.Resume = SDL_SYS_CDResume; + SDL_CDcaps.Stop = SDL_SYS_CDStop; + SDL_CDcaps.Eject = SDL_SYS_CDEject; + SDL_CDcaps.Close = SDL_SYS_CDClose; + + /* Look in the environment for our CD-ROM drive list */ + SDLcdrom = SDL_getenv("SDL_CDROM"); /* ':' separated list of devices */ + if ( SDLcdrom != NULL ) { + char *cdpath, *delim; + size_t len = SDL_strlen(SDLcdrom)+1; + cdpath = SDL_stack_alloc(char, len); + if ( cdpath != NULL ) { + SDL_strlcpy(cdpath, SDLcdrom, len); + SDLcdrom = cdpath; + do { + delim = SDL_strchr(SDLcdrom, ':'); + if ( delim ) { + *delim++ = '\0'; + } +#ifdef DEBUG_CDROM + fprintf(stderr, "Checking CD-ROM drive from SDL_CDROM: %s\n", SDLcdrom); +#endif + if ( CheckDrive(SDLcdrom, &stbuf) > 0 ) { + AddDrive(SDLcdrom, &stbuf); + } + if ( delim ) { + SDLcdrom = delim; + } else { + SDLcdrom = NULL; + } + } while ( SDLcdrom ); + SDL_stack_free(cdpath); + } + + /* If we found our drives, there's nothing left to do */ + if ( SDL_numcds > 0 ) { + return(0); + } + } + + CheckMounts(); + CheckNonmounts(); + + return 0; +} + +/* General ioctl() CD-ROM command function */ +static int SDL_SYS_CDioctl(int id, int command, void *arg) +{ + int retval; + + retval = ioctl(id, command, arg); + if ( retval < 0 ) { + SDL_SetError("ioctl() error: %s", strerror(errno)); + } + return retval; +} + +static const char *SDL_SYS_CDName(int drive) +{ + return(SDL_cdlist[drive]); +} + +static int SDL_SYS_CDOpen(int drive) +{ + int fd; + char* lastsl; + char* cdromname; + size_t len; + + /* + * We found /dev/cd? drives and that is in our list. But we can + * open only the /dev/rcd? versions of those devices for Audio CD. + */ + len = SDL_strlen(SDL_cdlist[drive])+2; + cdromname = (char*)SDL_malloc(len); + SDL_strlcpy(cdromname,SDL_cdlist[drive],len); + lastsl = SDL_strrchr(cdromname,'/'); + if (lastsl) { + *lastsl = 0; + SDL_strlcat(cdromname,"/r",len); + lastsl = SDL_strrchr(SDL_cdlist[drive],'/'); + if (lastsl) { + lastsl++; + SDL_strlcat(cdromname,lastsl,len); + } + } + +#ifdef DEBUG_CDROM + fprintf(stderr, "Should open drive %s, opening %s\n", SDL_cdlist[drive], cdromname); +#endif + + /* + * Use exclusive access. Don't use SC_DIAGNOSTICS as xmcd does because they + * require root priviledges, and we don't want that. SC_SINGLE provides + * exclusive access with less trouble. + */ + fd = openx(cdromname, O_RDONLY, NULL, SC_SINGLE); + if ( fd < 0 ) + { +#ifdef DEBUG_CDROM + fprintf(stderr, "Could not open drive %s (%s)\n", cdromname, strerror(errno)); +#endif + } + else + { + struct mode_form_op cdMode; + int ret; +#ifdef DEBUG_CDROM + cdMode.action = CD_GET_MODE; + ret = SDL_SYS_CDioctl(fd, DK_CD_MODE, &cdMode); + if ( ret < 0 ) { + fprintf(stderr, + "Could not get drive mode for %s (%s)\n", + cdromname, strerror(errno)); + } else { + switch(cdMode.cd_mode_form) { + case CD_MODE1 : + fprintf(stderr, + "Drive mode for %s is %s\n", + cdromname, "CD-ROM Data Mode 1"); + break; + case CD_MODE2_FORM1 : + fprintf(stderr, + "Drive mode for %s is %s\n", + cdromname, "CD-ROM XA Data Mode 2 Form 1"); + break; + case CD_MODE2_FORM2 : + fprintf(stderr, + "Drive mode for %s is %s\n", + cdromname, "CD-ROM XA Data Mode 2 Form 2"); + break; + case CD_DA : + fprintf(stderr, + "Drive mode for %s is %s\n", + cdromname, "CD-DA"); + break; + default : + fprintf(stderr, + "Drive mode for %s is %s\n", + cdromname, "unknown"); + break; + } + } +#endif + + cdMode.action = CD_CHG_MODE; + cdMode.cd_mode_form = CD_DA; + ret = SDL_SYS_CDioctl(fd, DK_CD_MODE, &cdMode); + if ( ret < 0 ) { +#ifdef DEBUG_CDROM + fprintf(stderr, + "Could not set drive mode for %s (%s)\n", + cdromname, strerror(errno)); +#endif + SDL_SetError("ioctl() error: Could not set CD drive mode, %s", + strerror(errno)); + } else { +#ifdef DEBUG_CDROM + fprintf(stderr, + "Drive mode for %s set to CD_DA\n", + cdromname); +#endif + } + } + SDL_free(cdromname); + return fd; +} + +static int SDL_SYS_CDGetTOC(SDL_CD *cdrom) +{ + struct cd_audio_cmd cmd; + struct cd_audio_cmd entry; + int i; + int okay; + + cmd.audio_cmds = CD_TRK_INFO_AUDIO; + cmd.msf_flag = FALSE; + if ( SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &cmd) < 0 ) { + return -1; + } + + okay = 0; + cdrom->numtracks = cmd.indexing.track_index.last_track + - cmd.indexing.track_index.first_track+1; + if ( cdrom->numtracks > SDL_MAX_TRACKS ) { + cdrom->numtracks = SDL_MAX_TRACKS; + } + + /* Read all the track TOC entries */ + for ( i=0; i<=cdrom->numtracks; ++i ) { + if ( i == cdrom->numtracks ) { + cdrom->track[i].id = 0xAA;; + } else { + cdrom->track[i].id = cmd.indexing.track_index.first_track+i; + } + entry.audio_cmds = CD_GET_TRK_MSF; + entry.indexing.track_msf.track = cdrom->track[i].id; + if ( SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &entry) < 0 ) { + break; + } else { + cdrom->track[i].type = 0; /* don't know how to detect 0x04 data track */ + cdrom->track[i].offset = MSF_TO_FRAMES( + entry.indexing.track_msf.mins, + entry.indexing.track_msf.secs, + entry.indexing.track_msf.frames); + cdrom->track[i].length = 0; + if ( i > 0 ) { + cdrom->track[i-1].length = cdrom->track[i].offset + - cdrom->track[i-1].offset; + } + } + } + if ( i == (cdrom->numtracks+1) ) { + okay = 1; + } + return(okay ? 0 : -1); +} + +/* Get CD-ROM status */ +static CDstatus SDL_SYS_CDStatus(SDL_CD *cdrom, int *position) +{ + CDstatus status; + struct cd_audio_cmd cmd; + cmd.audio_cmds = CD_INFO_AUDIO; + + if ( SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &cmd) < 0 ) { +#ifdef DEBUG_CDROM + fprintf(stderr, "ioctl failed in SDL_SYS_CDStatus (%s)\n", SDL_GetError()); +#endif + status = CD_ERROR; + } else { + switch (cmd.status) { + case CD_NO_AUDIO: + case CD_COMPLETED: + status = CD_STOPPED; + break; + case CD_PLAY_AUDIO: + status = CD_PLAYING; + break; + case CD_PAUSE_AUDIO: + status = CD_PAUSED; + break; + case CD_NOT_VALID: +#ifdef DEBUG_CDROM + fprintf(stderr, "cdStatus failed with CD_NOT_VALID\n"); +#endif + status = CD_ERROR; + break; + case CD_STATUS_ERROR: +#ifdef DEBUG_CDROM + fprintf(stderr, "cdStatus failed with CD_STATUS_ERROR\n"); +#endif + status = CD_ERROR; + break; + default: +#ifdef DEBUG_CDROM + fprintf(stderr, "cdStatus failed with unknown error\n"); +#endif + status = CD_ERROR; + break; + } + } + if ( position ) { + if ( status == CD_PLAYING || (status == CD_PAUSED) ) { + *position = MSF_TO_FRAMES( cmd.indexing.info_audio.current_mins, + cmd.indexing.info_audio.current_secs, + cmd.indexing.info_audio.current_frames); + } else { + *position = 0; + } + } + return status; +} + +/* Start play */ +static int SDL_SYS_CDPlay(SDL_CD *cdrom, int start, int length) +{ + struct cd_audio_cmd cmd; + + /* + * My CD Rom is muted by default. I think I read that this is new with + * AIX 4.3. SDL does not change the volume, so I need a kludge. Maybe + * its better to do this elsewhere? + */ + cmd.audio_cmds = CD_PLAY_AUDIO | CD_SET_VOLUME; + cmd.msf_flag = TRUE; + FRAMES_TO_MSF(start, + &cmd.indexing.msf.first_mins, + &cmd.indexing.msf.first_secs, + &cmd.indexing.msf.first_frames); + FRAMES_TO_MSF(start+length, + &cmd.indexing.msf.last_mins, + &cmd.indexing.msf.last_secs, + &cmd.indexing.msf.last_frames); + cmd.volume_type = CD_VOLUME_ALL; + cmd.all_channel_vol = 255; /* This is a uchar. What is a good value? No docu! */ + cmd.out_port_0_sel = CD_AUDIO_CHNL_0; + cmd.out_port_1_sel = CD_AUDIO_CHNL_1; + cmd.out_port_2_sel = CD_AUDIO_CHNL_2; + cmd.out_port_3_sel = CD_AUDIO_CHNL_3; + +#ifdef DEBUG_CDROM + fprintf(stderr, "Trying to play from %d:%d:%d to %d:%d:%d\n", + cmd.indexing.msf.first_mins, + cmd.indexing.msf.first_secs, + cmd.indexing.msf.first_frames, + cmd.indexing.msf.last_mins, + cmd.indexing.msf.last_secs, + cmd.indexing.msf.last_frames); +#endif + return(SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &cmd)); +} + +/* Pause play */ +static int SDL_SYS_CDPause(SDL_CD *cdrom) +{ + struct cd_audio_cmd cmd; + cmd.audio_cmds = CD_PAUSE_AUDIO; + return(SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &cmd)); +} + +/* Resume play */ +static int SDL_SYS_CDResume(SDL_CD *cdrom) +{ + struct cd_audio_cmd cmd; + cmd.audio_cmds = CD_RESUME_AUDIO; + return(SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &cmd)); +} + +/* Stop play */ +static int SDL_SYS_CDStop(SDL_CD *cdrom) +{ + struct cd_audio_cmd cmd; + cmd.audio_cmds = CD_STOP_AUDIO; + return(SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &cmd)); +} + +/* Eject the CD-ROM */ +static int SDL_SYS_CDEject(SDL_CD *cdrom) +{ + return(SDL_SYS_CDioctl(cdrom->id, DKEJECT, 0)); +} + +/* Close the CD-ROM handle */ +static void SDL_SYS_CDClose(SDL_CD *cdrom) +{ + close(cdrom->id); +} + +void SDL_SYS_CDQuit(void) +{ + int i; + + if ( SDL_numcds > 0 ) { + for ( i=0; i