Changeset 166 for sbliveos2/trunk/drv16


Ignore:
Timestamp:
Mar 22, 2001, 7:13:01 PM (25 years ago)
Author:
sandervl
Message:

update for new direct audio interface

Location:
sbliveos2/trunk/drv16
Files:
2 added
8 edited

Legend:

Unmodified
Added
Removed

  • sbliveos2/trunk/drv16/ioctl.cpp

    r148 r166  
    2424#define INCL_NOPMAPI
    2525#include <os2.h>
     26#include <os2me.h>
    2627#include <audio.h>
    2728
    … …  
    3031#include "mpu401.hpp"
    3132#include "wavehw.hpp"
    32 #include "wavestrm.hpp"
     33#include "dwavestrm.hpp"
    3334#include "midistrm.hpp"
    3435
    … …  
    4142#include <parse.h>
    4243#include "ioctl.h"
     44
     45#include <daudio.h>
    4346
    4447//Map of possible 256 supported ioctls (IOCTl 90 mixer api)
    … …  
    205208
    206209   if (p->usIOCtlRequest != AUDIO_CHANGE) {
    207         p->sReturnCode = INVALID_REQUEST;
    208         prp->usStatus |= RPERR | RPBADCMD;
    209         return;
     210    p->sReturnCode = INVALID_REQUEST;
     211    prp->usStatus |= RPERR | RPBADCMD;
     212    return;
    210213   }
    211214   p->sReturnCode=0;
    … …  
    217220   addr += sizeof(MCI_AUDIO_CHANGE);
    218221   if(addr >= 0x10000UL) {
    219         dprintf(("Invalid MCI_AUDIO_CHANGE pointer %lx!!", (ULONG)pAudChange));
    220         p->sReturnCode = INVALID_REQUEST;
    221         prp->usStatus |= RPERR | RPBADCMD;
    222         return;
     222    dprintf(("Invalid MCI_AUDIO_CHANGE pointer %lx!!", (ULONG)pAudChange));
     223    p->sReturnCode = INVALID_REQUEST;
     224    prp->usStatus |= RPERR | RPBADCMD;
     225    return;
    223226   }
    224227   pMasterVol = (LPMCI_TRACK_INFO)pAudChange->pvDevInfo;
    … …  
    228231   addr += sizeof(MCI_TRACK_INFO);
    229232   if(addr >= 0x10000UL) {
    230         dprintf(("Invalid MCI_TRACK_INFO pointer %lx!!", (ULONG)pMasterVol));
    231         p->sReturnCode = INVALID_REQUEST;
    232         prp->usStatus |= RPERR | RPBADCMD;
    233         return;
     233    dprintf(("Invalid MCI_TRACK_INFO pointer %lx!!", (ULONG)pMasterVol));
     234    p->sReturnCode = INVALID_REQUEST;
     235    prp->usStatus |= RPERR | RPBADCMD;
     236    return;
    234237   }
    235238
    236239   pStream = FindStream_fromFile((ULONG) prp->s.ioctl.usSysFileNum);
    237240   if(pStream == NULL) {
    238         dprintf(("IoctlAudioControl stream %lx not found!", (ULONG) prp->s.ioctl.usSysFileNum));
    239         DebugInt3();
    240         return;
     241    dprintf(("IoctlAudioControl stream %lx not found!", (ULONG) prp->s.ioctl.usSysFileNum));
     242    DebugInt3();
     243    return;
    241244   }
    242245   if(pAudChange->lBalance != AUDIO_IGNORE)
    243         pStream->SetBalance(pAudChange->lBalance);
     246    pStream->SetBalance(pAudChange->lBalance);
    244247
    245248   if(pAudChange->lVolume != AUDIO_IGNORE) {
    246         // stream volume ranges from 0 to 0x7FFFFFFF (linear)
    247         volume = pAudChange->lVolume >> 16UL;
    248         volume = (volume*100UL)/0x7FFFUL;
    249         dprintf(("Set stream volume of %x to %d", prp->s.ioctl.usSysFileNum, volume));
    250         pStream->SetVolume(MAKE_VOLUME_LR(volume, volume));
    251    }
    252    
     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));
     254   }
     255
    253256   if(pMasterVol && pMasterVol->usMasterVolume != AUDIO_IGNORE) {
    254         // master volume ranges from 0 to 0x7FFF (linear)
    255         volume = pMasterVol->usMasterVolume;
    256         volume = (volume*100UL)/0x7FFFUL;               
    257         if(volume > 100) {
    258                 volume = 100;
    259         }
    260         dprintf(("Set mastervolume to %d", volume));
    261         pStream->SetMasterVol(MAKE_VOLUME_LR(volume, volume));
     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));
    262265   }
    263266   if(!fRecSrcIOCTL90) {
    264         for(int i=0;i<8;i++)
    265         {
    266                 switch(pAudChange->rInputList[0].ulDevType) {
    267                 case NULL_INPUT:
    268                         break; //continue;
    269                 case STEREO_LINE_INPUT:
    270                 case LEFT_LINE_INPUT:
    271                 case RIGHT_LINE_INPUT:
    272                         pStream->SetInputSrc(MIX_RECSRC_LINE);
    273                         break;
    274        
    275                 case MIC_INPUT:
    276                 case BOOSTED_MIC_INPUT:
    277                         pStream->SetInputSrc(MIX_RECSRC_MIC);
    278                         break;
    279        
    280                 case PHONE_LINE_INPUT:
    281                 case HANDSET_INPUT:
    282                 case SYNTH_INPUT:
    283                 case DIGITAL_PHONE_LINE_INPUT:
    284                 case DIGITAL_HANDSET_INPUT:
    285                 case MIDI_IN_PORT:
    286 //              case LOOPBACK:
    287                         pStream->SetInputSrc(MIX_RECSRC_MIXER);
    288                         break;
    289                 }
    290         }
     267    for(int i=0;i<8;i++)
     268    {
     269        switch(pAudChange->rInputList[0].ulDevType) {
     270        case NULL_INPUT:
     271            break; //continue;
     272        case STEREO_LINE_INPUT:
     273        case LEFT_LINE_INPUT:
     274        case RIGHT_LINE_INPUT:
     275            pStream->SetInputSrc(MIX_RECSRC_LINE);
     276            break;
     277
     278        case MIC_INPUT:
     279        case BOOSTED_MIC_INPUT:
     280            pStream->SetInputSrc(MIX_RECSRC_MIC);
     281            break;
     282
     283        case PHONE_LINE_INPUT:
     284        case HANDSET_INPUT:
     285        case SYNTH_INPUT:
     286        case DIGITAL_PHONE_LINE_INPUT:
     287        case DIGITAL_HANDSET_INPUT:
     288        case MIDI_IN_PORT:
     289//      case LOOPBACK:
     290            pStream->SetInputSrc(MIX_RECSRC_MIXER);
     291            break;
     292        }
     293    }
    291294   }
    292295   if(!fRecGainIOCTL90 && pAudChange->lGain != AUDIO_IGNORE) {
    293         // input ranges from 0 to 0x7FFFFFFF (linear)
    294         volume = pAudChange->lGain >> 16UL;
    295         volume = (volume*100UL)/0x7FFFUL;
    296         if(volume > 100) {
    297                 volume = 100;
    298         }
    299         dprintf(("Set input gain of %x to %d", prp->s.ioctl.usSysFileNum, volume));
    300         pStream->SetInputGain(MAKE_VOLUME_LR(volume, volume));
    301    }
     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));
     304   }
     305}
     306//******************************************************************************
     307//******************************************************************************
     308void IoctlDirectAudio(PREQPACKET prp)
     309{
     310 PSTREAM pStream;
     311
     312    if(prp->s.ioctl.bCode == DAUDIO_OPEN)
     313    {
     314        LPMCI_AUDIO_INIT pInit = (LPMCI_AUDIO_INIT) prp->s.ioctl.pvData;
     315        PAUDIOHW pHWobj;
     316        MCI_AUDIO_CAPS audioCaps;
     317
     318        if(DevHelp_VerifyAccess(SELECTOROF(pInit), sizeof(MCI_AUDIO_INIT), OFFSETOF(pInit), VERIFY_READWRITE))
     319        {
     320            dprintf(("Invalid MCI_AUDIO_INIT pointer %lx!!", (ULONG)pInit));
     321            prp->usStatus |= RPERR | RPBADCMD;
     322            return;
     323        }
     324
     325        audioCaps.ulLength        = sizeof(MCI_AUDIO_CAPS);
     326        audioCaps.ulSamplingRate  = pInit->lSRate;
     327        audioCaps.ulChannels      = pInit->sChannels;
     328        audioCaps.ulBitsPerSample = pInit->lBitsPerSRate;
     329        audioCaps.ulDataType      = pInit->sMode;
     330        audioCaps.ulOperation     = OPERATION_PLAY;
     331
     332        // get the pointer to the hardware object
     333        // call DevCaps
     334        // bailout if no hardware object is returned..
     335        pHWobj = GetHardwareDevice(AUDIOHW_WAVE_PLAY);
     336        if (pHWobj)
     337        {
     338            pHWobj->DevCaps(&audioCaps);
     339            if (audioCaps.ulSupport != SUPPORT_SUCCESS) {
     340                dprintf(("IoctlDirectAudio: DevCaps failed"));
     341                pInit->sReturnCode = INVALID_REQUEST;
     342                prp->usStatus |= RPERR;
     343                return;
     344            }
     345        }
     346        else {
     347            pInit->sReturnCode = INVALID_REQUEST;
     348            prp->usStatus |= RPERR;
     349            return;
     350        }
     351
     352        pStream = new DWAVESTREAM(AUDIOHW_WAVE_PLAY, pInit,  prp->s.ioctl.usSysFileNum);
     353        if(pStream == NULL) {
     354            DebugInt3();
     355            pInit->sReturnCode = INVALID_REQUEST;
     356            prp->usStatus |= RPERR;
     357            return;
     358        }
     359
     360        pInit->ulFlags |= VOLUME;           /* volume control is supported   */
     361        pInit->ulFlags |= INPUT;            /* Input select is supported     */
     362        pInit->ulFlags |= OUTPUT;           /* Output select is supported    */
     363        pInit->ulFlags |= MONITOR;          /* Record Monitor is supported   */
     364        pInit->sDeviceID = SB_LIVE;      /* Reported in VSD dll           */
     365        pStream->ulSysFileNum = prp->s.ioctl.usSysFileNum;
     366        pInit->pvReserved = (VOID FAR *) (ULONG) prp->s.ioctl.usSysFileNum;
     367        pInit->sReturnCode = 0;
     368
     369        return;
     370    }
     371    else
     372    if(prp->s.ioctl.bCode == DAUDIO_QUERYFORMAT)
     373    {
     374        LPMCI_AUDIO_INIT pInit = (LPMCI_AUDIO_INIT) prp->s.ioctl.pvData;
     375        PAUDIOHW pHWobj;
     376        MCI_AUDIO_CAPS audioCaps;
     377
     378        if(DevHelp_VerifyAccess(SELECTOROF(pInit), sizeof(MCI_AUDIO_INIT), OFFSETOF(pInit), VERIFY_READWRITE))
     379        {
     380            dprintf(("Invalid MCI_AUDIO_INIT pointer %lx!!", (ULONG)pInit));
     381            prp->usStatus |= RPERR | RPBADCMD;
     382            return;
     383        }
     384
     385        audioCaps.ulLength        = sizeof(MCI_AUDIO_CAPS);
     386        audioCaps.ulSamplingRate  = pInit->lSRate;
     387        audioCaps.ulChannels      = pInit->sChannels;
     388        audioCaps.ulBitsPerSample = pInit->lBitsPerSRate;
     389        audioCaps.ulDataType      = pInit->sMode;
     390        audioCaps.ulOperation     = OPERATION_PLAY;
     391
     392        // get the pointer to the hardware object
     393        // call DevCaps
     394        // bailout if no hardware object is returned..
     395        pHWobj = GetHardwareDevice(AUDIOHW_WAVE_PLAY);
     396        if (pHWobj)
     397        {
     398            pHWobj->DevCaps(&audioCaps);
     399            if (audioCaps.ulSupport != SUPPORT_SUCCESS) {
     400                dprintf(("IoctlDirectAudio: DevCaps failed"));
     401                prp->usStatus |= RPERR;
     402                pInit->sReturnCode = INVALID_REQUEST;
     403                return;
     404            }
     405            pInit->sReturnCode = 0;
     406            return;
     407        }
     408        else {
     409            pInit->sReturnCode = INVALID_REQUEST;
     410            prp->usStatus |= RPERR;
     411            return;
     412        }
     413    }
     414
     415    pStream = FindStream_fromFile((ULONG) prp->s.ioctl.usSysFileNum);
     416    if(pStream == NULL) {
     417        dprintf(("IoctlDirectAudio stream %lx not found!", (ULONG) prp->s.ioctl.usSysFileNum));
     418        DebugInt3();
     419        prp->usStatus |= RPERR | RPBADCMD;
     420        return;
     421    }
     422
     423    LPDAUDIO_CMD pDAudioCmd = (LPDAUDIO_CMD) prp->s.ioctl.pvData;
     424    ULONG        rc = 0;
     425
     426    if(DevHelp_VerifyAccess(SELECTOROF(pDAudioCmd), sizeof(DAUDIO_CMD), OFFSETOF(pDAudioCmd), VERIFY_READWRITE))
     427    {
     428        dprintf(("Invalid DAUDIO_CMD pointer %lx!!", (ULONG)pDAudioCmd));
     429        prp->usStatus |= RPERR | RPBADCMD;
     430        return;
     431    }
     432
     433    switch(prp->s.ioctl.bCode)
     434    {
     435    case DAUDIO_CLOSE:
     436        delete pStream;
     437        break;
     438
     439    case DAUDIO_SETVOLUME:
     440        pStream->SetVolume(pDAudioCmd->Vol.Volume);
     441        break;
     442
     443    case DAUDIO_GETVOLUME:
     444        pDAudioCmd->Vol.Volume = pStream->GetVolume();
     445        break;
     446
     447    case DAUDIO_START:
     448        rc = pStream->StartStream();
     449        break;
     450
     451    case DAUDIO_STOP:
     452    {
     453        CONTROL_PARM cParm;
     454        rc = pStream->StopStream(&cParm);
     455        break;
     456    }
     457
     458    case DAUDIO_PAUSE:
     459    {
     460        CONTROL_PARM cParm;
     461        rc = pStream->PauseStream(&cParm);
     462        break;
     463    }
     464
     465    case DAUDIO_RESUME:
     466        rc = pStream->ResumeStream();
     467        break;
     468
     469    case DAUDIO_GETPOS:
     470        pDAudioCmd->Pos.ulCurrentPos = pStream->GetCurrentPos();
     471        break;
     472
     473    case DAUDIO_ADDBUFFER:
     474    {
     475        rc = pStream->Write((PSTREAMBUF)pDAudioCmd->Buffer.lpBuffer, pDAudioCmd->Buffer.ulBufferLength);
     476        break;
     477    }
     478
     479    case DAUDIO_REGISTER_THREAD:
     480    {
     481        DDCMDREGISTER reg;
     482
     483        if(DevHelp_OpenEventSem(pDAudioCmd->Thread.hSemaphore) != 0) {
     484            dprintf(("DevHlp_OpenEventSem %lx failed!", pDAudioCmd->Thread.hSemaphore));
     485            prp->usStatus |= RPERR | RPBADCMD;
     486            return;
     487        }
     488
     489        reg.ulFunction     = DDCMD_REG_STREAM;
     490        reg.hStream        = pDAudioCmd->Thread.hSemaphore;
     491        reg.ulSysFileNum   = prp->s.ioctl.usSysFileNum;
     492        reg.pSHDEntryPoint = NULL;
     493        rc = pStream->Register(&reg);
     494        break;
     495    }
     496
     497    case DAUDIO_DEREGISTER_THREAD:
     498    {
     499        pStream->DeRegister();
     500
     501        if(DevHelp_CloseEventSem(pDAudioCmd->Thread.hSemaphore) != 0) {
     502            dprintf(("DevHlp_CloseEventSemaphore %lx failed!", pDAudioCmd->Thread.hSemaphore));
     503            prp->usStatus |= RPERR | RPBADCMD;
     504            return;
     505        }
     506        break;
     507    }
     508
     509    }
     510
     511    if(rc) {
     512        prp->usStatus |= RPERR | RPBADCMD;
     513        return;
     514    }
     515    return;
    302516}
    303517//******************************************************************************
    … …  
    310524 USHORT    VolumeL, VolumeR;
    311525
    312    if((prp->s.ioctl.bCode & 0xF0) == 0x40) 
     526   if((prp->s.ioctl.bCode & 0xF0) == 0x40)
    313527   {
    314         if(DevHelp_VerifyAccess(SELECTOROF(pMixStruct), sizeof(MIXSTRUCT), OFFSETOF(pMixStruct), VERIFY_READWRITE))
    315         {
    316                 dprintf(("Invalid IOCTL90 pointer %lx!!", (ULONG)pMixStruct));
    317                 prp->usStatus |= RPERR | RPBADCMD;
    318                 return;
    319         }
    320         MixerSettings[prp->s.ioctl.bCode & 0xF].VolumeL = pMixStruct->VolumeL;
    321         MixerSettings[prp->s.ioctl.bCode & 0xF].VolumeR = pMixStruct->VolumeR;
    322         MixerSettings[prp->s.ioctl.bCode & 0xF].Mute = pMixStruct->Mute;
    323         VolumeL = (USHORT)pMixStruct->VolumeL;
    324         VolumeR = (USHORT)pMixStruct->VolumeR;
    325         if(prp->s.ioctl.bCode != BASSTREBLESET) {
    326                 if(pMixStruct->Mute == 1)
    327                         VolumeL = VolumeR = 0;
    328         }
     528    if(DevHelp_VerifyAccess(SELECTOROF(pMixStruct), sizeof(MIXSTRUCT), OFFSETOF(pMixStruct), VERIFY_READWRITE))
     529    {
     530        dprintf(("Invalid IOCTL90 pointer %lx!!", (ULONG)pMixStruct));
     531        prp->usStatus |= RPERR | RPBADCMD;
     532        return;
     533    }
     534    MixerSettings[prp->s.ioctl.bCode & 0xF].VolumeL = pMixStruct->VolumeL;
     535    MixerSettings[prp->s.ioctl.bCode & 0xF].VolumeR = pMixStruct->VolumeR;
     536    MixerSettings[prp->s.ioctl.bCode & 0xF].Mute = pMixStruct->Mute;
     537    VolumeL = (USHORT)pMixStruct->VolumeL;
     538    VolumeR = (USHORT)pMixStruct->VolumeR;
     539    if(prp->s.ioctl.bCode != BASSTREBLESET) {
     540        if(pMixStruct->Mute == 1)
     541            VolumeL = VolumeR = 0;
     542    }
    329543   }
    330544   else
    331    if((prp->s.ioctl.bCode & 0xF0) == 0x60) 
     545   if((prp->s.ioctl.bCode & 0xF0) == 0x60)
    332546   {
    333         if(DevHelp_VerifyAccess(SELECTOROF(pMixStruct), sizeof(MIXSTRUCT), OFFSETOF(pMixStruct), VERIFY_READONLY))
    334         {
    335                 dprintf(("Invalid IOCTL90 pointer %lx!!", (ULONG)pMixStruct));
    336                 prp->usStatus |= RPERR | RPBADCMD;
    337                 return;
    338         }
    339    }
    340 
    341    switch(prp->s.ioctl.bCode) {
    342    case MICSET:
    343         OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETMICVOL, MAKE_VOLUME_LR(VolumeL, VolumeR));
    344         break;
    345    case LINESET:
    346         OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETLINEINVOL, MAKE_VOLUME_LR(VolumeL, VolumeR));
    347         break;
    348    case CDSET:
    349         OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETCDVOL, MAKE_VOLUME_LR(VolumeL, VolumeR));
    350         break;
    351    case VIDEOSET:
    352         OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETVIDEOVOL, MAKE_VOLUME_LR(VolumeL, VolumeR));
    353         break;
    354    case AUXSET:
    355         OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETAUXVOL, MAKE_VOLUME_LR(VolumeL, VolumeR));
    356         break;
    357 
    358    case BASSTREBLESET:
    359         OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETBASS, MAKE_VOLUME_LR(VolumeL, VolumeL));
    360         OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETTREBLE, MAKE_VOLUME_LR(VolumeR, VolumeR));
    361         break;
     547    if(DevHelp_VerifyAccess(SELECTOROF(pMixStruct), sizeof(MIXSTRUCT), OFFSETOF(pMixStruct), VERIFY_READONLY))
     548    {
     549        dprintf(("Invalid IOCTL90 pointer %lx!!", (ULONG)pMixStruct));
     550        prp->usStatus |= RPERR | RPBADCMD;
     551        return;
     552    }
     553   }
     554
     555    switch(prp->s.ioctl.bCode) {
     556    case MICSET:
     557        OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETMICVOL, MAKE_VOLUME_LR(VolumeL, VolumeR));
     558        break;
     559    case LINESET:
     560        OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETLINEINVOL, MAKE_VOLUME_LR(VolumeL, VolumeR));
     561        break;
     562    case CDSET:
     563        OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETCDVOL, MAKE_VOLUME_LR(VolumeL, VolumeR));
     564        break;
     565    case VIDEOSET:
     566        OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETVIDEOVOL, MAKE_VOLUME_LR(VolumeL, VolumeR));
     567        break;
     568    case AUXSET:
     569        OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETAUXVOL, MAKE_VOLUME_LR(VolumeL, VolumeR));
     570        break;
     571
     572    case BASSTREBLESET:
     573        OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETBASS, MAKE_VOLUME_LR(VolumeL, VolumeL));
     574        OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETTREBLE, MAKE_VOLUME_LR(VolumeR, VolumeR));
     575        break;
    362576#if 0
    363    case STREAMVOLSET:
    364         //release stream volume override?
    365         if(pMixStruct->Mute == 2) {
    366                 fStreamVolIOCTL90 = FALSE;
    367                 break;
    368         }
    369         fStreamVolIOCTL90 = TRUE;
    370         OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETMASTERVOL, MAKE_VOLUME_LR(VolumeL, VolumeR));
    371         break;
     577    case STREAMVOLSET:
     578        //release stream volume override?
     579        if(pMixStruct->Mute == 2) {
     580            fStreamVolIOCTL90 = FALSE;
     581            break;
     582        }
     583        fStreamVolIOCTL90 = TRUE;
     584        OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETMASTERVOL, MAKE_VOLUME_LR(VolumeL, VolumeR));
     585        break;
    372586#endif
    373587
    374    case RECORDSRCSET:
    375    {
    376      int recsrc;
    377 
    378         //release recording source override?
    379         if(pMixStruct->Mute == 2) {
    380                 fRecSrcIOCTL90 = FALSE;
    381                 break;
    382         }
    383         fRecSrcIOCTL90 = TRUE;
    384         switch(pMixStruct->VolumeL) {
    385         case I90SRC_MIC:
    386                 recsrc = MIX_RECSRC_MIC;
    387                 break;
    388         case I90SRC_CD:
    389                 recsrc = MIX_RECSRC_CD;
    390                 break;
    391         case I90SRC_VIDEO:
    392                 recsrc = MIX_RECSRC_VIDEO;
    393                 break;
    394         case I90SRC_LINE:
    395                 recsrc = MIX_RECSRC_LINE;
    396                 break;
    397         case I90SRC_AUX:
    398                 recsrc = MIX_RECSRC_AUX;
    399                 break;
    400 //      case I90SRC_RES5:
    401 //      case I90SRC_RES6:
    402 //      case I90SRC_PHONE:
    403         default:
    404                 break;
    405         }
    406         OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETINPUTSRC, recsrc);
    407         break; 
    408    }
    409    case RECORDGAINSET:
    410         //release recording gain override?
    411         if(pMixStruct->Mute == 2) {
    412                 fRecGainIOCTL90 = FALSE;
    413                 break;
    414         }
    415         fRecGainIOCTL90 = TRUE;
    416         OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETINPUTGAIN, MAKE_VOLUME_LR(VolumeL, VolumeR));
    417         break;
    418 
    419    case MICQUERY:
    420    case LINEQUERY:
    421    case AUXQUERY:
    422    case CDQUERY:
    423    case VIDEOQUERY:
    424    case RECORDSRCQUERY:
    425    case RECORDGAINQUERY:
    426         pMixStruct->VolumeL = MixerSettings[prp->s.ioctl.bCode & 0xF].VolumeL;
    427         pMixStruct->VolumeR = MixerSettings[prp->s.ioctl.bCode & 0xF].VolumeR;
    428         pMixStruct->Mute    = MixerSettings[prp->s.ioctl.bCode & 0xF].Mute;
    429         break;
    430 
    431    case BASSTREBLEQUERY:
    432         pMixStruct->VolumeL = MixerSettings[prp->s.ioctl.bCode & 0xF].VolumeL;
    433         pMixStruct->VolumeR = MixerSettings[prp->s.ioctl.bCode & 0xF].VolumeR;
    434         pMixStruct->Mute    = 3; //bass & treble
    435         break;
    436 
    437    case APILEVELQUERY:
    438         if(DevHelp_VerifyAccess(SELECTOROF(pIoctlData), sizeof(ULONG), OFFSETOF(pIoctlData), VERIFY_READWRITE))
    439         {
    440                 dprintf(("Invalid IOCTL90 pointer %lx!!", (ULONG)pIoctlData));
    441                 prp->usStatus |= RPERR | RPBADCMD;
    442                 return;
    443         }
    444         *pIoctlData = 2;
    445         break;
    446 
    447    case GETAPIMAP:
    448         if(DevHelp_VerifyAccess(SELECTOROF(pIoctlMap), sizeof(SBLiveIOCTLMap), OFFSETOF(pIoctlMap), VERIFY_READWRITE))
    449         {
    450                 dprintf(("Invalid IOCTL90 pointer %lx!!", (ULONG)pMixStruct));
    451                 prp->usStatus |= RPERR | RPBADCMD;
    452                 return;
    453         }
    454         _fmemcpy(pIoctlMap, SBLiveIOCTLMap, sizeof(SBLiveIOCTLMap));
    455         break;
     588    case RECORDSRCSET:
     589    {
     590        int recsrc = MIX_RECSRC_LINE;
     591
     592        //release recording source override?
     593        if(pMixStruct->Mute == 2) {
     594            fRecSrcIOCTL90 = FALSE;
     595            break;
     596        }
     597        fRecSrcIOCTL90 = TRUE;
     598        switch(pMixStruct->VolumeL) {
     599        case I90SRC_MIC:
     600            recsrc = MIX_RECSRC_MIC;
     601            break;
     602        case I90SRC_CD:
     603            recsrc = MIX_RECSRC_CD;
     604            break;
     605        case I90SRC_VIDEO:
     606            recsrc = MIX_RECSRC_VIDEO;
     607            break;
     608        case I90SRC_LINE:
     609            recsrc = MIX_RECSRC_LINE;
     610            break;
     611        case I90SRC_AUX:
     612            recsrc = MIX_RECSRC_AUX;
     613            break;
     614    //  case I90SRC_RES5:
     615    //  case I90SRC_RES6:
     616    //  case I90SRC_PHONE:
     617        default:
     618            break;
     619        }
     620        OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETINPUTSRC, recsrc);
     621        break;
     622    }
     623    case RECORDGAINSET:
     624        //release recording gain override?
     625        if(pMixStruct->Mute == 2) {
     626            fRecGainIOCTL90 = FALSE;
     627            break;
     628        }
     629        fRecGainIOCTL90 = TRUE;
     630        OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETINPUTGAIN, MAKE_VOLUME_LR(VolumeL, VolumeL));
     631        break;
     632
     633    case MICQUERY:
     634    case LINEQUERY:
     635    case AUXQUERY:
     636    case CDQUERY:
     637    case VIDEOQUERY:
     638    case RECORDSRCQUERY:
     639    case RECORDGAINQUERY:
     640        pMixStruct->VolumeL = MixerSettings[prp->s.ioctl.bCode & 0xF].VolumeL;
     641        pMixStruct->VolumeR = MixerSettings[prp->s.ioctl.bCode & 0xF].VolumeR;
     642        pMixStruct->Mute    = MixerSettings[prp->s.ioctl.bCode & 0xF].Mute;
     643        break;
     644
     645    case BASSTREBLEQUERY:
     646        pMixStruct->VolumeL = MixerSettings[prp->s.ioctl.bCode & 0xF].VolumeL;
     647        pMixStruct->VolumeR = MixerSettings[prp->s.ioctl.bCode & 0xF].VolumeR;
     648        pMixStruct->Mute    = 3; //bass & treble
     649        break;
     650
     651    case APILEVELQUERY:
     652        if(DevHelp_VerifyAccess(SELECTOROF(pIoctlData), sizeof(ULONG), OFFSETOF(pIoctlData), VERIFY_READWRITE))
     653        {
     654            dprintf(("Invalid IOCTL90 pointer %lx!!", (ULONG)pIoctlData));
     655            prp->usStatus |= RPERR | RPBADCMD;
     656            return;
     657        }
     658        *pIoctlData = 2;
     659        break;
     660
     661    case GETAPIMAP:
     662        if(DevHelp_VerifyAccess(SELECTOROF(pIoctlMap), sizeof(SBLiveIOCTLMap), OFFSETOF(pIoctlMap), VERIFY_READWRITE))
     663        {
     664            dprintf(("Invalid IOCTL90 pointer %lx!!", (ULONG)pMixStruct));
     665            prp->usStatus |= RPERR | RPBADCMD;
     666            return;
     667        }
     668        _fmemcpy(pIoctlMap, SBLiveIOCTLMap, sizeof(SBLiveIOCTLMap));
     669        break;
    456670//   case STREAMVOLQUERY:
    457671//   case MONOINSET:
    … …  
    463677//   case CALLBACKREG:
    464678//   case MSGBUF:
    465    default:
    466         prp->usStatus |= RPERR | RPBADCMD;
    467         return;
    468    }
     679    default:
     680        prp->usStatus |= RPERR | RPBADCMD;
     681        return;
     682    }
    469683}
    470684//******************************************************************************
    … …  
    475689 MIXSTRUCT mixinfo;
    476690
    477         SBLiveIOCTLMap[MICSET]           = 1;
    478         SBLiveIOCTLMap[MICQUERY]         = 1;
    479         SBLiveIOCTLMap[LINESET]          = 1;
    480         SBLiveIOCTLMap[LINEQUERY]        = 1;
    481         SBLiveIOCTLMap[CDSET]            = 1;
    482         SBLiveIOCTLMap[CDQUERY]          = 1;
    483         SBLiveIOCTLMap[VIDEOSET]         = 1;
    484         SBLiveIOCTLMap[VIDEOQUERY]       = 1;
    485         SBLiveIOCTLMap[AUXSET]           = 1;
    486         SBLiveIOCTLMap[AUXQUERY]         = 1;
    487         SBLiveIOCTLMap[BASSTREBLESET]    = 1;
    488         SBLiveIOCTLMap[BASSTREBLEQUERY]  = 1;
    489 ////    SBLiveIOCTLMap[STREAMVOLSET]     = 1;
    490 ////    SBLiveIOCTLMap[STREAMVOLQUERY]   = 1;
    491         SBLiveIOCTLMap[RECORDSRCSET]     = 1;
    492         SBLiveIOCTLMap[RECORDSRCQUERY]   = 1;
    493         SBLiveIOCTLMap[RECORDGAINSET]    = 1;
    494         SBLiveIOCTLMap[RECORDGAINQUERY]  = 1;
    495         SBLiveIOCTLMap[APILEVELQUERY]    = 1;
    496         SBLiveIOCTLMap[GETAPIMAP]        = 1;
    497 //      SBLiveIOCTLMap[CALLBACKREG]      = 1;
    498 
    499         //Set mic
    500         rp.s.ioctl.bCode  = MICSET;
    501         rp.s.ioctl.pvData = (void FAR *)&mixinfo;
    502         mixinfo.Mute    = fMicMute;
    503         mixinfo.VolumeR = mixinfo.VolumeL = 60;
    504         IoctlMixer(&rp);
    505 
    506         //Set line
    507         rp.s.ioctl.bCode  = LINESET;
    508         rp.s.ioctl.pvData = (void FAR *)&mixinfo;
    509         mixinfo.Mute    = fLineMute;
    510         mixinfo.VolumeR = mixinfo.VolumeL = 80;
    511         IoctlMixer(&rp);
    512 
    513         //Set CD
    514         rp.s.ioctl.bCode  = CDSET;
    515         rp.s.ioctl.pvData = (void FAR *)&mixinfo;
    516         mixinfo.Mute    = fCDMute;
    517         mixinfo.VolumeR = mixinfo.VolumeL = 80;
    518         IoctlMixer(&rp);
    519 
    520         //Set bass/treble
    521         rp.s.ioctl.bCode  = BASSTREBLESET;
    522         rp.s.ioctl.pvData = (void FAR *)&mixinfo;
    523         mixinfo.Mute    = 3;
    524         mixinfo.VolumeR = mixinfo.VolumeL = 50;
    525         IoctlMixer(&rp);
    526 
    527         //Set recording source to line in
    528         rp.s.ioctl.bCode  = RECORDSRCSET;
    529         rp.s.ioctl.pvData = (void FAR *)&mixinfo;
    530         mixinfo.Mute    = 0;
    531         mixinfo.VolumeL = I90SRC_LINE;
    532         IoctlMixer(&rp);
    533 
    534         //Release recording source override
    535         rp.s.ioctl.bCode  = RECORDSRCSET;
    536         rp.s.ioctl.pvData = (void FAR *)&mixinfo;
    537         mixinfo.Mute    = 2;
    538         mixinfo.VolumeL = I90SRC_LINE;
    539         IoctlMixer(&rp);
    540 
    541         //Set master volume
    542         rp.s.ioctl.bCode  = STREAMVOLSET;
    543         rp.s.ioctl.pvData = (void FAR *)&mixinfo;
    544         mixinfo.Mute    = 0;
    545         mixinfo.VolumeR = mixinfo.VolumeL = 90;
    546         IoctlMixer(&rp);
    547 
    548         //Release master volume override
    549         rp.s.ioctl.bCode  = STREAMVOLSET;
    550         rp.s.ioctl.pvData = (void FAR *)&mixinfo;
    551         mixinfo.Mute    = 2;
    552         mixinfo.VolumeR = mixinfo.VolumeL = 90;
    553         IoctlMixer(&rp);
     691    SBLiveIOCTLMap[MICSET]           = 1;
     692    SBLiveIOCTLMap[MICQUERY]         = 1;
     693    SBLiveIOCTLMap[LINESET]          = 1;
     694    SBLiveIOCTLMap[LINEQUERY]        = 1;
     695    SBLiveIOCTLMap[CDSET]            = 1;
     696    SBLiveIOCTLMap[CDQUERY]          = 1;
     697    SBLiveIOCTLMap[VIDEOSET]         = 1;
     698    SBLiveIOCTLMap[VIDEOQUERY]       = 1;
     699    SBLiveIOCTLMap[AUXSET]           = 1;
     700    SBLiveIOCTLMap[AUXQUERY]         = 1;
     701    SBLiveIOCTLMap[BASSTREBLESET]    = 1;
     702    SBLiveIOCTLMap[BASSTREBLEQUERY]  = 1;
     703////    SBLiveIOCTLMap[STREAMVOLSET]     = 1;
     704////    SBLiveIOCTLMap[STREAMVOLQUERY]   = 1;
     705    SBLiveIOCTLMap[RECORDSRCSET]     = 1;
     706    SBLiveIOCTLMap[RECORDSRCQUERY]   = 1;
     707    SBLiveIOCTLMap[RECORDGAINSET]    = 1;
     708    SBLiveIOCTLMap[RECORDGAINQUERY]  = 1;
     709    SBLiveIOCTLMap[APILEVELQUERY]    = 1;
     710    SBLiveIOCTLMap[GETAPIMAP]        = 1;
     711//  SBLiveIOCTLMap[CALLBACKREG]      = 1;
     712
     713    //Set mic
     714    rp.s.ioctl.bCode  = MICSET;
     715    rp.s.ioctl.pvData = (void FAR *)&mixinfo;
     716    mixinfo.Mute    = fMicMute;
     717    mixinfo.VolumeR = mixinfo.VolumeL = 60;
     718    IoctlMixer(&rp);
     719
     720    //Set line
     721    rp.s.ioctl.bCode  = LINESET;
     722    rp.s.ioctl.pvData = (void FAR *)&mixinfo;
     723    mixinfo.Mute    = fLineMute;
     724    mixinfo.VolumeR = mixinfo.VolumeL = 80;
     725    IoctlMixer(&rp);
     726
     727    //Set CD
     728    rp.s.ioctl.bCode  = CDSET;
     729    rp.s.ioctl.pvData = (void FAR *)&mixinfo;
     730    mixinfo.Mute    = fCDMute;
     731    mixinfo.VolumeR = mixinfo.VolumeL = 80;
     732    IoctlMixer(&rp);
     733
     734    //Set bass/treble
     735    rp.s.ioctl.bCode  = BASSTREBLESET;
     736    rp.s.ioctl.pvData = (void FAR *)&mixinfo;
     737    mixinfo.Mute    = 3;
     738    mixinfo.VolumeR = mixinfo.VolumeL = 50;
     739    IoctlMixer(&rp);
     740
     741    //Set recording source to line in
     742    rp.s.ioctl.bCode  = RECORDSRCSET;
     743    rp.s.ioctl.pvData = (void FAR *)&mixinfo;
     744    mixinfo.Mute    = 0;
     745    mixinfo.VolumeL = I90SRC_LINE;
     746    IoctlMixer(&rp);
     747
     748    //Release recording source override
     749    rp.s.ioctl.bCode  = RECORDSRCSET;
     750    rp.s.ioctl.pvData = (void FAR *)&mixinfo;
     751    mixinfo.Mute    = 2;
     752    mixinfo.VolumeL = I90SRC_LINE;
     753    IoctlMixer(&rp);
     754
     755    //Set master volume
     756    rp.s.ioctl.bCode  = STREAMVOLSET;
     757    rp.s.ioctl.pvData = (void FAR *)&mixinfo;
     758    mixinfo.Mute    = 0;
     759    mixinfo.VolumeR = mixinfo.VolumeL = 90;
     760    IoctlMixer(&rp);
     761
     762    //Release master volume override
     763    rp.s.ioctl.bCode  = STREAMVOLSET;
     764    rp.s.ioctl.pvData = (void FAR *)&mixinfo;
     765    mixinfo.Mute    = 2;
     766    mixinfo.VolumeR = mixinfo.VolumeL = 90;
     767    IoctlMixer(&rp);
    554768}
    555769//******************************************************************************
    … …  
    569783extern "C" void StrategyIoctl(PREQPACKET prp, USHORT LDev)
    570784{
    571    if(prp->s.ioctl.bCategory == 0x90) {
    572         IoctlMixer(prp);
    573         return;
    574    }
    575    if(prp->s.ioctl.bCategory != AUDIO_IOCTL_CAT) {
    576         prp->usStatus |= RPERR | RPBADCMD;
    577         return;
    578    }
    579 
    580    switch (prp->s.ioctl.bCode) {
    581       case AUDIO_INIT:
    582          IoctlAudioInit(prp, LDev);
    583          break;
    584       case AUDIO_CONTROL:
    585          IoctlAudioControl(prp);
    586          break;
    587       case AUDIO_CAPABILITY:
    588          IoctlAudioCapability(prp, LDev);
    589          break;
    590       default:
    591          prp->usStatus |= RPERR | RPBADCMD;
    592          break;
    593    }
    594    return;
     785    if(prp->s.ioctl.bCategory == DAUDIO_IOCTL_CAT) {
     786        IoctlDirectAudio(prp);
     787        return;
     788    }
     789
     790    if(prp->s.ioctl.bCategory == 0x90) {
     791        IoctlMixer(prp);
     792        return;
     793    }
     794    if(prp->s.ioctl.bCategory != AUDIO_IOCTL_CAT) {
     795        prp->usStatus |= RPERR | RPBADCMD;
     796        return;
     797    }
     798
     799    switch (prp->s.ioctl.bCode)
     800    {
     801    case AUDIO_INIT:
     802        IoctlAudioInit(prp, LDev);
     803        break;
     804    case AUDIO_CONTROL:
     805        IoctlAudioControl(prp);
     806        break;
     807    case AUDIO_CAPABILITY:
     808        IoctlAudioCapability(prp, LDev);
     809        break;
     810    default:
     811        prp->usStatus |= RPERR | RPBADCMD;
     812        break;
     813    }
     814    return;
    595815}

  • sbliveos2/trunk/drv16/makefile.os2

    r148 r166  
    109109OBJS7=parse.obj queue.obj rm.obj rtmidi.obj
    110110OBJS8=ssm_idc.obj strategy.obj stream.obj timer.obj vddentry.obj waudio.obj
    111 OBJS9=waveplay.obj waverec.obj wavestrm.obj ossidc16.obj
     111OBJS9=waveplay.obj waverec.obj wavestrm.obj dwavestrm.obj ossidc16.obj
    112112OBJS=$(OBJS1) $(OBJS2) $(OBJS3) $(OBJS4) $(OBJS5) $(OBJS6) $(OBJS7) $(OBJS8) $(OBJS9)
    113113

  • sbliveos2/trunk/drv16/stream.cpp

    r147 r166  
    8888void STREAM::ProcessEvents(void)
    8989{
     90//SvL: BUGFIX: check all events
     91#if 1
     92   if (qhEvent.IsElements()) {
     93        PEVENT pnextevent = (PEVENT)qhEvent.Head();
     94        ULONG  time = GetCurrentTime();
     95        while(pnextevent) {
     96                ULONG eventtime = pnextevent->GetEventTime();
     97                if (eventtime <= time)
     98                        pnextevent->Report(time);
     99                pnextevent = (PEVENT)pnextevent->pNext;
     100        }
     101   }
     102#else
    90103   if (qhEvent.IsElements()) {
    91104      PEVENT pnextevent = (PEVENT)qhEvent.Head();
    … …  
    95108         pnextevent->Report(time);
    96109   }
    97 
    98 }
     110#endif
     111}
     112
    99113ULONG STREAM::EnableEvent(PDDCMDCONTROL pControl)
    100114{
    … …  
    174188
    175189
    176 virtual ULONG STREAM::Write(PSTREAMBUF pbuf, unsigned uLength)
     190virtual ULONG STREAM::Write(PSTREAMBUF pbuf, ULONG uLength)
    177191{
    178192   qhInProcess.PushOnTail((PQUEUEELEMENT)new STREAMBUFFER(uLength, pbuf));

  • sbliveos2/trunk/drv16/stream.hpp

    r142 r166  
    8282   virtual ULONG Register(PDDCMDREGISTER);
    8383   void  DeRegister(void);
    84    virtual ULONG Write(PSTREAMBUF, unsigned);
     84   virtual ULONG Write(PSTREAMBUF, ULONG);
    8585   virtual ULONG Read(PSTREAMBUF, unsigned) = 0;
    8686   virtual ULONG GetCurrentTime(void) = 0;
     87   virtual ULONG GetCurrentPos(void) = 0;
    8788   virtual void  SetCurrentTime(ULONG time) = 0;
    8889   virtual ULONG StartStream(void) = 0;
    … …  
    9495   virtual void  SetInputGain(ULONG gain);
    9596   virtual void  SetVolume(ULONG volume);
     97           ULONG GetVolume() { return volume; };
    9698   virtual void  SetBalance(ULONG balance);
    9799   virtual BOOL  SetMasterVol(ULONG volume);
    … …  
    104106   ULONG ulCurrentTime;
    105107   PAUDIOHW pahw;            // pointer to the hardware object for this stream
    106    void ReturnBuffer(void);   // returns one buffer
     108   virtual void ReturnBuffer(void);   // returns one buffer
    107109   void ReturnBuffers(void);  // returns all buffers
    108110   void ProcessEvents(void);

  • sbliveos2/trunk/drv16/strmbuff.hpp

    r142 r166  
    4444typedef STREAMBUFFER *PSTREAMBUFFER;
    4545
     46
     47class STREAMBUFFEREX : public STREAMBUFFER
     48{
     49public:
     50    STREAMBUFFEREX(ULONG bufsize, PSTREAMBUF bufptr, ULONG lockHandle):
     51    STREAMBUFFER(bufsize, bufptr), hLock(lockHandle), fDone(FALSE)
     52    {};
     53
     54    ULONG hLock;
     55    BOOL  fDone;
     56
     57};
     58typedef STREAMBUFFEREX *PSTREAMBUFFEREX;
     59
    4660#endif

  • sbliveos2/trunk/drv16/vddentry.asm

    r151 r166  
    103103_OSSIDC_ENTRY ENDP
    104104
     105        PUBLIC  HookHandlerAsm_
     106        EXTERN  _HookHandler:near
     107HookHandlerAsm_ PROC FAR
     108        push    eax
     109        call    _HookHandler
     110        add     sp, 4
     111        retf
     112HookHandlerAsm_ ENDP
     113
    105114        PUBLIC  _inpd
    106115_inpd proc near

  • sbliveos2/trunk/drv16/wavestrm.cpp

    r160 r166  
    316316}
    317317
    318 ULONG WAVESTREAM::Write(PSTREAMBUF pbuf, unsigned uLength)
    319 {
    320    qhInProcess.PushOnTail((PQUEUEELEMENT)new STREAMBUFFER(uLength, pbuf));
     318ULONG WAVESTREAM::Write(PSTREAMBUF pbuf, ULONG uLength)
     319{
     320 PSTREAMBUFFER pStreamBuf = new STREAMBUFFER(uLength, pbuf);
     321
     322   return Write(pStreamBuf);
     323}
     324
     325ULONG WAVESTREAM::Write(PSTREAMBUFFER pStreamBuf)
     326{
     327   qhInProcess.PushOnTail((PQUEUEELEMENT)pStreamBuf);
    321328   dprintf2(("WAVESTREAM::Write: Push on tail %lx %d", ((PSTREAMBUFFER)qhInProcess.Head())->pBuffptr, ((PSTREAMBUFFER)qhInProcess.Head())->ulBuffsz));
    322329   if(fUnderrun) {
    … …  
    376383}
    377384
     385ULONG WAVESTREAM::GetCurrentPos(void)
     386{
     387   ULONG Processed;
     388
     389   if (ulStreamState == STREAM_STREAMING)  // if the stream is active
     390   {
     391        if (ulStreamType & STREAM_WRITE) {
     392                OSS16_StreamGetPos(this, &Processed);
     393        }
     394        else    Processed = _ulBytesProcessed;
     395   }
     396   else Processed = _ulBytesProcessed;
     397
     398   return Processed;
     399}
     400
    378401//
    379402// SetCurrentTime

  • sbliveos2/trunk/drv16/wavestrm.hpp

    r160 r166  
    3939   void Process(void);           // called every timer interrupt
    4040   virtual ULONG  GetCurrentTime(void);
     41   virtual ULONG  GetCurrentPos(void);
    4142   virtual void   SetCurrentTime(ULONG time);
    4243   virtual ULONG  Read(PSTREAMBUF, unsigned);
    43    virtual ULONG  Write(PSTREAMBUF, unsigned);
     44   virtual ULONG  Write(PSTREAMBUF, ULONG);
     45           ULONG  Write(PSTREAMBUFFER);
    4446   virtual ULONG  StartStream(void);
    4547   virtual ULONG  StopStream(PCONTROL_PARM);
Note: See TracChangeset for help on using the changeset viewer.