Create Xref-Html Frames Remove All Frames
file:/home/jivera/wd/pcsx/plugins.c (Tue Nov 25 22:46:14 2003
)
1: /* Pcsx - Pc Psx Emulator
2: * Copyright (C) 1999-2003 Pcsx Team
3: *
4: * This program is free software; you can redistribute it and/or modify
5: * it under the terms of the GNU General Public License as published by
6: * the Free Software Foundation; either version 2 of the License, or
7: * (at your option) any later version.
8: *
9: * This program is distributed in the hope that it will be useful,
10: * but WITHOUT ANY WARRANTY; without even the implied warranty of
11: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12: * GNU General Public License for more details.
13: *
14: * You should have received a copy of the GNU General Public License
15: * along with this program; if not, write to the Free Software
16: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17: */
18:
19: #include <stdio.h>
20: #include <stdlib.h>
21: #include <string.h>
22:
23: #include "PsxCommon.h"
24:
25: #ifdef _MSC_VER_
26: #pragma warning(disable:4244)
27: #endif
28:
29: #define CheckErr(func) \
30: err = SysLibError(); \
31: if (err != NULL) { SysMessage(_("Error loading %s: %s"), func, err); return -1; }
32:
33: #if defined (__MACOSX__)
34: #define LoadSym(dest, src, name, checkerr) \
35: dest = (src) SysLoadSym(drv, "_" name); \
36: if(!checkerr) { SysLibError(); /*clean error*/ } \
37: if (checkerr == 1) CheckErr(name); \
38: if (checkerr == 2) { err = SysLibError(); if (err != NULL) errval = 1; }
39: #else
40: #define LoadSym(dest, src, name, checkerr) \
41: dest = (src) SysLoadSym(drv, name); if (checkerr == 1) CheckErr(name); \
42: if (checkerr == 2) { err = SysLibError(); if (err != NULL) errval = 1; }
43: #endif
44:
45: static const char *err;
46: static int errval;
47:
48: void *hGPUDriver;
49:
50: void ConfigurePlugins();
51:
52: void CALLBACK GPU__readDataMem(unsigned long *pMem, int iSize) {
53: while (iSize > 0) {
54: *pMem = GPU_readData();
55: iSize--;
56: pMem++;
57: }
58: }
59:
60: void CALLBACK GPU__writeDataMem(unsigned long *pMem, int iSize) {
61: while (iSize > 0) {
62: GPU_writeData(*pMem);
63: iSize--;
64: pMem++;
65: }
66: }
67:
68: void CALLBACK GPU__displayText(char *pText) {
69: SysPrintf("%s\n", pText);
70: }
71:
72: extern int StatesC;
73: long CALLBACK GPU__freeze(unsigned long ulGetFreezeData, GPUFreeze_t *pF) {
74: pF->ulFreezeVersion = 1;
75: if (ulGetFreezeData == 0) {
76: int val;
77:
78: val = GPU_readStatus();
79: val = 0x04000000 | ((val >> 29) & 0x3);
80: GPU_writeStatus(0x04000003);
81: GPU_writeStatus(0x01000000);
82: GPU_writeData(0xa0000000);
83: GPU_writeData(0x00000000);
84: GPU_writeData(0x02000400);
85: GPU_writeDataMem((unsigned long*)pF->psxVRam, 0x100000/4);
86: GPU_writeStatus(val);
87:
88: val = pF->ulStatus;
89: GPU_writeStatus(0x00000000);
90: GPU_writeData(0x01000000);
91: GPU_writeStatus(0x01000000);
92: GPU_writeStatus(0x03000000 | ((val>>24)&0x1));
93: GPU_writeStatus(0x04000000 | ((val>>29)&0x3));
94: GPU_writeStatus(0x08000000 | ((val>>17)&0x3f) | ((val>>10)&0x40));
95: GPU_writeData(0xe1000000 | (val&0x7ff));
96: GPU_writeData(0xe6000000 | ((val>>11)&3));
97:
98: /* GPU_writeData(0xe3000000 | pF->ulControl[0] & 0xffffff);
99: GPU_writeData(0xe4000000 | pF->ulControl[1] & 0xffffff);
100: GPU_writeData(0xe5000000 | pF->ulControl[2] & 0xffffff);*/
101: return 1;
102: }
103: if (ulGetFreezeData == 1) {
104: int val;
105:
106: val = GPU_readStatus();
107: val = 0x04000000 | ((val >> 29) & 0x3);
108: GPU_writeStatus(0x04000003);
109: GPU_writeStatus(0x01000000);
110: GPU_writeData(0xc0000000);
111: GPU_writeData(0x00000000);
112: GPU_writeData(0x02000400);
113: GPU_readDataMem((unsigned long*)pF->psxVRam, 0x100000/4);
114: GPU_writeStatus(val);
115:
116: pF->ulStatus = GPU_readStatus();
117:
118: /* GPU_writeStatus(0x10000003);
119: pF->ulControl[0] = GPU_readData();
120: GPU_writeStatus(0x10000004);
121: pF->ulControl[1] = GPU_readData();
122: GPU_writeStatus(0x10000005);
123: pF->ulControl[2] = GPU_readData();*/
124: return 1;
125: }
126: if(ulGetFreezeData==2) {
127: long lSlotNum=*((long *)pF);
128: char Text[32];
129:
130: sprintf (Text, "*PCSX*: Selected State %ld", lSlotNum+1);
131: GPU_displayText(Text);
132: return 1;
133: }
134: return 0;
135: }
136:
137: long CALLBACK GPU__configure(void) { return 0; }
138: long CALLBACK GPU__test(void) { return 0; }
139: void CALLBACK GPU__about(void) {}
140: void CALLBACK GPU__makeSnapshot(void) {}
141: void CALLBACK GPU__keypressed(int key) {}
142: long CALLBACK GPU__getScreenPic(unsigned char *pMem) { return -1; }
143: long CALLBACK GPU__showScreenPic(unsigned char *pMem) { return -1; }
144: void CALLBACK GPU__clearDynarec(void (CALLBACK *callback)(void)) { }
145:
146: #define LoadGpuSym1(dest, name) \
147: LoadSym(GPU_##dest, GPU##dest, name, 1);
148:
149: #define LoadGpuSym0(dest, name) \
150: LoadSym(GPU_##dest, GPU##dest, name, 0); \
151: if (GPU_##dest == NULL) GPU_##dest = (GPU##dest) GPU__##dest;
152:
153: #define LoadGpuSymN(dest, name) \
154: LoadSym(GPU_##dest, GPU##dest, name, 0);
155:
156: int LoadGPUplugin(char *GPUdll) {
157: void *drv;
158:
159: hGPUDriver = SysLoadLibrary(GPUdll);
160: if (hGPUDriver == NULL) {
161: GPU_configure = NULL;
162: SysMessage (_("Could Not Load GPU Plugin %s"), GPUdll); return -1;
163: }
164: drv = hGPUDriver;
165: LoadGpuSym1(init, "GPUinit");
166: LoadGpuSym1(shutdown, "GPUshutdown");
167: LoadGpuSym1(open, "GPUopen");
168: LoadGpuSym1(close, "GPUclose");
169: LoadGpuSym1(readData, "GPUreadData");
170: LoadGpuSym0(readDataMem, "GPUreadDataMem");
171: LoadGpuSym1(readStatus, "GPUreadStatus");
172: LoadGpuSym1(writeData, "GPUwriteData");
173: LoadGpuSym0(writeDataMem, "GPUwriteDataMem");
174: LoadGpuSym1(writeStatus, "GPUwriteStatus");
175: LoadGpuSym1(dmaChain, "GPUdmaChain");
176: LoadGpuSym1(updateLace, "GPUupdateLace");
177: LoadGpuSym0(keypressed, "GPUkeypressed");
178: LoadGpuSym0(displayText, "GPUdisplayText");
179: LoadGpuSym0(makeSnapshot, "GPUmakeSnapshot");
180: LoadGpuSym0(freeze, "GPUfreeze");
181: LoadGpuSym0(getScreenPic, "GPUgetScreenPic");
182: LoadGpuSym0(showScreenPic, "GPUshowScreenPic");
183: LoadGpuSym0(clearDynarec, "GPUclearDynarec");
184: LoadGpuSym0(configure, "GPUconfigure");
185: LoadGpuSym0(test, "GPUtest");
186: LoadGpuSym0(about, "GPUabout");
187:
188: return 0;
189: }
190:
191: void *hCDRDriver;
192:
193: long CALLBACK CDR__play(unsigned char *sector) { return 0; }
194: long CALLBACK CDR__stop(void) { return 0; }
195:
196: long CALLBACK CDR__getStatus(struct CdrStat *stat) {
197: if (cdOpenCase) stat->Status = 0x10;
198: else stat->Status = 0;
199: return 0;
200: }
201:
202: char* CALLBACK CDR__getDriveLetter(void) { return NULL; }
203: unsigned char* CALLBACK CDR__getBufferSub(void) { return NULL; }
204: long CALLBACK CDR__configure(void) { return 0; }
205: long CALLBACK CDR__test(void) { return 0; }
206: void CALLBACK CDR__about(void) {}
207:
208: #define LoadCdrSym1(dest, name) \
209: LoadSym(CDR_##dest, CDR##dest, name, 1);
210:
211: #define LoadCdrSym0(dest, name) \
212: LoadSym(CDR_##dest, CDR##dest, name, 0); \
213: if (CDR_##dest == NULL) CDR_##dest = (CDR##dest) CDR__##dest;
214:
215: #define LoadCdrSymN(dest, name) \
216: LoadSym(CDR_##dest, CDR##dest, name, 0);
217:
218: int LoadCDRplugin(char *CDRdll) {
219: void *drv;
220:
221: hCDRDriver = SysLoadLibrary(CDRdll);
222: if (hCDRDriver == NULL) {
223: CDR_configure = NULL;
224: SysMessage (_("Could Not load CDR plugin %s"), CDRdll); return -1;
225: }
226: drv = hCDRDriver;
227: LoadCdrSym1(init, "CDRinit");
228: LoadCdrSym1(shutdown, "CDRshutdown");
229: LoadCdrSym1(open, "CDRopen");
230: LoadCdrSym1(close, "CDRclose");
231: LoadCdrSym1(getTN, "CDRgetTN");
232: LoadCdrSym1(getTD, "CDRgetTD");
233: LoadCdrSym1(readTrack, "CDRreadTrack");
234: LoadCdrSym1(getBuffer, "CDRgetBuffer");
235: LoadCdrSym0(play, "CDRplay");
236: LoadCdrSym0(stop, "CDRstop");
237: LoadCdrSym0(getStatus, "CDRgetStatus");
238: LoadCdrSym0(getDriveLetter, "CDRgetDriveLetter");
239: LoadCdrSym0(getBufferSub, "CDRgetBufferSub");
240: LoadCdrSym0(configure, "CDRconfigure");
241: LoadCdrSym0(test, "CDRtest");
242: LoadCdrSym0(about, "CDRabout");
243:
244: return 0;
245: }
246:
247: void *hSPUDriver;
248:
249: long CALLBACK SPU__configure(void) { return 0; }
250: void CALLBACK SPU__about(void) {}
251: long CALLBACK SPU__test(void) { return 0; }
252:
253: unsigned short regArea[10000];
254: unsigned short spuCtrl,spuStat,spuIrq;
255: unsigned long spuAddr;
256:
257: void CALLBACK SPU__writeRegister(unsigned long add,unsigned short value) { // Old Interface
258: unsigned long r=add&0xfff;
259: regArea[(r-0xc00)/2] = value;
260:
261: if(r>=0x0c00 && r<0x0d80) {
262: unsigned char ch=(r>>4)-0xc0;
263: switch(r&0x0f) {//switch voices
264: case 0: //left volume
265: SPU_setVolumeL(ch,value);
266: return;
267: case 2: //right volume
268: SPU_setVolumeR(ch,value);
269: return;
270: case 4: //frequency
271: SPU_setPitch(ch,value);
272: return;
273: case 6://start address
274: SPU_setAddr(ch,value);
275: return;
276: //------------------------------------------------// level
277: // case 8:
278: // s_chan[ch].ADSRX.AttackModeExp = (val&0x8000)?TRUE:FALSE;
279: // s_chan[ch].ADSRX.AttackRate = (float)((val>>8) & 0x007f)*1000.0f/240.0f;
280: // s_chan[ch].ADSRX.DecayRate = (float)((val>>4) & 0x000f)*1000.0f/240.0f;
281: // s_chan[ch].ADSRX.SustainLevel = (float)((val) & 0x000f);
282:
283: // return;
284: // case 10:
285: // s_chan[ch].ADSRX.SustainModeExp = (val&0x8000)?TRUE:FALSE;
286: // s_chan[ch].ADSRX.ReleaseModeExp = (val&0x0020)?TRUE:FALSE;
287: // s_chan[ch].ADSRX.SustainRate = ((float)((val>>6) & 0x007f))*R_SUSTAIN;
288: // s_chan[ch].ADSRX.ReleaseRate = ((float)((val) & 0x001f))*R_RELEASE;
289: // if(val & 0x4000) s_chan[ch].ADSRX.SustainModeDec=-1.0f;
290: // else s_chan[ch].ADSRX.SustainModeDec=1.0f;
291: // return;
292: // case 12:
293: // return;
294: // case 14:
295: // s_chan[ch].pRepeat=spuMemC+((unsigned long) val<<3);
296: // return;
297: }
298: return;
299: }
300:
301: switch(r) {
302: case H_SPUaddr://SPU-memory address
303: spuAddr = (unsigned long) value<<3;
304: // spuAddr=value * 8;
305: return;
306: case H_SPUdata://DATA to SPU
307: // spuMem[spuAddr/2] = value;
308: // spuAddr+=2;
309: // if(spuAddr>0x7ffff) spuAddr=0;
310: SPU_putOne(spuAddr,value);
311: spuAddr+=2;
312: return;
313: case H_SPUctrl://SPU control 1
314: spuCtrl=value;
315: return;
316: case H_SPUstat://SPU status
317: spuStat=value & 0xf800;
318: return;
319: case H_SPUirqAddr://SPU irq
320: spuIrq = value;
321: return;
322: case H_SPUon1://start sound play channels 0-16
323: SPU_startChannels1(value);
324: return;
325: case H_SPUon2://start sound play channels 16-24
326: SPU_startChannels2(value);
327: return;
328: case H_SPUoff1://stop sound play channels 0-16
329: SPU_stopChannels1(value);
330: return;
331: case H_SPUoff2://stop sound play channels 16-24
332: SPU_stopChannels2(value);
333: return;
334: }
335: }
336:
337: unsigned short CALLBACK SPU__readRegister(unsigned long add) {
338: switch(add&0xfff) {// Old Interface
339: case H_SPUctrl://spu control
340: return spuCtrl;
341: case H_SPUstat://spu status
342: return spuStat;
343: case H_SPUaddr://SPU-memory address
344: return (unsigned short)(spuAddr>>3);
345: case H_SPUdata://DATA to SPU
346: spuAddr+=2;
347: // if(spuAddr>0x7ffff) spuAddr=0;
348: // return spuMem[spuAddr/2];
349: return SPU_getOne(spuAddr);
350: case H_SPUirqAddr://spu irq
351: return spuIrq;
352: //case H_SPUIsOn1:
353: //return IsSoundOn(0,16);
354: //case H_SPUIsOn2:
355: //return IsSoundOn(16,24);
356: }
357: return regArea[((add&0xfff)-0xc00)/2];
358: }
359:
360: void CALLBACK SPU__writeDMA(unsigned short val) {
361: SPU_putOne(spuAddr, val);
362: spuAddr += 2;
363: if (spuAddr > 0x7ffff) spuAddr = 0;
364: }
365:
366: unsigned short CALLBACK SPU__readDMA(void) {
367: unsigned short tmp = SPU_getOne(spuAddr);
368: spuAddr += 2;
369: if (spuAddr > 0x7ffff) spuAddr = 0;
370: return tmp;
371: }
372:
373: void CALLBACK SPU__writeDMAMem(unsigned short *pMem, int iSize) {
374: while (iSize > 0) {
375: SPU_writeDMA(*pMem);
376: iSize--;
377: pMem++;
378: }
379: }
380:
381: void CALLBACK SPU__readDMAMem(unsigned short *pMem, int iSize) {
382: while (iSize > 0) {
383: *pMem = SPU_readDMA();
384: iSize--;
385: pMem++;
386: }
387: }
388:
389: void CALLBACK SPU__playADPCMchannel(xa_decode_t *xap) {}
390:
391: long CALLBACK SPU__freeze(unsigned long ulFreezeMode, SPUFreeze_t *pF) {
392: if (ulFreezeMode == 2) {
393: memset(pF, 0, 16);
394: strcpy((char *)pF->PluginName, "Pcsx");
395: pF->PluginVersion = 1;
396: pF->Size = 0x200 + 0x80000 + 16 + sizeof(xa_decode_t);
397:
398: return 1;
399: }
400: if (ulFreezeMode == 1) {
401: unsigned long addr;
402: unsigned short val;
403:
404: val = SPU_readRegister(0x1f801da6);
405: SPU_writeRegister(0x1f801da6, 0);
406: SPU_readDMAMem((unsigned short *)pF->SPURam, 0x80000/2);
407: SPU_writeRegister(0x1f801da6, val);
408:
409: for (addr = 0x1f801c00; addr < 0x1f801e00; addr+=2) {
410: if (addr == 0x1f801da8) { pF->SPUPorts[addr - 0x1f801c00] = 0; continue; }
411: pF->SPUPorts[addr - 0x1f801c00] = SPU_readRegister(addr);
412: }
413:
414: return 1;
415: }
416: if (ulFreezeMode == 0) {
417: unsigned long addr;
418: unsigned short val;
419: unsigned short *regs = (unsigned short *)pF->SPUPorts;
420:
421: val = SPU_readRegister(0x1f801da6);
422: SPU_writeRegister(0x1f801da6, 0);
423: SPU_writeDMAMem((unsigned short *)pF->SPURam, 0x80000/2);
424: SPU_writeRegister(0x1f801da6, val);
425:
426: for (addr = 0x1f801c00; addr < 0x1f801e00; addr+=2) {
427: if (addr == 0x1f801da8) { regs++; continue; }
428: SPU_writeRegister(addr, *(regs++));
429: }
430:
431: return 1;
432: }
433:
434: return 0;
435: }
436:
437: void CALLBACK SPU__registerCallback(void (CALLBACK *callback)(void)) {}
438:
439: #define LoadSpuSym1(dest, name) \
440: LoadSym(SPU_##dest, SPU##dest, name, 1);
441:
442: #define LoadSpuSym2(dest, name) \
443: LoadSym(SPU_##dest, SPU##dest, name, 2);
444:
445: #define LoadSpuSym0(dest, name) \
446: LoadSym(SPU_##dest, SPU##dest, name, 0); \
447: if (SPU_##dest == NULL) SPU_##dest = (SPU##dest) SPU__##dest;
448:
449: #define LoadSpuSymE(dest, name) \
450: LoadSym(SPU_##dest, SPU##dest, name, errval); \
451: if (SPU_##dest == NULL) SPU_##dest = (SPU##dest) SPU__##dest;
452:
453: #define LoadSpuSymN(dest, name) \
454: LoadSym(SPU_##dest, SPU##dest, name, 0); \
455:
456: int LoadSPUplugin(char *SPUdll) {
457: void *drv;
458:
459: hSPUDriver = SysLoadLibrary(SPUdll);
460: if (hSPUDriver == NULL) {
461: SPU_configure = NULL;
462: SysMessage (_("Could not open SPU plugin %s"), SPUdll); return -1;
463: }
464: drv = hSPUDriver;
465: LoadSpuSym1(init, "SPUinit");
466: LoadSpuSym1(shutdown, "SPUshutdown");
467: LoadSpuSym1(open, "SPUopen");
468: LoadSpuSym1(close, "SPUclose");
469: LoadSpuSym0(configure, "SPUconfigure");
470: LoadSpuSym0(about, "SPUabout");
471: LoadSpuSym0(test, "SPUtest");
472: errval = 0;
473: LoadSpuSym2(startChannels1, "SPUstartChannels1");
474: LoadSpuSym2(startChannels2, "SPUstartChannels2");
475: LoadSpuSym2(stopChannels1, "SPUstopChannels1");
476: LoadSpuSym2(stopChannels2, "SPUstopChannels2");
477: LoadSpuSym2(putOne, "SPUputOne");
478: LoadSpuSym2(getOne, "SPUgetOne");
479: LoadSpuSym2(setAddr, "SPUsetAddr");
480: LoadSpuSym2(setPitch, "SPUsetPitch");
481: LoadSpuSym2(setVolumeL, "SPUsetVolumeL");
482: LoadSpuSym2(setVolumeR, "SPUsetVolumeR");
483: LoadSpuSymE(writeRegister, "SPUwriteRegister");
484: LoadSpuSymE(readRegister, "SPUreadRegister");
485: LoadSpuSymE(writeDMA, "SPUwriteDMA");
486: LoadSpuSymE(readDMA, "SPUreadDMA");
487: LoadSpuSym0(writeDMAMem, "SPUwriteDMAMem");
488: LoadSpuSym0(readDMAMem, "SPUreadDMAMem");
489: LoadSpuSym0(playADPCMchannel, "SPUplayADPCMchannel");
490: LoadSpuSym0(freeze, "SPUfreeze");
491: LoadSpuSym0(registerCallback, "SPUregisterCallback");
492: LoadSpuSymN(async, "SPUasync");
493:
494: return 0;
495: }
496:
497:
498: void *hPAD1Driver;
499: void *hPAD2Driver;
500:
501: static unsigned char buf[256];
502: unsigned char stdpar[10] = { 0x00, 0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
503: unsigned char mousepar[8] = { 0x00, 0x12, 0x5a, 0xff, 0xff, 0xff, 0xff };
504: unsigned char analogpar[9] = { 0x00, 0xff, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
505:
506: static int bufcount, bufc;
507:
508: PadDataS padd1, padd2;
509:
510: unsigned char _PADstartPoll(PadDataS *pad) {
511: bufc = 0;
512:
513: switch (pad->controllerType) {
514: case PSE_PAD_TYPE_MOUSE:
515: mousepar[3] = pad->buttonStatus & 0xff;
516: mousepar[4] = pad->buttonStatus >> 8;
517: mousepar[5] = pad->moveX;
518: mousepar[6] = pad->moveY;
519:
520: memcpy(buf, mousepar, 7);
521: bufcount = 6;
522: break;
523: case PSE_PAD_TYPE_NEGCON: // npc101/npc104(slph00001/slph00069)
524: analogpar[1] = 0x23;
525: analogpar[3] = pad->buttonStatus & 0xff;
526: analogpar[4] = pad->buttonStatus >> 8;
527: analogpar[5] = pad->rightJoyX;
528: analogpar[6] = pad->rightJoyY;
529: analogpar[7] = pad->leftJoyX;
530: analogpar[8] = pad->leftJoyY;
531:
532: memcpy(buf, analogpar, 9);
533: bufcount = 8;
534: break;
535: case PSE_PAD_TYPE_ANALOGPAD: // scph1150
536: analogpar[1] = 0x73;
537: analogpar[3] = pad->buttonStatus & 0xff;
538: analogpar[4] = pad->buttonStatus >> 8;
539: analogpar[5] = pad->rightJoyX;
540: analogpar[6] = pad->rightJoyY;
541: analogpar[7] = pad->leftJoyX;
542: analogpar[8] = pad->leftJoyY;
543:
544: memcpy(buf, analogpar, 9);
545: bufcount = 8;
546: break;
547: case PSE_PAD_TYPE_ANALOGJOY: // scph1110
548: analogpar[1] = 0x53;
549: analogpar[3] = pad->buttonStatus & 0xff;
550: analogpar[4] = pad->buttonStatus >> 8;
551: analogpar[5] = pad->rightJoyX;
552: analogpar[6] = pad->rightJoyY;
553: analogpar[7] = pad->leftJoyX;
554: analogpar[8] = pad->leftJoyY;
555:
556: memcpy(buf, analogpar, 9);
557: bufcount = 8;
558: break;
559: case PSE_PAD_TYPE_STANDARD:
560: default:
561: stdpar[3] = pad->buttonStatus & 0xff;
562: stdpar[4] = pad->buttonStatus >> 8;
563:
564: memcpy(buf, stdpar, 5);
565: bufcount = 4;
566: }
567:
568: return buf[bufc++];
569: }
570:
571: unsigned char _PADpoll(unsigned char value) {
572: if (bufc > bufcount) return 0;
573: return buf[bufc++];
574: }
575:
576: unsigned char CALLBACK PAD1__startPoll(int pad) {
577: PadDataS padd;
578:
579: PAD1_readPort1(&padd);
580:
581: return _PADstartPoll(&padd);
582: }
583:
584: unsigned char CALLBACK PAD1__poll(unsigned char value) {
585: return _PADpoll(value);
586: }
587:
588: long CALLBACK PAD1__configure(void) { return 0; }
589: void CALLBACK PAD1__about(void) {}
590: long CALLBACK PAD1__test(void) { return 0; }
591: long CALLBACK PAD1__query(void) { return 3; }
592: long CALLBACK PAD1__keypressed() { return 0; }
593:
594: #define LoadPad1Sym1(dest, name) \
595: LoadSym(PAD1_##dest, PAD##dest, name, 1);
596:
597: #define LoadPad1SymN(dest, name) \
598: LoadSym(PAD1_##dest, PAD##dest, name, 0);
599:
600: #define LoadPad1Sym0(dest, name) \
601: LoadSym(PAD1_##dest, PAD##dest, name, 0); \
602: if (PAD1_##dest == NULL) PAD1_##dest = (PAD##dest) PAD1__##dest;
603:
604: int LoadPAD1plugin(char *PAD1dll) {
605: void *drv;
606:
607: hPAD1Driver = SysLoadLibrary(PAD1dll);
608: if (hPAD1Driver == NULL) {
609: PAD1_configure = NULL;
610: SysMessage (_("Could Not load PAD1 plugin %s"), PAD1dll); return -1;
611: }
612: drv = hPAD1Driver;
613: LoadPad1Sym1(init, "PADinit");
614: LoadPad1Sym1(shutdown, "PADshutdown");
615: LoadPad1Sym1(open, "PADopen");
616: LoadPad1Sym1(close, "PADclose");
617: LoadPad1Sym0(query, "PADquery");
618: LoadPad1Sym1(readPort1, "PADreadPort1");
619: LoadPad1Sym0(configure, "PADconfigure");
620: LoadPad1Sym0(test, "PADtest");
621: LoadPad1Sym0(about, "PADabout");
622: LoadPad1Sym0(keypressed, "PADkeypressed");
623: LoadPad1Sym0(startPoll, "PADstartPoll");
624: LoadPad1Sym0(poll, "PADpoll");
625: LoadPad1SymN(setSensitive, "PADsetSensitive");
626:
627: return 0;
628: }
629:
630: unsigned char CALLBACK PAD2__startPoll(int pad) {
631: PadDataS padd;
632:
633: PAD2_readPort2(&padd);
634:
635: return _PADstartPoll(&padd);
636: }
637:
638: unsigned char CALLBACK PAD2__poll(unsigned char value) {
639: return _PADpoll(value);
640: }
641:
642: long CALLBACK PAD2__configure(void) { return 0; }
643: void CALLBACK PAD2__about(void) {}
644: long CALLBACK PAD2__test(void) { return 0; }
645: long CALLBACK PAD2__query(void) { return 3; }
646: long CALLBACK PAD2__keypressed() { return 0; }
647:
648: #define LoadPad2Sym1(dest, name) \
649: LoadSym(PAD2_##dest, PAD##dest, name, 1);
650:
651: #define LoadPad2Sym0(dest, name) \
652: LoadSym(PAD2_##dest, PAD##dest, name, 0); \
653: if (PAD2_##dest == NULL) PAD2_##dest = (PAD##dest) PAD2__##dest;
654:
655: #define LoadPad2SymN(dest, name) \
656: LoadSym(PAD2_##dest, PAD##dest, name, 0);
657:
658: int LoadPAD2plugin(char *PAD2dll) {
659: void *drv;
660:
661: hPAD2Driver = SysLoadLibrary(PAD2dll);
662: if (hPAD2Driver == NULL) {
663: PAD2_configure = NULL;
664: SysMessage (_("Could Not load PAD plugin %s"), PAD2dll); return -1;
665: }
666: drv = hPAD2Driver;
667: LoadPad2Sym1(init, "PADinit");
668: LoadPad2Sym1(shutdown, "PADshutdown");
669: LoadPad2Sym1(open, "PADopen");
670: LoadPad2Sym1(close, "PADclose");
671: LoadPad2Sym0(query, "PADquery");
672: LoadPad2Sym1(readPort2, "PADreadPort2");
673: LoadPad2Sym0(configure, "PADconfigure");
674: LoadPad2Sym0(test, "PADtest");
675: LoadPad2Sym0(about, "PADabout");
676: LoadPad2Sym0(keypressed, "PADkeypressed");
677: LoadPad2Sym0(startPoll, "PADstartPoll");
678: LoadPad2Sym0(poll, "PADpoll");
679: LoadPad2SymN(setSensitive, "PADsetSensitive");
680:
681: return 0;
682: }
683:
684: void *hNETDriver;
685:
686: void CALLBACK NET__setInfo(netInfo *info) {}
687: void CALLBACK NET__keypressed(int key) {}
688: long CALLBACK NET__configure(void) { return 0; }
689: long CALLBACK NET__test(void) { return 0; }
690: void CALLBACK NET__about(void) {}
691:
692: #define LoadNetSym1(dest, name) \
693: LoadSym(NET_##dest, NET##dest, name, 1);
694:
695: #define LoadNetSymN(dest, name) \
696: LoadSym(NET_##dest, NET##dest, name, 0);
697:
698: #define LoadNetSym0(dest, name) \
699: LoadSym(NET_##dest, NET##dest, name, 0); \
700: if (NET_##dest == NULL) NET_##dest = (NET##dest) NET__##dest;
701:
702: int LoadNETplugin(char *NETdll) {
703: void *drv;
704:
705: hNETDriver = SysLoadLibrary(NETdll);
706: if (hNETDriver == NULL) {
707: SysMessage (_("Could Not load NET plugin %s"), NETdll); return -1;
708: }
709: drv = hNETDriver;
710: LoadNetSym1(init, "NETinit");
711: LoadNetSym1(shutdown, "NETshutdown");
712: LoadNetSym1(open, "NETopen");
713: LoadNetSym1(close, "NETclose");
714: LoadNetSymN(sendData, "NETsendData");
715: LoadNetSymN(recvData, "NETrecvData");
716: LoadNetSym1(sendPadData, "NETsendPadData");
717: LoadNetSym1(recvPadData, "NETrecvPadData");
718: LoadNetSym1(queryPlayer, "NETqueryPlayer");
719: LoadNetSym1(pause, "NETpause");
720: LoadNetSym1(resume, "NETresume");
721: LoadNetSym0(setInfo, "NETsetInfo");
722: LoadNetSym0(keypressed, "NETkeypressed");
723: LoadNetSym0(configure, "NETconfigure");
724: LoadNetSym0(test, "NETtest");
725: LoadNetSym0(about, "NETabout");
726:
727: return 0;
728: }
729:
730: void CALLBACK clearDynarec(void) {
731: psxCpu->Reset();
732: }
733:
734: int LoadPlugins() {
735: int ret;
736: char Plugin[256];
737:
738: sprintf(Plugin, "%s%s", Config.PluginsDir, Config.Cdr);
739: if (LoadCDRplugin(Plugin) == -1) return -1;
740: sprintf(Plugin, "%s%s", Config.PluginsDir, Config.Gpu);
741: if (LoadGPUplugin(Plugin) == -1) return -1;
742: sprintf(Plugin, "%s%s", Config.PluginsDir, Config.Spu);
743: if (LoadSPUplugin(Plugin) == -1) return -1;
744: sprintf(Plugin, "%s%s", Config.PluginsDir, Config.Pad1);
745: if (LoadPAD1plugin(Plugin) == -1) return -1;
746: sprintf(Plugin, "%s%s", Config.PluginsDir, Config.Pad2);
747: if (LoadPAD2plugin(Plugin) == -1) return -1;
748:
749: if (!strcmp("Disabled", Config.Net)) Config.UseNet = 0;
750: else {
751: Config.UseNet = 1;
752: sprintf(Plugin, "%s%s", Config.PluginsDir, Config.Net);
753: if (LoadNETplugin(Plugin) == -1) return -1;
754: }
755:
756: ret = CDR_init();
757: if (ret < 0) { SysMessage (_("CDRinit error : %d"), ret); return -1; }
758: ret = GPU_init();
759: if (ret < 0) { SysMessage (_("GPUinit error: %d"), ret); return -1; }
760: ret = SPU_init();
761: if (ret < 0) { SysMessage (_("SPUinit error: %d"), ret); return -1; }
762: ret = PAD1_init(1);
763: if (ret < 0) { SysMessage (_("PAD1init error: %d"), ret); return -1; }
764: ret = PAD2_init(2);
765: if (ret < 0) { SysMessage (_("PAD2init error: %d"), ret); return -1; }
766: if (Config.UseNet) {
767: ret = NET_init();
768: if (ret < 0) { SysMessage (_("NETinit error: %d"), ret); return -1; }
769: }
770:
771: return 0;
772: }
773:
774: void ReleasePlugins() {
775: if (hCDRDriver == NULL || hGPUDriver == NULL || hSPUDriver == NULL ||
776: hPAD1Driver == NULL || hPAD2Driver == NULL) return;
777:
778: if (Config.UseNet) {
779: int ret = NET_close();
780: if (ret < 0) Config.UseNet = 0;
781: NetOpened = 0;
782: }
783:
784: CDR_shutdown();
785: GPU_shutdown();
786: SPU_shutdown();
787: PAD1_shutdown();
788: PAD2_shutdown();
789: if (Config.UseNet && hNETDriver != NULL) NET_shutdown();
790:
791: SysCloseLibrary(hCDRDriver); hCDRDriver = NULL;
792: SysCloseLibrary(hGPUDriver); hGPUDriver = NULL;
793: SysCloseLibrary(hSPUDriver); hSPUDriver = NULL;
794: SysCloseLibrary(hPAD1Driver); hPAD1Driver = NULL;
795: SysCloseLibrary(hPAD2Driver); hPAD2Driver = NULL;
796: if (Config.UseNet && hNETDriver != NULL) {
797: SysCloseLibrary(hNETDriver); hNETDriver = NULL;
798: }
799: }
800: /* arch-tag: Matthew Dempsky Wed Oct 15 10:35:05 CST 2003 (plugins.c)
801: */
802:
Html form generated by Xrefactory version 1.6.4 on Fri Dec 12 20:52:56 2003
Trial version.