Annotation of src/sosez.c, revision 1.1.1.1

1.1       root        1: /****************************************************************************
                      2: *
                      3: *  File              : sosez.c
                      4: *  Date Created      : 2/27/95
                      5: *  Description       : easy interface to help get started
                      6: *
                      7: *  Programmer(s)     : Nick Skrepetos
                      8: *  Last Modification : 2/27/95 - 7:59:16 PM
                      9: *  Additional Notes  :
                     10: *
                     11: *****************************************************************************
                     12: *            Copyright (c) 1994-5,  HMI, Inc.  All Rights Reserved          *
                     13: ****************************************************************************/
                     14: 
                     15: #include <stdlib.h>
                     16: #include <stdio.h>
                     17: #include <dos.h>
                     18: #include <fcntl.h> 
                     19: #include <bios.h>
                     20: #include <io.h>
                     21: #include <malloc.h>
                     22: #include <conio.h>
                     23: #include <ctype.h>
                     24: #include <string.h>
                     25: #include "sos.h"
                     26: #include "sosm.h"
                     27: #include "sosez.h"
                     28: #include "profile.h"
                     29: 
                     30: #include "corr7snd.def"
                     31: 
                     32: /***************************************************************************
                     33: 
                     34:    Notes:
                     35: 
                     36:       This file 'sosez.c' is intended to help get the first time user
                     37:       up and running in just a few minutes.  The sample program allows
                     38:       you to play digital samples and MIDI songs with ease.  Although
                     39:       the 'sosEZ' functions to not use every capability of the system,
                     40:       it should ease the integration process.
                     41: 
                     42:       The user must run the 'SETUP.EXE' program provided with the SOS
                     43:       to set up the file 'hmiset.cfg' before running any program containing
                     44:       this module.
                     45: 
                     46: ****************************************************************************/
                     47: 
                     48: // local data for digital driver
                     49: _SOS_DIGI_DRIVER        sDIGIDriver;               // digital driver structure
                     50: 
                     51: // local data for MIDI driver
                     52: _SOS_MIDI_DRIVER        sMIDIDriver;               // midi driver structure
                     53: 
                     54: // handles for sample, song, midi and digital drivers
                     55: W32      wDIGIDeviceID;                            // digital device ID
                     56: HANDLE   hDIGIDriver;                              // handle to digital driver
                     57: HANDLE   hDIGITimer;                               // handle to digital mixer
                     58: W32      wMIDIDeviceID;                            // midi device ID
                     59: HANDLE   hMIDIDriver;                              // handle to MIDI driver
                     60: HANDLE   hMIDISong;                                // handle to MIDI song
                     61: PSTR     pSong;                                    // pointer to MIDI song
                     62: PSTR     pMelodicPatch;                            // melodic FM instruments
                     63: PSTR     pDrumPatch;                               // drum FM instruments
                     64: 
                     65: 
                     66: // W32  sosEZInitSystem( W32 wDDeviceID, W32 wMDeviceID )
                     67: W32  cdecl sosEZInitSystem( W32 wDDeviceID, W32 wMDeviceID )
                     68:    {
                     69:       // set up the digital driver
                     70:       sDIGIDriver.wDriverRate       =  _SOSEZ_SAMPLE_RATE;
                     71:       sDIGIDriver.wDMABufferSize    =  _SOSEZ_DMA_BUFFER;
                     72: 
                     73:       // initialize the timer system
                     74: //      sosTIMERInitSystem( _TIMER_DOS_RATE, _SOS_DEBUG_NORMAL );
                     75: 
                     76:       // initialize the digital and midi systems
                     77:       sosDIGIInitSystem( _NULL, _SOS_DEBUG_NORMAL );
                     78:       sosMIDIInitSystem( _NULL, _SOS_DEBUG_NORMAL );
                     79: 
                     80:       // check to see if the midi device is to be initialized
                     81:       if ( wMDeviceID != -1 )
                     82:       {
                     83:          // initialize MIDI
                     84:          sMIDIDriver.wID = wMDeviceID;
                     85:          if ( sosMIDIInitDriver( &sMIDIDriver, &hMIDIDriver ) )
                     86:          {
                     87:             // uninitialize digital system
                     88:             sosDIGIUnInitDriver( hDIGIDriver, _TRUE, _TRUE );
                     89: 
                     90:             // uninitialize digital system
                     91:             sosDIGIUnInitSystem();
                     92: 
                     93:             // uninitialize system
                     94:             sosMIDIUnInitSystem();
                     95: 
                     96:             // return
                     97:             return( _SOSEZ_MIDI_INIT );
                     98:          }
                     99:       }
                    100: 
                    101:       // initialize the digital driver
                    102:       if ( wDDeviceID != -1 )
                    103:       {
                    104:          // initialize digital
                    105:          sDIGIDriver.wID = wDDeviceID;
                    106:          if ( sosDIGIInitDriver( &sDIGIDriver, &hDIGIDriver ) )
                    107:          {
                    108:             // uninitialize digital system
                    109:             sosDIGIUnInitSystem();
                    110: 
                    111:             // return
                    112:             return( _SOSEZ_DIGI_INIT );
                    113:          }
                    114:       }
                    115: 
                    116:       // register digital timer event (mixer)
                    117:       if ( wDDeviceID != -1 )
                    118:          sosTIMERRegisterEvent( _SOSEZ_TIMER_RATE, sDIGIDriver.pfnMixFunction,
                    119:             &hDIGITimer );
                    120: 
                    121:       // check driver type, if it is an OPL2/3 driver, we
                    122:       // need to load the patch files for the driver.
                    123:       if ( wMDeviceID == _MIDI_FM || wMDeviceID == _MIDI_OPL3 && wMDeviceID != -1 )
                    124:       {
                    125:          // attempt to load melodic patch
                    126:          if (  ( pMelodicPatch = sosEZLoadPatch( "melodic.bnk" ) ) == _NULL )
                    127:          {
                    128:             // uninitialize system
                    129:             sosEZUnInitSystem();
                    130: 
                    131:             // return error
                    132:             return( _SOSEZ_PATCH_MELODIC );
                    133:          }
                    134: 
                    135:          // attempt to load drum patch
                    136:          if (  ( pDrumPatch = sosEZLoadPatch( "drum.bnk" ) ) == _NULL )
                    137:          {
                    138:             // uninitialize system
                    139:             sosEZUnInitSystem();
                    140: 
                    141:             // return error
                    142:             return( _SOSEZ_PATCH_DRUM );
                    143:          }
                    144: 
                    145:          // set instrument data
                    146:          if ( ( sosMIDISetInsData( hMIDIDriver, pMelodicPatch, 1 ) ) )
                    147:          {
                    148:             // uninitialize system
                    149:             sosEZUnInitSystem();
                    150: 
                    151:             // return error
                    152:             return( _SOSEZ_PATCH_INIT );
                    153:          }
                    154: 
                    155:          // set instrument data
                    156:          if ( ( sosMIDISetInsData( hMIDIDriver, pDrumPatch, 1 ) ) )
                    157:          {
                    158:             // uninitialize system
                    159:             sosEZUnInitSystem();
                    160: 
                    161:             // return error
                    162:             return( _SOSEZ_PATCH_INIT );
                    163:          }
                    164:       }
                    165: 
                    166:       // return success
                    167:       return( _SOSEZ_NO_ERROR );
                    168:    }
                    169: 
                    170: // W32  sosEZUnInitSystem( VOID )
                    171: W32  cdecl sosEZUnInitSystem( VOID )
                    172:    {
                    173:       // release timer event
                    174:       sosTIMERRemoveEvent( hDIGITimer );
                    175: 
                    176:       // uninitialize digital driver
                    177:       if ( wDIGIDeviceID != -1 )
                    178:          sosDIGIUnInitDriver( hDIGIDriver, _TRUE, _TRUE );
                    179: 
                    180:       // uninitialize midi driver
                    181:       if ( wMIDIDeviceID != -1 )
                    182:          sosMIDIUnInitDriver( hMIDIDriver, _TRUE );
                    183: 
                    184:       // uninitialize midi system
                    185:       sosMIDIUnInitSystem();
                    186: 
                    187:       // uninitialze digital system
                    188:       sosDIGIUnInitSystem();
                    189: 
                    190:       // uninitialize timer system
                    191: //      sosTIMERUnInitSystem( 0 );
                    192: 
                    193:       // return success
                    194:       return( _TRUE );
                    195:    }
                    196: 
                    197: // BOOL  sosEZGetConfig( PSTR szName )
                    198: BOOL  cdecl sosEZGetConfig( PSTR szName )
                    199:    {
                    200:       _INI_INSTANCE  sInstance;
                    201:       BOOL           wError;
                    202: 
                    203:       // reset digital and MIDI driver structures
                    204:       memset( &sDIGIDriver, 0, sizeof( _SOS_DIGI_DRIVER ) );
                    205:       memset( &sMIDIDriver, 0, sizeof( _SOS_MIDI_DRIVER ));
                    206: 
                    207:       // open .ini file 
                    208:       if ( !hmiINIOpen( &sInstance, szName ) )
                    209:          return( _FALSE );
                    210: 
                    211:       // locate section for digital settings
                    212:       if ( !hmiINILocateSection( &sInstance, "DIGITAL" ) )
                    213:       {  
                    214:          // close file
                    215:          hmiINIClose( &sInstance );
                    216: 
                    217:          // return error
                    218:          return( _FALSE );
                    219:       }
                    220: 
                    221:       // fetch device ID, Port, DMA, IRQ
                    222:       wError   =  hmiINIGetItemDecimal( &sInstance, "DeviceID", &wDIGIDeviceID );
                    223:       wError   =  hmiINIGetItemDecimal( &sInstance, "DevicePort", &sDIGIDriver.sHardware.wPort );
                    224:       wError   =  hmiINIGetItemDecimal( &sInstance, "DeviceDMA", &sDIGIDriver.sHardware.wDMA );
                    225:       wError   =  hmiINIGetItemDecimal( &sInstance, "DeviceIRQ", &sDIGIDriver.sHardware.wIRQ );
                    226: 
                    227:       // error
                    228:       if ( !wError )
                    229:       {
                    230:          // close file
                    231:          hmiINIClose( &sInstance );
                    232: 
                    233:          // return error
                    234:          return( _FALSE );
                    235:       }
                    236: 
                    237:       // locate section for MIDI settings
                    238:       if ( !hmiINILocateSection( &sInstance, "MIDI" ) )
                    239:       {  
                    240:          // close file
                    241:          hmiINIClose( &sInstance );
                    242: 
                    243:          // return error
                    244:          return( _FALSE );
                    245:       }
                    246: 
                    247:       // fetch device ID, Port, DMA, IRQ
                    248:       wError   =  hmiINIGetItemDecimal( &sInstance, "DeviceID", &wMIDIDeviceID );
                    249:       wError   =  hmiINIGetItemDecimal( &sInstance, "DevicePort", &sMIDIDriver.sHardware.wPort );
                    250: 
                    251:       // error
                    252:       if ( !wError )
                    253:       {
                    254:          // close file
                    255:          hmiINIClose( &sInstance );
                    256: 
                    257:          // return error
                    258:          return( _FALSE );
                    259:       }
                    260: 
                    261:       // close file
                    262:       hmiINIClose( &sInstance );
                    263: 
                    264:       // return success
                    265:       return( _TRUE );
                    266:    }
                    267: 
                    268: // PSTR  sosEZLoadSample( PSTR szName )
                    269: _SOS_SAMPLE * cdecl sosEZLoadSample( PSTR szName )
                    270:    {
                    271:       W32  hFile;
                    272:       W32  wSize;
                    273:       PSTR  pData;
                    274:       _SOS_SAMPLE *  pSample;
                    275:       _WAVHEADER * pWaveHeader;
                    276: 
                    277:       // attempt to open file
                    278:       if ( ( hFile = open( szName, O_RDONLY | O_BINARY ) ) == -1 )
                    279:          return( _NULL );
                    280: 
                    281:       // seek to the end of the file to determine 
                    282:       // the file length;
                    283:       wSize =  lseek( hFile, 0, SEEK_END );
                    284: 
                    285:       // seek back to the start of the file
                    286:       lseek( hFile, 0, SEEK_SET );
                    287: 
                    288:       // allocate memory for the file
                    289:       if ( ( pData = (PSTR)SND_alcmem( wSize + sizeof( _SOS_SAMPLE  ) ) ) == _NULL )
                    290:       {
                    291:          // close file
                    292:          close( hFile );
                    293: 
                    294:          // return error
                    295:          return( _NULL );
                    296:       }
                    297: 
                    298:       // read in file
                    299:       if ( read( hFile, pData + sizeof( _SOS_SAMPLE ), wSize ) != wSize )
                    300:       {
                    301:          // close file
                    302:          close( hFile );
                    303: 
                    304:          // free memory
                    305:          SND_alcfree( (long)pData );
                    306: 
                    307:          // return error
                    308:          return( _NULL );
                    309:       }
                    310: 
                    311:       // close file
                    312:       close( hFile );
                    313: 
                    314:       // reset start sample structure
                    315:       memset( pData, 0, sizeof( _SOS_SAMPLE ) );
                    316: 
                    317:       // set pointer to sample
                    318:       pSample  =  ( _SOS_SAMPLE * )pData;
                    319: 
                    320:       // check to see if this is a .WAV file, if so then grab the settings
                    321:       // out of the file
                    322:       if( !strncmp( pData + sizeof( _SOS_SAMPLE ), "RIFF", 0x04 ) )
                    323:       {
                    324:          // setup a pointer to the wave header
                    325:          pWaveHeader = ( _WAVHEADER * )( pData + sizeof( _SOS_SAMPLE ) );
                    326: 
                    327:          // set size of the sample and pointer to the sample
                    328:          pSample->pSample        =  ( PSTR )pData + sizeof( _SOS_SAMPLE ) + 
                    329:             sizeof( _WAVHEADER );
                    330:          pSample->wLength        = pWaveHeader->dwDataLength - sizeof( _WAVHEADER );
                    331:          pSample->wBitsPerSample = pWaveHeader->wBitsPerSample;
                    332:          pSample->wChannels      = pWaveHeader->wChannels;
                    333:          if( pWaveHeader->wBitsPerSample == 0x08 )
                    334:             pSample->wFormat    = _PCM_UNSIGNED;
                    335:          else
                    336:             pSample->wFormat    = 0x00;
                    337:          pSample->wRate          = pWaveHeader->dwSamplesPerSec;
                    338:       }
                    339:       else
                    340:       {
                    341:          // set size of the sample and pointer to the sample
                    342:          pSample->pSample    =  ( PSTR )pData + sizeof( _SOS_SAMPLE );
                    343:          pSample->wLength   =  ( DWORD )wSize;
                    344:          pSample->wBitsPerSample = 0x08;
                    345:          pSample->wChannels = 0x01;
                    346:          pSample->wFormat = _PCM_UNSIGNED;
                    347:          pSample->wRate = 11025;
                    348:       }
                    349: 
                    350:       // set the pan and volume
                    351:       pSample->wPanPosition = _PAN_CENTER;
                    352:       pSample->wVolume = MK_VOLUME( 0x7fff, 0x7fff );
                    353: 
                    354:       // return pointer to the sample
                    355:       return( pSample );
                    356:    }
                    357: 
                    358: // W32  sosEZLoadSong( PSTR szName )
                    359: W32  cdecl sosEZLoadSong( PSTR szName )
                    360:    {
                    361:       W32  hFile;
                    362:       W32  hSong;
                    363:       PSTR  pData;
                    364:       W32  wSize;
                    365:       W32  wIndex;
                    366:       _SOS_MIDI_SONG *      sSong;
                    367: 
                    368:       // attempt to open file
                    369:       if ( ( hFile = open( szName, O_RDONLY | O_BINARY ) ) == -1 )
                    370:          return( (W32)-1 );
                    371: 
                    372:       // seek to the end of the file to determine 
                    373:       // the file length;
                    374:       wSize =  lseek( hFile, 0, SEEK_END );
                    375: 
                    376:       // seek back to the start of the file
                    377:       lseek( hFile, 0, SEEK_SET );
                    378: 
                    379:       // allocate memory for the file, init song structure and track map
                    380:       if ( ( pData = (PSTR)SND_alcmem( wSize  + sizeof( _SOS_MIDI_SONG ))) == _NULL )
                    381:       {
                    382:          // close file
                    383:          close( hFile );
                    384: 
                    385:          // return error
                    386:          return( (W32)-1 );
                    387:       }
                    388: 
                    389:       // read in file
                    390:       if ( read( hFile, pData + sizeof( _SOS_MIDI_SONG ), wSize ) != wSize )
                    391:       {
                    392:          // close file
                    393:          close( hFile );
                    394: 
                    395:          // free memory
                    396:          SND_alcfree( (long)pData );
                    397: 
                    398:          // return error
                    399:          return( (W32)-1 );
                    400:       }
                    401: 
                    402:       // close file
                    403:       close( hFile );
                    404: 
                    405:       // set up pointers to track mapping and song
                    406:       sSong       =  ( _SOS_MIDI_SONG * )pData;
                    407: 
                    408:       // reset song structure
                    409:       memset( sSong, 0, sizeof( _SOS_MIDI_SONG ) );
                    410: 
                    411:       // set up song structure
                    412:       sSong->pSong =  ( PSTR )( pData + sizeof( _SOS_MIDI_SONG ));
                    413: 
                    414:       // initialize song
                    415:       if ( sosMIDIInitSong( sSong, &hSong ) )
                    416:       {
                    417:          // free song memory
                    418:          SND_alcfree( (long)pData );
                    419: 
                    420:          // return error
                    421:          return( (W32)-1 );
                    422:       }
                    423: 
                    424:       // save pointer to song memory area to free
                    425:       // later.
                    426:       pSong    =  pData;
                    427: 
                    428:       // return song handle
                    429:       return( hSong );
                    430:    }
                    431: 
                    432: // PSTR  cdecl sosEZLoadPatch( PSTR szName )
                    433: PSTR  cdecl sosEZLoadPatch( PSTR szName )
                    434:    {
                    435:       PSTR  pData;
                    436:       W32  wSize;
                    437:       W32  hFile;
                    438: 
                    439:       // attempt to open file
                    440:       if ( ( hFile = open( szName, O_RDONLY | O_BINARY ) ) == -1 )
                    441:          return( _NULL );
                    442: 
                    443:       // seek to the end of the file to determine 
                    444:       // the file length;
                    445:       wSize =  lseek( hFile, 0, SEEK_END );
                    446: 
                    447:       // seek back to the start of the file
                    448:       lseek( hFile, 0, SEEK_SET );
                    449: 
                    450:       // allocate memory for the file, init song structure and track map
                    451:       if ( ( pData = (PSTR)SND_alcmem( wSize )) == _NULL )
                    452:       {
                    453:          // close file
                    454:          close( hFile );
                    455: 
                    456:          // return error
                    457:          return( _NULL );
                    458:       }
                    459: 
                    460:       // read in file
                    461:       if ( read( hFile, pData, wSize ) != wSize )
                    462:       {
                    463:          // close file
                    464:          close( hFile );
                    465: 
                    466:          // free memory
                    467:          SND_alcfree( (long)pData );
                    468: 
                    469:          // return error
                    470:          return( _NULL );
                    471:       }
                    472: 
                    473:       // close file
                    474:       close( hFile );
                    475: 
                    476:       // return pointer
                    477:       return( pData );
                    478:    }

unix.superglobalmegacorp.com