static inline SIPTR readargs_file(CONST_STRPTR format, IPTR *args, CONST_STRPTR input, struct RDArgs **retp)
{
SIPTR retval;
struct RDArgs *ret;
BPTR oldin;
BPTR io;
CONST_STRPTR tmpfile = "RAM:readargs.test";
BPTR oldout;
oldout = SelectOutput(Open("NIL:", MODE_NEWFILE));
io = Open(tmpfile, MODE_NEWFILE);
Write(io, input, strlen(input));
Close(io);
io = Open(tmpfile, MODE_OLDFILE);
oldin = Input();
SelectInput(io);
SetIoErr(0);
ret = ReadArgs(format, args, NULL);
*retp = ret;
retval = (ret != NULL) ? RETURN_OK : IoErr();
Close(SelectInput(oldin));
Close(SelectOutput(oldout));
DeleteFile(tmpfile);
return retval;
}
/*
* amiopenwin - opens a window if we don't already have one.
*/
void
amiopenwin(char *termtype)
{
if (!IsInteractive(Input()))
{
/* open our own window in RAW mode */
if (isOldDOS() || (BPTR) 0 == (fh = Open(title, MODE_READWRITE)))
{
PutStr((UBYTE *) "Couldn't open RAW: window");
clean_exit(2);
} else
{
oldinputFH = SelectInput(fh);
oldoutputFH = SelectOutput(fh);
}
}
inputFH = Input();
outputFH = Output();
if (!strcmp(termtype, TERMTYPE))
{
amigaterm = 1;
Write(outputFH, AUTOWRAP_OFF, sizeof(AUTOWRAP_OFF));
}
return;
}
void __exitcommandline(void)
{
struct WBStartup *wbs=_WBenchMsg;
if (wbs!=NULL)
{ BPTR file;
if((file=window)!=0) {
SelectOutput(output);
SelectInput(input);
PPCClose(file);
}
if(wbs->sm_ArgList!=NULL) { // set original lock
UnLock(CurrentDir(cd));
}
}
else
{
char *cl=cline;
if(cl!=NULL)
{ char **av=__argv;
if(av!=NULL)
{
PPCFreeVec(av);
}
PPCFreeVec(cl);
}
}
}
void NewFreeArgs(struct NewRDArgs *rdargs)
{
ENTER();
D(DBF_STARTUP, "FreeArgs(rdargs->FreeArgs)");
FreeArgs(rdargs->FreeArgs);
if(rdargs->RDArgs != NULL)
{
free((void *)rdargs->RDArgs->RDA_Source.CS_Buffer);
D(DBF_STARTUP, "FreeDosObject(DOS_RDARGS, rdargs->RDArgs)");
FreeDosObject(DOS_RDARGS, rdargs->RDArgs);
}
if(rdargs->Args != NULL)
{
ULONG i;
for(i=0; i < rdargs->MaxArgs; i++)
{
if(rdargs->Args[i] != NULL)
FreeVecPooled(rdargs->Pool, rdargs->Args[i]);
}
FreeVecPooled(rdargs->Pool, rdargs->Args);
rdargs->Args = NULL;
}
if(rdargs->ToolWindow != NULL)
{
FreeVecPooled(rdargs->Pool, rdargs->ToolWindow);
rdargs->ToolWindow = NULL;
}
if(rdargs->WinFH != 0)
{
D(DBF_STARTUP, "SelectOutput( .. ) .. Close( ... )");
SelectOutput(rdargs->OldOutput);
SelectInput(rdargs->OldInput);
Close(rdargs->WinFH);
rdargs->WinFH = 0;
}
if(rdargs->Pool != NULL)
{
#if defined(__amigaos4__)
FreeSysObject(ASOT_MEMPOOL, rdargs->Pool);
#else
DeletePool(rdargs->Pool);
#endif
rdargs->Pool = NULL;
}
D(DBF_STARTUP, "memory freed");
LEAVE();
}
/*
* amiclosewin - closes a window if we opened one.
*/
void
amiclosewin()
{
if (amigaterm)
{
Write(outputFH, AUTOWRAP_ON, sizeof(AUTOWRAP_ON)); /* Amiga default */
}
if (fh)
{ /* Close down the window */
SelectInput(oldinputFH);
SelectOutput(oldoutputFH);
Close(fh);
}
return;
}
/****** SmartReadArgs/SmartFreeArgs ******************************************
* NAME
* SmartFreeArgs -- Free all resources allocated by SmartReadArgs().
* SYNOPSIS
* SmartFreeArgs(smart_args);
*
* void SmartFreeArgs(struct SmartArgs *);
* FUNCTION
* Free all resources allocated by a previous call to SmartReadArgs().
* INPUTS
* smart_args - Same pointer as passed to SmartReadArgs() before
* NOTES
* Always call SmartFreeArgs(), even if SmartReadArgs() failed! Take a look
* at the example for SmartReadArgs().
* SEE ALSO
* SmartReadArgs()
****************************************************************************/
void SmartFreeArgs(struct SmartArgs *args)
{
/* FreeArgs() can handle a NULL pointer */
FreeArgs(args->sa_FreeArgs);
if (args->sa_Flags & SAF_ALLOCRDARGS)
if (args->sa_RDArgs)
FreeDosObject(DOS_RDARGS, args->sa_RDArgs);
if (args->sa_Flags & SAF_ALLOCBUFFER)
FreeMem(args->sa_Buffer, args->sa_BufferSize);
if (args->sa_WindowFH)
{
SelectOutput(args->sa_OldOutput);
SelectInput(args->sa_OldInput);
Close(args->sa_WindowFH);
}
if (args->sa_Flags & SAF_ALLOCWINDOW && args->sa_Window)
FreeVec(args->sa_Window);
}
LONG SmartReadArgs(struct WBStartup * wb_startup, struct SmartArgs * args)
{
LONG error;
args->sa_Flags = 0;
D(bug("UtilityBase = 0x%lx\n", (ULONG) UtilityBase));
D(bug("IconBase = 0x%lx\n", (ULONG) IconBase));
D(bug("WBStartup = 0x%lx\n", (ULONG) wb_startup));
if (wb_startup != NULL)
{
struct WBArg *wbarg = wb_startup->sm_ArgList;
LONG arg_counter = 0;
D(bug(" numArgs = %ld\n", wb_startup->sm_NumArgs));
while (arg_counter < wb_startup->sm_NumArgs)
{
D(bug(" name[%ld] = \"%s\"\n", arg_counter, wbarg->wa_Name));
wbarg += 1;
arg_counter += 1;
}
}
if (wb_startup != NULL)
{
if (!(args->sa_RDArgs = AllocDosObject(DOS_RDARGS, NULL)))
{
return (ERROR_NO_FREE_STORE);
}
else
{
args->sa_Flags |= SAF_ALLOCRDARGS;
if (!args->sa_Buffer)
{
args->sa_BufferSize = MAX(SA_MINIMUM_BUFFER_SIZE, args->sa_BufferSize);
args->sa_Buffer = AllocMem(args->sa_BufferSize, MEMF_ANY);
args->sa_Flags |= SAF_ALLOCBUFFER;
}
if (!args->sa_Buffer)
return (ERROR_NO_FREE_STORE);
else
{
struct DiskObject *dobj;
args->sa_ActualPtr = args->sa_Buffer;
args->sa_EndPtr = args->sa_Buffer + args->sa_BufferSize - 1;
if (!(dobj = smart_get_icon(args, wb_startup)))
{
return (ERROR_OBJECT_NOT_FOUND);
}
else
{
struct WBArg *wbarg = args->sa_WBArg;
ULONG num = args->sa_NumArgs;
STRPTR *tooltypes = (STRPTR *) dobj->do_ToolTypes;
STRPTR name;
STRPTR temp;
STRPTR ptr;
if (num > 1 && args->sa_FileParameter >= 0 && (temp = AllocMem(TEMPSIZE, MEMF_ANY)))
{
ULONG modes = 0;
get_arg_name(args, temp, TEMPSIZE, &modes);
fstrcpy(args, temp);
fstrcpy(args, " ");
/* no "/M" specifier in the ReadArgs() template, thus use only the first file */
if (modes != MODE_MULTI)
num = 2;
while (num > 1)
{
get_wbarg_name(wbarg, temp, TEMPSIZE);
fstrcpy(args, "\"");
fstrcpy(args, temp);
fstrcpy(args, "\" ");
num--;
wbarg++;
}
FreeMem(temp, TEMPSIZE);
}
D(bug("tooltypes=%lx\n", (ULONG) tooltypes));
if (tooltypes)
{
while (*tooltypes)
{
ptr = *tooltypes;
name = ptr;
/* check if this tooltype enabled and part of the
* template */
if ((*ptr != '(')
&& is_in_template(name, args->sa_Template))
{
while (*ptr != '=' && *ptr != EOS)
ptr++;
if (*ptr == '=')
{
*ptr = EOS;
if (!Stricmp(name, "WINDOW"))
{
STRPTR win;
if ((win = AllocVec(strlen(ptr + 1) + 1, MEMF_ANY)))
{
strcpy(win, ptr + 1);
args->sa_Window = win;
args->sa_Flags |= SAF_ALLOCWINDOW;
}
}
else
{
fstrcpy(args, name);
/* enclose the argument in "" */
if (*(ptr + 1) == '"')
{
fstrcpy(args, "=");
fstrcpy(args, ptr + 1);
}
else
{
fstrcpy(args, "=\"");
fstrcpy(args, ptr + 1);
fstrcpy(args, "\"");
}
*ptr = '=';
}
}
else
fstrcpy(args, name);
fstrcpy(args, " ");
}
tooltypes++;
} /* while (*tooltypes) */
} /* if (tooltypes) */
fstrcpy(args, "\n");
D(bug("final wb command line : \"%s\"\n", args->sa_Buffer));
}
}
}
args->sa_RDArgs->RDA_Source.CS_Buffer = args->sa_Buffer;
args->sa_RDArgs->RDA_Source.CS_Length = strlen(args->sa_Buffer);
args->sa_Flags |= SAF_WORKBENCH;
}
args->sa_FreeArgs = ReadArgs(args->sa_Template, args->sa_Parameter, args->sa_RDArgs);
if (SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C)
{
SetIoErr(ERROR_BREAK);
}
if ((error = IoErr()) == 0 && (wb_startup != NULL))
{
if (args->sa_Window)
{
args->sa_WindowFH = Open(args->sa_Window, MODE_NEWFILE);
if (args->sa_WindowFH)
{
args->sa_OldOutput = SelectOutput(args->sa_WindowFH);
args->sa_OldInput = SelectInput(args->sa_WindowFH);
}
}
}
return (error);
}
bool AudioAdapter::Init(){
char buf[256];
PaError err;
f_init=true;
inChan=CHANNELS;
outChan=CHANNELS;
framesPerBuffer=FRAMES_PER_BUFFER;
Logger::Println("[AudioAdapter] Initialize");
Logger::Debugln("[AudioAdapter] Initialize PortAudio");
err = Pa_Initialize();
if( err != paNoError ) goto error;
memset( &inputParameters , 0 , sizeof( inputParameters ) );
inputParameters.channelCount = inChan;
inputParameters.hostApiSpecificStreamInfo = NULL;
inputParameters.sampleFormat = paFloat32;
inputParameters.hostApiSpecificStreamInfo = NULL;
memset( &outputParameters, 0 , sizeof( outputParameters ) );
outputParameters.channelCount = outChan;
outputParameters.hostApiSpecificStreamInfo = NULL;
outputParameters.sampleFormat = paFloat32;
outputParameters.hostApiSpecificStreamInfo = NULL;
hostApiCount = Pa_GetHostApiCount();
devCount = Pa_GetDeviceCount();
int usesetup=ApplicationProperty::ReadSetupInt("Audio","UseSetup",1);
int useDefaultSetting=ApplicationProperty::ReadSetupInt("Audio","UseDefault",1);
int settingInDev=ApplicationProperty::ReadSetupInt("Audio","InputDeviceNumber",Pa_GetDefaultInputDevice());
int settingOutDev=ApplicationProperty::ReadSetupInt("Audio","OutputDeviceNumber",Pa_GetDefaultOutputDevice());
if(usesetup==0){
if(useDefaultSetting==1){
inDevNum=Pa_GetDefaultInputDevice();
outDevNum=Pa_GetDefaultOutputDevice();
}else{
inDevNum=settingInDev;
outDevNum=settingOutDev;
}
inputParameters.device = inDevNum;
outputParameters.device = outDevNum;
if(inDevNum!=devCount){
inputParameters.suggestedLatency = Pa_GetDeviceInfo(inDevNum)->defaultLowInputLatency ;
}
if(outDevNum!=devCount){
outputParameters.suggestedLatency = Pa_GetDeviceInfo(outDevNum)->defaultLowOutputLatency ;
}
err = Pa_IsFormatSupported(
inDevNum==devCount?NULL:&inputParameters
,outDevNum==devCount?NULL:&outputParameters
, SAMPLE_RATE );
if( err != paNoError ){
cout << "[AudioAdapter] Error: " << Pa_GetErrorText(err) << endl;
usesetup=1;
}
}
if(usesetup==1){
do{
hostApiNum=SelectApi();
inDevNum=SelectInput();
outDevNum=SelectOutput();
inputParameters.device = inDevNum;
outputParameters.device = outDevNum;
if(inDevNum!=devCount){
inputParameters.suggestedLatency = Pa_GetDeviceInfo(inDevNum)->defaultLowInputLatency ;
}
if(outDevNum!=devCount){
outputParameters.suggestedLatency = Pa_GetDeviceInfo(outDevNum)->defaultLowOutputLatency ;
}
err = Pa_IsFormatSupported(
inDevNum==devCount?NULL:&inputParameters
,outDevNum==devCount?NULL:&outputParameters
, SAMPLE_RATE );
if( err != paNoError ){
cout << "[AudioAdapter] Error: " << Pa_GetErrorText(err) << endl;
}
}while(err!=paNoError);
}
Logger::Println("[AudioAdapter] Audio Info");
if(0<=outDevNum && outDevNum<devCount){
Logger::Println(" HostApi : %s",Pa_GetHostApiInfo(Pa_GetDeviceInfo(outDevNum)->hostApi)->name);
}
if(devCount==inDevNum){
Logger::Println(" No Input");
}else{
getDeviceType(Pa_GetDeviceInfo(inDevNum)->maxInputChannels,Pa_GetDeviceInfo(inDevNum)->maxOutputChannels,buf);
Logger::Println(" Input Device : %s",Pa_GetDeviceInfo(inDevNum)->name);
}
if(devCount==outDevNum){
Logger::Println(" No Output");
}else{
getDeviceType(Pa_GetDeviceInfo(outDevNum)->maxInputChannels,Pa_GetDeviceInfo(outDevNum)->maxOutputChannels,buf);
Logger::Println(" Output Device : %s",Pa_GetDeviceInfo(outDevNum)->name);
}
ApplicationProperty::WriteSetupInt("Audio","InputDeviceNumber",inDevNum);
ApplicationProperty::WriteSetupInt("Audio","OutputDeviceNumber",outDevNum);
audioApi=new MyAudioApi;
audioApi->Init();
return true;
error:
Logger::Println("[AudioAdapter] Error : %s",Pa_GetErrorText(err));
return false;
}
void __nocommandline(void)
{
struct WBStartup *wbs=_WBenchMsg;
if (wbs!=NULL)
{
if(__stdiowin[0])
{ BPTR win;
if((window=win=PPCOpen(__stdiowin,MODE_OLDFILE))==0l)
exit(RETURN_FAIL);
input = SelectInput(win);
output = SelectOutput(win);
}
if(wbs->sm_ArgList!=NULL) /* cd to icon */
cd=CurrentDir(DupLock(wbs->sm_ArgList->wa_Lock));
__argc=0;
__argv=(char **)wbs;
}
else
{
char **av,*a,*cl=__commandline;
size_t i=__commandlen;
int ac;
if(!(cline=(char *)PPCAllocVec(i+1,MEMF_ANY))) /* get buffer */
exit(RETURN_FAIL);
for(a=cline,ac=1;;) /* and parse commandline */
{
while(i&&(*cl==' '||*cl=='\t'||*cl=='\n'))
{ cl++;
i--; }
if(!i)
break;
if(*cl=='\"')
{
cl++;
i--;
while(i)
{
if(*cl=='\"')
{
cl++;
i--;
break;
}
if(*cl=='*')
{
cl++;
i--;
if(!i)
break;
}
*a++=*cl++;
i--;
}
}
else
while(i&&(*cl!=' '&&*cl!='\t'&&*cl!='\n'))
{ *a++=*cl++;
i--; }
*a++='\0';
ac++;
}
/* NULL Terminated */
if(!(__argv=av=(char **)PPCAllocVec(((__argc=ac-1)+1)*sizeof(char *),MEMF_ANY|MEMF_CLEAR)))
exit(RETURN_FAIL);
for(a=cline,i=1;i<ac;i++)
{
av[i-1]=a;
while(*a++)
;
}
}
}
void __initcommandline(void)
{
struct WBStartup *wbs=_WBenchMsg;
if(wbs!=NULL)
{ if(__stdiowin[0])
{ BPTR win;
if((window=win=Open(__stdiowin,MODE_OLDFILE))==0l)
exit(RETURN_FAIL);
SelectInput(win);
SelectOutput(win);
}
if(wbs->sm_ArgList!=NULL) /* cd to icon */
cd=CurrentDir(DupLock(wbs->sm_ArgList->wa_Lock));
__argc=0;
__argv=(char **)wbs;
}else
{
char **av,*a,*cl=__commandline;
size_t i=__commandlen;
int ac;
if(!(cline=(char *)AllocVec(i+1,MEMF_ANY))) /* get buffer */
exit(RETURN_FAIL);
for(a=cline,ac=1;;) /* and parse commandline */
{
while(i&&(*cl==' '||*cl=='\t'||*cl=='\n'))
{ cl++;
i--; }
if(!i)
break;
if(*cl=='\"')
{
cl++;
i--;
while(i)
{
if(*cl=='\"')
{
cl++;
i--;
break;
}
if(*cl=='*')
{
cl++;
i--;
if(!i)
break;
}
*a++=*cl++;
i--;
}
}
else
while(i&&(*cl!=' '&&*cl!='\t'&&*cl!='\n'))
{ *a++=*cl++;
i--; }
*a++='\0';
ac++;
}
/* NULL Terminated */
if(!(__argv=av=(char **)AllocVec(((__argc=ac)+1)*sizeof(char *),MEMF_ANY|MEMF_CLEAR)))
exit(RETURN_FAIL);
for(a=cline,i=1;i<ac;i++)
{
av[i]=a;
while(*a++)
;
}
for(i=256;;i+=256) /* try in steps of 256 bytes */
{ if(!(*av=(char *)AllocVec(i,MEMF_ANY)))
break;
GetProgramName(*av,i); /* Who am I ? */
if(IoErr()!=ERROR_LINE_TOO_LONG)
break;
FreeVec(*av);
}
if(*av==NULL)
exit(RETURN_FAIL);
}
}
