Changeset 178


Ignore:
Timestamp:
Apr 30, 2001, 11:08:00 PM (24 years ago)
Author:
sandervl
Message:

DirectAudio interface updates

Location:
sbliveos2/trunk/drv16
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • sbliveos2/trunk/drv16/dwavestrm.cpp

    r174 r178  
    2626
    2727#include <devhelp.h>
     28#include <include.h>
    2829
    2930#include "dwavestrm.hpp"
    … …  
    3233#include "ioctl.h"
    3334#include "malloc.h"
     35#include <ossidc.h>
    3436
    3537void cdecl HookHandler(ULONG ulSysFileNum)
    3638{
    3739    PDWAVESTREAM pStream;
    38     PSTREAMBUFFEREX temp;
     40    PSTREAMBUFFER temp;
    3941    int rc;
    4042
    … …  
    4648    }
    4749
    48     temp = (PSTREAMBUFFEREX)pStream->qhReturn.PopHead();
     50    temp = (PSTREAMBUFFER)pStream->qhReturn.PopHead();
    4951    while(temp) {
    5052        if(pStream->hSem) {
    … …  
    5860        delete temp;
    5961
    60         temp = (PSTREAMBUFFEREX)pStream->qhReturn.PopHead();
     62        temp = (PSTREAMBUFFER)pStream->qhReturn.PopHead();
    6163    }
    6264    return;
    … …  
    6466
    6567
    66 ULONG DWAVESTREAM::Write(PSTREAMBUF pbuf, ULONG uLength)
    67 {
    68     PSTREAMBUFFEREX pStreamBuf;
     68ULONG DWAVESTREAM::Write(PSTREAMBUF pbuf, ULONG uLength, BOOL fLooping)
     69{
     70    PSTREAMBUFFER pStreamBuf;
    6971    LIN             linAddr;
    7072    PULONG          pLock;
    … …  
    7375    int             rc;
    7476
    75     pStreamBuf = new STREAMBUFFEREX(uLength, (PSTREAMBUF)0);
     77    pStreamBuf = new STREAMBUFFER(uLength, (PSTREAMBUF)0, fLooping);
    7678    if(pStreamBuf == NULL) {
    7779        DebugInt3();
    … …  
    110112void DWAVESTREAM::ReturnBuffer(void)
    111113{
    112    PSTREAMBUFFEREX temp = (PSTREAMBUFFEREX)qhDone.PopHead();
     114   PSTREAMBUFFER temp = (PSTREAMBUFFER)qhDone.PopHead();
    113115
    114116   if(temp)
    … …  
    148150}
    149151
     152//
     153//
     154ULONG DWAVESTREAM::StartStream(void)
     155{
     156   return WAVESTREAM::StartStream();
     157}
     158
     159
     160void DWAVESTREAM::AddBuffers(BOOL fFirst)
     161{
     162   PSTREAMBUFFER pTemp = (PSTREAMBUFFER)qhDone.Tail();
     163   ULONG space, Buff_left, byteswritten;
     164
     165   if(!pTemp) pTemp = (PSTREAMBUFFER)qhInProcess.Tail();
     166
     167   if(ulStreamType & STREAM_WRITE && pTemp && pTemp->looping)
     168   {
     169        Buff_left = pTemp->ulBuffsz - pTemp->ulBuffpos;
     170
     171        space = OSS16_StreamGetSpace(this);
     172        if(fFirst) {
     173             space = min(space, 4*fragsize);
     174        }
     175        else space = min(space, fragsize);
     176
     177        if(space) {
     178            if(space >= Buff_left) {
     179                 byteswritten = AddBuffer(Buff_left);
     180                 if(byteswritten == Buff_left) {
     181                     pTemp->ulBuffpos = 0; //reset fill position
     182                     AddBuffer(space - Buff_left);
     183                 }
     184            }
     185            else AddBuffer(space);
     186        }       
     187        pTemp->ulDonepos = 0; //make sure it ::Process never thinks it's done
     188   }
     189   else WAVESTREAM::AddBuffers(fFirst);
     190}
     191
     192BOOL DWAVESTREAM::SetProperty(int type, ULONG value, ULONG reserved)
     193{
     194   switch(type) {
     195   case PROPERTY_LOOPING:
     196   {
     197       cli();
     198       PSTREAMBUFFER pTemp = (PSTREAMBUFFER)qhInProcess.Head();
     199
     200       if(!pTemp) pTemp = (PSTREAMBUFFER)qhDone.Head();
     201
     202       if(pTemp) {
     203           pTemp->looping = (BOOL)value;
     204           if(pTemp->looping == FALSE) {
     205               //calculate current play position
     206               pTemp->ulDonepos = (_ulBytesProcessed % pTemp->ulBuffsz);
     207           }
     208       }
     209       sti();
     210   }
     211   case PROPERTY_FREQUENCY:
     212       break;
     213
     214   default:
     215       return WAVESTREAM::SetProperty(type, value, reserved);
     216
     217   }
     218   return TRUE;
     219}
     220
     221ULONG DWAVESTREAM::GetProperty(int type)
     222{
     223   switch(type) {
     224   case PROPERTY_LOOPING:
     225   {
     226       cli();
     227       PSTREAMBUFFER pTemp = (PSTREAMBUFFER)qhInProcess.Head();
     228       ULONG         ret = FALSE;
     229
     230       if(!pTemp) pTemp = (PSTREAMBUFFER)qhDone.Head();
     231
     232       if(pTemp) {
     233           ret = pTemp->looping;
     234       }
     235       sti();
     236       return ret;
     237   }
     238
     239   default:
     240       return WAVESTREAM::GetProperty(type);
     241   }
     242}
    150243
    151244DWAVESTREAM::DWAVESTREAM(ULONG streamtype, LPMCI_AUDIO_INIT pinit, USHORT filesysnum):
    … …  
    161254{
    162255    if (ulStreamState == STREAM_STREAMING) {
    163         CONTROL_PARM cParm;
    164         StopStream(&cParm);
     256         CONTROL_PARM cParm;
     257         StopStream(&cParm);
    165258    }
    166259    else ReturnBuffers();

  • sbliveos2/trunk/drv16/dwavestrm.hpp

    r167 r178  
    4343
    4444public:
    45    virtual ULONG  Write(PSTREAMBUF, ULONG);
     45   virtual ULONG Write(PSTREAMBUF, ULONG, BOOL fLooping = 0);
    4646   virtual ULONG Register(PDDCMDREGISTER);
    4747   virtual void  DeRegister(void);
     48   virtual ULONG StartStream();
    4849
    4950   DWAVESTREAM(ULONG streamtype, LPMCI_AUDIO_INIT pinit, USHORT filesysnum);
    … …  
    5253   BOOL     IsEverythingOk() { return (fError == FALSE); };
    5354
     55   virtual BOOL  SetProperty(int type, ULONG value, ULONG reserved = 0);
     56   virtual ULONG GetProperty(int type);
     57
    5458private:
    5559   virtual void ReturnBuffer(void);   // returns one buffer
     60
     61   virtual void AddBuffers(BOOL fFirst);            // Initialize the audio buffer object
    5662
    5763   QUEUEHEAD qhReturn;          //queue with buffers to be returned
    5864   ULONG     hCtxHook;
    5965   ULONG     hSem;
    60 
    6166   BOOL      fError;
    6267

  • sbliveos2/trunk/drv16/init.cpp

    r176 r178  
    7474static char NEWLINE[]     = "\r\n";
    7575static char szSBLiveNotFound[] = "SB Live! hardware not detected!";
     76static char szSBLiveAllocResFailed1[] = "Another device driver was granted exclusive access to IRQ ";
     77static char szSBLiveAllocResFailed2[] = "Unable to allocate hardware resources! Aborting...";
    7678static char szSBLiveConfig1[]  = "SB Live! configuration: IRQ ";
    7779static char szSBLiveConfig2[]  = ", IO Port 0x";
    … …  
    157159   if ((!pResources) || pResources->isEmpty()) {
    158160        goto hardware_notfound;
     161   }
     162   if (pRM->getState() == rmAllocFailed) {
     163        USHORT result;
     164
     165        DosWrite(1, (VOID FAR*)szSBLiveAllocResFailed1, sizeof(szSBLiveAllocResFailed1)-1, &result);
     166        DecWordToASCII(digit, (USHORT)pResources->uIRQLevel[0], 0);
     167        DosWrite(1, (VOID FAR*)digit, strlen(digit), &result);
     168        DosWrite(1, (VOID FAR*)NEWLINE, sizeof(NEWLINE)-1, &result);
     169        DosWrite(1, (VOID FAR*)szSBLiveAllocResFailed2, sizeof(szSBLiveAllocResFailed2)-1, &result);
     170        DosWrite(1, (VOID FAR*)NEWLINE, sizeof(NEWLINE)-1, &result);
     171        DosWrite(1, (VOID FAR*)NEWLINE, sizeof(NEWLINE)-1, &result);
     172        return;
    159173   }
    160174

  • sbliveos2/trunk/drv16/ioctl.cpp

    r172 r178  
    5353BOOL      fRecGainIOCTL90     = FALSE;
    5454
     55int       numFreeStreams      = SBLIVECAPS_MAXSTREAMS;
     56
    5557/**@internal
    5658 * @param    PREQPACKET pointer to the strategy request packet
    … …  
    208210
    209211   if (p->usIOCtlRequest != AUDIO_CHANGE) {
    210     p->sReturnCode = INVALID_REQUEST;
    211     prp->usStatus |= RPERR | RPBADCMD;
    212     return;
     212       p->sReturnCode = INVALID_REQUEST;
     213       prp->usStatus |= RPERR | RPBADCMD;
     214       return;
    213215   }
    214216   p->sReturnCode=0;
    … …  
    220222   addr += sizeof(MCI_AUDIO_CHANGE);
    221223   if(addr >= 0x10000UL) {
    222     dprintf(("Invalid MCI_AUDIO_CHANGE pointer %lx!!", (ULONG)pAudChange));
    223     p->sReturnCode = INVALID_REQUEST;
    224     prp->usStatus |= RPERR | RPBADCMD;
    225     return;
     224       dprintf(("Invalid MCI_AUDIO_CHANGE pointer %lx!!", (ULONG)pAudChange));
     225       p->sReturnCode = INVALID_REQUEST;
     226       prp->usStatus |= RPERR | RPBADCMD;
     227       return;
    226228   }
    227229   pMasterVol = (LPMCI_TRACK_INFO)pAudChange->pvDevInfo;
    … …  
    231233   addr += sizeof(MCI_TRACK_INFO);
    232234   if(addr >= 0x10000UL) {
    233     dprintf(("Invalid MCI_TRACK_INFO pointer %lx!!", (ULONG)pMasterVol));
    234     p->sReturnCode = INVALID_REQUEST;
    235     prp->usStatus |= RPERR | RPBADCMD;
    236     return;
     235       dprintf(("Invalid MCI_TRACK_INFO pointer %lx!!", (ULONG)pMasterVol));
     236       p->sReturnCode = INVALID_REQUEST;
     237       prp->usStatus |= RPERR | RPBADCMD;
     238       return;
    237239   }
    238240
    239241   pStream = FindStream_fromFile((ULONG) prp->s.ioctl.usSysFileNum);
    240242   if(pStream == NULL) {
    241     dprintf(("IoctlAudioControl stream %lx not found!", (ULONG) prp->s.ioctl.usSysFileNum));
    242     DebugInt3();
    243     return;
     243       dprintf(("IoctlAudioControl stream %lx not found!", (ULONG) prp->s.ioctl.usSysFileNum));
     244       DebugInt3();
     245       return;
    244246   }
    245247   if(pAudChange->lBalance != AUDIO_IGNORE)
    246     pStream->SetBalance(pAudChange->lBalance);
     248       pStream->SetProperty(PROPERTY_BALANCE, pAudChange->lBalance);
    247249
    248250   if(pAudChange->lVolume != AUDIO_IGNORE) {
    249     // stream volume ranges from 0 to 0x7FFFFFFF (linear)
    250     volume = pAudChange->lVolume >> 16UL;
    251     volume = (volume*100UL)/0x7FFFUL;
    252     dprintf(("Set stream volume of %x to %d", prp->s.ioctl.usSysFileNum, volume));
    253     pStream->SetVolume(MAKE_VOLUME_LR(volume, volume));
     251       // stream volume ranges from 0 to 0x7FFFFFFF (linear)
     252       volume = pAudChange->lVolume >> 16UL;
     253       volume = (volume*100UL)/0x7FFFUL;
     254       dprintf(("Set stream volume of %x to %d", prp->s.ioctl.usSysFileNum, volume));
     255       pStream->SetProperty(PROPERTY_VOLUME, MAKE_VOLUME_LR(volume, volume));
    254256   }
    255257
    256258   if(pMasterVol && pMasterVol->usMasterVolume != AUDIO_IGNORE) {
    257     // master volume ranges from 0 to 0x7FFF (linear)
    258     volume = pMasterVol->usMasterVolume;
    259     volume = (volume*100UL)/0x7FFFUL;
    260     if(volume > 100) {
    261         volume = 100;
    262     }
    263     dprintf(("Set mastervolume to %d", volume));
    264     pStream->SetMasterVol(MAKE_VOLUME_LR(volume, volume));
     259       // master volume ranges from 0 to 0x7FFF (linear)
     260       volume = pMasterVol->usMasterVolume;
     261       volume = (volume*100UL)/0x7FFFUL;
     262       if(volume > 100) {
     263           volume = 100;
     264       }
     265       dprintf(("Set mastervolume to %d", volume));
     266       pStream->SetProperty(PROPERTY_MASTERVOL, MAKE_VOLUME_LR(volume, volume));
    265267   }
    266268   if(!fRecSrcIOCTL90) {
    … …  
    273275        case LEFT_LINE_INPUT:
    274276        case RIGHT_LINE_INPUT:
    275             pStream->SetInputSrc(MIX_RECSRC_LINE);
     277            pStream->SetProperty(PROPERTY_INPUTSRC, MIX_RECSRC_LINE);
    276278            break;
    277279
    278280        case MIC_INPUT:
    279281        case BOOSTED_MIC_INPUT:
    280             pStream->SetInputSrc(MIX_RECSRC_MIC);
     282            pStream->SetProperty(PROPERTY_INPUTSRC, MIX_RECSRC_MIC);
    281283            break;
    282284
    … …  
    288290        case MIDI_IN_PORT:
    289291//      case LOOPBACK:
    290             pStream->SetInputSrc(MIX_RECSRC_MIXER);
     292            pStream->SetProperty(PROPERTY_INPUTSRC, MIX_RECSRC_MIXER);
    291293            break;
    292294        }
    … …  
    294296   }
    295297   if(!fRecGainIOCTL90 && pAudChange->lGain != AUDIO_IGNORE) {
    296     // input ranges from 0 to 0x7FFFFFFF (linear)
    297     volume = pAudChange->lGain >> 16UL;
    298     volume = (volume*100UL)/0x7FFFUL;
    299     if(volume > 100) {
    300         volume = 100;
    301     }
    302     dprintf(("Set input gain of %x to %d", prp->s.ioctl.usSysFileNum, volume));
    303     pStream->SetInputGain(MAKE_VOLUME_LR(volume, volume));
     298       // input ranges from 0 to 0x7FFFFFFF (linear)
     299       volume = pAudChange->lGain >> 16UL;
     300       volume = (volume*100UL)/0x7FFFUL;
     301       if(volume > 100) {
     302           volume = 100;
     303       }
     304       dprintf(("Set input gain of %x to %d", prp->s.ioctl.usSysFileNum, volume));
     305       pStream->SetProperty(PROPERTY_INPUTGAIN, MAKE_VOLUME_LR(volume, volume));
    304306   }
    305307}
    … …  
    418420        }
    419421    }
    420 
     422    else
     423    if(prp->s.ioctl.bCode == DAUDIO_QUERYCAPS)
     424    {
     425        LPDAUDIO_CAPS lpCaps = (LPDAUDIO_CAPS) prp->s.ioctl.pvData;
     426        PWAVEAUDIO pHWobj;
     427
     428        if(DevHelp_VerifyAccess(SELECTOROF(lpCaps), sizeof(DAUDIO_CAPS), OFFSETOF(lpCaps), VERIFY_READWRITE) ||
     429           lpCaps->dwSize != sizeof(DAUDIO_CAPS))
     430        {
     431            dprintf(("Invalid DAUDIO_CAPS pointer %lx!!", (ULONG)lpCaps));
     432            prp->usStatus |= RPERR | RPBADCMD;
     433            return;
     434        }
     435        // get the pointer to the hardware object
     436        // call DevCaps
     437        // bailout if no hardware object is returned..
     438        pHWobj = (PWAVEAUDIO)GetHardwareDevice(AUDIOHW_WAVE_PLAY);
     439        if (pHWobj)
     440        {
     441            pHWobj->DevCaps(lpCaps);
     442            lpCaps->dwFreeHwMixingAllBuffers       = numFreeStreams;
     443            lpCaps->dwFreeHwMixingStaticBuffers    = numFreeStreams;
     444            lpCaps->dwFreeHwMixingStreamingBuffers = numFreeStreams;
     445            return;
     446        }
     447        else {
     448            prp->usStatus |= RPERR;
     449            return;
     450        }
     451    }
    421452    PSTREAM pStream;
    422453
    … …  
    447478    case DAUDIO_SETVOLUME:
    448479    {
    449         pStream->SetVolume(MAKE_VOLUME_LR(pDAudioCmd->Vol.VolumeL, pDAudioCmd->Vol.VolumeR));
     480        pStream->SetProperty(PROPERTY_VOLUME, MAKE_VOLUME_LR(pDAudioCmd->Vol.VolumeL, pDAudioCmd->Vol.VolumeR));
    450481        break;
    451482    }
    452483
    453484    case DAUDIO_GETVOLUME:
    454         pDAudioCmd->Vol.VolumeL = GET_VOLUME_L(pStream->GetVolume());
    455         pDAudioCmd->Vol.VolumeR = GET_VOLUME_R(pStream->GetVolume());
     485        pDAudioCmd->Vol.VolumeL = GET_VOLUME_L(pStream->GetProperty(PROPERTY_VOLUME));
     486        pDAudioCmd->Vol.VolumeR = GET_VOLUME_R(pStream->GetProperty(PROPERTY_VOLUME));
    456487        break;
    457488
    458489    case DAUDIO_START:
    459         rc = pStream->StartStream();
     490        if(numFreeStreams > 0) {
     491              rc = pStream->StartStream();
     492              if(!rc) numFreeStreams--;
     493        }
     494        else  rc = 1; //fail
     495
    460496        break;
    461497
    … …  
    463499    {
    464500        CONTROL_PARM cParm;
     501        int          fActive = pStream->isActive();
     502
    465503        rc = pStream->StopStream(&cParm);
     504        if(!rc && fActive) numFreeStreams++;
    466505        break;
    467506    }
    … …  
    480519    case DAUDIO_GETPOS:
    481520        pDAudioCmd->Pos.ulCurrentPos = pStream->GetCurrentPos();
     521        pDAudioCmd->Pos.ulWritePos   = pStream->GetCurrentWritePos();
    482522        break;
    483523
    … …  
    486526        rc = pStream->Write((PSTREAMBUF)pDAudioCmd->Buffer.lpBuffer, pDAudioCmd->Buffer.ulBufferLength);
    487527        break;
     528    }
     529
     530    case DAUDIO_SETPROPERTY:
     531    {
     532        rc = pStream->SetProperty(pDAudioCmd->SetProperty.type, pDAudioCmd->SetProperty.value);
    488533    }
    489534
    … …  
    506551    }
    507552
     553    case DAUDIO_QUERYVERSION:
     554        pDAudioCmd->Version.ulVersion = DAUDIO_VERSION;
     555        break;
    508556    }
    509557

  • sbliveos2/trunk/drv16/makefile.os2

    r176 r178  
    7070   $(LINK) @$(OBJDIR)\$(NAME).lrf
    7171   copy $(OBJDIR)\$(NAME).sys $(SBLIVE_BIN)
     72   copy $(OBJDIR)\$(NAME).sys $(SBLIVE_BIN_)
    7273
    7374$(OBJDIR)\$(NAME).sym: $(OBJDIR)\$(WMAPNAME)

  • sbliveos2/trunk/drv16/ossidc16.cpp

    r153 r178  
    9191BOOL OSS16_WriteMidiByte(ULONG streamid, BYTE midiByte)
    9292{
    93    return CallOSS32(IDC32_MIDI_WRITE, 0x666, OSS_STREAM_MIDIOUT, streamid, midiByte, 0);
     93   return (BOOL)CallOSS32(IDC32_MIDI_WRITE, 0x666, OSS_STREAM_MIDIOUT, streamid, midiByte, 0);
    9494}
    9595//******************************************************************************
    … …  
    9797int OSS16_ReadMidiBytes(ULONG streamid, char far *buffer, int bufsize)
    9898{
    99    return CallOSS32(IDC32_MIDI_READ, 0x666, OSS_STREAM_MIDIIN, streamid, (ULONG)buffer, bufsize);
     99   return (int)CallOSS32(IDC32_MIDI_READ, 0x666, OSS_STREAM_MIDIIN, streamid, (ULONG)buffer, bufsize);
    100100}
    101101//******************************************************************************

  • sbliveos2/trunk/drv16/rm.cpp

    r157 r178  
    4242#include <dbgos2.h>
    4343
    44 char DeviceName[64] = "Creative Labs SoundBlaster Live";
    45 
     44#define EMU10K1_JOYSTICK_EXTENT 0x8     /* 8 byte I/O space */
     45#define EMU10K1_EXTENT  0x20    /* 32 byte I/O space */
     46
     47char DeviceName[64] = "Creative Labs SoundBlaster Live!";
     48char DeviceNameJoy[64] = "Creative Labs SoundBlaster Live! Joystick";
    4649/**@external LDev_Resources::isEmpty
    4750 *  Returns TRUE iff the LDev_Resources structure has no information.
    … …  
    141144           ((pGIS->uchMajorVersion == 20) && (pGIS->uchMinorVersion > 30)) );
    142145   }
    143 
    144    if(getPCIConfiguration(pciId) == FALSE) {
    145       _state = rmDriverFailed;
    146    }
    147 
    148146}
    149147
    … …  
    166164{
    167165#if 1
     166   if(getPCIConfiguration(DevID) == FALSE) {
     167      return FALSE;
     168   }
     169
    168170   //Manual detection in ResourceManager class constructor;
    169171   return (_state == rmDriverCreated || _state == rmAdapterCreated);
    … …  
    203205 */
    204206#pragma off (unreferenced)
    205 LDev_Resources* ResourceManager::GetRMDetectedResources ( DEVID DevID , ULONG ulSearchFlags, bool fPciDevice)
     207LDev_Resources* ResourceManager::GetRMDetectedResources ( DEVID DevID , ULONG ulSearchFlags, bool fPciDevice, bool fJoystick)
    206208#pragma on (unreferenced)
    207209{
    … …  
    215217
    216218   //Fill in resources read from PCI Configuration space
    217    pResources->uIRQLevel[0]  = pciConfigData->InterruptLine;
    218    if(pResources->uIRQLevel[0] == 0 || pResources->uIRQLevel[0] > 15)  {
    219         dprintf(("Invalid PCI irq %x", (int)pResources->uIRQLevel[0]));
    220         DebugInt3();
    221         return NULL;
     219   if(!fJoystick) {
     220        pResources->uIRQLevel[0]  = pciConfigData->InterruptLine;
     221        if(pResources->uIRQLevel[0] == 0 || pResources->uIRQLevel[0] > 15)  {
     222                dprintf(("Invalid PCI irq %x", (int)pResources->uIRQLevel[0]));
     223                DebugInt3();
     224                return NULL;
     225        }
    222226   }
    223227   pResources->uIOBase[0]   = (USHORT)(pciConfigData->Bar0 & 0xFFFFFFF0);
    224    pResources->uIOLength[0] = 0x20;
     228   if(fJoystick) {
     229        pResources->uIOLength[0] = EMU10K1_JOYSTICK_EXTENT;
     230   }
     231   else pResources->uIOLength[0] = EMU10K1_EXTENT;
    225232
    226233   return pResources;
    … …  
    345352 */
    346353
    347 LDev_Resources* ResourceManager::pGetDevResources ( DEVID DevID , ULONG ulSearchFlags, bool fPciDevice)
     354LDev_Resources* ResourceManager::pGetDevResources ( DEVID DevID , ULONG ulSearchFlags, bool fPciDevice, bool fJoystick)
    348355{
    349356   APIRET rc;
    … …  
    362369   // Initialize resource object.  Use detected information if available,
    363370   // otherwise use hardcoded defaults.
    364    pResources = GetRMDetectedResources( DevID, ulSearchFlags, fPciDevice );
     371   pResources = GetRMDetectedResources( DevID, ulSearchFlags, fPciDevice, fJoystick);
    365372   if (!pResources) goto exit;
    366373
    … …  
    369376   if (! pResourceList) goto exit;
    370377   pahResources = _pahRMAllocResources( pResourceList );
    371    if (! pahResources) goto exit;
     378   if (! pahResources) {
     379       _state = rmAllocFailed;
     380       goto exit;
     381   }
    372382
    373383   //--- Here, we got all the resources we wanted.  Register adapter if not yet done.
    … …  
    375385   if (_state != rmAdapterCreated) {
    376386      rc = _rmCreateAdapter();
    377 
    378       // Register the device with OS/2 RM.
    379       _rmCreateDevice((unsigned char __far *)DeviceName, pahResources );
    380    }
     387   }
     388
     389   // Register the device with OS/2 RM.
     390   if(fJoystick) {
     391        _rmCreateDevice((unsigned char __far *)DeviceNameJoy, pahResources );
     392   }
     393   else _rmCreateDevice((unsigned char __far *)DeviceName, pahResources );
    381394
    382395exit:

  • sbliveos2/trunk/drv16/rm.hpp

    r151 r178  
    147147 */
    148148
    149 enum RMObjectState { rmDriverCreated, rmDriverFailed, rmAdapterCreated, rmAdapterFailed };
     149enum RMObjectState { rmDriverCreated, rmDriverFailed, rmAdapterCreated, rmAdapterFailed, rmAllocFailed };
    150150
    151151class ResourceManager {         // A class to encapsulate system resource
    … …  
    169169
    170170   //###
    171    LDev_Resources* GetRMDetectedResources ( DEVID DevID , ULONG ulSearchFlags, bool fPciDevice );
    172 
    173    LDev_Resources* pGetDevResources ( DEVID DevID , ULONG ulSearchFlags, bool fPciDevice);
     171   LDev_Resources* GetRMDetectedResources ( DEVID DevID , ULONG ulSearchFlags, bool fPciDevice, bool fJoystick );
     172
     173   LDev_Resources* pGetDevResources ( DEVID DevID , ULONG ulSearchFlags, bool fPciDevice, bool fJoystick = FALSE);
    174174
    175175   inline RMObjectState getState() { return _state; };

  • sbliveos2/trunk/drv16/stream.cpp

    r166 r178  
    188188
    189189
    190 virtual ULONG STREAM::Write(PSTREAMBUF pbuf, ULONG uLength)
     190#pragma off (unreferenced)
     191virtual ULONG STREAM::Write(PSTREAMBUF pbuf, ULONG uLength, BOOL fLooping)
     192#pragma on (unreferenced)
    191193{
    192194   qhInProcess.PushOnTail((PQUEUEELEMENT)new STREAMBUFFER(uLength, pbuf));
    … …  
    280282}
    281283
    282 void STREAM::SetInputSrc(int src)          { inputsrc      = src; }
    283 void STREAM::SetInputGain(ULONG gain)      { inputgain     = gain; }
    284 void STREAM::SetVolume(ULONG volume)       { this->volume  = volume; }
    285 void STREAM::SetBalance(ULONG balance)     { this->balance = balance; }
    286 
    287 BOOL STREAM::SetMasterVol(ULONG volume)
    288 {
    289   if(mastervol != volume) {
    290         mastervol = volume;
    291         return OSS16_SetMasterVol(this, volume);
    292   }
    293   return TRUE;
    294 }
     284#pragma off (unreferenced)
     285void STREAM::SetLooping(BOOL fLooping)
     286#pragma on (unreferenced)
     287{
     288   return;
     289}
     290
     291BOOL STREAM::SetProperty(int type, ULONG value, ULONG reserved)
     292{
     293   switch(type) {
     294   case PROPERTY_VOLUME:
     295       volume = value;
     296       break;
     297
     298   case PROPERTY_BALANCE:
     299       balance = value;
     300       break;
     301
     302   case PROPERTY_MASTERVOL:
     303       if(mastervol != value) {
     304           mastervol = value;
     305           return OSS16_SetMasterVol(this, mastervol);
     306       }
     307       break;
     308   default:
     309       return FALSE;
     310   }
     311   return TRUE;
     312}
     313
     314ULONG STREAM::GetProperty(int type)
     315{
     316   switch(type) {
     317   case PROPERTY_FREQUENCY:
     318   case PROPERTY_LOOPING:
     319       break;
     320
     321   case PROPERTY_VOLUME:
     322       return volume;
     323
     324   case PROPERTY_BALANCE:
     325       return balance;
     326
     327   case PROPERTY_MASTERVOL:
     328       return mastervol;
     329   }
     330   return -1;
     331}
     332
    295333ULONG STREAM::mastervol = MAKE_VOLUME_LR(100, 100);
    296334

  • sbliveos2/trunk/drv16/stream.hpp

    r167 r178  
    3333#include "audiohw.hpp"
    3434#include "strmbuff.hpp"
     35#include <daudio.h>
    3536
    3637extern PQUEUEHEAD pStreamList;   // List head for Streams.Defined in STREAM.CPP.
    … …  
    8283   virtual ULONG Register(PDDCMDREGISTER);
    8384   virtual void  DeRegister(void);
    84    virtual ULONG Write(PSTREAMBUF, ULONG);
     85   virtual ULONG Write(PSTREAMBUF, ULONG, BOOL fLooping = 0);
     86   virtual void  SetLooping(BOOL fLooping);
    8587   virtual ULONG Read(PSTREAMBUF, unsigned) = 0;
    8688   virtual ULONG GetCurrentTime(void) = 0;
    8789   virtual ULONG GetCurrentPos(void) = 0;
     90   virtual ULONG GetCurrentWritePos(void) = 0;
    8891   virtual void  SetCurrentTime(ULONG time) = 0;
    8992   virtual ULONG StartStream(void) = 0;
    … …  
    9295   virtual ULONG ResumeStream(void) = 0;
    9396
    94    virtual void  SetInputSrc(int src);
    95    virtual void  SetInputGain(ULONG gain);
    96    virtual void  SetVolume(ULONG volume);
    97            ULONG GetVolume() { return volume; };
    98    virtual void  SetBalance(ULONG balance);
    99    virtual BOOL  SetMasterVol(ULONG volume);
     97           BOOL  isActive()        { return ulStreamState == STREAM_STREAMING; };
     98
     99   virtual BOOL  SetProperty(int type, ULONG value, ULONG reserved = 0);
     100   virtual ULONG GetProperty(int type);
    100101
    101102   void SetNextEvent(void);

  • sbliveos2/trunk/drv16/strmbuff.hpp

    r168 r178  
    3434    ULONG       ulBuffpos; // Current buffer position
    3535    ULONG       ulDonepos; // position at which the buffer can be returned
    36     STREAMBUFFER(ULONG bufsize, PSTREAMBUF bufptr):
     36    ULONG       lock[3];        //lock handle
     37    ULONG       linLock;
     38    BOOL        fDone;
     39    BOOL        looping;
     40
     41    STREAMBUFFER(ULONG bufsize, PSTREAMBUF bufptr, BOOL fLooping = FALSE):
    3742    pBuffptr(bufptr),
    3843    ulBuffsz(bufsize),
    3944    ulBuffpos(0),
    40     ulDonepos(0)
     45    ulDonepos(0),
     46    looping(fLooping),
     47    fDone(0),
     48    linLock(0)
    4149    {};
    4250
    … …  
    4452typedef STREAMBUFFER *PSTREAMBUFFER;
    4553
    46 
    47 class STREAMBUFFEREX : public STREAMBUFFER
    48 {
    49 public:
    50     STREAMBUFFEREX(ULONG bufsize, PSTREAMBUF bufptr):
    51     STREAMBUFFER(bufsize, bufptr), fDone(FALSE)
    52     {
    53     };
    54 
    55     ULONG  lock[3];     //lock handle
    56     ULONG  linLock;
    57     BOOL   fDone;
    58 
    59 };
    60 typedef STREAMBUFFEREX *PSTREAMBUFFEREX;
    61 
    6254#endif

  • sbliveos2/trunk/drv16/timer.cpp

    r151 r178  
    150150 *  TIMER_Disabled state on problem.
    151151 */
     152#pragma off (unreferenced)
    152153TIMER::TIMER( IRQ* pIRQ, USHORT uTargetMSec, ULONG ulStreamType ) :
    153154   _ulStreamType ( ulStreamType )
     155#pragma on (unreferenced)
    154156{
    155157   USHORT rc;
    156    BOOL bGoodReturn;
    157158   static ULONG hookHandle;
    158159
    … …  
    353354{
    354355   USHORT rc;
    355    BOOL bGoodReturn;
    356356
    357357   // Disable any any pre-existing timer and reset state variables.

  • sbliveos2/trunk/drv16/waudio.cpp

    r142 r178  
    250250 *
    251251 */
     252void WAVEAUDIO::DevCaps(LPDAUDIO_CAPS lpCaps)
     253{
     254    lpCaps->dwFlags                        = DAUDIOCAPS_PRIMARYMONO |
     255                                             DAUDIOCAPS_PRIMARYSTEREO |
     256                                             DAUDIOCAPS_PRIMARY8BIT |
     257                                             DAUDIOCAPS_PRIMARY16BIT |
     258                                             DAUDIOCAPS_CONTINUOUSRATE |
     259                                             DAUDIOCAPS_CERTIFIED |
     260                                             DAUDIOCAPS_SECONDARYMONO |
     261                                             DAUDIOCAPS_SECONDARYSTEREO |
     262                                             DAUDIOCAPS_SECONDARY8BIT |
     263                                             DAUDIOCAPS_SECONDARY16BIT;
     264
     265    lpCaps->dwMinSecondarySampleRate       = SBLIVECAPS_MINSAMPLERATE;
     266    lpCaps->dwMaxSecondarySampleRate       = SBLIVECAPS_MAXSAMPLERATE;
     267    lpCaps->dwPrimaryBuffers               = 1;
     268    lpCaps->dwMaxHwMixingAllBuffers        = SBLIVECAPS_MAXSTREAMS;
     269    lpCaps->dwMaxHwMixingStaticBuffers     = SBLIVECAPS_MAXSTREAMS;
     270    lpCaps->dwMaxHwMixingStreamingBuffers  = SBLIVECAPS_MAXSTREAMS;
     271    lpCaps->dwMaxHw3DAllBuffers            = 0;
     272    lpCaps->dwMaxHw3DStaticBuffers         = 0;
     273    lpCaps->dwMaxHw3DStreamingBuffers      = 0;
     274    lpCaps->dwFreeHw3DAllBuffers           = 0;
     275    lpCaps->dwFreeHw3DStaticBuffers        = 0;
     276    lpCaps->dwFreeHw3DStreamingBuffers     = 0;
     277    lpCaps->dwTotalHwMemBytes              = 0;
     278    lpCaps->dwFreeHwMemBytes               = 0;
     279    lpCaps->dwMaxContigFreeHwMemBytes      = 0;
     280    lpCaps->dwUnlockTransferRateHwBuffers  = 0;
     281    lpCaps->dwPlayCpuOverheadSwBuffers     = 0;
     282    lpCaps->dwReserved1                    = 0;
     283    lpCaps->dwReserved2                    = 0;
     284}
     285
     286/**@internal
     287 * @param
     288 * @return
     289 * @notes
     290 *
     291 */
    252292#pragma off (unreferenced)
    253293virtual void WAVEAUDIO::ConfigDev(STREAM *stream, PWAVECONFIGINFO pConfigInfo)

  • sbliveos2/trunk/drv16/wavestrm.cpp

    r168 r178  
    2525#include <os2me.h>
    2626#include <audio.h>                // for #define MIDI
     27#include <include.h>
    2728
    2829#include "wavestrm.hpp"
    … …  
    154155// if this is a write stream call _vFillAudioBuf
    155156//
    156 void WAVESTREAM::AddBuffers(void)
     157#pragma off (unreferenced)
     158void WAVESTREAM::AddBuffers(BOOL fFirst)
     159#pragma on (unreferenced)
    157160{
    158161 ULONG space, byteswritten;
    … …  
    303306                ReturnBuffer();
    304307        }
    305         AddBuffers();
     308        AddBuffers(FALSE);
    306309        break;
    307310   }
    … …  
    316319}
    317320
    318 ULONG WAVESTREAM::Write(PSTREAMBUF pbuf, ULONG uLength)
     321#pragma off (unreferenced)
     322ULONG WAVESTREAM::Write(PSTREAMBUF pbuf, ULONG uLength, BOOL fLooping)
     323#pragma on (unreferenced)
    319324{
    320325 PSTREAMBUFFER pStreamBuf = new STREAMBUFFER(uLength, pbuf);
    … …  
    330335        fUnderrun = FALSE;
    331336        OSS16_StreamReset(this);
    332         AddBuffers();
     337        AddBuffers(TRUE);
    333338        if(ulStreamType == STREAM_WAVE_PLAY)
    334339                OSS16_SetWaveOutVol(this, volume);
    … …  
    399404}
    400405
     406ULONG WAVESTREAM::GetCurrentWritePos(void)
     407{
     408   ULONG writepos = 0;
     409
     410   cli();
     411   PSTREAMBUFFER pTemp = (PSTREAMBUFFER)qhDone.Tail();
     412
     413   if(!pTemp) {
     414       pTemp = (PSTREAMBUFFER)qhInProcess.Head();
     415   }
     416   if(pTemp) {
     417       writepos = pTemp->ulBuffpos;
     418   }
     419   sti();
     420   return writepos;
     421}
     422
    401423//
    402424// SetCurrentTime
    … …  
    415437{
    416438 PSTREAMBUFFER pTemp = (PSTREAMBUFFER)qhInProcess.Head();
    417  ULONG fragsize;
    418439
    419440   // configure the wave device
    … …  
    445466   //Adding the first buffer also starts playback
    446467   if(ulStreamType == STREAM_WAVE_PLAY) {
    447         AddBuffers();
     468        AddBuffers(TRUE);
    448469   }
    449470   else {
    … …  
    464485
    465486}
     487
    466488ULONG  WAVESTREAM::StopStream(PCONTROL_PARM pControl)
    467489{
    … …  
    521543   ulStreamState = STREAM_STREAMING;
    522544   //Adding the first buffer also starts playback
    523    AddBuffers();
     545   AddBuffers(TRUE);
    524546
    525547   return NO_ERROR;
    … …  
    527549}
    528550
    529 void WAVESTREAM::SetInputSrc(int src)
    530 {
    531    inputsrc = src;
    532 }
    533 
    534 void WAVESTREAM::SetInputGain(ULONG gain)
    535 {
    536    inputgain = gain;
    537 }
    538 
    539 void WAVESTREAM::SetVolume(ULONG volume)
    540 {
    541    this->volume = volume;
    542    if(ulStreamState == STREAM_STREAMING && ulStreamType == STREAM_WAVE_PLAY) {
    543         OSS16_SetWaveOutVol(this, volume);
     551
     552BOOL WAVESTREAM::SetProperty(int type, ULONG value, ULONG reserved)
     553{
     554   switch(type) {
     555   case PROPERTY_VOLUME:
     556       volume = value;
     557       if(ulStreamState == STREAM_STREAMING && ulStreamType == STREAM_WAVE_PLAY) {
     558           OSS16_SetWaveOutVol(this, volume);
     559       }
     560       break;
     561
     562   case PROPERTY_INPUTSRC:
     563       inputsrc = value;
     564       break;
     565
     566   case PROPERTY_INPUTGAIN:
     567       inputgain = value;
     568       break;
     569
     570   default:
     571       return STREAM::SetProperty(type, value, reserved);
     572
     573   }
     574   return TRUE;
     575}
     576
     577ULONG WAVESTREAM::GetProperty(int type)
     578{
     579   switch(type) {
     580   case PROPERTY_FREQUENCY:
     581       return _configinfo.ulSampleRate;
     582
     583   case PROPERTY_INPUTSRC:
     584       return inputsrc;
     585
     586   case PROPERTY_INPUTGAIN:
     587       return inputgain;
     588
     589   default:
     590       return STREAM::GetProperty(type);
    544591   }
    545592}

  • sbliveos2/trunk/drv16/wavestrm.hpp

    r166 r178  
    4040   virtual ULONG  GetCurrentTime(void);
    4141   virtual ULONG  GetCurrentPos(void);
     42   virtual ULONG  GetCurrentWritePos(void);
    4243   virtual void   SetCurrentTime(ULONG time);
    4344   virtual ULONG  Read(PSTREAMBUF, unsigned);
    44    virtual ULONG  Write(PSTREAMBUF, ULONG);
     45   virtual ULONG  Write(PSTREAMBUF, ULONG, BOOL fLooping = 0);
    4546           ULONG  Write(PSTREAMBUFFER);
    4647   virtual ULONG  StartStream(void);
    … …  
    5152   virtual ~WAVESTREAM();
    5253
    53    virtual void  SetInputSrc(int src);
    54    virtual void  SetInputGain(ULONG gain);
    55    virtual void  SetVolume(ULONG volume);
    56 //   virtual void  SetBalance(ULONG balance);
     54   virtual BOOL  SetProperty(int type, ULONG value, ULONG reserved = 0);
     55   virtual ULONG GetProperty(int type);
    5756
    58 private:
     57protected:
    5958
    6059   ULONG   _ulAudioBufSz;         // size of the audio buffer
    … …  
    6261   ULONG   _ulBytesProcessed;     // number of bytes consumed or produces
    6362   ULONG   _ulTimeBase;           // value in ms. MMPM sends for stream time
     63   ULONG   fragsize;
    6464   USHORT  _vRealignBuffer(ULONG FAR *endpos, PSTREAMBUFFER pbuffer);
    6565   void    _vRealignPausedBuffers(ULONG endpos = 0);
    66    void    AddBuffers();            // Initialize the audio buffer object
     66   virtual void    AddBuffers(BOOL fFirst);         // Initialize the audio buffer object
    6767   ULONG   AddBuffer(ULONG space);             // write one buffer to the audio buffer
    6868   BOOL    _vReadAudioBuf(void);    // read data from the audio buffer
Note: See TracChangeset for help on using the changeset viewer.