Changeset 391


Ignore:
Timestamp:
Oct 8, 2008, 11:28:16 PM (17 years ago)
Author:
rjerant
Message:

Add GetHwPtr() to code base

Location:
OCO/trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • OCO/trunk/drv16/ossidc16.cpp

    r288 r391  
    151151{
    152152   IDC32_PACKET idcpacket;
    153    
     153
    154154   _fmemset(&idcpacket, 0, sizeof(idcpacket));
    155155
    … …  
    214214   _fmemset(&idcpacket, 0, sizeof(idcpacket));
    215215
    216    if(SELECTOROF(pHwParams) != _SS()) 
     216   if(SELECTOROF(pHwParams) != _SS())
    217217   {//must be located on the stack!
    218218       dprintf(("OSS16_WaveSetFormat error. Invalid stack segment for parameters..."));
    … …  
    228228//******************************************************************************
    229229//******************************************************************************
    230 OSSRET DBGCALLCONV OSS16_WaveAddBuffer(OSSSTREAMID StreamId, LINEAR pBuffer, ULONG size, 
     230OSSRET DBGCALLCONV OSS16_WaveAddBuffer(OSSSTREAMID StreamId, LINEAR pBuffer, ULONG size,
    231231                                       ULONG FAR *lpBytesTransferred)
    232 {                   
     232{
    233233   IDC32_PACKET idcpacket;
    234234   OSSRET       ret;
    … …  
    241241   idcpacket.buffer.size   = size;
    242242   ret =  CallOSS32(IDC32_WAVE_ADDBUFFER, &idcpacket);
    243    
     243
    244244   *lpBytesTransferred = idcpacket.buffer.transferred;
    245245   return ret;
    … …  
    257257   idcpacket.streamid      = StreamId;
    258258   ret =  CallOSS32(IDC32_WAVE_GETPOS, &idcpacket);
    259    
     259
    260260   *lpPosition = idcpacket.getpos.position;
    261261   return ret;
    … …  
    273273   idcpacket.streamid      = StreamId;
    274274   ret =  CallOSS32(IDC32_WAVE_GETSPACE, &idcpacket);
    275    
     275
    276276   *lpBytesLeft = idcpacket.getspace.bytesavail;
    277277   return ret;
    … …  
    279279//******************************************************************************
    280280//******************************************************************************
     281//******************************************************************************
     282//******************************************************************************
     283OSSRET DBGCALLCONV OSS16_WaveGetHwPtr(OSSSTREAMID StreamId, ULONG FAR *lpBytesLeft)
     284{
     285   IDC32_PACKET idcpacket;
     286   OSSRET       ret;
     287
     288   _fmemset(&idcpacket, 0, sizeof(idcpacket));
     289
     290   idcpacket.fileid        = FindStreamFileId_fromStreamId(StreamId);
     291   idcpacket.streamid      = StreamId;
     292   ret =  CallOSS32(IDC32_WAVE_GETHWPTR, &idcpacket);
     293
     294   *lpBytesLeft = idcpacket.getspace.bytesavail;
     295   return ret;
     296}
    281297OSSRET DBGCALLCONV OSS16_WaveSetVolume(OSSSTREAMID StreamId, ULONG volume)
    282298{
    … …  
    344360   _fmemset(&idcpacket, 0, sizeof(idcpacket));
    345361
    346    if(SELECTOROF(buffer) != _SS()) 
     362   if(SELECTOROF(buffer) != _SS())
    347363   {//must be located on the stack!
    348364       DebugInt3();
    … …  
    617633    ULONG idcptr  = (ULONG)IDCTable.ProtIDCEntry;
    618634    ULONG idcparm;
    619  
     635
    620636    if(idcptr == 0)
    621637            return OSSERR_ACCESS_DENIED;
    … …  
    673689{
    674690//    dprintf(("OSSIDC ep. cmd: %x param1: %x, param2: %x",cmd, param1, param2));
    675     switch(cmd & 0xFFFF) 
     691    switch(cmd & 0xFFFF)
    676692    {
    677693    case IDC16_INIT:
    … …  
    837853    if (pWaveCaps->ulChanFlags & OSS32_CAPS_PCM_CHAN_5_1)
    838854        dprintf (("                OSS32_CAPS_PCM_CHAN_5_1"));
    839    
     855
    840856
    841857    dprintf (("  ulMinRate     %ld",   pWaveCaps->ulMinRate));

  • OCO/trunk/drv16/waudio.cpp

    r369 r391  
    1313/**@internal %W%
    1414 * @notes
    15  *  The default for 8 bps is unsigned and signed for > 8 bps 
     15 *  The default for 8 bps is unsigned and signed for > 8 bps
    1616 *  The default byte order for > 8 bps is little endian
    1717 *  (important for devices that support both formats)
    … …  
    226226       //NOTE2: The default byte order for > 8 bps is little endian
    227227
    228        switch(ulBitsPerSample) 
     228       switch(ulBitsPerSample)
    229229       {
    230230       case 8:
    … …  
    234234           //default = signed
    235235           ulFlags |= TWOS_COMPLEMENT;
    236            
     236
    237237           if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_LE))
    238238           {
    … …  
    242242           break;
    243243       case 24:
    244            if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_24BPS_SIGNED) 
     244           if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_24BPS_SIGNED)
    245245           {
    246246               ulFlags |= TWOS_COMPLEMENT;
    … …  
    255255           break;
    256256       case 32:
    257            if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_32BPS_SIGNED) 
     257           if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_32BPS_SIGNED)
    258258           {
    259259               ulFlags |= TWOS_COMPLEMENT;
    … …  
    284284       break;
    285285
    286    default: 
     286   default:
    287287       DebugInt3();
    288288       return 0;
    … …  
    293293//Get the OSS data format for the specified stream parameters
    294294//******************************************************************************
    295 ULONG WAVEAUDIO::QueryOSSDataFormat(ULONG ulOperation, ULONG ulDataType, 
     295ULONG WAVEAUDIO::QueryOSSDataFormat(ULONG ulOperation, ULONG ulDataType,
    296296                                    ULONG ulBitsPerSample)
    297297{
    298298   ULONG ulDataFormat;
    299299   PWAVE_CAPS pWaveCaps;
    300  
     300
    301301   if(ulOperation == OPERATION_PLAY) {
    302302        pWaveCaps = &devCaps[ulDeviceNr].waveOutCaps;
    … …  
    310310       //NOTE1: The default for 8 bps is unsigned and signed for > 8 bps !!!
    311311       //NOTE2: The default byte order for > 8 bps is little endian
    312        switch(ulBitsPerSample) 
     312       switch(ulBitsPerSample)
    313313       {
    314314       case 8:
    315315           //Default is unsigned, so check that first
    316            if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U8) 
     316           if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U8)
    317317           {
    318318                ulDataFormat = OSS32_PCM_FORMAT_U8;
    … …  
    323323       case 16:
    324324           //Default is signed, so check that first
    325            if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_SIGNED) 
     325           if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_SIGNED)
    326326           {//signed LE or BE
    327327               //Default is LE, so check that first
    328                if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_LE) 
     328               if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_LE)
    329329               {
    330330                    ulDataFormat = OSS32_PCM_FORMAT_S16_LE;
    … …  
    332332               else ulDataFormat = OSS32_PCM_FORMAT_S16_BE;
    333333           }
    334            else 
     334           else
    335335           {//unsigned LE or BE
    336336               //Default is LE, so check that first
    337                if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_LE) 
     337               if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_LE)
    338338               {
    339339                    ulDataFormat = OSS32_PCM_FORMAT_U16_LE;
    … …  
    345345       case 24:
    346346           //Default is signed, so check that first
    347            if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_24BPS_SIGNED) 
     347           if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_24BPS_SIGNED)
    348348           {//signed LE or BE
    349349               //Default is LE, so check that first
    350                if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_24BPS_LE) 
     350               if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_24BPS_LE)
    351351               {
    352352                    ulDataFormat = OSS32_PCM_FORMAT_S24_LE;
    … …  
    354354               else ulDataFormat = OSS32_PCM_FORMAT_S24_BE;
    355355           }
    356            else 
     356           else
    357357           {//unsigned LE or BE
    358358               //Default is LE, so check that first
    359                if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_24BPS_LE) 
     359               if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_24BPS_LE)
    360360               {
    361361                    ulDataFormat = OSS32_PCM_FORMAT_U24_LE;
    … …  
    367367       case 32:
    368368           //Default is signed, so check that first
    369            if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_32BPS_SIGNED) 
     369           if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_32BPS_SIGNED)
    370370           {//signed LE or BE
    371371               //Default is LE, so check that first
    372                if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_32BPS_LE) 
     372               if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_32BPS_LE)
    373373               {
    374374                    ulDataFormat = OSS32_PCM_FORMAT_S32_LE;
    … …  
    376376               else ulDataFormat = OSS32_PCM_FORMAT_S32_BE;
    377377           }
    378            else 
     378           else
    379379           {//unsigned LE or BE
    380380               //Default is LE, so check that first
    381                if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_32BPS_LE) 
     381               if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_32BPS_LE)
    382382               {
    383383                    ulDataFormat = OSS32_PCM_FORMAT_U32_LE;
    … …  
    406406       break;
    407407
    408    default: 
     408   default:
    409409       DebugInt3();
    410410       return 0;
    … …  
    415415//Setup conversion type & factor required for specified wave data format
    416416//******************************************************************************
    417 BOOL WAVEAUDIO::SetupConversion(PWAVECONFIGINFO pConfigInfo, 
    418                                 ULONG ulOperation, ULONG ulDataType, 
     417BOOL WAVEAUDIO::SetupConversion(PWAVECONFIGINFO pConfigInfo,
     418                                ULONG ulOperation, ULONG ulDataType,
    419419                                ULONG ulNumChannels, ULONG ulBitsPerSample)
    420420{
    … …  
    424424
    425425    usConversion = CONVERT_NONE;
    426    
     426
    427427    if(ulOperation == OPERATION_PLAY) {
    428428         pWaveCaps = &devCaps[ulDeviceNr].waveOutCaps;
    … …  
    464464    case DATATYPE_WAVEFORM:
    465465    case PCM:
    466         switch(ulBitsPerSample) 
     466        switch(ulBitsPerSample)
    467467        {
    468468        case 8:
    469             if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_8BPS)) 
     469            if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_8BPS))
    470470            {
    471471                if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS)) {
    … …  
    477477                else usConversion |= CONVERT_16_8;
    478478
    479                 if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_SIGNED) 
     479                if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_SIGNED)
    480480                {
    481481                    if(ulOperation == OPERATION_PLAY) {
    … …  
    487487            }
    488488            else
    489             if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U8) && 
     489            if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U8) &&
    490490                (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_S8))
    491491            {
    … …  
    502502
    503503        case 16:
    504             if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS)) 
     504            if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS))
    505505            {
    506506                if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_8BPS)) {
    507507                    DebugInt3();
    508508                    return FALSE;
    509                 }             
     509                }
    510510                if(ulOperation == OPERATION_PLAY)
    511511                     usConversion |= CONVERT_16_8;
    512512                else usConversion |= CONVERT_8_16;
    513            
    514                 if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U8) 
     513
     514                if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U8)
    515515                {
    516516                    if(ulOperation == OPERATION_PLAY) {
    … …  
    522522            }
    523523            else
    524             if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_SIGNED) && 
    525                 (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_UNSIGNED)) 
     524            if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_SIGNED) &&
     525                (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_UNSIGNED))
    526526            {
    527527                if(ulOperation == OPERATION_PLAY)
    … …  
    546546    case DATATYPE_ADPCM_AVC:
    547547    case DATATYPE_CT_ADPCM:
    548     default: 
     548    default:
    549549        DebugInt3();
    550550        return FALSE;
    … …  
    615615        dprintf(("CONVERT_8_UNSIGNED_TO_8_UNSIGNED_STEREO_MONO"));
    616616        break;
    617    
     617
    618618    case CONVERT_8_SIGNED_TO_8_SIGNED_STEREO_MONO:
    619619        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,1);   //factor 0.5
    … …  
    718718        dprintf(("CONVERT_16_UNSIGNED_TO_16_UNSIGNED_STEREO_MONO"));
    719719        break;
    720    
     720
    721721    case CONVERT_16_SIGNED_TO_16_SIGNED_STEREO_MONO:
    722722        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,1);   //factor 0.5
    … …  
    754754        dprintf(("CONVERT_16_SIGNED_TO_8_UNSIGNED_STEREO_MONO"));
    755755        break;
    756    
     756
    757757    default:
    758758        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,0);   //factor 1
    … …  
    778778    }
    779779
    780     if(pConfigInfo->fSampleRateConversion) 
     780    if(pConfigInfo->fSampleRateConversion)
    781781    {
    782         if(QuerySampleFormat(ulOperation, pConfigInfo) == TRUE) 
     782        if(QuerySampleFormat(ulOperation, pConfigInfo) == TRUE)
    783783        {
    784784            if(pConfigInfo->ulHwBitsPerSample == 8) {
    … …  
    788788                else pConfigInfo->pfnSRateConv = SRateConvert8Mono;
    789789            }
    790             else 
     790            else
    791791            if(pConfigInfo->ulHwBitsPerSample == 16) {
    792792                if(pConfigInfo->ulHwNumChannels == 2) {
    … …  
    966966//Find the closest matching samplerate from the OSS srate capability flags
    967967//******************************************************************************
    968 ULONG WAVEAUDIO::FindMatchingSampleRate(ULONG ulSampleRate, ULONG ulOSSSRateFlags, 
     968ULONG WAVEAUDIO::FindMatchingSampleRate(ULONG ulSampleRate, ULONG ulOSSSRateFlags,
    969969                                        ULONG FAR *pulNrSampleRates, ULONG FAR *pulFixedSampleRate)
    970970{
    … …  
    980980    if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_8000) {
    981981        sampleRates[nrSampleRates++] = 8000;
    982     }                                               
     982    }
    983983    if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_11025) {
    984984        sampleRates[nrSampleRates++] = 11025;
    … …  
    10211021        if(nrSampleRates <= 2 && pulFixedSampleRate) {
    10221022            //sampleRates[0] = 44100; /* hardware set to 44100 */
    1023             *pulFixedSampleRate = sampleRates[0]; 
     1023            *pulFixedSampleRate = sampleRates[0];
    10241024            nrSampleRates = 1;
    10251025        }
    … …  
    10531053
    10541054    if ( pCaps->ulOperation != OPERATION_PLAY &&
    1055          pCaps->ulOperation != OPERATION_RECORD ) 
     1055         pCaps->ulOperation != OPERATION_RECORD )
    10561056    {
    10571057        pCaps->ulSupport = UNSUPPORTED_OPERATION;
    10581058        return;
    10591059    }
    1060    
     1060
    10611061    if(pCaps->ulOperation == OPERATION_PLAY) {
    10621062         pWaveCaps = &devCaps[ulDeviceNr].waveOutCaps;
    … …  
    10641064    else pWaveCaps = &devCaps[ulDeviceNr].waveInCaps;
    10651065
    1066     // We always support stereo and mono 
    1067     if (pCaps->ulChannels != 1 && pCaps->ulChannels != 2) 
     1066    // We always support stereo and mono
     1067    if (pCaps->ulChannels != 1 && pCaps->ulChannels != 2)
    10681068    {
    10691069        if(pCaps->ulChannels > pWaveCaps->ulMaxChannels) {
    … …  
    10791079    //Determine supported rates
    10801080    ulSampleRate = pCaps->ulSamplingRate; //save the sampling rate called with
    1081    
    1082     if(pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_CONTINUOUS) 
     1081
     1082    if(pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_CONTINUOUS)
    10831083    {//supports all sample rates from min to max
    10841084        if (ulSampleRate < pWaveCaps->ulMinRate) {
    … …  
    11111111    // Determine the ulDataSubType and update any format specific flags
    11121112    // Note: All data types have more than one value.
    1113     switch ( pCaps->ulDataType ) 
     1113    switch ( pCaps->ulDataType )
    11141114    {
    11151115    case DATATYPE_NULL: //Warp 3 buggy data type
    … …  
    11221122        case 16:
    11231123            //NOTE: We always support 8 & 16 bits playback & recording; if the card
    1124             //      can't handle one of these formats, then we'll convert the 
     1124            //      can't handle one of these formats, then we'll convert the
    11251125            //      wave data ourselves (same for mono/stereo).
    11261126            break;
    … …  
    11631163        pCaps->ulDataSubType = aaulAlaw[usSampleRateIndex][pCaps->ulChannels-1];
    11641164        break;
    1165    
     1165
    11661166    case DATATYPE_MULAW:
    11671167    case DATATYPE_RIFF_MULAW:
    … …  
    11791179        pCaps->ulDataSubType = aaulMulaw[usSampleRateIndex][pCaps->ulChannels-1];
    11801180        break;
    1181    
     1181
    11821182    case DATATYPE_ADPCM_AVC:
    11831183    case DATATYPE_CT_ADPCM:
    … …  
    11941194        pCaps->ulDataSubType = aaulMulaw[usSampleRateIndex][pCaps->ulChannels-1];
    11951195        break;
    1196    
     1196
    11971197    default:
    11981198        pCaps->ulSupport = UNSUPPORTED_DATATYPE;
    11991199        return;
    12001200    } // end switch
    1201    
     1201
    12021202    pCaps->ulFlags |= FIXED        |    // Fixed length data
    12031203                      LEFT_ALIGNED |    // Left align bits on byte bndry
    … …  
    12401240        pCaps->ulResourceUnits = 1;
    12411241    }
    1242    
     1242
    12431243    if ( pCaps->ulOperation == OPERATION_PLAY)
    12441244        pCaps->ulResourceClass = 1;
    … …  
    12871287#pragma on (unreferenced)
    12881288{
    1289          ULONG  ulBytesPerIRQ; 
    1290          
     1289         ULONG  ulBytesPerIRQ;
     1290
    12911291#ifdef DEBUG
    12921292    dprintf(("WAVEAUDIO::ConfigDev"));
    … …  
    13231323    } /* endswitch */
    13241324
    1325           // Calculate the BytesPerIRQ
    1326           // The BytesPerIRQ is the number of bytes consumed by this data format
    1327           // for every interrupt generated by the codec.
    1328           // This information is returned to the WAVESTREAM which uses it in
    1329           // buffer management decisions....
    1330           // rjj Fix for Bug #18 28082008
    1331          
    1332           ulBytesPerIRQ = pConfigInfo->ulSampleRate;
    1333           ulBytesPerIRQ >>= 5; // 32 interrupts per second
    1334                                // we can tweak this as needed but generally this should do rjj
    1335          
    1336           if (pConfigInfo->ulBitsPerSample == 16) {
    1337                 ulBytesPerIRQ <<= 1;
    1338           }
    1339           if (pConfigInfo->ulNumChannels == 2) {
    1340                 ulBytesPerIRQ <<= 1;
    1341           }
    1342           // make sure it's an even multiple of 64
    1343           ulBytesPerIRQ += 0x00000040;
    1344           ulBytesPerIRQ &= 0xFFFFFFC0;
    1345                
    1346           if (ulBytesPerIRQ > 0x800) {
    1347                 ulBytesPerIRQ = 0x800;
    1348           }
    1349           pConfigInfo->ulBytesPerIRQ = ulBytesPerIRQ;
    1350 
    1351           // Calculate the PCMConsumeRate
     1325    // Calculate the PCMConsumeRate
    13521326    // The consume rate is the number of bytes consumed by this data format
    13531327    // per second. It calculated by taking the following equation:
    … …  
    13571331    pConfigInfo->ulSampleSize     = (pConfigInfo->ulBitsPerSample*pConfigInfo->ulNumChannels)/8;
    13581332    pConfigInfo->ulPCMConsumeRate = pConfigInfo->ulSampleRate * pConfigInfo->ulSampleSize;
    1359    
     1333
     1334    // Calculate the BytesPerIRQ
     1335    // The BytesPerIRQ is the number of bytes consumed by this data format
     1336    // for every interrupt generated by the codec.
     1337    // This information is returned to the WAVESTREAM which uses it in
     1338    // buffer management decisions....
     1339    // basic formula is  (sampling rate * ((BitsPerSample * NumChannels) /8) / Number of Interrupts per Second
     1340    // or pConfigInfo->ulPCMConsumeRate / Number of Interrupts Per Second
     1341    // rjj Fix for Bug #18 28082008
     1342
     1343    //ulBytesPerIRQ = pConfigInfo->ulPCMConsumeRate >> 5;  // 32 interrupts per second
     1344    ulBytesPerIRQ = pConfigInfo->ulPCMConsumeRate >> 6;  // 64 interrupts per second
     1345                                                         // we can tweak this as needed but generally this should do rjj
     1346    // make sure it's an even multiple of 64
     1347    ulBytesPerIRQ += 0x00000040;
     1348    ulBytesPerIRQ &= 0xFFFFFFC0;
     1349
     1350    if (ulBytesPerIRQ > 0x800) {
     1351          ulBytesPerIRQ = 0x800;
     1352    }
     1353    pConfigInfo->ulBytesPerIRQ = ulBytesPerIRQ;
     1354
     1355
    13601356    return TRUE;
    13611357}
    … …  
    14631459//NOTE: Can only be used for small numbers (up to about 4mb)!! (overflow)
    14641460//******************************************************************************
    1465 ULONG WAVEAUDIO::ConvertLength(ULONG length, PWAVECONFIGINFO pConfigInfo) 
     1461ULONG WAVEAUDIO::ConvertLength(ULONG length, PWAVECONFIGINFO pConfigInfo)
    14661462{
    14671463    ULONG newlen;
    … …  
    14751471    }
    14761472    if(newlen && pConfigInfo->fSampleRateConversion) {
    1477         newlen = SRATE_CONVERT_LENGTH(newlen, pConfigInfo->ulSRatePosition, 
     1473        newlen = SRATE_CONVERT_LENGTH(newlen, pConfigInfo->ulSRatePosition,
    14781474                                      pConfigInfo->ulSRateIncrement);
    14791475    }
    … …  
    14861482//NOTE: Can only be used for small numbers (up to about 4mb)!! (overflow)
    14871483//******************************************************************************
    1488 ULONG WAVEAUDIO::ConvertLengthInvert(ULONG length, PWAVECONFIGINFO pConfigInfo) 
     1484ULONG WAVEAUDIO::ConvertLengthInvert(ULONG length, PWAVECONFIGINFO pConfigInfo)
    14891485{
    14901486    ULONG newlen,tmp,len;
    … …  
    15041500
    15051501    if (!tmp) return 0;
    1506    
    1507     if (pConfigInfo->usConversion != CONVERT_NONE) 
     1502
     1503    if (pConfigInfo->usConversion != CONVERT_NONE)
    15081504    {
    15091505        newlen =  CONVERT_LENGTH_INVERT (tmp, pConfigInfo->ulConversionFactor);
    … …  
    15241520/*PS++
    15251521    if(newlen && pConfigInfo->fSampleRateConversion) {
    1526         newlen = SRATE_CONVERT_LENGTH_INVERT(newlen, pConfigInfo->ulSRatePosition, 
     1522        newlen = SRATE_CONVERT_LENGTH_INVERT(newlen, pConfigInfo->ulSRatePosition,
    15271523                                             pConfigInfo->ulSRateIncrement);
    15281524    }

  • OCO/trunk/drv16/waudio.hpp

    r369 r391  
    7676   ULONG  ulDataType;        // type of data (PCM, MuLaw, ALaw etc) Input
    7777   ULONG  ulPCMConsumeRate;  // number of bytes consumed/produced per sec Output
    78         ULONG  ulBytesPerIRQ;     // The number of bytes consumed per irq rjj Fix for Bug #18 28082008
     78  ULONG  ulBytesPerIRQ;     // The number of bytes consumed per irq rjj Fix for Bug #18 28082008
    7979
    8080   ULONG  ulFragsize;
    … …  
    122122
    123123   //Setup conversion type & factor required for specified wave data format
    124            BOOL  SetupConversion(PWAVECONFIGINFO pConfigInfo, 
    125                                  ULONG ulOperation, ULONG ulDataType, 
     124           BOOL  SetupConversion(PWAVECONFIGINFO pConfigInfo,
     125                                 ULONG ulOperation, ULONG ulDataType,
    126126                                 ULONG ulNumChannels, ULONG ulBitsPerSample);
    127127
    … …  
    136136   virtual BOOL  Transfer(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo, LINEAR pUserBuffer, ULONG ulBytesToTransfer, ULONG FAR *pulBytesTransferred) = 0;
    137137   virtual BOOL  GetPosition(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo, ULONG FAR *pulStreamPosition) = 0;
     138   virtual BOOL  GetHwPtr(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo, ULONG FAR *pulHwPtr) = 0;
    138139   virtual BOOL  GetSpace(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo, ULONG FAR *pulStreamSpace) = 0;
    139140   virtual BOOL  AddBuffer(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo, LINEAR pUserBuffer, ULONG ulBytesToTransfer, ULONG FAR *pulBytesTransferred) = 0;

  • OCO/trunk/drv16/wavehw.hpp

    r258 r391  
    4040   virtual BOOL  GetPosition(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo, ULONG FAR *pulStreamPosition);
    4141   virtual BOOL  GetSpace(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo, ULONG FAR *pulStreamSpace);
     42   virtual BOOL  GetHwPtr(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo, ULONG FAR *pulHwPtr);
    4243
    4344   virtual BOOL  SetVolume(OSSSTREAMID StreamId, OSSSTREAMID mixerStreamId, ULONG ulVolume);
    … …  
    6162   virtual BOOL  GetPosition(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo, ULONG FAR *pulStreamPosition);
    6263   virtual BOOL  GetSpace(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo, ULONG FAR *pulStreamSpace);
     64   virtual BOOL  GetHwPtr(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo, ULONG FAR *pulHwPtr);
    6365
    6466   virtual BOOL  SetVolume(OSSSTREAMID StreamId, OSSSTREAMID mixerStreamId, ULONG ulVolume);

  • OCO/trunk/drv16/waveplay.cpp

    r288 r391  
    233233    //while the stream is playing.
    234234    ULONG minimumsize = ulFirstBufSize/2;
    235     if(minimumsize && minimumsize < fragsize) 
     235    if(minimumsize && minimumsize < fragsize)
    236236    {
    237237        while(minimumsize < fragsize) fragsize = fragsize / 2;
    238238
    239             if(fragsize < ulPCMConsumeRate/256) 
     239            if(fragsize < ulPCMConsumeRate/256)
    240240            {//lower limit; don't accept extremely small buffers
    241241                fragsize = ulPCMConsumeRate/256;
    242242            }
    243     }   
     243    }
    244244    samplesize = (int)pConfigInfo->ulHwSampleSize;
    245245
    … …  
    280280//Convert (if required) and write wave data to audio device
    281281//******************************************************************************
    282 BOOL WAVEPLAY::Transfer(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo, 
    283                         LINEAR pUserBuffer, ULONG ulBytesToTransfer, 
     282BOOL WAVEPLAY::Transfer(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo,
     283                        LINEAR pUserBuffer, ULONG ulBytesToTransfer,
    284284                        ULONG FAR *pulBytesTransferred)
    285285{
    … …  
    301301//    if (!waveOpened) return TRUE;
    302302
    303     if(pConfigInfo->usConversion == CONVERT_NONE) 
     303    if(pConfigInfo->usConversion == CONVERT_NONE)
    304304    {
    305305#ifdef DEBUG
    306306        dprintf(("Transfer. NoConv ulB %ld",ulBytesToTransfer));
    307307#endif /* DEBUG */
    308         if(AddBuffer(StreamId, pConfigInfo, pUserBuffer, ulBytesToTransfer, pulBytesTransferred) == FALSE) 
     308        if(AddBuffer(StreamId, pConfigInfo, pUserBuffer, ulBytesToTransfer, pulBytesTransferred) == FALSE)
    309309        {
    310310            *pulBytesTransferred = 0;
    … …  
    320320            ulCvtBufferSize = min(CONVERSION_BUFFER_SIZE, ulCvtBufferSize);
    321321
    322             //convert back from conversion to 'real' 
     322            //convert back from conversion to 'real'
    323323            ulBytesToTransfer = CONVERT_LENGTH(ulCvtBufferSize, CONVERSION_INVERT(pConfigInfo->ulConversionFactor));
    324324
    … …  
    331331            }
    332332            pConfigInfo->pfnConvert(pUserBuffer, ulBytesToTransfer, pConfigInfo->pConversionBuffer);
    333             if(AddBuffer(StreamId, pConfigInfo, pConfigInfo->pConversionBuffer, ulCvtBufferSize, pulBytesTransferred) == FALSE) 
     333            if(AddBuffer(StreamId, pConfigInfo, pConfigInfo->pConversionBuffer, ulCvtBufferSize, pulBytesTransferred) == FALSE)
    334334            {
    335335                *pulBytesTransferred = 0;
    336336                return FALSE;
    337337            }
    338             //convert back from conversion to 'real' 
     338            //convert back from conversion to 'real'
    339339            *pulBytesTransferred = CONVERT_LENGTH(*pulBytesTransferred, CONVERSION_INVERT(pConfigInfo->ulConversionFactor));
    340340            if(*pulBytesTransferred & (pConfigInfo->ulSampleSize-1)) {
    … …  
    355355// Perform sample rate conversion if required, else send buffer directly to ALSA
    356356//******************************************************************************
    357 BOOL WAVEPLAY::AddBuffer(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo, LINEAR pUserBuffer, 
     357BOOL WAVEPLAY::AddBuffer(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo, LINEAR pUserBuffer,
    358358                         ULONG ulBytesToTransfer, ULONG FAR *pulBytesTransferred)
    359359{
    … …  
    378378
    379379        //bytes to convert is bounded by bytes to transfer & max conversion buffer size
    380         ulCvtBufferSize = SRATE_CONVERT_LENGTH(ulBytesToTransfer, pConfigInfo->ulSRatePosition, 
     380        ulCvtBufferSize = SRATE_CONVERT_LENGTH(ulBytesToTransfer, pConfigInfo->ulSRatePosition,
    381381                                               pConfigInfo->ulSRateIncrement);
    382382        ulCvtBufferSize = min(CONVERSION_BUFFER_SIZE, ulCvtBufferSize);
    383383        //round to sample boundary
    384384        ulCvtBufferSize &= ~(pConfigInfo->ulHwSampleSize - 1);
    385        
     385
    386386        if(ulCvtBufferSize == 0) {
    387387            *pulBytesTransferred = ulBytesToTransfer;
    388             if(pConfigInfo->ulSRatePosition >= pConfigInfo->ulSRateIncrement) { 
     388            if(pConfigInfo->ulSRatePosition >= pConfigInfo->ulSRateIncrement) {
    389389                pConfigInfo->ulSRatePosition -= pConfigInfo->ulSRateIncrement;
    390390            }
    … …  
    394394            return TRUE;
    395395        }
    396         pConfigInfo->pfnSRateConv(pUserBuffer, ulCvtBufferSize, pConfigInfo->pSRateConvBuffer, 
     396        pConfigInfo->pfnSRateConv(pUserBuffer, ulCvtBufferSize, pConfigInfo->pSRateConvBuffer,
    397397                                  pConfigInfo->ulSRatePosition, pConfigInfo->ulSRateIncrement);
    398398//PS++ !!!!! This don't be !!!!!!!
    … …  
    413413        }
    414414        if((rc = OSS16_WaveAddBuffer(StreamId, pConfigInfo->pSRateConvBuffer, ulCvtBufferSize, pulBytesTransferred)) != OSSERR_SUCCESS ||
    415            *pulBytesTransferred == 0) 
     415           *pulBytesTransferred == 0)
    416416        {
    417417            if(rc == OSSERR_BUFFER_FULL) {
    … …  
    425425        ulHwSampleCount = *pulBytesTransferred/pConfigInfo->ulHwSampleSize;
    426426
    427         //convert back from conversion to 'real' 
    428         ulSampleCount   = SRATE_CONVERT_LENGTH_INVERT(ulHwSampleCount, 
    429                                                       pConfigInfo->ulSRatePosition, 
     427        //convert back from conversion to 'real'
     428        ulSampleCount   = SRATE_CONVERT_LENGTH_INVERT(ulHwSampleCount,
     429                                                      pConfigInfo->ulSRatePosition,
    430430                                                      pConfigInfo->ulSRateIncrement);
    431431
    … …  
    447447        *pulBytesTransferred = ulSampleCount*pConfigInfo->ulHwSampleSize;
    448448    }
    449     else 
    450     {
    451        if( (rc=OSS16_WaveAddBuffer(StreamId, pUserBuffer, ulBytesToTransfer, pulBytesTransferred)) != OSSERR_SUCCESS) 
     449    else
     450    {
     451       if( (rc=OSS16_WaveAddBuffer(StreamId, pUserBuffer, ulBytesToTransfer, pulBytesTransferred)) != OSSERR_SUCCESS)
    452452       {
    453453        *pulBytesTransferred = 0;
    … …  
    500500    //round to sample boundary
    501501    *pulStreamSpace =cvt & ( ~(pConfigInfo->ulSampleSize - 1));
     502    return TRUE;
     503}
     504//******************************************************************************
     505//Get Bytes written to cyclic buffer (+ take conversion factor into account)
     506//******************************************************************************
     507BOOL WAVEPLAY::GetHwPtr(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo, ULONG FAR *pulHwPtr)
     508{
     509    ULONG space,cvt;
     510
     511    if(OSS16_WaveGetHwPtr(StreamId, &space) != OSSERR_SUCCESS) {
     512        *pulHwPtr = 0;
     513        #ifdef DEBUG
     514        dprintf(("OSS16_WAVEPLAY::WaveGetHwPtr: Failed"));
     515        #endif /* DEBUG */
     516        return FALSE;
     517    }
     518    cvt  = ConvertLengthInvert(space, pConfigInfo);
     519    //round to sample boundary
     520    *pulHwPtr = cvt & ( ~(pConfigInfo->ulSampleSize - 1));
    502521    return TRUE;
    503522}

  • OCO/trunk/drv16/waverec.cpp

    r252 r391  
    4141BOOL WAVEREC::Open(ULONG ulDevice, ULONG ulStreamType, ULONG ulSysFileNum, OSSSTREAMID FAR *pStreamId)
    4242{
    43     if(StreamId == 0) 
    44     {
    45         if(OSS16_WaveOpen(ulDevice, ulStreamType, ulSysFileNum, pStreamId) != OSSERR_SUCCESS) 
     43    if(StreamId == 0)
     44    {
     45        if(OSS16_WaveOpen(ulDevice, ulStreamType, ulSysFileNum, pStreamId) != OSSERR_SUCCESS)
    4646        {
    4747            dprintf(("OSS16_WaveOpen failed!!"));
    … …  
    6767BOOL WAVEREC::Close(OSSSTREAMID StreamId)
    6868{
    69     if(devCaps[ulDeviceNr].waveInCaps.nrStreams > 1) 
     69    if(devCaps[ulDeviceNr].waveInCaps.nrStreams > 1)
    7070    {
    7171        return OSS16_WaveClose(StreamId) == OSSERR_SUCCESS;
    … …  
    115115    //while the stream is playing.
    116116    ULONG minimumsize = (ulFirstBufSize/2);
    117     if(minimumsize && minimumsize < fragsize) 
     117    if(minimumsize && minimumsize < fragsize)
    118118    {
    119119        while(minimumsize < fragsize) fragsize = fragsize / 2;
    120            
    121         if(fragsize < ulPCMConsumeRate/256) 
     120
     121        if(fragsize < ulPCMConsumeRate/256)
    122122            {//lower limit; don't accept extremely small buffers
    123123                fragsize = ulPCMConsumeRate/256;
    124124            }
    125     }   
     125    }
    126126    samplesize = (int)pConfigInfo->ulHwSampleSize;
    127127
    … …  
    133133
    134134    dprintf(("WAVEREC::ConfigDev: Fragment size %d", (USHORT)fragsize));
    135  
     135
    136136    hwparam.ulSampleRate    = pConfigInfo->ulHwSampleRate;
    137137    hwparam.ulBitsPerSample = pConfigInfo->ulHwBitsPerSample;
    … …  
    147147//Read and convert (if required) wave data from audio device
    148148//******************************************************************************
    149 BOOL WAVEREC::Transfer(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo, 
    150                        LINEAR pUserBuffer, ULONG ulBytesToTransfer, 
     149BOOL WAVEREC::Transfer(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo,
     150                       LINEAR pUserBuffer, ULONG ulBytesToTransfer,
    151151                       ULONG FAR *pulBytesTransferred)
    152152{
    153     if(pConfigInfo->usConversion == CONVERT_NONE) 
    154     {
    155         if(AddBuffer(StreamId, pConfigInfo, pUserBuffer, ulBytesToTransfer, pulBytesTransferred) == FALSE) 
     153    if(pConfigInfo->usConversion == CONVERT_NONE)
     154    {
     155        if(AddBuffer(StreamId, pConfigInfo, pUserBuffer, ulBytesToTransfer, pulBytesTransferred) == FALSE)
    156156        {
    157157            *pulBytesTransferred = 0;
    … …  
    159159        }
    160160    }
    161     else 
    162     {
    163         if(pConfigInfo->pfnConvert) 
     161    else
     162    {
     163        if(pConfigInfo->pfnConvert)
    164164        {
    165165            ULONG ulCvtBufferSize;
    … …  
    169169            ulCvtBufferSize = min(CONVERSION_BUFFER_SIZE, ulCvtBufferSize);
    170170
    171             if(AddBuffer(StreamId, pConfigInfo, pConfigInfo->pConversionBuffer, ulCvtBufferSize, pulBytesTransferred) == FALSE) 
     171            if(AddBuffer(StreamId, pConfigInfo, pConfigInfo->pConversionBuffer, ulCvtBufferSize, pulBytesTransferred) == FALSE)
    172172            {
    173173                *pulBytesTransferred = 0;
    … …  
    198198// Perform sample rate conversion if required, else send buffer directly to ALSA
    199199//******************************************************************************
    200 BOOL WAVEREC::AddBuffer(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo, LINEAR pUserBuffer, 
     200BOOL WAVEREC::AddBuffer(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo, LINEAR pUserBuffer,
    201201                        ULONG ulBytesToTransfer, ULONG FAR *pulBytesTransferred)
    202202{
    203     if(pConfigInfo->fSampleRateConversion) 
     203    if(pConfigInfo->fSampleRateConversion)
    204204    {
    205205        ULONG ulCvtBufferSize, ulHwSampleCount, ulSampleCount;
    … …  
    207207
    208208        //bytes to convert is bounded by bytes to transfer & max conversion buffer size
    209         ulCvtBufferSize = SRATE_CONVERT_LENGTH_INVERT(ulBytesToTransfer, pConfigInfo->ulSRatePosition, 
     209        ulCvtBufferSize = SRATE_CONVERT_LENGTH_INVERT(ulBytesToTransfer, pConfigInfo->ulSRatePosition,
    210210                                                      pConfigInfo->ulSRateIncrement);
    211211        ulCvtBufferSize = min(CONVERSION_BUFFER_SIZE, ulCvtBufferSize);
    212        
     212
    213213        //round to sample boundary
    214214        ulCvtBufferSize &= ~(pConfigInfo->ulHwSampleSize - 1);
    215215        if(ulCvtBufferSize == 0) {
    216216            *pulBytesTransferred = ulBytesToTransfer;
    217             if(pConfigInfo->ulSRatePosition >= pConfigInfo->ulSRateIncrement) { 
     217            if(pConfigInfo->ulSRatePosition >= pConfigInfo->ulSRateIncrement) {
    218218                pConfigInfo->ulSRatePosition -= pConfigInfo->ulSRateIncrement;
    219219            }
    … …  
    223223
    224224        if(OSS16_WaveAddBuffer(StreamId, pConfigInfo->pSRateConvBuffer, ulCvtBufferSize, pulBytesTransferred) != OSSERR_SUCCESS ||
    225            *pulBytesTransferred == 0) 
     225           *pulBytesTransferred == 0)
    226226        {
    227227            *pulBytesTransferred = 0;
    … …  
    229229        }
    230230        ulHwSampleCount      = *pulBytesTransferred/pConfigInfo->ulHwSampleSize;
    231        
    232         //convert back from conversion to 'real' 
    233         ulSampleCount        = SRATE_CONVERT_LENGTH(ulHwSampleCount, pConfigInfo->ulSRatePosition, 
     231
     232        //convert back from conversion to 'real'
     233        ulSampleCount        = SRATE_CONVERT_LENGTH(ulHwSampleCount, pConfigInfo->ulSRatePosition,
    234234                                                    pConfigInfo->ulSRateIncrement);
    235235        *pulBytesTransferred = ulSampleCount*pConfigInfo->ulHwSampleSize;
    236        
     236
    237237        if(ulSampleCount == 0) {
    238238            return FALSE;
    … …  
    245245
    246246        //convert recorded audio data
    247         pConfigInfo->pfnSRateConv(pConfigInfo->pSRateConvBuffer, *pulBytesTransferred, pUserBuffer, 
     247        pConfigInfo->pfnSRateConv(pConfigInfo->pSRateConvBuffer, *pulBytesTransferred, pUserBuffer,
    248248                                  pConfigInfo->ulSRatePosition, pConfigInfo->ulSRateIncrement);
    249249
    … …  
    253253        pConfigInfo->ulSRatePosition  = (ULONG)lSRatePosition;
    254254    }
    255     else 
    256     if(OSS16_WaveAddBuffer(StreamId, pUserBuffer, ulBytesToTransfer, pulBytesTransferred) != OSSERR_SUCCESS) 
     255    else
     256    if(OSS16_WaveAddBuffer(StreamId, pUserBuffer, ulBytesToTransfer, pulBytesTransferred) != OSSERR_SUCCESS)
    257257    {
    258258        *pulBytesTransferred = 0;
    … …  
    293293    //round to sample boundary
    294294    *pulStreamSpace &= ~(pConfigInfo->ulSampleSize - 1);
     295    return TRUE;
     296}
     297//******************************************************************************
     298//Get Bytes written to cyclic buffer (+ take conversion factor into account)
     299//******************************************************************************
     300BOOL WAVEREC::GetHwPtr(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo, ULONG FAR *pulHwPtr)
     301{
     302    ULONG space,cvt;
     303
     304    if(OSS16_WaveGetHwPtr(StreamId, &space) != OSSERR_SUCCESS) {
     305        *pulHwPtr = 0;
     306        #ifdef DEBUG
     307        dprintf(("OSS16_WAVEREC::WaveGetHwPtr: Failed"));
     308        #endif /* DEBUG */
     309        return FALSE;
     310    }
     311    cvt  = ConvertLengthInvert(space, pConfigInfo);
     312    //round to sample boundary
     313    *pulHwPtr = cvt & ( ~(pConfigInfo->ulSampleSize - 1));
    295314    return TRUE;
    296315}

  • OCO/trunk/include/ossidc.h

    r266 r391  
    3939
    4040//IDC communication packet
    41 typedef struct 
     41typedef struct
    4242{
    4343  OSSSTREAMID streamid; //IN:  stream id
    … …  
    131131#define IDC32_WAVE_GETPOS               0x1B
    132132#define IDC32_WAVE_SETVOLUME            0x1C
     133#define IDC32_WAVE_GETHWPTR             0x1D
    133134
    134135#define IDC32_MIXER_OPEN                0x20
    … …  
    246247
    247248
    248 typedef struct 
     249typedef struct
    249250{
    250251    char  name[SIZE_DEVICE_NAME];
    … …  
    255256
    256257#define SIZE_DEVICE_NAME            32
    257 typedef struct 
     258typedef struct
    258259{
    259260    ULONG nrchannels;
    … …  
    335336typedef struct {
    336337    ULONG  nrStreams;            //nr of activate wave streams supported
    337     ULONG  ulMinChannels;        //min nr of channels 
    338     ULONG  ulMaxChannels;        //max nr of channels 
     338    ULONG  ulMinChannels;        //min nr of channels
     339    ULONG  ulMaxChannels;        //max nr of channels
    339340    ULONG  ulChanFlags;          //channel flags
    340341    ULONG  ulMinRate;            //min sample rate

  • OCO/trunk/include/ossidc16.h

    r266 r391  
    7070OSSRET DBGCALLCONV OSS16_WaveGetSpace(OSSSTREAMID StreamId, ULONG FAR *lpBytesLeft);
    7171OSSRET DBGCALLCONV OSS16_WaveSetVolume(OSSSTREAMID StreamId, ULONG volume);
     72OSSRET DBGCALLCONV OSS16_WaveGetHwPtr(OSSSTREAMID StreamId, ULONG FAR *lpPosition);
    7273
    7374OSSRET DBGCALLCONV OSS16_MixOpen(ULONG devicenr, OSSSTREAMID FAR *pStreamid);
Note: See TracChangeset for help on using the changeset viewer.