static void entry(void)
{
struct MsgPort *port1,*port2;
struct Message *msg;
Forbid();
port1=FindPort("message test port");
Permit();
port2=CreateMsgPort();
if(port2!=NULL)
{
msg=(struct Message *)CreateIORequest(port2,sizeof(struct Message));
if(msg!=NULL)
{
int i;
for(i=0;i<10;i++)
{
msg->mn_Node.ln_Name=(char *)i;
PutMsg(port1,msg);
WaitPort(port2);
GetMsg(port2);
}
DeleteIORequest((struct IORequest *)msg);
}
DeleteMsgPort(port2);
}
Signal(port1->mp_SigTask,1<<port1->mp_SigBit);
Wait(0);/* Let the parent remove me */
}
// Send an IPC startup
int ASM L_IPC_Startup(
REG(a0, IPCData *ipc),
REG(a1, APTR data),
REG(a2, struct MsgPort *reply))
{
struct MsgPort *port=0;
IPCMessage startup;
// If no message port supplied, create one
if (!reply) port=reply=CreateMsgPort();
// Fill out startup message
startup.msg.mn_ReplyPort=reply;
startup.command=IPC_STARTUP;
startup.flags=(ULONG)ipc;
startup.data=data;
// Send the startup message
PutMsg(&ipc->proc->pr_MsgPort,(struct Message *)&startup);
// Wait for reply back
WaitPort(reply);
GetMsg(reply);
// Delete port if we created one
if (port) DeleteMsgPort(port);
// If there's no command port, report failure
if (startup.command!=IPC_STARTUP) return 0;
return 1;
}
IPC_StartupCode(funced_init, FunctionStartup *, startup)
#endif
{
FuncEdData *data;
// Allocate data
if (!(data=AllocVec(sizeof(FuncEdData),MEMF_CLEAR)))
return 0;
// Store data
startup->data=data;
// Initialise some pointers
data->startup=startup;
data->function=startup->function;
data->locale=startup->locale;
// Create timer
if (!(data->drag.timer=AllocTimer(UNIT_VBLANK,0)))
return 0;
// Create lists
if (!(data->func_display_list=Att_NewList(0)) ||
!(data->flag_list=Att_NewList(0)) ||
!(data->function_list=Att_NewList(0)))
return 0;
// Create app port
data->appport=CreateMsgPort();
return 1;
}
struct NepClassRocket * AllocRocket(struct NepClassRocket *nch)
{
nch->nch_Task = FindTask(NULL);
if((nch->nch_TaskMsgPort = CreateMsgPort()))
{
nch->nch_IF0 = psdFindInterface(nch->nch_Device, NULL,
IFA_InterfaceNum, 0,
TAG_END);
nch->nch_IF1 = psdFindInterface(nch->nch_Device, NULL,
IFA_InterfaceNum, 1,
TAG_END);
if(nch->nch_IF0 && nch->nch_IF1)
{
if((nch->nch_EP0Pipe = psdAllocPipe(nch->nch_Device, nch->nch_TaskMsgPort, NULL)))
{
return(nch);
} else {
PutStr("Couldn't allocate default pipe\n");
}
} else {
PutStr("Couldn't find interfaces\n");
}
DeleteMsgPort(nch->nch_TaskMsgPort);
}
return(NULL);
}
int dllKillLibrary(char *portname)
{
dll_tMessage msg,*reply;
struct MsgPort *myport;
struct MsgPort *dllport;
bug("[DynLink] %s('%s')\n", __PRETTY_FUNCTION__, portname);
if(!(myport=CreateMsgPort()))
exit(0L); //Arghh
bzero(&msg, sizeof(msg));
msg.dllMessageType=DLLMTYPE_Kill;
msg.Message.mn_ReplyPort = myport;
if((dllport=FindPort(portname)))
{
PutMsg(dllport, (struct Message *)&msg);
/*WaitPort(myport);*/
while(!(reply=(dll_tMessage *)GetMsg(myport)))
{
Delay(2);
if(FindPort(portname)!=dllport)
break;
}
}
DeleteMsgPort(myport);
return (dllport?1:0);
}
static int Audio_Available(void)
{
int ok=0;
struct MsgPort *p;
struct AHIRequest *req;
if(p=CreateMsgPort())
{
if(req=(struct AHIRequest *)CreateIORequest(p,sizeof(struct AHIRequest)))
{
req->ahir_Version=4;
if(!OpenDevice(AHINAME,0,(struct IORequest *)req,NULL))
{
D(bug("AHI available.\n"));
ok=1;
CloseDevice((struct IORequest *)req);
}
DeleteIORequest((struct IORequest *)req);
}
DeleteMsgPort(p);
}
D(if(!ok) bug("AHI not available\n"));
return ok;
}
BOOL Initialize(void) {
LocaleBase = OpenLibrary("locale.library", 38);
OpenahiprefsCatalog();
AHImp=CreateMsgPort();
if( AHImp != NULL ) {
AHIio = (struct AHIRequest *)CreateIORequest(
AHImp,sizeof(struct AHIRequest));
if( AHIio != NULL ) {
AHIio->ahir_Version = 4;
AHIDevice = OpenDevice(AHINAME,AHI_NO_UNIT,(struct IORequest *)AHIio,NULL);
if(AHIDevice == 0) {
AHIBase = (struct Library *)AHIio->ahir_Std.io_Device;
return TRUE;
}
}
}
Printf((char *) msgTextNoOpen, (ULONG) "ahi.device", 4);
Printf("\n");
return FALSE;
}
int uae_start_thread (void *(*f) (void *), void *arg, uae_thread_id *foo)
{
struct MsgPort *replyport = CreateMsgPort();
if (replyport) {
*foo = (struct Task *)myCreateNewProcTags (NP_Output, Output (),
NP_Input, Input (),
NP_Name, (ULONG) "UAE thread",
NP_CloseOutput, FALSE,
NP_CloseInput, FALSE,
NP_StackSize, 16384,
NP_Entry, (ULONG) do_thread,
TAG_DONE);
if(*foo) {
struct startupmsg msg;
msg.msg.mn_ReplyPort = replyport;
msg.msg.mn_Length = sizeof msg;
msg.func = f;
msg.arg = arg;
PutMsg (&((struct Process*)*foo)->pr_MsgPort, (struct Message*)&msg);
WaitPort (replyport);
}
DeleteMsgPort (replyport);
}
return *foo!=0;
}
/*
* Start proxy thread
*/
static int start_proxy_thread (void)
{
int result = -1;
struct MsgPort *replyport = CreateMsgPort();
struct Process *p;
if (replyport) {
p = myCreateNewProcTags (NP_Name, (ULONG) "E-UAE semaphore proxy",
NP_Priority, 10,
NP_StackSize, 2048,
NP_Entry, (ULONG) proxy_thread_main,
TAG_DONE);
if (p) {
/* Send startup message */
struct Message msg;
msg.mn_ReplyPort = replyport;
msg.mn_Length = sizeof msg;
PutMsg (&p->pr_MsgPort, (struct Message*)&msg);
WaitPort (replyport);
proxy_thread = p;
atexit (stop_proxy_thread);
result = 0;
}
DeleteMsgPort (replyport);
}
return result;
}
void openLibrariesAndPorts(void) {
if(!(IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",
MINOSVERSION))) {
cleanup(EXIT_ERROR,"Can't open intuition.library.");
}
if(!(RexxSysBase = (struct RsxLib *)OpenLibrary("rexxsyslib.library",0L))) {
cleanup(EXIT_ERROR,"Can't open rexxsyslib.library.");
}
if(!(UtilityBase = OpenLibrary("utility.library", MINOSVERSION))) {
cleanup(EXIT_ERROR,"Can't open utility.library.");
}
if(!(NiKomBase = OpenLibrary("nikom.library", NIKLIBVERSION))) {
cleanup(EXIT_ERROR, "Can't open nikom.library v" NIKLIBVERSIONSTR " or later.");
}
if(!(permitport = (struct MsgPort *)CreatePort("NiKomPermit",0))) {
cleanup(EXIT_ERROR,"Can't open port 'NiKomPermit'");
}
if(!(nodereplyport = CreateMsgPort())) {
cleanup(EXIT_ERROR,"Can't open node reply message port.");
}
if(!(rexxport=(struct MsgPort *)CreatePort("NIKOMREXXHOST",0))) {
cleanup(EXIT_ERROR, "Could not open ARexx function host port.");
}
RegisterARexxFunctionHost(TRUE);
}
int
main(int argc, char* argv[]) {
int rc = RETURN_OK;
if (argc != 2) {
fprintf(stderr, "Usage: %s <audio mode id>\n", argv[0]);
rc = RETURN_ERROR;
}
else {
struct MsgPort* mp = CreateMsgPort();
if (mp != NULL) {
struct AHIRequest* io = (struct AHIRequest *)
CreateIORequest(mp, sizeof(struct AHIRequest));
if (io != NULL) {
io->ahir_Version = 4;
if (OpenDevice(AHINAME, AHI_NO_UNIT, (struct IORequest *) io, 0) == 0) {
AHIBase = (struct Library *) io->ahir_Std.io_Device;
BetterAudioID = atol(argv[1]);
Forbid();
OldBestAudioIDA = (BestAudioIDA_proto*)
SetFunction(AHIBase, _LVOAHI_BestAudioIDA,
(ULONG (*)(void)) MyBestAudioIDA );
Wait(SIGBREAKF_CTRL_C);
SetFunction(AHIBase, _LVOAHI_BestAudioIDA,
(ULONG (*)(void)) OldBestAudioIDA );
rc = 0;
Permit();
CloseDevice((struct IORequest *) io);
}
else {
fprintf(stderr, "Unable to open '" AHINAME "' version 4.\n");
rc = RETURN_FAIL;
}
DeleteIORequest((struct IORequest *) io);
}
else {
fprintf(stderr, "Unable to create IO request.\n");
rc = RETURN_FAIL;
}
DeleteMsgPort(mp);
}
else {
fprintf(stderr, "Unable to create message port.\n");
rc = RETURN_FAIL;
}
}
return rc;
}
void
OpenAHI( void )
{
if( AHIDevice != 0 )
{
AHImp = CreateMsgPort();
if( AHImp != NULL )
{
AHIio = (struct AHIRequest *)
CreateIORequest( AHImp, sizeof( struct AHIRequest ) );
if( AHIio != NULL )
{
AHIio->ahir_Version = AHIVERSION;
AHIDevice = OpenDevice( AHINAME,
AHI_NO_UNIT,
(struct IORequest *) AHIio,
AHIDF_NOMODESCAN );
}
}
if( AHIDevice != 0 )
{
Printf( "Unable to open %s version %ld\n", (ULONG) AHINAME, AHIVERSION );
cleanup( RETURN_FAIL );
}
AHIBase = (struct Library *) AHIio->ahir_Std.io_Device;
}
}
void SendEvent(LONG event) {
struct IOStdReq *InputRequest;
struct MsgPort *InputPort;
struct InputEvent *ie;
if ((InputPort = (struct MsgPort*)CreateMsgPort())) {
if ((InputRequest = (struct IOStdReq*)CreateIORequest(InputPort, sizeof(struct IOStdReq)))) {
if (!OpenDevice("input.device", 0, (struct IORequest*)InputRequest, 0)) {
if ((ie = AllocVec(sizeof(struct InputEvent), MEMF_PUBLIC | MEMF_CLEAR))) {
ie->ie_Class = event;
InputRequest->io_Command = IND_WRITEEVENT;
InputRequest->io_Data = ie;
InputRequest->io_Length = sizeof(struct InputEvent);
DoIO((struct IORequest*)InputRequest);
FreeVec(ie);
}
CloseDevice((struct IORequest*)InputRequest);
}
DeleteIORequest((struct IORequest *)InputRequest);
}
DeleteMsgPort (InputPort);
}
}
struct SysThread *Sys_Thread_CreateThread(void (*entrypoint)(void *), void *argument)
{
struct SysThread *thread;
thread = AllocVec(sizeof(*thread), MEMF_ANY);
if (thread)
{
thread->msgport = CreateMsgPort();
if (thread->msgport)
{
thread->msg.mn_Node.ln_Type = NT_MESSAGE;
thread->msg.mn_ReplyPort = thread->msgport;
thread->msg.mn_Length = sizeof(thread->msg);
thread->entrypoint = entrypoint;
thread->argument = argument;
thread->process = CreateNewProcTags(NP_Entry, Sys_Thread_Trampoline,
NP_UserData, thread,
NP_Name, "Fodquake Thread",
NP_StackSize, 32768,
TAG_DONE);
if (thread->process)
{
return thread;
}
DeleteMsgPort(thread->msgport);
}
FreeVec(thread);
}
return 0;
}
uint32_t urndis_ctrl_msg(struct NepClassEth *ncp, uint8_t rt, uint8_t r,
uint16_t index, uint16_t value, void *buf, size_t buflen)
{
LONG err=-1;
struct PsdPipe *pp;
struct MsgPort *mp;
if((mp = CreateMsgPort()))
{
if((pp = psdAllocPipe(ncp->ncp_Device, mp, NULL)))
{
psdSetAttrs(PGA_PIPE, pp,
PPA_NakTimeout, FALSE,
PPA_NakTimeoutTime, 5000,
PPA_AllowRuntPackets, TRUE,
TAG_END);
// bug("urndis_ctrl_msg:pipesetup( %d,%d,%d,%d,%d )\n",pp, rt, r, value, index);
psdPipeSetup(pp, rt, r, value, index);
// bug("urndis_ctrl_msg:psdDoPipe(%d,%d,%d)\n",pp, buf, buflen);
err = psdDoPipe(pp, buf, buflen);
if(err!=0){
bug("urndis_ctrl_msg:error %d,%s\n",err,psdNumToStr(NTS_IOERR, err, "unknown"));
}
psdFreePipe(pp);
}
DeleteMsgPort(mp);
}
return err;
}
VOID __saveds PingFunc( VOID )
{
struct MsgPort *ClientPort, *ReplyPort;
struct Library *SysBase;
BlankMsg PingMsg;
SysBase = *( struct Library ** )4L;
if( ReplyPort = CreateMsgPort())
{
PingMsg.bm_Mess.mn_ReplyPort = ReplyPort;
PingMsg.bm_Mess.mn_Length = sizeof( BlankMsg );
PingMsg.bm_Type = BM_PING;
/* Stealthimania, to alleviate processing at the blanker */
PingMsg.bm_Mess.mn_Node.ln_Name = ( UBYTE * )( &Blanking );
for( ;; )
{
if( SetSignal( 0L, SIGBREAKF_CTRL_C ) & SIGBREAKF_CTRL_C )
break;
if( ClientPort = FindPort( "GarshneClient" ))
{
PingMsg.bm_Flags = 0L;
PutMsg( ClientPort, ( struct Message * )( &PingMsg ));
WaitPort( ReplyPort );
GetMsg( ReplyPort );
}
}
DeletePort( ReplyPort );
}
}
/**
* Initializes the network core (as that is needed for some platforms
* @return true if the core has been initialized, false otherwise
*/
bool NetworkCoreInitialize()
{
#if defined(__MORPHOS__) || defined(__AMIGA__)
/*
* IMPORTANT NOTE: SocketBase needs to be initialized before we use _any_
* network related function, else: crash.
*/
DEBUG(net, 3, "[core] loading bsd socket library");
SocketBase = OpenLibrary("bsdsocket.library", 4);
if (SocketBase == NULL) {
DEBUG(net, 0, "[core] can't open bsdsocket.library version 4, network unavailable");
return false;
}
#if defined(__AMIGA__)
/* for usleep() implementation (only required for legacy AmigaOS builds) */
TimerPort = CreateMsgPort();
if (TimerPort != NULL) {
TimerRequest = (struct timerequest*)CreateIORequest(TimerPort, sizeof(struct timerequest);
if (TimerRequest != NULL) {
if (OpenDevice("timer.device", UNIT_MICROHZ, (struct IORequest*)TimerRequest, 0) == 0) {
TimerBase = TimerRequest->tr_node.io_Device;
if (TimerBase == NULL) {
/* free ressources... */
DEBUG(net, 0, "[core] can't initialize timer, network unavailable");
return false;
}
}
}
}
int32 V86Start (struct ContextState *state)
{
struct Msg *msg;
uint32 signals;
if ((v86_msgport = CreateMsgPort()) != NULL)
{
KSignal (v86_init_pid, SIG_INIT);
}
else
{
KPANIC ("V86 error");
}
while (1)
{
signals = KWait (1 << v86_msgport->signal);
if (signals & (1 << v86_msgport->signal))
if ((msg = GetMsg (v86_msgport)) != NULL)
break;
}
handler_v86msg = (struct V86Msg *) msg;
state->eax = handler_v86msg->state->eax;
state->ebx = handler_v86msg->state->ebx;
state->ecx = handler_v86msg->state->ecx;
state->edx = handler_v86msg->state->edx;
state->esi = handler_v86msg->state->esi;
state->edi = handler_v86msg->state->edi;
state->ebp = handler_v86msg->state->ebp;
state->gs = PL3_DATA_SEGMENT;
state->fs = PL3_DATA_SEGMENT;
state->es = PL3_DATA_SEGMENT;
state->ds = PL3_DATA_SEGMENT;
state->v86_gs = handler_v86msg->state->gs;
state->v86_fs = handler_v86msg->state->fs;
state->v86_es = handler_v86msg->state->es;
state->v86_ds = handler_v86msg->state->ds;
*(uint8 *)(0x00010000) = OPCODE_INT;
*(uint8 *)(0x00010001) = handler_v86msg->vector;
*(uint8 *)(0x00010002) = OPCODE_IRET;
state->return_eip = 0x0000;
state->return_cs = 0x1000;
state->return_eflags = EFLG_IF | EFLG_VM;
state->return_esp = 0xfff0;
state->return_ss = 0x2000;
return 0;
}
BOOL IPC_PutMsg( struct MsgPort *destino, IPCACT_T action, APTR udata )
{
struct MsgPort *replyport = NULL;
BOOL error = TRUE;
ENTER();
DBG_POINTER(destino);
if(destino && (replyport = CreateMsgPort()))
{
struct IPCMsg ipcmsg;
APTR xMsg;
ipcmsg.ipc_msg.mn_ReplyPort = replyport;
ipcmsg.ipc_msg.mn_Length = sizeof(struct IPCMsg);
ipcmsg.ipc_ID = IPC_MAGIC;
ipcmsg.ipc_action = action;
ipcmsg.ipc_result = IPCR_ABORTED;
ipcmsg.ipc_data = udata;
DBG("Sending action '%ld' from %lx to %lx\n", action, replyport, destino);
Forbid();
PutMsg( destino, &ipcmsg.ipc_msg);
WaitPort(replyport);
while((xMsg = GetMsg( replyport )))
{
DBG("Got reply...\n");
switch(((struct IPCMsg *)xMsg)->ipc_result)
{ // TODO
case IPCR_ABORTED:
DBG("IPCR_ABORTED\n");
break;
case IPCR_FAIL:
DBG("IPCR_FAIL\n");
break;
case IPCR_OK:
DBG("IPCR_OK\n");
break;
default:
break;
}
}
Permit();
DeleteMsgPort(replyport);
error = FALSE;
}
LEAVE();
return !error;
}
void SAVEDS handler(void)
{
struct Process *me = (struct Process *)FindTask(NULL);
struct startMsg *smsg;
struct MsgPort *port;
BOOL res = FALSE;
ENTER();
WaitPort(&me->pr_MsgPort);
smsg = (struct startMsg *)GetMsg(&me->pr_MsgPort);
#if defined(__amigaos4__)
port = AllocSysObject(ASOT_PORT, TAG_DONE);
#else
port = CreateMsgPort();
#endif
if(port != NULL)
res = localSendRexxMsg(port, smsg->port, smsg->cmd);
smsg->res = res;
ReplyMsg((struct Message *)smsg);
if(res == TRUE)
{
struct RexxMsg *rxmsg;
WaitPort(port);
rxmsg = (struct RexxMsg *)GetMsg(port);
DeleteArgstring((APTR)rxmsg->rm_Args[0]);
DeleteRexxMsg(rxmsg);
}
if(port != NULL)
{
#if defined(__amigaos4__)
FreeSysObject(ASOT_PORT, port);
#else
DeleteMsgPort(port);
#endif
}
ObtainSemaphore(&OpenURLBase->libSem);
OpenURLBase->rexx_use--;
ReleaseSemaphore(&OpenURLBase->libSem);
#if !defined(__amigaos4__)
// all systems except OS4 should leave this function in forbidden state
Forbid();
#endif
LEAVE();
}
// EMULATOR
int emulator::setUpEmulator2()
{
DEBUG(3) dprintf("emulator::setUpEmulator2() called. this=%p\n", this);
proc = (struct Process *)FindTask(0);
port = CreateMsgPort();
if(port == NULL)
return ENOMEM;
return 0;
}
int arexx_init(void)
{
int rc = 0;
Forbid();
if (!arexx_find())
{
if ((arexx_execute_port = CreateMsgPort()))
{
if ((arexx_port = CreateMsgPort()))
{
arexx_port->mp_Node.ln_Name = (char*)"SIMPLEMAIL.1";
AddPort(arexx_port);
rc = 1;
}
}
}
Permit();
return rc;
}
context *context::createContext()
{
DEBUG(3) dprintf("context::createContext() called.\n");
struct Process *my_proc = (struct Process *)FindTask(0);
struct MsgPort *my_port = CreateMsgPort();
if(my_port == NULL)
return NULL;
return new context(my_proc, my_port);
}
// Send an ARexx command
long __asm __saveds HookRexxCommand(
register __a0 char *command,
register __a1 char *result,
register __d0 long length,
register __a2 struct MsgPort *replyport,
register __d1 ULONG flags)
{
struct MsgPort *rexx,*reply;
struct RexxMsg *msg;
long rc=-1;
// Clear result
if (result) *result=0;
// Get rexx port
if (!GUI->rexx_proc || !(rexx=(struct MsgPort *)IPCDATA(GUI->rexx_proc)))
return -1;
// Create reply port if needed
if ((reply=replyport) || (reply=CreateMsgPort()))
{
// Create message
if (msg=BuildRexxMsgExTags(
reply,
".dopus5",
rexx->mp_Node.ln_Name,
RexxTag_Arg0,command,
TAG_END))
{
// Initialise message
msg->rm_Action|=1|RXCOMM;
if (result) msg->rm_Action|=RXFF_RESULT;
// Send the message and wait for reply
PutMsg(rexx,(struct Message *)msg);
WaitPort(reply);
GetMsg(reply);
// String reply?
if (msg->rm_Result2 && result)
stccpy(result,(char *)msg->rm_Result2,length);
rc=msg->rm_Result1;
// Free message
FreeRexxMsgEx(msg);
}
// Free message port
if (reply!=replyport) DeleteMsgPort(reply);
}
return rc;
}
int OpenIO(struct Window *iowin) {
if(!(timerport=(struct MsgPort *)CreateMsgPort()))
return(FALSE);
if(!(timerreq=(struct timerequest *)CreateExtIO(timerport,(LONG)sizeof(struct timerequest))))
return(FALSE);
if(OpenTimer(timerreq)) return(FALSE);
else timeryes=TRUE;
if(!(conwriteport=(struct MsgPort *)CreateMsgPort()))
return(FALSE);
if(!(conwritereq=(struct IOStdReq *)CreateExtIO(conwriteport,(LONG)sizeof(struct IOStdReq))))
return(FALSE);
if(!(conreadport=(struct MsgPort *)CreateMsgPort()))
return(FALSE);
if(!(conreadreq=(struct IOStdReq *)CreateExtIO(conreadport,(LONG)sizeof(struct IOStdReq))))
return(FALSE);
if(OpenConsole(iowin))
return(FALSE);
else consoleyes=TRUE;
return(TRUE);
}
int main()
{
APTR ProcessorBase;
IPTR args[6] = { 0, 0, 0, 0, 0, 0 };
struct RDArgs *rda;
int max_cpus = 0;
int max_iter = 0;
int req_width = 0, req_height = 0;
char tmpbuf[200];
int explicit_mode = 0;
struct MsgPort *timerPort = CreateMsgPort();
struct timerequest *tr = CreateIORequest(timerPort, sizeof(struct timerequest));
struct TimerBase *TimerBase = NULL;
struct timeval start_time;
struct timeval now;
struct Window *displayWin;
struct BitMap *outputBMap = NULL;
IPTR coreCount = 1;
struct TagItem tags[] =
{
{GCIT_NumberOfProcessors, (IPTR)&coreCount},
{0, (IPTR)NULL}};
ProcessorBase = OpenResource(PROCESSORNAME);
if (!ProcessorBase)
return 0;
KernelBase = OpenResource("kernel.resource");
if (!KernelBase)
return 0;
if (timerPort)
{
FreeSignal(timerPort->mp_SigBit);
timerPort->mp_SigBit = -1;
timerPort->mp_Flags = PA_IGNORE;
}
if (tr)
{
if (!OpenDevice("timer.device", UNIT_VBLANK, (struct IORequest *)tr, 0))
{
TimerBase = (struct TimerBase *)tr->tr_node.io_Device;
}
} else return 0;
GetCPUInfo(tags);
D(bug("[SMP-Smallpt] %s: detected %d CPU cores\n", __func__, coreCount);)
int uae_start_thread (const TCHAR *name, void *(*f)(void *), void *arg, uae_thread_id *tid)
{
struct MsgPort *replyport;
struct Process *newtask = NULL;
struct TagItem procTags[] =
{
{ NP_Name, (IPTR) NULL},
{ NP_StackSize, (IPTR)(64 * 1024)},
{ NP_Entry, (IPTR) do_thread},
//{ NP_Output, Output ()},
//{ NP_Input, Input ()},
//{ NP_CloseOutput, FALSE},
//{ NP_CloseInput, FALSE},
{ TAG_DONE, 0}
};
#warning Do we need to care for priorities here? WinUAE does..
if(!name)
procTags[0].ti_Data = (IPTR)default_name;
else
procTags[0].ti_Data = (IPTR)name;
bug("[JUAE:PX] %s('%s', f %lx, arg %lx, tid %lx)\n", __PRETTY_FUNCTION__, procTags[0].ti_Data, f, arg, tid);
replyport = CreateMsgPort();
if(!replyport) {
write_log("ERROR: Unable to create MsgPort!\n");
}
newtask = CreateNewProc (procTags);
bug("[JUAE:PX] %s: Process @ %p, MsgPort @ %p\n", __PRETTY_FUNCTION__, newtask, newtask->pr_MsgPort);
if(newtask) {
struct startupmsg msg;
msg.msg.mn_ReplyPort = replyport;
msg.msg.mn_Length = sizeof msg;
msg.func = f;
msg.arg = arg;
PutMsg (&newtask->pr_MsgPort, (struct Message*)&msg);
WaitPort (replyport);
}
DeleteMsgPort (replyport);
if(tid) {
*tid=newtask;
}
return (newtask != 0);
}
void main(void)
{
struct AHIAudioModeRequester *req;
BOOL res;
if(AHImp=CreateMsgPort())
if(AHIio=(struct AHIRequest *)CreateIORequest(AHImp,sizeof(struct AHIRequest))) {
AHIio->ahir_Version = 2;
AHIDevice=OpenDevice(AHINAME,AHI_NO_UNIT,(struct IORequest *)AHIio,NULL);
}
if(AHIDevice) {
Printf("Unable to open %s version 2\n",AHINAME);
cleanup(RETURN_FAIL);
}
AHIBase=(struct Library *)AHIio->ahir_Std.io_Device;
req=AHI_AllocAudioRequest(
AHIR_SleepWindow,TRUE,
AHIR_UserData,999,
AHIR_PubScreenName,NULL,
TAG_DONE);
res=AHI_AudioRequest(req,
AHIR_TitleText, "Select a mode or cancel",
AHIR_NegativeText, "Abort",
AHIR_DoMixFreq, TRUE,
AHIR_DoDefaultMode, TRUE,
AHIR_InitialAudioID, 0x20003,
AHIR_InitialMixFreq, 30000,
AHIR_FilterTags, ReqFilterTags,
TAG_DONE);
if(!res)
{
if(IoErr() == ERROR_NO_FREE_STORE)
Printf("AHI ran out of memory!\n");
else if(IoErr() == ERROR_NO_MORE_ENTRIES)
Printf("No available modes!\n");
else
Printf("Requester cancelled!\n");
}
else
Printf("Selected AudioMode: 0x%08lx, %ld Hz\n",req->ahiam_AudioID,req->ahiam_MixFreq);
AHI_FreeAudioRequest(req);
cleanup(RETURN_OK);
}
int
main( int argc, char* argv[] ) {
int rc = RETURN_OK;
if( argc != 1 ) {
fprintf( stderr, "Usage: %s\n", argv[ 0 ] );
rc = RETURN_ERROR;
}
else {
struct MsgPort* mp = CreateMsgPort();
if( mp != NULL ) {
struct AHIRequest* io = (struct AHIRequest *)
CreateIORequest( mp, sizeof( struct AHIRequest ) );
if( io != NULL ) {
// We use 32 bit samples, so we need version 6.
io->ahir_Version = 6;
if( OpenDevice( AHINAME, AHI_NO_UNIT, (struct IORequest *) io, 0 )
== 0 ) {
AHIBase = (struct Library *) io->ahir_Std.io_Device;
rc = PlaySineEverywhere();
CloseDevice( (struct IORequest *) io );
}
else {
fprintf( stderr, "Unable to open '" AHINAME "' version 6.\n" );
rc = RETURN_FAIL;
}
DeleteIORequest( (struct IORequest *) io );
}
else {
fprintf( stderr, "Unable to create IO request.\n" );
rc = RETURN_FAIL;
}
DeleteMsgPort( mp );
}
else {
fprintf( stderr, "Unable to create message port.\n" );
rc = RETURN_FAIL;
}
}
return rc;
}
static void openpar(void)
{
ParMP = CreateMsgPort();
if (!ParMP) cleanup("Failed to create msgport", RETURN_ERROR);
ParIO = (struct IOStdReq *)CreateIORequest(ParMP, sizeof(struct IOExtPar));
if (!ParIO) cleanup("Failed to create IO request", RETURN_ERROR);
if (OpenDevice("parallel.device", 0, (struct IORequest *)ParIO, 0))
{
cleanup("Failed to open parallel.device", RETURN_ERROR);
}
ParOpen = TRUE;
}
