/*
* Open and initialize an audio port.
*/
static ALport sfxInitAudioPort(int init) {
ALport ap;
ALconfig audioPortConfig;
long pvbuf[6];
if (init) {
pvbuf[0] = AL_LEFT_SPEAKER_GAIN;
pvbuf[2] = AL_RIGHT_SPEAKER_GAIN;
pvbuf[4] = AL_OUTPUT_RATE;
ALgetparams(AL_DEFAULT_DEVICE, pvbuf, 6L);
currLeftGain = origLeftGain = pvbuf[1];
currRightGain = origRightGain = pvbuf[3];
origOutputRate = pvbuf[5];
sfxSetGainIndex((origLeftGain+origRightGain)/2);
}
/*
* Configure and open audio port.
*/
audioPortConfig = ALnewconfig();
ALsetwidth(audioPortConfig, AL_SAMPLE_16);
ALsetchannels(audioPortConfig, AL_STEREO);
ALsetqueuesize(audioPortConfig, 16000);
ap = ALopenport("spacetrek", "w", audioPortConfig);
ALfreeconfig(audioPortConfig);
return ap;
}
static int
open_audio_port (AudioContext return_ac, AudioContext desc)
{
ALconfig config = ALnewconfig();
long params[2];
adjust_audio_volume (& desc->device);
return_ac->ac_left_speaker_gain = desc->ac_left_speaker_gain;
return_ac->ac_right_speaker_gain = desc->ac_right_speaker_gain;
params[0] = AL_OUTPUT_RATE;
params[1] = desc->ac_output_rate;
ALsetparams (desc->ac_device, params, 2);
return_ac->ac_output_rate = desc->ac_output_rate;
if (set_channels (config, desc->ac_nchan)==-1)
return -1;
return_ac->ac_nchan = desc->ac_nchan;
if (set_output_format (config, desc->ac_format)==-1)
return -1;
return_ac->ac_format = desc->ac_format;
ALsetqueuesize (config, (long) CHUNKSIZE);
return_ac->ac_port = ALopenport("XEmacs audio output", "w", config);
ALfreeconfig (config);
if (return_ac->ac_port==0)
{
report_file_error ("Opening audio output port", Qnil);
return -1;
}
return 0;
}
/**
* Start recording.
*
* @param pathname [in] path name to open or NULL for default
*
* @return TRUE on success, FALSE on failure.
*/
boolean
adin_mic_begin(char *pathname)
{
/* open audio port */
if (pathname != NULL) {
jlog("Stat: adin_o2: opening audio device \"%s\"\n", pathname);
aport = ALopenport(pathname,"r",ac);
} else {
aport = ALopenport("mic","r",ac);
}
if (aport == (ALport)(0)) {
jlog("Error: adin_o2: cannot open microphone audio port for reading\n");
return(FALSE);
}
return(TRUE);
}
int sound_init()
{
long pvbuf[2];
pvbuf[0] = AL_OUTPUT_COUNT;
pvbuf[2] = AL_MONITOR_CTL;
if (ALgetparams(AL_DEFAULT_DEVICE, pvbuf, 4) < 0)
{
fprintf(stderr,"sound driver : No audio hardware\n");
return 0;
}
pvbuf[0] = AL_OUTPUT_RATE;
pvbuf[1] = 11025;
if (ALsetparams(AL_DEFAULT_DEVICE,pvbuf,4) < 0)
{
fprintf(stderr,"sound driver : Could not set sample rate\n");
return 0;
}
ALseterrorhandler(0);
audioconfig = ALnewconfig();
if (!audioconfig)
{
fprintf(stderr,"failed to create audio config\n");
return 0;
}
else if (ALsetchannels(audioconfig,AL_MONO))
{ fprintf(stderr,"sound driver : could not set audio channels\n");
return 0;
}
else if (ALsetqueuesize(audioconfig,BUF_SIZE))
{
fprintf(stderr,"sound driver : could not set audio que size\n");
ALfreeconfig(audioconfig);
return 0;
} else if (ALsetwidth (audioconfig, AL_SAMPLE_8))
{
fprintf(stderr,"sound driver :could not set 8 bit samples\n");
ALfreeconfig(audioconfig);
return 0;
}
audioport=ALopenport("Abuse sound driver","w",audioconfig);
if (!audioport)
{
fprintf(stderr,"sound driver : could not open audio port\n");
ALfreeconfig(audioconfig);
return 0;
}
int i=0,j;
uchar *vd=volume_table;
for (;i<32;i++)
{
for (j=0;j<256;j++,vd++)
*vd=(j-128)*i/31+128;
}
return 1;
}
static int sgi_init(const char *param, int *speed, int *fragsize, int *fragnr, int *channels)
{
long chpars[] = { AL_OUTPUT_RATE, 0 };
int st;
/* No stereo capability. */
*channels = 1;
ALseterrorhandler(sgi_errorhandler);
chpars[1] = *speed;
st = ALsetparams(AL_DEFAULT_DEVICE, chpars, 2);
if (st < 0) {
return 1;
}
st = ALgetparams(AL_DEFAULT_DEVICE, chpars, 2);
if (st < 0) {
return 1;
}
*speed = chpars[1];
sgi_audioconfig = ALnewconfig();
if (!sgi_audioconfig) {
return 1;
}
st = ALsetchannels(sgi_audioconfig, AL_MONO);
if (st < 0) {
goto fail;
}
st = ALsetwidth(sgi_audioconfig, AL_SAMPLE_16);
if (st < 0) {
goto fail;
}
st = ALsetqueuesize(sgi_audioconfig, *fragsize * *fragnr);
if (st < 0) {
goto fail;
}
sgi_audioport = ALopenport("outport", "w", sgi_audioconfig);
if (!sgi_audioport) {
goto fail;
}
return 0;
fail:
ALfreeconfig(sgi_audioconfig);
sgi_audioconfig = NULL;
return 1;
}
FileDescriptor InitAudio(ALport *alpp) {
/* initialize audio driver
for 16-bit 44100kHz monophonic sample source to DACs */
ALconfig alc;
alc = ALnewconfig();
ALsetwidth (alc, AL_SAMPLE_16);
ALsetqueuesize (alc, OUTPUTQUEUESIZE);
ALsetchannels(alc, (long)1);
*alpp = ALopenport("obuf", "w", alc);
{
long pvbuf[2];
long pvlen=2;
pvbuf[0] = AL_OUTPUT_RATE;
pvbuf[1] = AL_RATE_44100;
ALsetparams(AL_DEFAULT_DEVICE, pvbuf, pvlen);
the_sample_rate = 44100.0f;
}
/* obtain a file descriptor associated with sound output port */
return ALgetfd(*alpp);
}
int esd_audio_open()
{
ALconfig audioconfig;
audioconfig = ALnewconfig();
rate_params[1] = esd_audio_rate;
rate_params[3] = esd_audio_rate;
if (!audioconfig) {
printf( "Couldn't initialize new audio config\n" );
esd_audio_fd = -1;
return esd_audio_fd;
} else {
long pvbuf[] = { AL_OUTPUT_COUNT, 0,
AL_MONITOR_CTL, 0,
AL_OUTPUT_RATE, 0 };
if (ALgetparams(AL_DEFAULT_DEVICE, pvbuf, 6) < 0)
if (oserror() == AL_BAD_DEVICE_ACCESS) {
esd_audio_fd = -1;
return esd_audio_fd;
}
if (pvbuf[1] == 0 && pvbuf[3] == AL_MONITOR_OFF) {
ALsetparams(AL_DEFAULT_DEVICE, rate_params, 2);
} else
if (pvbuf[5] != esd_audio_rate) {
printf("audio device is already in use with wrong sample output rate\n");
esd_audio_fd = -1;
return esd_audio_fd;
}
/* ALsetsampfmt(audioconfig, AL_SAMPFMT_TWOSCOMP); this is the default */
/* ALsetwidth(audioconfig, AL_SAMPLE_16); this is the default */
if ( (esd_audio_format & ESD_MASK_CHAN) == ESD_MONO)
ALsetchannels(audioconfig, AL_MONO);
/* else ALsetchannels(audioconfig, AL_STEREO); this is the default */
ALsetqueuesize(audioconfig, ESD_BUF_SIZE * 2);
outaudioport = ALopenport("esd", "w", audioconfig);
if (outaudioport == (ALport) 0) {
switch (oserror()) {
case AL_BAD_NO_PORTS:
printf( "system is out of ports\n");
esd_audio_fd = -1;
return esd_audio_fd;
break;
case AL_BAD_DEVICE_ACCESS:
printf("couldn't access audio device\n");
esd_audio_fd = -1;
return esd_audio_fd;
break;
case AL_BAD_OUT_OF_MEM:
printf("out of memory\n");
esd_audio_fd = -1;
return esd_audio_fd;
break;
}
/* don't know how we got here, but it must be bad */
esd_audio_fd = -1;
return esd_audio_fd;
}
ALsetfillpoint(outaudioport, ESD_BUF_SIZE);
esd_audio_fd = ALgetfd(outaudioport);
/*
* If we are recording, open a second port to read from
* and return that fd instead
*/
if ( (esd_audio_format & ESD_MASK_FUNC) == ESD_RECORD ) {
inaudioport = ALopenport("esd", "r", audioconfig);
if (inaudioport == (ALport) 0) {
switch (oserror()) {
case AL_BAD_NO_PORTS:
printf( "system is out of ports\n");
esd_audio_fd = -1;
return esd_audio_fd;
break;
case AL_BAD_DEVICE_ACCESS:
printf("couldn't access audio device\n");
esd_audio_fd = -1;
return esd_audio_fd;
break;
case AL_BAD_OUT_OF_MEM:
printf("out of memory\n");
esd_audio_fd = -1;
return esd_audio_fd;
break;
default:
printf( "Unknown error opening port\n" );
}
/* don't know how we got here, but it must be bad */
esd_audio_fd = -1;
return esd_audio_fd;
}
ALsetfillpoint(inaudioport, ESD_BUF_SIZE);
ALsetparams(AL_DEFAULT_DEVICE, (rate_params + 2), 2);
esd_audio_fd = ALgetfd(inaudioport);
}
}
return esd_audio_fd;
}
void *Audio_Irix::open (AudioConfig& cfg, const char *)
{
// Copy input parameters. May later be replaced with driver defaults.
_settings = cfg;
_config = ALnewconfig();
// Set sample format
ALsetsampfmt(_config, AL_SAMPFMT_TWOSCOMP);
// stereo or mono mode
_settings.channels = cfg.channels >= 2 ? 2 : 1;
if (_settings.channels == 2)
ALsetchannels(_config, AL_STEREO);
else
ALsetchannels(_config, AL_MONO);
// 16 or 8 bit sample
_settings.precision = cfg.precision >= 16 ? 16 : 8;
if (_settings.precision == 16)
ALsetwidth(_config, AL_SAMPLE_16);
else
ALsetwidth(_config, AL_SAMPLE_8);
// Frequency
long chpars[] = {AL_OUTPUT_RATE, 0};
if (cfg.frequency > 48000)
chpars[1] = AL_RATE_48000;
else if (cfg.frequency > 44100)
chpars[1] = AL_RATE_44100;
else if (cfg.frequency > 32000)
chpars[1] = AL_RATE_32000;
else if (cfg.frequency > 22050)
chpars[1] = AL_RATE_22050;
else if (cfg.frequency > 16000)
chpars[1] = AL_RATE_16000;
else
chpars[1] = AL_RATE_11025;
ALsetparams(AL_DEFAULT_DEVICE, chpars, 2);
ALgetparams(AL_DEFAULT_DEVICE, chpars, 2);
_settings.frequency = (uint_least32_t) chpars[1];
// Allocate sound buffers and set audio queue
ALsetqueuesize(_config, chpars[1]);
// open audio device
_audio = ALopenport("SIDPLAY2 sound", "w", _config);
if (_audio == NULL)
{
perror("AUDIO:");
_errorString = "ERROR: Could not open audio device.\n See standard error output.";
ALfreeconfig(_config);
return 0;
}
// Setup internal Config
_settings.encoding = AUDIO_SIGNED_PCM;
_settings.bufSize = (uint_least32_t) chpars[1];
// Update the users settings
getConfig (cfg);
// Allocate memory same size as buffer
#ifdef HAVE_EXCEPTIONS
_sampleBuffer = new(std::nothrow) int_least8_t[chpars[1]];
#else
_sampleBuffer = new int_least8_t[chpars[1]];
#endif
_errorString = "OK";
return (void *) _sampleBuffer;
}
static int setaudio(struct xmp_options *o)
{
int bsize = 32 * 1024;
ALconfig config;
long pvbuffer[2];
char *token, **parm;
int i;
parm_init();
chkparm1("buffer", bsize = strtoul(token, NULL, 0));
parm_end();
if ((config = ALnewconfig()) == 0)
return XMP_ERR_DINIT;
/*
* Set sampling rate
*/
pvbuffer[0] = AL_OUTPUT_RATE;
#if 0 /* DOESN'T WORK */
for (i = 0; srate[i]; i++) {
if (srate[i] <= o->freq)
pvbuffer[1] = o->freq = srate[i];
}
#endif /* DOESN'T WORK */
/*
* This was flawed as far as I can tell - it just progressively lowered
* the sample rate to the lowest possible!
*
* o->freq = 44100
*
* i = 0 / if (48000 <= 44100)
* i = 1 / if (44100 <= 44100)
* then pvbuffer[1] = o->freq = 44100
* i = 2 / if (32000 <= 44100)
* then pvbuffer[1] = o->freq = 32000
* i = 3 / if (22050 <= 32000)
* then pvbuffer[1] = o->freq = 22050
* etc...
*
* Below is my attempt to write a new one. It picks the next highest
* rate available up to the maximum. This seems a lot more reasonable.
*
* - 19990706 bdowning
*/
for (i = 0; srate[i]; i++) ; /* find the end of the array */
while (i-- > 0) {
if (srate[i] >= o->freq) {
pvbuffer[1] = o->freq = srate[i];
break;
}
}
if (i == 0)
pvbuffer[1] = o->freq = srate[0]; /* 48 kHz. Wow! */
if (ALsetparams(AL_DEFAULT_DEVICE, pvbuffer, 2) < 0)
return XMP_ERR_DINIT;
/*
* Set sample format to signed integer
*/
if (ALsetsampfmt(config, AL_SAMPFMT_TWOSCOMP) < 0)
return XMP_ERR_DINIT;
/*
* Set sample width; 24 bit samples are not currently supported by xmp
*/
if (o->resol > 8) {
if (ALsetwidth(config, AL_SAMPLE_16) < 0) {
if (ALsetwidth(config, AL_SAMPLE_8) < 0)
return XMP_ERR_DINIT;
o->resol = 8;
} else
al_sample_16 = 1;
} else {
if (ALsetwidth(config, AL_SAMPLE_8) < 0) {
if (ALsetwidth(config, AL_SAMPLE_16) < 0)
return XMP_ERR_DINIT;
o->resol = 16;
} else
al_sample_16 = 0;
}
/*
* Set number of channels; 4 channel output is not currently supported
*/
if (o->outfmt & XMP_FMT_MONO) {
if (ALsetchannels(config, AL_MONO) < 0) {
if (ALsetchannels(config, AL_STEREO) < 0)
return XMP_ERR_DINIT;
o->outfmt &= ~XMP_FMT_MONO;
}
} else {
if (ALsetchannels(config, AL_STEREO) < 0) {
if (ALsetchannels(config, AL_MONO) < 0)
return XMP_ERR_DINIT;
o->outfmt |= XMP_FMT_MONO;
}
}
/*
* Set buffer size
*/
if (ALsetqueuesize(config, bsize) < 0)
return XMP_ERR_DINIT;
/*
* Open the audio port
*/
if ((audio_port = ALopenport("xmp", "w", config)) == 0)
return XMP_ERR_DINIT;
return 0;
}
int main(int argc, char **argv)
{
iso_primary_descriptor_type ipd;
char *dev = default_dev;
char vendor[9],model[17],rev[5];
unsigned char reply[1024];
char tmpstr[255];
int replylen=sizeof(reply);
int trackno = 0;
int info_only = 0;
unsigned char *buffer;
int buffersize = READBLOCKS*BLOCKSIZE;
int start,stop,imagesize=0,tracksize=0;
int counter = 0;
long readsize = 0;
long imagesize_bytes = 0;
int drive_block_size, init_bsize;
int force_mode = 0;
int scanbus_mode = 0;
int dump_start, dump_count;
MD5_CTX *MD5;
char digest[16],digest_text[33];
int md5_mode = 0;
int opt_index = 0;
int audio_track = 0;
int readblocksize = BLOCKSIZE;
int file_format = AF_FILE_AIFFC;
#ifdef IRIX
CDPARSER *cdp = CDcreateparser();
CDFRAME cdframe;
#endif
int dev_type;
int i,c,o;
int len;
int start_time,cur_time,kbps;
if (rcsid);
MD5 = malloc(sizeof(MD5_CTX));
buffer=(unsigned char*)malloc(READBLOCKS*AUDIOBLOCKSIZE);
if (!buffer || !MD5) die("No memory");
if (argc<2) die("parameter(s) missing\n"
"Try '%s --help' for more information.\n",PRGNAME);
/* parse command line parameters */
while(1) {
if ((c=getopt_long(argc,argv,"SMmvhid:",long_options,&opt_index))
== -1) break;
switch (c) {
case 'a':
file_format=AF_FILE_AIFF;
break;
case 'A':
file_format=AF_FILE_AIFFC;
break;
case 'v':
verbose_mode=1;
break;
case 'h':
p_usage();
break;
case 'd':
dev=strdup(optarg);
break;
case 't':
if (sscanf(optarg,"%d",&trackno)!=1) trackno=0;
break;
case 'i':
info_only=1;
break;
case 'c':
if (sscanf(optarg,"%d,%d",&dump_start,&dump_count)!=2)
die("invalid parameters");
dump_mode=1;
break;
#ifdef IRIX
case 'C':
if (sscanf(optarg,"%d,%d",&dump_start,&dump_count)!=2)
die("invalid parameters");
dump_mode=2;
break;
#endif
case 'f':
if (sscanf(optarg,"%d",&force_mode)!=1) die("invalid parameters");
if (force_mode<1 || force_mode >2) {
die("invalid parameters");
}
break;
case 'm':
md5_mode=1;
break;
case 'M':
md5_mode=2;
break;
case 's':
audio_mode=1;
break;
case 'S':
scanbus_mode=1;
break;
case 'V':
printf(PRGNAME " " VERSION " " HOST_TYPE
"\nCopyright (c) Timo Kokkonen, 1997-1998.\n\n");
exit(0);
break;
case '?':
break;
default:
die("error parsing parameters");
}
}
if (!info_only) {
if (md5_mode==2) outfile=fopen("/dev/null","w");
else outfile=fopen(argv[optind],"w");
if (!outfile) {
if (argv[optind]) die("cannot open output file '%s'",argv[optind]);
info_only=1;
}
}
printf("readiso(9660) " VERSION "\n");
/* open the scsi device */
if (scsi_open(dev)) die("error opening scsi device '%s'",dev);
if (scanbus_mode) {
printf("\n");
scan_bus();
exit(0);
}
memset(reply,0,sizeof(reply));
if ((dev_type=inquiry(vendor,model,rev))<0)
die("error accessing scsi device");
if (verbose_mode) {
printf("device: %s\n",dev);
printf("Vendor: %s\nModel: %s\nRevision: %s\n",vendor,model,rev);
}
if ( (dev_type&0x1f) != 0x5 ) {
die("Device doesn't seem to be a CD-ROM!");
}
#ifdef IRIX
if (strcmp(vendor,"TOSHIBA")) {
warn("NOTE! Audio track reading probably not supported on this device.\n");
}
#endif
test_ready();
if (test_ready()!=0) {
sleep(2);
if (test_ready()!=0) die("device not ready");
}
fprintf(stderr,"Initializing...\n");
if (audio_mode) {
#ifdef IRIX
audioport=ALopenport("readiso","w",0);
if (!audioport) {
warn("Cannot initialize audio.");
audio_mode=0;
}
#else
audio_mode=0;
#endif
}
#ifdef IRIX
/* Make sure we get sane underflow exception handling */
sigfpe_[_UNDERFL].repls = _ZERO;
handle_sigfpes(_ON, _EN_UNDERFL, NULL, _ABORT_ON_ERROR, NULL);
#endif
/* set_removable(1); */
#if 0
replylen=255;
if (mode_sense10(reply,&replylen)==0) {
printf("replylen=%d blocks=%d blocklen=%d\n",replylen,
V3(&reply[8+1]),V3(&reply[8+5]));
PRINT_BUF(reply,replylen);
}
replylen=255; /* sizeof(reply); */
if (mode_sense(reply,&replylen)==0) {
printf("replylen=%d blocks=%d blocklen=%d\n",replylen,
V3(&reply[4+1]),V3(&reply[4+5]));
PRINT_BUF(reply,replylen);
}
#endif
if (dump_mode==2) init_bsize=AUDIOBLOCKSIZE;
else init_bsize=BLOCKSIZE;
start_stop(0);
if ( (drive_block_size=get_block_size()) < 0 ) {
warn("cannot get current block size");
drive_block_size=init_bsize;
}
if (drive_block_size != init_bsize) {
mode_select(init_bsize,(dump_mode==2?0x82:0x00));
drive_block_size=get_block_size();
if (drive_block_size!=init_bsize) warn("cannot set drive block size.");
}
start_stop(1);
if (dump_mode && !info_only) {
#ifdef IRIX
CDFRAME buf;
if (dump_mode==2) {
if (cdp) {
CDaddcallback(cdp, cd_audio, (CDCALLBACKFUNC)playaudio, 0);
} else die("No audioparser");
}
#endif
fprintf(stderr,"Dumping %d sector(s) starting from LBA=%d\n",
dump_count,dump_start);
for (i=dump_start;i<dump_start+dump_count;i++) {
len=buffersize;
read_10(i,1,buffer,&len);
if (len<init_bsize) break;
#ifdef IRIX
if (dump_mode==2) {
memcpy(&buf,buffer,CDDA_BLOCKSIZE);
CDparseframe(cdp,&buf);
}
#endif
fwrite(buffer,len,1,outfile);
fprintf(stderr,".");
}
fprintf(stderr,"\ndone.\n");
goto quit;
}
fprintf(stderr,"Reading disc TOC...");
replylen=sizeof(reply);
read_toc(reply,&replylen,verbose_mode);
printf("\n");
if (trackno==0) { /* try to find first data track */
for (i=0;i<(reply[3]-reply[2]+1);i++) {
o=4+i*8;
if (reply[o+1]&DATA_TRACK) { trackno=i+1; break; }
}
if (trackno==0) die("No data track(s) found.");
}
fprintf(stderr,"Reading track %d...\n",trackno);
if ( (trackno < reply[2]) || (trackno > reply[3]) )
die("Invalid track specified.");
if ( ((reply[(trackno-1)*8+4+1]&DATA_TRACK)==0) ) {
fprintf(stderr,"Not a data track.\n");
mode_select(AUDIOBLOCKSIZE,0x82);
if (mode_sense(reply,&replylen)!=0) die("cannot get sense data");
drive_block_size=V3(&reply[9]);
fprintf(stderr,"Selecting CD-DA mode, output file format: %s\n",
file_format==AF_FILE_AIFFC?"AIFFC":"AIFF");
audio_track=1;
} else {
audio_track=0;
}
start=V4(&reply[(trackno-1)*8+4+4]);
stop=V4(&reply[(trackno)*8+4+4]);
tracksize=abs(stop-start);
/* if (verbose_mode) printf("Start LBA=%d\nStop LBA=%d\n",start,stop); */
len=buffersize;
read_10(start-0,1,buffer,&len);
/* PRINT_BUF(buffer,32); */
if (!audio_track) {
/* read the iso9660 primary descriptor */
fprintf(stderr,"Reading ISO9660 primary descriptor...\n");
len=buffersize;
read_10(start+16,1,buffer,&len);
if (len<sizeof(ipd)) die("cannot read iso9660 primary descriptor.");
memcpy(&ipd,buffer,sizeof(ipd));
imagesize=ISONUM(ipd.volume_space_size);
/* we should really check here if we really got a valid primary
descriptor or not... */
if ( (imagesize>(stop-start)) || (imagesize<1) ) {
fprintf(stderr,"\aInvalid ISO primary descriptor!!!\n");
if (!info_only) fprintf(stderr,"Copying entire track to image file.\n");
force_mode=2;
}
if (force_mode==1) {} /* use size from ISO primary descriptor */
else if (force_mode==2) imagesize=tracksize; /* use size from TOC */
else {
if ( ( (tracksize-imagesize) > MAX_DIFF_ALLOWED ) ||
( imagesize > tracksize ) ) {
fprintf(stderr,"ISO primary descriptor has suspicious volume size"
" (%d blocks)\n",imagesize);
imagesize=tracksize;
fprintf(stderr,
"Using track size from TOC record (%d blocks) instead.\n",
imagesize);
fprintf(stderr,
"(option -f can be used to override this behaviour.)\n");
}
}
imagesize_bytes=imagesize*BLOCKSIZE;
if (verbose_mode||info_only) {
printf("ISO9660 image info:\n");
printf("Type: %02xh\n",ipd.type[0]);
ISOGETSTR(tmpstr,ipd.id,5);
printf("ID: %s\n",tmpstr);
printf("Version: %u\n",ipd.version[0]);
ISOGETSTR(tmpstr,ipd.system_id,32);
printf("System id: %s\n",tmpstr);
ISOGETSTR(tmpstr,ipd.volume_id,32);
printf("Volume id: %s\n",tmpstr);
ISOGETSTR(tmpstr,ipd.volume_set_id,128);
if (strlen(tmpstr)>0) printf("Volume set id: %s\n",tmpstr);
ISOGETSTR(tmpstr,ipd.publisher_id,128);
if (strlen(tmpstr)>0) printf("Publisher id: %s\n",tmpstr);
ISOGETSTR(tmpstr,ipd.preparer_id,128);
if (strlen(tmpstr)>0) printf("Preparer id: %s\n",tmpstr);
ISOGETSTR(tmpstr,ipd.application_id,128);
if (strlen(tmpstr)>0) printf("Application id: %s\n",tmpstr);
ISOGETDATE(tmpstr,ipd.creation_date);
printf("Creation date: %s\n",tmpstr);
ISOGETDATE(tmpstr,ipd.modification_date);
if (!NULLISODATE(ipd.modification_date))
printf("Modification date: %s\n",tmpstr);
ISOGETDATE(tmpstr,ipd.expiration_date);
if (!NULLISODATE(ipd.expiration_date))
printf("Expiration date: %s\n",tmpstr);
ISOGETDATE(tmpstr,ipd.effective_date);
if (!NULLISODATE(ipd.effective_date))
printf("Effective date: %s\n",tmpstr);
printf("Image size: %02d:%02d:%02d, %d blocks (%ld bytes)\n",
LBA_MIN(ISONUM(ipd.volume_space_size)),
LBA_SEC(ISONUM(ipd.volume_space_size)),
LBA_FRM(ISONUM(ipd.volume_space_size)),
ISONUM(ipd.volume_space_size),
(long)ISONUM(ipd.volume_space_size)*BLOCKSIZE
);
printf("Track size: %02d:%02d:%02d, %d blocks (%ld bytes)\n",
LBA_MIN(tracksize),
LBA_SEC(tracksize),
LBA_FRM(tracksize),
tracksize,
(long)tracksize*BLOCKSIZE
);
}
} else {
#ifdef IRIX
/* if reading audio track */
imagesize=tracksize;
imagesize_bytes=imagesize*CDDA_DATASIZE;
buffersize = READBLOCKS*AUDIOBLOCKSIZE;
readblocksize = AUDIOBLOCKSIZE;
if (cdp) {
CDaddcallback(cdp, cd_audio, (CDCALLBACKFUNC)playaudio, 0);
} else die("No audioparser");
fclose(outfile);
aiffsetup=AFnewfilesetup();
AFinitrate(aiffsetup,AF_DEFAULT_TRACK,44100.0); /* 44.1 kHz */
AFinitfilefmt(aiffsetup,file_format); /* set file format */
AFinitchannels(aiffsetup,AF_DEFAULT_TRACK,2); /* stereo */
AFinitsampfmt(aiffsetup,AF_DEFAULT_TRACK,
AF_SAMPFMT_TWOSCOMP,16); /* 16bit */
aiffoutfile=AFopenfile(argv[optind],"w",aiffsetup);
if (!aiffoutfile) die("Cannot open target file (%s).",argv[optind]);
#endif
}
/* read the image */
if (md5_mode) MD5Init(MD5);
if (!info_only) {
start_time=(int)time(NULL);
fprintf(stderr,"Reading %s (%ldMb)...\n",
audio_track?"audio track":"ISO9660 image",
imagesize_bytes/(1024*1024));
do {
len=buffersize;
if(readsize/readblocksize+READBLOCKS>imagesize) {
read_10(start+counter,imagesize-readsize/readblocksize,buffer,&len);
}
else
read_10(start+counter,READBLOCKS,buffer,&len);
if ((counter%(1024*1024/readblocksize))<READBLOCKS) {
cur_time=(int)time(NULL);
if ((cur_time-start_time)>0) {
kbps=(readsize/1024)/(cur_time-start_time);
} else {
kbps=0;
}
fprintf(stderr,"%3dM of %dM read. (%d kb/s) \r",
counter/512,imagesize/512,kbps);
}
counter+=READBLOCKS;
readsize+=len;
if (!audio_track) {
fwrite(buffer,len,1,outfile);
} else {
#ifdef IRIX
/* audio track */
for(i=0;i<(len/CDDA_BLOCKSIZE);i++) {
CDparseframe(cdp,(CDFRAME*)&buffer[i*CDDA_BLOCKSIZE]);
}
#endif
}
if (md5_mode) MD5Update(MD5,buffer,(readsize>imagesize_bytes?
len-(readsize-imagesize_bytes):len) );
} while (len==readblocksize*READBLOCKS&&readsize<imagesize*readblocksize);
fprintf(stderr,"\n");
if (!audio_track) {
if (readsize > imagesize_bytes)
ftruncate(fileno(outfile),imagesize_bytes);
if (readsize < imagesize_bytes)
fprintf(stderr,"Image not complete!\n");
else fprintf(stderr,"Image complete.\n");
fclose(outfile);
} else {
#ifdef IRIX
AFclosefile(aiffoutfile);
#endif
}
}
if (md5_mode && !info_only) {
MD5Final((unsigned char*)digest,MD5);
md2str((unsigned char*)digest,digest_text);
fprintf(stderr,"MD5 (%s) = %s\n",(md5_mode==2?"'image'":argv[optind]),
digest_text);
}
quit:
start_stop(0);
/* set_removable(1); */
/* close the scsi device */
scsi_close();
return 0;
}
Error SoundCardPMO::Init(OutputInfo * info)
{
ALconfig config = ALnewconfig();
long pvbuffer[2];
m_properlyInitialized = false;
if (!info)
{
info = myInfo;
}
else
{
m_iDataSize = info->max_buffer_size;
}
pvbuffer[0] = AL_OUTPUT_RATE;
pvbuffer[1] = info->samples_per_second;
if (ALsetparams(AL_DEFAULT_DEVICE, pvbuffer, 2) < 0)
{
ReportError("Cannot set the soundcard's sampling speed.");
return (Error) pmoError_IOCTL_SNDCTL_DSP_SPEED;
}
int ret = -1;
if (info->bits_per_sample > 8)
ret = ALsetwidth(config, AL_SAMPLE_16);
else
ret = ALsetwidth(config, AL_SAMPLE_8);
if (ret < 0)
{
ReportError("The soundcard does not support 16 bit sample size.");
return (Error) pmoError_IOCTL_SNDCTL_DSP_SAMPLESIZE;
}
ret = -1;
if (info->number_of_channels == 2)
ret = ALsetchannels(config, AL_STEREO);
else
ret = ALsetchannels(config, AL_MONO);
if (ret < 0)
{
ReportError("Cannot set the soundcard to stereo.");
return (Error) pmoError_IOCTL_SNDCTL_DSP_STEREO;
}
ALsetqueuesize(config, m_iDataSize);
outaudioport = ALopenport("freeamp", "w", config);
if (outaudioport == (ALport)0)
{
ReportError("Couldn't open port.");
return (Error) pmoError_IOCTL_SNDCTL_DSP_STEREO;
}
audio_fd = ALgetfd(outaudioport);
channels = info->number_of_channels;
// configure the device:
int play_precision = info->bits_per_sample;
int play_stereo = channels - 1;
int play_sample_rate = info->samples_per_second;
memcpy(myInfo, info, sizeof(OutputInfo));
m_properlyInitialized = true;
// PORTING: The GETOSPACE ioctl determines how much space the kernel's
// output buffer has. Your OS may not have this.
m_iTotalFragments = 2048; /* arbitrary blah */
m_iOutputBufferSize = play_precision * m_iTotalFragments;
m_iBytesPerSample = info->number_of_channels * (info->bits_per_sample / 8);
return kError_NoErr;
}
static BOOL SGI_Init(void)
{
long chpars[] = { AL_OUTPUT_RATE, AL_RATE_22050 };
switch(md_mixfreq) {
case 8000:
chpars[1] = AL_RATE_8000;
break;
case 11025:
chpars[1] = AL_RATE_11025;
break;
case 16000:
chpars[1] = AL_RATE_16000;
break;
case 22050:
chpars[1] = AL_RATE_22050;
break;
case 32000:
chpars[1] = AL_RATE_32000;
break;
case 44100:
chpars[1] = AL_RATE_44100;
break;
case 48000:
chpars[1] = AL_RATE_48000;
break;
default:
_mm_errno=MMERR_SGI_SPEED;
return 1;
}
ALseterrorhandler(0);
ALsetparams(AL_DEFAULT_DEVICE, chpars, 2);
if (!(sgi_config=ALnewconfig())) {
_mm_errno=MMERR_OPENING_AUDIO;
return 1;
}
if (md_mode&DMODE_16BITS) {
if (ALsetwidth(sgi_config,AL_SAMPLE_16)<0) {
_mm_errno=MMERR_SGI_16BIT;
return 1;
}
sample_factor = 1;
} else {
if (ALsetwidth(sgi_config,AL_SAMPLE_8)<0) {
_mm_errno=MMERR_SGI_8BIT;
return 1;
}
sample_factor = 0;
}
if (md_mode&DMODE_STEREO) {
if (ALsetchannels(sgi_config,AL_STEREO)<0) {
_mm_errno=MMERR_SGI_STEREO;
return 1;
}
} else {
if (ALsetchannels(sgi_config,AL_MONO)<0) {
_mm_errno=MMERR_SGI_MONO;
return 1;
}
}
if ((getenv("MM_SGI_FRAGSIZE"))&&(sgi_fragsize!=DEFAULT_SGI_FRAGSIZE))
sgi_fragsize=atol(getenv("MM_SGI_FRAGSIZE"));
if (!sgi_fragsize) sgi_fragsize=DEFAULT_SGI_FRAGSIZE;
if ((getenv("MM_SGI_BUFSIZE"))&&(sgi_bufsize!=DEFAULT_SGI_BUFSIZE))
sgi_bufsize=atol(getenv("MM_SGI_BUFSIZE"));
if (!sgi_bufsize) sgi_fragsize=DEFAULT_SGI_BUFSIZE;
ALsetqueuesize(sgi_config, sgi_bufsize);
if (!(sgi_port=ALopenport("libmikmod","w",sgi_config))) {
_mm_errno=MMERR_OPENING_AUDIO;
return 1;
}
if(!(audiobuffer=(SBYTE*)_mm_malloc(sgi_fragsize))) return 1;
return VC_Init();
}
int
sgi_audio_open(audio_desc_t ad, audio_format* ifmt, audio_format *ofmt)
{
ALconfig c;
long cmd[8];
if (audio_fd != -1) {
sgi_audio_close(ad);
}
if (ifmt->encoding != DEV_S16) return FALSE;
if ((c = ALnewconfig()) == NULL) {
fprintf(stderr, "ALnewconfig error\n");
exit(1);
}
switch(ifmt->channels) {
case 1:
ALsetchannels(c, AL_MONO); break;
case 2:
ALsetchannels(c, AL_STEREO); break;
default:
sgi_audio_close(ad);
}
ALsetwidth(c, AL_SAMPLE_16);
ALsetqueuesize(c, QSIZE);
ALsetsampfmt(c, AL_SAMPFMT_TWOSCOMP);
if ((wp = ALopenport("RAT write", "w", c)) == NULL) {
fprintf(stderr, "ALopenport (write) error\n");
sgi_audio_close(ad);
return FALSE;
}
if ((rp = ALopenport("RAT read", "r", c)) == NULL) {
fprintf(stderr, "ALopenport (read) error\n");
sgi_audio_close(ad);
return FALSE;
}
cmd[0] = AL_OUTPUT_RATE;
cmd[1] = ofmt->sample_rate;
cmd[2] = AL_INPUT_RATE;
cmd[3] = ifmt->sample_rate;
cmd[4] = AL_MONITOR_CTL;
cmd[5] = AL_MONITOR_OFF;
/*cmd[6] = AL_INPUT_SOURCE;*/
/*cmd[7] = AL_INPUT_MIC;*/
if (ALsetparams(AL_DEFAULT_DEVICE, cmd, 6L/*was 8L*/) == -1) {
fprintf(stderr, "audio_open/ALsetparams error\n");
sgi_audio_close(ad);
}
/* Get the file descriptor to use in select */
audio_fd = ALgetfd(rp);
if (ALsetfillpoint(rp, ifmt->bytes_per_block) < 0) {
debug_msg("ALsetfillpoint failed (%d samples)\n", ifmt->bytes_per_block);
}
bytes_per_block = ifmt->bytes_per_block;
/* We probably should free the config here... */
return TRUE;
}
