Changeset 147


Ignore:
Timestamp:
Apr 24, 2000, 9:45:21 PM (25 years ago)
Author:
sandervl
Message:

Fixed wave volume, recording gain + wave recording

Location:
sbliveos2/trunk
Files:
21 edited

Legend:

Unmodified
Added
Removed

  • sbliveos2/trunk/ChangeLog

    r145 r147  
    11$Id$
     2
     3 2000-04-24: Sander van Leeuwen <sandervl@xs4all.nl>
     4        - Fixed wave volume, recording gain + wave recording
    25
    36 2000-04-23: Sander van Leeuwen <sandervl@xs4all.nl>

  • sbliveos2/trunk/back.cmd

    r142 r147  
    1 : $Id$
     1rem $Id$
    22
    33del sblivesrc.zip

  • sbliveos2/trunk/drv16/init.cpp

    r142 r147  
    5656#include <sbversion.h>
    5757
     58#ifndef PCI_VENDOR_ID_CREATIVE
     59#define PCI_VENDOR_ID_CREATIVE 0x1102UL
     60#endif
     61
     62#ifndef PCI_DEVICE_ID_CREATIVE_EMU10K1
     63#define PCI_DEVICE_ID_CREATIVE_EMU10K1 0x0002UL
     64#endif
     65#define PCI_ID  ((PCI_VENDOR_ID_CREATIVE<<16UL)|PCI_DEVICE_ID_CREATIVE_EMU10K1)
     66
    5867// Default MIDI timer interval, milliseconds.
    5968static USHORT MIDI_TimerInterval = 10;
    … …  
    6271static char szCopyRight[] = "Copyright 2000 Sander van Leeuwen (sandervl@xs4all.nl)";
    6372static char NEWLINE[]     = "\r\n";
     73static char szSBLiveNotFound[] = "SB Live! hardware not detected!";
     74static char szAltF1[]     = "Reboot, press Alt-F1 during OS/2 startup and select Enable Hardware Detection";
    6475
    6576//
    … …  
    122133      memcpy(phdr->abName,szCL_DevName,8);   // yes, copy it to the dev header
    123134
    124    // Resources identified by the Resource Manager are saved into the
    125    // *pResourcesWSS and *pResourcesICS objects, repectively.
    126 
    127135   pRM = new ResourceManager();        // Create the RM object.
    128136   if (! pRM) {
    … …  
    131139   else if (pRM->getState() != rmDriverCreated) {
    132140      return;
     141   }
     142
     143   //SvL: Check if SB Live hardware has been detected by the resource manager
     144   //     If not, tell user to reboot, press alt-f1 and enable hardware detection
     145   if(!pRM->bIsDevDetected(PCI_ID, SEARCH_ID_DEVICEID, TRUE)) {
     146        USHORT result;
     147
     148        DosWrite(1, (VOID FAR*)szSBLiveNotFound, strlen(szSBLiveNotFound), &result);
     149        DosWrite(1, (VOID FAR*)NEWLINE, sizeof(NEWLINE)-1, &result);
     150        DosWrite(1, (VOID FAR*)szAltF1, sizeof(szAltF1), &result);
     151        DosWrite(1, (VOID FAR*)NEWLINE, sizeof(NEWLINE)-1, &result);
     152        return;
    133153   }
    134154

  • sbliveos2/trunk/drv16/ioctl.cpp

    r142 r147  
    131131         break;
    132132#if 0
    133       case AUDIOHW_FMSYNTH_CAPTURE:
    134       case AUDIOHW_FMSYNTH_PLAY:
    135       case AUDIOHW_MPU401_CAPTURE:
    136133      case AUDIOHW_MPU401_PLAY:
    137          pstream = new MIDISTREAM(HardwareType);
     134         pstream = new MIDISTREAM(HardwareType, prp->s.ioctl.usSysFileNum);
    138135         break;
    139136#endif
    … …  
    204201   LPMCI_TRACK_INFO    pMasterVol;
    205202   PSTREAM             pStream;
     203   ULONG               volume;
    206204
    207205   if (p->usIOCtlRequest != AUDIO_CHANGE) {
    … …  
    239237        pStream->SetBalance(pAudChange->lBalance);
    240238
    241    if(pAudChange->lVolume != AUDIO_IGNORE)
    242         pStream->SetVolume(pAudChange->lVolume);
     239   if(pAudChange->lVolume != AUDIO_IGNORE) {
     240        // stream volume ranges from 0 to 0x7FFFFFFF (linear)
     241        volume = pAudChange->lVolume >> 16UL;
     242        volume = (volume*100UL)/0x7FFFUL;
     243        dprintf(("Set stream volume of %x to %d", prp->s.ioctl.usSysFileNum, volume));
     244        pStream->SetVolume(MAKE_VOLUME_LR(volume, volume));
     245   }
    243246   
    244247   if(pMasterVol && pMasterVol->usMasterVolume != AUDIO_IGNORE) {
    245248        // master volume ranges from 0 to 0x7FFF (linear)
    246         ULONG volume = pMasterVol->usMasterVolume;
    247 
     249        volume = pMasterVol->usMasterVolume;
    248250        volume = (volume*100UL)/0x7FFFUL;               
    249251        if(volume > 100) {
    250252                volume = 100;
    251253        }
    252         volume = (((USHORT)volume << 16) | (USHORT)volume);
    253         pStream->SetMasterVol(volume);
    254    }
    255    for(int i=0;i<8;i++)
    256    {
    257         switch(pAudChange->rInputList[0].ulDevType) {
    258         case NULL_INPUT:
    259                 break; //continue;
    260         case STEREO_LINE_INPUT:
    261         case LEFT_LINE_INPUT:
    262         case RIGHT_LINE_INPUT:
    263                 pStream->SetInputSrc(MIX_RECSRC_LINE);
    264                 break;
    265 
    266         case MIC_INPUT:
    267         case BOOSTED_MIC_INPUT:
    268                 pStream->SetInputSrc(MIX_RECSRC_MIC);
    269                 break;
    270 
    271         case PHONE_LINE_INPUT:
    272         case HANDSET_INPUT:
    273         case SYNTH_INPUT:
    274         case DIGITAL_PHONE_LINE_INPUT:
    275         case DIGITAL_HANDSET_INPUT:
    276         case MIDI_IN_PORT:
    277 //      case LOOPBACK:
    278                 pStream->SetInputSrc(MIX_RECSRC_MIXER);
    279                 break;
    280         }
    281    }
    282    pStream->SetInputGain(pAudChange->lGain);
     254        dprintf(("Set mastervolume to %d", volume));
     255        pStream->SetMasterVol(MAKE_VOLUME_LR(volume, volume));
     256   }
     257   if(!fRecSrcIOCTL90) {
     258        for(int i=0;i<8;i++)
     259        {
     260                switch(pAudChange->rInputList[0].ulDevType) {
     261                case NULL_INPUT:
     262                        break; //continue;
     263                case STEREO_LINE_INPUT:
     264                case LEFT_LINE_INPUT:
     265                case RIGHT_LINE_INPUT:
     266                        pStream->SetInputSrc(MIX_RECSRC_LINE);
     267                        break;
     268       
     269                case MIC_INPUT:
     270                case BOOSTED_MIC_INPUT:
     271                        pStream->SetInputSrc(MIX_RECSRC_MIC);
     272                        break;
     273       
     274                case PHONE_LINE_INPUT:
     275                case HANDSET_INPUT:
     276                case SYNTH_INPUT:
     277                case DIGITAL_PHONE_LINE_INPUT:
     278                case DIGITAL_HANDSET_INPUT:
     279                case MIDI_IN_PORT:
     280//              case LOOPBACK:
     281                        pStream->SetInputSrc(MIX_RECSRC_MIXER);
     282                        break;
     283                }
     284        }
     285   }
     286   if(!fRecGainIOCTL90 && pAudChange->lGain != AUDIO_IGNORE) {
     287        // input ranges from 0 to 0x7FFFFFFF (linear)
     288        volume = pAudChange->lGain >> 16UL;
     289        volume = (volume*100UL)/0x7FFFUL;
     290        if(volume > 100) {
     291                volume = 100;
     292        }
     293        dprintf(("Set input gain of %x to %d", prp->s.ioctl.usSysFileNum, volume));
     294        pStream->SetInputGain(MAKE_VOLUME_LR(volume, volume));
     295   }
    283296}
    284297//******************************************************************************
    … …  
    322335   switch(prp->s.ioctl.bCode) {
    323336   case MICSET:
    324         OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETMICVOL, MAKE_VOLUME(VolumeL, VolumeR));
     337        OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETMICVOL, MAKE_VOLUME_LR(VolumeL, VolumeR));
    325338        break;
    326339   case LINESET:
    327         OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETLINEINVOL, MAKE_VOLUME(VolumeL, VolumeR));
     340        OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETLINEINVOL, MAKE_VOLUME_LR(VolumeL, VolumeR));
    328341        break;
    329342   case CDSET:
    330         OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETCDVOL, MAKE_VOLUME(VolumeL, VolumeR));
     343        OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETCDVOL, MAKE_VOLUME_LR(VolumeL, VolumeR));
    331344        break;
    332345   case VIDEOSET:
    333         OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETVIDEOVOL, MAKE_VOLUME(VolumeL, VolumeR));
     346        OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETVIDEOVOL, MAKE_VOLUME_LR(VolumeL, VolumeR));
    334347        break;
    335348   case AUXSET:
    336         OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETAUXVOL, MAKE_VOLUME(VolumeL, VolumeR));
     349        OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETAUXVOL, MAKE_VOLUME_LR(VolumeL, VolumeR));
    337350        break;
    338351
    339352   case BASSTREBLESET:
    340         OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETBASS, MAKE_VOLUME(VolumeL, VolumeL));
    341         OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETTREBLE, MAKE_VOLUME(VolumeR, VolumeR));
     353        OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETBASS, MAKE_VOLUME_LR(VolumeL, VolumeL));
     354        OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETTREBLE, MAKE_VOLUME_LR(VolumeR, VolumeR));
    342355        break;
    343356#if 0
    … …  
    349362        }
    350363        fStreamVolIOCTL90 = TRUE;
    351         OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETMASTERVOL, MAKE_VOLUME(VolumeL, VolumeR));
     364        OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETMASTERVOL, MAKE_VOLUME_LR(VolumeL, VolumeR));
    352365        break;
    353366#endif
    … …  
    395408        }
    396409        fRecGainIOCTL90 = TRUE;
    397         OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETINPUTGAIN, MAKE_VOLUME(VolumeL, VolumeR));
     410        OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETINPUTGAIN, MAKE_VOLUME_LR(VolumeL, VolumeR));
    398411        break;
    399412
    … …  
    427440
    428441   case GETAPIMAP:
    429         if(DevHelp_VerifyAccess(SELECTOROF(pIoctlMap), 256, OFFSETOF(pIoctlMap), VERIFY_READWRITE))
     442        if(DevHelp_VerifyAccess(SELECTOROF(pIoctlMap), sizeof(SBLiveIOCTLMap), OFFSETOF(pIoctlMap), VERIFY_READWRITE))
    430443        {
    431444                dprintf(("Invalid IOCTL90 pointer %lx!!", (ULONG)pMixStruct));

  • sbliveos2/trunk/drv16/makefile.os2

    r146 r147  
    140140   mapsym $(NAME).MAP
    141141   copy $(NAME).sym ..\bin
     142
     143clean:
     144     del *.obj *.err *.lnk *.sys *.sym *.lst *.map *.wmap

  • sbliveos2/trunk/drv16/midipars.cpp

    r142 r147  
    273273
    274274      if (cmdByte >= 7) {              // Timing Compression (Short) [ 7-127 ]
    275          lWait = cmdByte * ulPerClock;
     275         //SvL: += instead of = (BUGFIX)
     276         lWait += cmdByte * ulPerClock;
    276277      }
    277278
    278279      else if (cmdByte == 1) {         // Timing compression (Long) [ 1 ]
    279          lWait = (((ULONG) (message[2] << 7)) + ((ULONG) message[1])) * ulPerClock;
     280         //SvL: += instead of = (BUGFIX)
     281         lWait += (((ULONG) (message[2] << 7)) + ((ULONG) message[1])) * ulPerClock;
    280282      }
    281283

  • sbliveos2/trunk/drv16/midistrm.cpp

    r142 r147  
    167167   state = S_Init;                        // Reset parser state.
    168168   message.clear();                       // Clear current message.
     169   lWait = 0;   //SvL, reset this too
    169170   ulStreamState = STREAM_STREAMING;
    170171   return NO_ERROR;

  • sbliveos2/trunk/drv16/mpu401.cpp

    r142 r147  
    3939
    4040#include "parse.h"
     41#include "ossidc.h"
    4142
    4243
    … …  
    4849   static char szName[] = "SBLive #";  // Instance name for RTMIDI.  A number will be appended.
    4950   static char szSuffix[] = "0";       // Printable char that is appended to szName.
    50 
    51    usDataPort = 0x300;
    52    usStatPort = 0x300 + 1;
    5351
    5452   // RTMIDI (MIDI.SYS) related stuff
    … …  
    5957   // When we have an IRQ and a send capability, add next line.
    6058   // ulCapabilities |= MIDICAPSA_OUTPUT;
    61 }
    62 
    63 
    64 #define TIMEOUT   60000
    65 
    66 unsigned MPUcommand(USHORT usDataPort, BYTE b)
    67 /* Returns 0 when command is properly accepted by the specified port;
    68  * Returns 1 - 4 to indicate various timeout conditions.
    69  */
    70 {
    71    unsigned i;
    72    const usStatPort = usDataPort + 1;
    73 
    74    i=1000;
    75    while (--i) {
    76       if (inp(usStatPort) & DSR) break;
    77       inp(usDataPort);
    78       iodelay(1);                      // Delay >= 0.5 uSec
    79    }
    80    if ( !i ) {                         // >500 millisecond wait?
    81       return 4;
    82    }
    83 
    84    for (i=0; i<TIMEOUT; i++) {
    85       if (!(inp(usStatPort) & DRR)) {  // wait until it's ready
    86          iodelay(1);                   // just to be safe
    87          outp(usStatPort,b);
    88          iodelay(1);                   // just to be safe
    89          for (i=0; i<TIMEOUT; i++) {
    90             if (!(inp(usStatPort) & DSR)) {
    91                iodelay(1);             // just to be safe
    92                i=inp(usDataPort);
    93                if (i == 0xFE)
    94                   return 0;
    95                else {
    96                   return 3;
    97                }
    98             }
    99             iodelay(1);
    100          }
    101          if (b == 0xFF) {
    102             return 0;
    103          }
    104          else {
    105             return 1;
    106          }
    107       }
    108       iodelay(1);
    109    }
    110 
    111    return 2;
     59
     60   midiOutStreamId = 0;
     61   midiInStreamId  = 0;
    11262}
    11363
    … …  
    174124int MPU_401::writeByte(BYTE b)
    175125{
    176    unsigned i;
    177 
    178    for (i=0; i<TIMEOUT; i++) {
    179       cli();
    180       if (!(inp(usStatPort) & DRR)) {
    181          outp(usDataPort, b);
    182          sti();
    183          return 1;
    184       }
    185       sti();
    186       iodelay(1);
    187    }
     126   //TODO:
    188127   return 0;
    189128}
    … …  
    191130int MPU_401::readByte(void)
    192131{
    193    unsigned i;
    194 
    195    for (i=0; i<TIMEOUT; i++) {
    196       cli();
    197       if (!(inp(usStatPort) & DSR)) {
    198          i=inp(usDataPort);
    199          sti();
    200          return i;
    201       }
    202       sti();
    203       iodelay(1);
    204    }
     132   //TODO:
    205133   return -1;
    206134}
    207135
    208 /* MPU_401::_iInitialize
    209  * ### Need cleanup return codes - currently they are not consistent
    210  * ### or documented.  Currently, returns 0 on SUCCESS.
    211  */
    212 int MPU_401::_iInitialize(void)
    213 {
    214    int rc;              // Return code from MPUcommand().
    215 
    216    rc = MPUcommand(usDataPort, 0xFF);
    217    if (rc == 0)
    218       rc = MPUcommand(usDataPort, 0x3F);
    219 
    220    return rc;
    221 }
    222 
    223136#pragma off (unreferenced)
    224137
    … …  
    231144{
    232145   BOOL rc;
    233    _iInitialize();
    234146
    235147   // Start timer on 4 mSec interval.
    … …  
    263175USHORT MPU_401::RTMIDI_OpenReceive(void)
    264176{
    265    //### Need to add serialization b/t MMPM/2 + RTMIDI, plus mult RTMIDI opens.
    266 
    267    USHORT us = _iInitialize();
    268    if (us)
    269       return MIDIERRA_HW_FAILED;
    270    else
    271       return 0;
     177   if(midiInStreamId == 0) {
     178          midiInStreamId = OSS16_OpenMidiStream(MIDI_RECEIVE);
     179   }
     180   return (midiInStreamId) ? 0 : MIDIERRA_HW_FAILED;
    272181}
    273182
    274183USHORT MPU_401::RTMIDI_OpenSend(void)
    275184{
    276    //### Need to add serialization b/t MMPM/2 + RTMIDI, plus mult RTMIDI opens.
    277    //### Send capability pending but not currently implemented.
    278 
    279    return MIDIERRA_HW_FAILED;
     185   if(midiOutStreamId == 0) {
     186          midiOutStreamId = OSS16_OpenMidiStream(MIDI_SEND);
     187   }
     188   return (midiOutStreamId) ? 0 : MIDIERRA_HW_FAILED;
    280189}
    281190
    282191USHORT MPU_401::RTMIDI_CloseReceive(void)
    283192{
    284    MPUcommand(usDataPort, 0xFF);
     193   OSS16_CloseMidiStream(MIDI_RECEIVE, midiInStreamId);
    285194   return 0;
    286195}
    … …  
    288197USHORT MPU_401::RTMIDI_CloseSend(void)
    289198{
    290    MPUcommand(usDataPort, 0xFF);
    291    return 0;
    292 }
    293 
     199   OSS16_CloseMidiStream(MIDI_SEND, midiOutStreamId);
     200   return 0;
     201}
     202

  • sbliveos2/trunk/drv16/mpu401.hpp

    r142 r147  
    4343   BYTE n;                       // This is the nth MPU-401
    4444   int  _iAllNotesOff(void);      // function to turn all notes off
    45    int  _iInitialize(void);
     45   ULONG midiInStreamId;
     46   ULONG midiOutStreamId;
    4647public:
    47    USHORT usDataPort;
    48    USHORT usStatPort;
    49 
    5048   // Constructor.
    5149   MPU_401( TIMER* pTimer );

  • sbliveos2/trunk/drv16/ossidc16.cpp

    r142 r147  
    8282//******************************************************************************
    8383//******************************************************************************
     84ULONG OSS16_OpenMidiStream(MIDITYPE midiType)
     85{
     86   return CallOSS32(IDC32_STREAM_OPEN, 0x666, (midiType == MIDI_RECEIVE) ? OSS_STREAM_MIDIIN : OSS_STREAM_MIDIOUT, 0, 0, 0);
     87}
     88//******************************************************************************
     89//******************************************************************************
     90void OSS16_CloseMidiStream(MIDITYPE midiType, ULONG streamid)
     91{
     92   CallOSS32(IDC32_STREAM_CLOSE, 0x666, (midiType == MIDI_RECEIVE) ? OSS_STREAM_MIDIIN : OSS_STREAM_MIDIOUT, streamid, 0, 0);
     93}
     94//******************************************************************************
     95//******************************************************************************
    8496BOOL OSS16_StartStream(STREAM *stream)
    8597{

  • sbliveos2/trunk/drv16/strategy.cpp

    r142 r147  
    5252void StrategyInitComplete(PREQPACKET prp)
    5353{
    54 //   RTMIDI::vConnect();
     54   RTMIDI::vConnect();
    5555   if(OSS16_AttachToPdd() == FALSE) {
    5656        prp->usStatus = RPDONE | RPERR | RPGENFAIL;

  • sbliveos2/trunk/drv16/stream.cpp

    r142 r147  
    279279  return TRUE;
    280280}
    281 ULONG STREAM::mastervol = MAKE_VOLUME(100, 100);
     281ULONG STREAM::mastervol = MAKE_VOLUME_LR(100, 100);
    282282
    283283PSTREAM FindActiveStream(ULONG StreamType)

  • sbliveos2/trunk/drv16/wavestrm.cpp

    r142 r147  
    226226   }
    227227
    228    dprintf(("_vReadAudioBuf %lx size %d, bytes read %d", pdataBuf, Buff_left, bytesread));
     228////   dprintf(("_vReadAudioBuf %lx size %d, bytes read %d", pdataBuf, Buff_left, bytesread));
    229229
    230230   // update the buffer pos counter
    … …  
    236236   }
    237237   if(pTemp->ulBuffpos == pTemp->ulBuffsz) {
     238        dprintf(("_vReadAudioBuf return buffer %lx size %ld, bytes read %ld", (ULONG)pTemp->pBuffptr, pTemp->ulBuffsz, bytesread));
    238239        ReturnBuffer();
    239240   }
    … …  
    322323{
    323324   qhInProcess.PushOnTail((PQUEUEELEMENT)new STREAMBUFFER(uLength, pbuf));
     325   dprintf(("WAVESTREAM::Read: Push on tail %lx %d", ((PSTREAMBUFFER)qhInProcess.Head())->pBuffptr, ((PSTREAMBUFFER)qhInProcess.Head())->ulBuffsz));
    324326   return 0;
    325327}

  • sbliveos2/trunk/lib32/makefile.os2

    r142 r147  
    8686$(TARGET).lib: $(TARGET).lnk $(FILES)
    8787    $(LIB) $(TARGET).lib @$(TARGET).lnk
     88
     89clean:
     90     del *.obj *.err *.lnk *.sys *.sym *.lst *.map *.wmap *.lib

  • sbliveos2/trunk/lib32/sound.c

    r142 r147  
    329329        return 0;
    330330  }
     331  if(ossfile.f_mode == FMODE_READ && *fStart == PCM_ENABLE_INPUT) {
     332        //need to call poll to really start the stream
     333        int rc;
     334        struct poll_table_struct poll = {0};
     335
     336        rc = oss_devices[ossid].poll(&ossfile, &poll);
     337        if(rc & POLLERR)
     338                return 0;
     339        return 1;
     340  }
     341  else
    331342  if(oss_devices[ossid].ioctl(&ossinode, &ossfile, cmd, (ULONG)fStart)) {
    332343        return 0;
    … …  
    459470  case MIX_SETWAVEVOL:
    460471        ioctl = SOUND_MIXER_WRITE_PCM;
    461         // channel volume ranges from 0 to 0x7FFFFFFF (linear)
    462         volume = volume >> 16;
    463         volume = (volume*100)/0x7FFF;
    464         volume = (volume << 8) | volume; //l&r
    465472        break;
    466473  case MIX_SETMIDIVOL:
    … …  
    495502        break;
    496503  case MIX_SETINPUTGAIN:
    497         ioctl = SOUND_MIXER_WRITE_IGAIN;
     504        ioctl = SOUND_MIXER_WRITE_RECLEV;
    498505        break;
    499506  case MIX_SETLINEINVOL:

  • sbliveos2/trunk/lib32/task.c

    r142 r147  
    3939}
    4040
    41 //Not pretty, but sblive driver compared pointers
     41//Not pretty, but sblive driver compares pointers
    4242ULONG OSS32_SetFileId(ULONG fileid)
    4343{

  • sbliveos2/trunk/makefile.os2

    r142 r147  
     1# $Id$
    12#******************************************************************************
    23# makefile for the SoundBlaster Live! OS/2 audio project

  • sbliveos2/trunk/runtime/makefile.os2

    r146 r147  
    4747CFLAGS=-ms -4 -bt=os2 -olinars -s -wx -zl -zfp -zgp -zq -zu -zm
    4848!else
    49 CFLAGS=-ms -4 -bt=os2 -d1 -olinars -s -wx -zl -zfp -zgp -zq -zu -zm $(DEBUG)
     49CFLAGS=-ms -4 -bt=os2 -d1 -olinars -s -wx -zl -zfp -zgp -zq -zu -zm -DDEBUG
    5050!endif
    5151CINC=-i$(%WATCOM)\H;$(%WATCOM)\H\SYS;$(H)

  • sbliveos2/trunk/sblive/audio.c

    r142 r147  
    316316
    317317#ifdef TARGET_OS2
    318                         woinst->fragment_size = 0;
     318                        wiinst->fragment_size = 0;
    319319#endif
    320320                        wiinst->total_recorded = 0;

  • sbliveos2/trunk/sblive/makefile.os2

    r142 r147  
    8282$(TARGET).lib: $(TARGET).lnk $(FILES)
    8383    $(LIB) $(TARGET).lib @$(TARGET).lnk
     84
     85clean:
     86     del *.obj *.err *.lnk *.sys *.sym *.lst *.map *.wmap *.lib

  • sbliveos2/trunk/sblive/mixer.c

    r142 r147  
    523523        //     Check here that current->files != 0
    524524        for (i = 0; i < MAX_PCM_CHANNELS; i++) {
     525#ifdef TARGET_OS2
    525526                if (current->files && sblive_pcm_volume[i].files == current->files) {
     527#else
     528                if (sblive_pcm_volume[i].files == current->files) {
     529#endif
    526530                        sblive_pcm_volume[i].mixer = mixer;
    527531                        if (sblive_pcm_volume[i].opened) {
Note: See TracChangeset for help on using the changeset viewer.