///////////////////////////////////////////////////////////////////////////////
// Copyright (c) Winnov L.P., 1997. All rights reserved
// asrc.c: asrc class implementation
//
// Modified : C++ -> C
////////////////////////////////////////////////////////////////////////////////
#include "common.h"
#include "wnvasrc.h"
#include "asrc.h"
#include "asrcpriv.h"
#undef PUBLIC
#undef PRIVATE
#define PUBLIC
#define PRIVATE
#ifdef ECHOCANCEL
///////////////////////////////////////////////////////////////////////////////
// Temporary location of ECHO class
///////////////////////////////////////////////////////////////////////////////
PRIVATE DWORD Local_SetFilter (PECHO pEcho, LPECHOPARAM lpParam)
{
UINT i;
BOOL fEnabled;
if (lpParam->nTaps > ECHO_MAX_TAPS) return 1; // fail, too many taps
if (lpParam->nDelay > (sizeof (pEcho->dwBuf)/sizeof(DWORD))) return 2; // delay too large
// save the new parameters
pEcho->param = *lpParam;
// disable while changing
fEnabled = pEcho->param.fEnabled;
pEcho->param.fEnabled = FALSE;
// reset the sample history buffers
for (i = 0; (i < pEcho->param.nTaps); i++)
{
pEcho->lLeftHistory [i] = 0;
pEcho->lRightHistory [i] = 0;
}
// reset the sample buffer
pEcho->dwInIndex = 0;
pEcho->dwOutIndex = pEcho->param.nDelay;
for (i = 0; (i < (sizeof (pEcho->dwBuf)/sizeof(DWORD))); i++)
pEcho->dwBuf [i] = 0;
// restore enable
pEcho->param.fEnabled = fEnabled;
return 0; // pass
}
///////////////////////////////////////////////////////////////////////////////
ECHOPARAM defParam = {
ECHO_DEF_ENABLE, // fEnable
ECHO_DEF_DELAY, // nDelay
ECHO_DEF_TAPS, // nTaps
0, // nCoefIndex
-ECHO_SCALE/4L, -ECHO_SCALE/2L, -ECHO_SCALE/4L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // lCoef
///////////////////////////////////////////////////////////////////////////////
PUBLIC void echoConstructor (PECHO pEcho)
{
Local_SetFilter (pEcho, &defParam);
}
PUBLIC void echoDestructor (PECHO pEcho)
{
}
///////////////////////////////////////////////////////////////////////////////
// A wrapper for setting up echo parameters
PUBLIC DWORD echoGetParamIndex (PECHO pEcho)
{
return pEcho->dwParamIndex;
}
PUBLIC DWORD echoSetParamIndex (PECHO pEcho, DWORD dwIndex)
{
pEcho->dwParamIndex = dwIndex;
return 0;
}
PUBLIC DWORD echoSetParam (PECHO pEcho, DWORD dwParam)
{
BOOL fEnabled;
fEnabled = pEcho->param.fEnabled;
switch (pEcho->dwParamIndex)
{
case ECHOPARAM_ENABLE:
pEcho->param.fEnabled = (BOOL)dwParam;
break;
case ECHOPARAM_DELAY:
pEcho->param.nDelay = (UINT)dwParam;
break;
case ECHOPARAM_TAPS:
pEcho->param.nTaps = (UINT)dwParam;
break;
case ECHOPARAM_COEFINDEX:
pEcho->param.nCoefIndex = (UINT)dwParam;
break;
case ECHOPARAM_COEF:
pEcho->param.lCoef [pEcho->param.nCoefIndex] = (long)dwParam;
break;
}
if (!fEnabled && pEcho->param.fEnabled)
Local_SetFilter (pEcho, &pEcho->param);
return 0;
}
PUBLIC DWORD echoGetParam (PECHO pEcho)
{
switch (pEcho->dwParamIndex)
{
case ECHOPARAM_ENABLE:
return (DWORD)pEcho->param.fEnabled;
case ECHOPARAM_DELAY:
return (DWORD)pEcho->param.nDelay;
case ECHOPARAM_TAPS:
return (DWORD)pEcho->param.nTaps;
case ECHOPARAM_COEFINDEX:
return (DWORD)pEcho->param.nCoefIndex;
case ECHOPARAM_COEF:
return (DWORD)pEcho->param.lCoef [pEcho->param.nCoefIndex];
}
return (DWORD)-1; // fail
}
///////////////////////////////////////////////////////////////////////////////
// save input stream to echo buffer
PUBLIC void echoRecord (PECHO pEcho, LPDWORD lpBuf, DWORD dwSize)
{
if (!pEcho->param.fEnabled) return;
dwSize &= ~(sizeof(DWORD)-1);
while (dwSize)
{
pEcho->dwBuf [pEcho->dwInIndex++] = *lpBuf++;
if (pEcho->dwInIndex >= (sizeof (pEcho->dwBuf)/sizeof(DWORD)))
pEcho->dwInIndex = 0;
dwSize -= sizeof(DWORD);
}
}
///////////////////////////////////////////////////////////////////////////////
// Apply cancellation filter to playback data
PRIVATE WORD Local_FilterSample (long lSample, UINT nTaps, LPLONG lpCoef, LPLONG lpHistory)
{
UINT i;
lSample *= ECHO_SCALE;
// apply n tap filter of delayed input to output
for (i = 0; (i < nTaps); i++)
{
lSample += lpCoef[i] * lpHistory[i];
}
// scale
lSample /= ECHO_SCALE;
// saturate
if (lSample < -32768)
lSample = -32768;
if (lSample > 32767)
lSample = 32767;
return (WORD)(lSample);
}
///////////////////////////////////////////////////////////////////////////////
// invoked on each playback buffer
// cancel input to output feedback
PUBLIC void echoPlayback (PECHO pEcho, LPWORD lpBuf, DWORD dwSize)
{
UINT i;
if (!pEcho->param.fEnabled) return;
dwSize &= ~(sizeof(DWORD)-1);
while (dwSize)
{
// apply n tap filter of delayed input to output
*lpBuf = Local_FilterSample ((long)(int)*lpBuf, pEcho->param.nTaps, pEcho->param.lCoef, pEcho->lLeftHistory);
lpBuf++;
*lpBuf = Local_FilterSample ((long)(int)*lpBuf, pEcho->param.nTaps, pEcho->param.lCoef, pEcho->lRightHistory);
lpBuf++;
// update sample history
for (i = 0; (i < (pEcho->param.nTaps-1)); i++)
{
pEcho->lLeftHistory [i] = pEcho->lLeftHistory [i+1];
pEcho->lRightHistory [i] = pEcho->lRightHistory [i+1];
}
pEcho->lLeftHistory [pEcho->param.nTaps-1] = (long)(int)(WORD)pEcho->dwBuf [pEcho->dwOutIndex];
pEcho->lRightHistory [pEcho->param.nTaps-1] = (long)(int)HIWORD(pEcho->dwBuf [pEcho->dwOutIndex]);
pEcho->dwOutIndex++;
if (pEcho->dwOutIndex >= (sizeof(pEcho->dwBuf)/sizeof(DWORD)))
pEcho->dwOutIndex = 0;
dwSize -= sizeof(DWORD);
}
}
///////////////////////////////////////////////////////////////////////////////
//////////////////////////// End Echo Class ///////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
#endif // ECHOCANCEL
///////////////////////////////////////////////////////////////////////////////
// This is a callback from HAL to set the mute bit in the codec.
void Local_SetSpeakerMute (DWORD dwInstance, BOOL fMute)
{
PASRC pAsrc = (PASRC)dwInstance;
asrcCodecSetSpeakerMute (pAsrc, fMute);
}
void Local_SetWaveOutMute (DWORD dwInstance, BOOL fMute)
{
PASRC pAsrc = (PASRC)dwInstance;
asrcCodecSetWaveOutMute (pAsrc, fMute);
}
///////////////////////////////////////////////////////////////////////////////
// Constructor
PUBLIC void IAsrcConstructor (PASRC pAsrc)
{
pAsrc->m_nInputAge = (UINT)-1;
pAsrc->m_lLeftDC = 0;
pAsrc->m_lRightDC = 0;
sharedConstructor (pAsrc->m_pShared);
sharedSetBoard (pAsrc->m_pShared, pAsrc->m_nBoard);
serviceConstructor (&pAsrc->m_service,
pAsrc->m_nBoard,
pAsrc->m_pShared,
pAsrc->m_pIrp);
halConstructor(&pAsrc->m_hal,
pAsrc->m_pShared,
&pAsrc->m_service,
pAsrc->m_nBoard,
Local_SetSpeakerMute,
Local_SetWaveOutMute,
(DWORD)(NEARPTR)pAsrc);
codecConstructor(&pAsrc->m_codec,
pAsrc->m_pShared,
pAsrc->m_nBoard,
&pAsrc->m_hal);
#ifdef ECHOCANCEL
echoConstructor (&pAsrc->m_echo);
#endif
}
// Destructor
PUBLIC void IAsrcDestructor (PASRC pAsrc)
{
#ifdef ECHOCANCEL
echoDestructor (&pAsrc->m_echo);
#endif
codecDestructor (&pAsrc->m_codec);
halDestructor (&pAsrc->m_hal);
serviceDestructor (&pAsrc->m_service);
sharedDestructor (pAsrc->m_pShared);
}
PUBLIC UINT asrcReadReg (PASRC pAsrc, UINT nReg)
{
return halReadReg (&pAsrc->m_hal, nReg);
}
PUBLIC void asrcWriteReg (PASRC pAsrc, UINT nReg, UINT nVal)
{
halWriteReg (&pAsrc->m_hal, nReg, nVal);
}
PUBLIC DWORD IAsrcGet (PASRC pAsrc, DWORD dwItem)
{
if (!sharedGetInitialized (pAsrc->m_pShared)) return 0;
if (asrcIsVideoOnly (pAsrc)) return 0;
switch (LOWORD(dwItem))
{
case WNVASRC_VERSION: return asrcGetVersion (pAsrc); // this is always first
case WNVASRC_SAMPLERATE: return asrcGetSampleRate (pAsrc);
case WNVASRC_ACE: return asrcGetACE (pAsrc);
case WNVASRC_AMS: return asrcGetAMS (pAsrc);
case WNVASRC_APE: return asrcGetAPE (pAsrc);
case WNVASRC_PTR: return asrcGetPtr (pAsrc);
case WNVASRC_ISPLAYING: return asrcGetIsPlaying (pAsrc);
case WNVASRC_WAVEOUTSTATE: return asrcGetWaveOutState (pAsrc);
case WNVASRC_LEFTGAINCURRENTSOURCE: return asrcGetLeftGainCurrentSource (pAsrc);
case WNVASRC_RIGHTGAINCURRENTSOURCE: return asrcGetRightGainCurrentSource (pAsrc);
case WNVASRC_LEFTGAINPERSOURCE: return asrcGetLeftGainPerSource (pAsrc, HIWORD(dwItem));
case WNVASRC_RIGHTGAINPERSOURCE: return asrcGetRightGainPerSource (pAsrc, HIWORD(dwItem));
case WNVASRC_SOURCE: return asrcGetSource (pAsrc);
case WNVASRC_LINE2SOURCE: return asrcGetLine2Source (pAsrc);
case WNVASRC_OUTPUTSOURCE: return asrcGetOutputSource (pAsrc);
case WNVASRC_MUTEOUT: return asrcGetMuteOut (pAsrc);
case WNVASRC_MUTEIN: return asrcGetMuteIn (pAsrc);
case WNVASRC_AUXMUTE: return asrcGetAuxMute (pAsrc);
case WNVASRC_WAVEMUTE: return asrcGetWaveOutMute (pAsrc);
case WNVASRC_MONITORMUTE: return asrcGetMonitorMute (pAsrc);
case WNVASRC_VOLUME: return asrcGetVolume (pAsrc);
case WNVASRC_BALANCE: return asrcGetBalance (pAsrc);
case WNVASRC_LEFTVOLUME: return asrcGetLeftVolume (pAsrc);
case WNVASRC_RIGHTVOLUME: return asrcGetRightVolume (pAsrc);
case WNVASRC_WAVEVOLUME: return asrcGetWaveVolume (pAsrc);
case WNVASRC_AUXVOLUME: return asrcGetAuxVolume (pAsrc);
case WNVASRC_MONITORVOLUME: return asrcGetMonitorVolume (pAsrc);
case WNVASRC_LINE1VOLUME: return asrcGetLine1Volume (pAsrc);
case WNVASRC_LINE2VOLUME: return asrcGetLine2Volume (pAsrc);
case WNVASRC_MICVOLUME: return asrcGetMicVolume (pAsrc);
case WNVASRC_AUDIOWITHVIDEO: return asrcGetAudioWithVideo (pAsrc);
case WNVASRC_VIDEOSOURCE: return asrcGetVideoSource (pAsrc);
case WNVASRC_SOURCEASSOCIATION: return asrcGetSourceAssociation (pAsrc, HIWORD(dwItem));
case WNVASRC_SOURCEASSOCIATIONENABLE: return asrcGetSourceAssociationEnable (pAsrc);
case WNVASRC_WAVEOUTPOWER: return 0;
case WNVASRC_WAVEINPOWER: return 0;
case WNVASRC_MIXERPOWER: return 0;
case WNVASRC_DEFAULTSAMPLERATE: return asrcGetDefaultSampleRate (pAsrc);
case WNVASRC_BLOCKDCENABLE: return asrcGetBlockDCEnabled (pAsrc);
case WNVASRC_LEFTDC: return asrcGetLeftDC (pAsrc);
case WNVASRC_RIGHTDC: return asrcGetRightDC (pAsrc);
case WNVASRC_LEFTINPUTLEVEL: return asrcGetLeftInputLevel (pAsrc);
case WNVASRC_RIGHTINPUTLEVEL: return asrcGetRightInputLevel (pAsrc);
case WNVASRC_ISWIMP: return asrcGetIsWimp (pAsrc);
#ifdef ECHOCANCEL
case WNVASRC_ECHOPARAMINDEX: return echoGetParamIndex (&pAsrc->m_echo);
case WNVASRC_ECHOPARAM: return echoGetParam (&pAsrc->m_echo);
#endif
case WNVASRC_CODECMUTE: return asrcGetCodecMute (pAsrc);
}
return 0;
}
PUBLIC DWORD IAsrcSet (PASRC pAsrc, DWORD dwItem, DWORD dwVal)
{
if (!sharedGetInitialized (pAsrc->m_pShared)) return 0;
if (asrcIsVideoOnly (pAsrc)) return 0;
switch (LOWORD(dwItem))
{
case WNVASRC_VERSION: return 0; // this is always first
case WNVASRC_SAMPLERATE: return asrcSetSampleRate (pAsrc, dwVal);
case WNVASRC_ACE: return asrcSetACE (pAsrc, dwVal);
case WNVASRC_AMS: return asrcSetAMS (pAsrc, dwVal);
case WNVASRC_APE: return asrcSetAPE (pAsrc, dwVal);
case WNVASRC_PTR: return asrcSetPtr (pAsrc, dwVal);
case WNVASRC_ISPLAYING: return asrcSetIsPlaying (pAsrc, dwVal);
case WNVASRC_WAVEOUTSTATE: return asrcSetWaveOutState (pAsrc, dwVal);
case WNVASRC_LEFTGAINCURRENTSOURCE: return asrcSetLeftGainCurrentSource (pAsrc, dwVal);
case WNVASRC_RIGHTGAINCURRENTSOURCE: return asrcSetRightGainCurrentSource (pAsrc, dwVal);
case WNVASRC_LEFTGAINPERSOURCE: return asrcSetLeftGainPerSource (pAsrc, HIWORD(dwItem), dwVal);
case WNVASRC_RIGHTGAINPERSOURCE: return asrcSetRightGainPerSource (pAsrc, HIWORD(dwItem), dwVal);
case WNVASRC_SOURCE: return asrcSetSource (pAsrc, dwVal);
case WNVASRC_LINE2SOURCE: return asrcSetLine2Source (pAsrc, dwVal);
case WNVASRC_OUTPUTSOURCE: return asrcSetOutputSource (pAsrc, dwVal);
case WNVASRC_MUTEOUT: return asrcSetMuteOut (pAsrc, dwVal);
case WNVASRC_MUTEIN: return asrcSetMuteIn (pAsrc, dwVal);
case WNVASRC_AUXMUTE: return asrcSetAuxMute (pAsrc, dwVal);
case WNVASRC_WAVEMUTE: return asrcSetWaveOutMute (pAsrc, dwVal);
case WNVASRC_MONITORMUTE: return asrcSetMonitorMute (pAsrc, dwVal);
case WNVASRC_VOLUME: return asrcSetVolume (pAsrc, dwVal);
case WNVASRC_BALANCE: return asrcSetBalance (pAsrc, dwVal);
case WNVASRC_LEFTVOLUME: return asrcSetLeftVolume (pAsrc, dwVal);
case WNVASRC_RIGHTVOLUME: return asrcSetRightVolume (pAsrc, dwVal);
case WNVASRC_WAVEVOLUME: return asrcSetWaveVolume (pAsrc, dwVal);
case WNVASRC_AUXVOLUME: return asrcSetAuxVolume (pAsrc, dwVal);
case WNVASRC_MONITORVOLUME: return asrcSetMonitorVolume (pAsrc, dwVal);
case WNVASRC_LINE1VOLUME: return asrcSetLine1Volume (pAsrc, dwVal);
case WNVASRC_LINE2VOLUME: return asrcSetLine2Volume (pAsrc, dwVal);
case WNVASRC_MICVOLUME: return asrcSetMicVolume (pAsrc, dwVal);
case WNVASRC_AUDIOWITHVIDEO: return asrcSetAudioWithVideo (pAsrc, dwVal);
case WNVASRC_VIDEOSOURCE: return asrcSetVideoSource (pAsrc, dwVal);
case WNVASRC_SOURCEASSOCIATION: return asrcSetSourceAssociation (pAsrc, dwVal);
case WNVASRC_SOURCEASSOCIATIONENABLE: return asrcSetSourceAssociationEnable (pAsrc, dwVal);
case WNVASRC_WAVEOUTPOWER: return asrcSetWaveOutPower (pAsrc, dwVal);
case WNVASRC_WAVEINPOWER: return asrcSetWaveInPower (pAsrc, dwVal);
case WNVASRC_MIXERPOWER: return asrcSetMixerPower (pAsrc, dwVal);
case WNVASRC_DEFAULTSAMPLERATE: return 0;
case WNVASRC_BLOCKDCENABLE: return asrcSetBlockDCEnabled (pAsrc, dwVal);
case WNVASRC_LEFTDC: return 0;
case WNVASRC_RIGHTDC: return 0;
case WNVASRC_LEFTINPUTLEVEL: return 0;
case WNVASRC_RIGHTINPUTLEVEL: return 0;
case WNVASRC_ISWIMP: return 0;
#ifdef ECHOCANCEL
case WNVASRC_ECHOPARAMINDEX: return echoSetParamIndex (&pAsrc->m_echo, dwVal);
case WNVASRC_ECHOPARAM: return echoSetParam (&pAsrc->m_echo, dwVal);
#endif
case WNVASRC_CODECMUTE: return asrcSetCodecMute (pAsrc, dwVal);
}
return 0;
}
// 10.0 10.1 11.0 11.1 00.0 00.1 01.0 01.1
WORD wSaturateAnd8 [8] = {0x0000, 0x0000, 0x0000, 0xffff, 0xffff, 0x0000, 0x0000, 0x0000};
WORD wSaturateOr8 [8] = {0x8000, 0x8000, 0x8000, 0x0000, 0x0000, 0x7fff, 0x7fff, 0x7fff};
#pragma warning( disable : 4704)
PRIVATE void asrcBlockDC (PASRC pAsrc, LPVOID lpBuf, DWORD dwSize)
{
long lNextLeftDC = pAsrc->m_lLeftDC;
long lNextRightDC = pAsrc->m_lRightDC;
long lPrevLeftDC = lNextLeftDC >> 16;
long lPrevRightDC = lNextRightDC >> 16;
#ifdef WIN32
#ifdef ix86 // Intel processor
_asm {
mov edi,lpBuf ; edi->sample buffer
mov ecx,dwSize ; loop count
shr ecx,2 ; one dword per loop
mov ebx,lNextLeftDC ; left DC
mov edx,lNextRightDC ; right DC
next_sample:
; left sample
mov ax,[edi] ; left sample
movsx eax,ax ; sign extend
sub eax,lPrevLeftDC ; remove DC from sample
add ebx,eax ; add to DC
mov esi,eax ; get sign/msb from sample
sar esi,15 ; /
and ax,wSaturateAnd8[2*esi][8] ; saturate result
or ax,wSaturateOr8[2*esi][8] ; /
stosw ; save filtered sample
; right sample
mov ax,[edi] ; left sample
movsx eax,ax ; sign extend
sub eax,lPrevRightDC ; remove DC from sample
add edx,eax ; add to DC
mov esi,eax ; get sign/msb from sample
sar esi,15 ; /
and ax,wSaturateAnd8[2*esi][8] ; saturate result
or ax,wSaturateOr8[2*esi][8] ; /
stosw ; save filtered sample
loop next_sample
mov lNextLeftDC,ebx ; save left DC
mov lNextRightDC,edx ; save right DC
}
#else // !ix86
LPWORD lpS = (LPWORD)lpBuf;
UINT i;
long l;
for (i = 0; (i
< (UINT)dwSize); i+=4)
{
l = (long)(int)*lpS;
l -= lPrevLeftDC;
if (l > 32767) l = 32767; // saturate
if (l < -32768) l = -32768;
lNextLeftDC += l;
*lpS = (int)l;
lpS++;
l = (long)(int)*lpS;
l -= lPrevRightDC;
if (l > 32767) l = 32767; // saturate
if (l < -32768) l = -32768;
lNextRightDC += l;
*lpS = (int)l;
lpS++;
}
#endif //!ix86
#else // !WIN32: 16 bit WinTel
_asm {
push es
les di,lpBuf ; es:di->sample buffer
mov cx,WORD PTR dwSize ; cx is the loop counter
shr cx,2 ; one dword per loop
next_sample:
; left sample
mov ax,es:[di] ; left sample
cwd ; sign extend to dx
sub ax,WORD PTR lPrevLeftDC ; remove DC from sample
sbb dx,WORD PTR lPrevLeftDC+2 ; /
add WORD PTR lNextLeftDC,ax ; add sample to DC
adc WORD PTR lNextLeftDC+2,dx ; /
mov si,ax ; get SS.C0 to use as word index
shl si,1 ; /
rcl dx,1 ; /
shl dx,1 ; /
mov si,dx ; /
and ax,wSaturateAnd8[si][8] ; saturate result
or ax,wSaturateOr8[si][8] ; /
stosw ; save filtered sample
; right sample
mov ax,es:[di] ; left sample
cwd ; sign extend to dx
sub ax,WORD PTR lPrevRightDC ; remove DC from sample
sbb dx,WORD PTR lPrevRightDC+2 ; /
add WORD PTR lNextRightDC,ax ; add sample to DC
adc WORD PTR lNextRightDC+2,dx ; /
mov si,ax ; get SS.C0 to use as word index
shl si,1 ; /
rcl dx,1 ; /
shl dx,1 ; /
mov si,dx ; /
and ax,wSaturateAnd8[si][8] ; saturate result
or ax,wSaturateOr8[si][8] ; /
stosw ; save filtered sample
loop next_sample
pop es
}
#endif // 16 bit WinTel
pAsrc->m_lLeftDC = lNextLeftDC; // save new DC's
pAsrc->m_lRightDC = lNextRightDC;
}
// returns:
// HIWORD: right channel abs max level
// LOWORD: left channel abs max level
PRIVATE DWORD Local_Level (short *lpBuf, DWORD dwSize)
{
short nMaxLeft = 0;
short nMaxRight = 0;
short n;
DWORD dw;
DWORD i;
for (i = 0; (i
< dwSize); i+=4)
{
if (*lpBuf < 0)
n = -*lpBuf;
else
n = *lpBuf;
if (n > nMaxLeft)
nMaxLeft = n;
lpBuf++;
if (*lpBuf < 0)
n = -*lpBuf;
else
n = *lpBuf;
if (n > nMaxRight)
nMaxRight = n;
lpBuf++;
}
dw = (DWORD)nMaxRight;
dw <<= 16;
dw |= ((DWORD)nMaxLeft) & 0x7fff;
return dw;
}
// returns:
// HIWORD: right channel abs max level
// LOWORD: left channel abs max level
PRIVATE DWORD asrcLevel (PASRC pAsrc, LPVOID lpBuf, DWORD dwSize)
{
DWORD dwResult;
#ifdef WIN32
#ifdef ix86
_asm {
mov edi,lpBuf ; edi->sample buffer
mov ecx,dwSize ; ecx = loop counter
shr ecx,2 ; dword/loop
mov bx,0 ; left
mov dx,0 ; right
next_sample:
mov ax,[edi] ; left
cwd ; dx
<- sign
xor ax,dx ; negate if negative
and dx,1
add ax,dx ; add 1 if negative
cmp ax,bx ; new max?
jb right ; no
mov bx,ax ; yes
right:
mov ax,[edi][2] ; right
cwd ; ax <- abs (ax)
xor ax,dx ; /
and dx,1 ; /
add ax,dx ; /
cmp ax,dx ; new max?
jb next ; no
mov dx,ax ; yes
next:
add edi,4
loop next_sample
mov WORD PTR dwResult,bx ; left
mov WORD PTR dwResult+2,dx ; right
}
#else //!ix86
dwResult = Local_Level (lpBuf, dwSize);
#endif //!ix86
#else //!WIN32: 16 bit WinTel
_asm {
push es
les di,lpBuf ; es:di->sample buffer
mov cx,WORD PTR dwSize ; cx = loop counter
shr cx,2 ; dword/loop
mov bx,0 ; left
mov dx,0 ; right
next_sample:
mov ax,es:[di] ; left
cwd ; dx
<- sign
xor ax,dx ; negate if negative
and dx,1
add ax,dx ; add 1 if negative
cmp ax,bx ; new max?
jb right ; no
mov bx,ax ; yes
right:
mov ax,es:[di][2] ; right
cwd ; ax <- abs (ax)
xor ax,dx ; /
and dx,1 ; /
add ax,dx ; /
cmp ax,dx ; new max?
jb next ; no
mov dx,ax ; yes
next:
add di,4
loop next_sample
mov WORD PTR dwResult,bx ; left
mov WORD PTR dwResult+2,dx ; right
pop es
}
#endif //!WIN32
return dwResult;
}
#define MIN_GAIN 8
PUBLIC DWORD IAsrcRead (PASRC pAsrc, LPVOID lpBuf, DWORD dwSize)
{
DWORD dwResult;
DWORD dwInputLevel;
if (!sharedGetInitialized (pAsrc->m_pShared)) return 0;
if (asrcIsVideoOnly (pAsrc)) return 0;
if ((codecGetLeftGain (&pAsrc->m_codec) < MIN_GAIN) &&
(codecGetRightGain (&pAsrc->m_codec) < MIN_GAIN))
{ // emulate zero input
#ifdef WIN32
memset (lpBuf, 0, dwSize);
#else
//for some reason memset crashes in win95/98...
_asm {
les di,lpBuf ; es:di->sample buffer
mov cx,WORD PTR dwSize ; loop count
shr cx,1 ; is left + right samples
next_word_z:
mov es:[di],0 ; zero out!
add di,2 ; next word
loop next_word_z
}
#endif
dwResult = 0;
}
else
dwResult = halXlatReadBuffer (&pAsrc->m_hal, lpBuf, (UINT)dwSize);
if (sharedGetBlockDCEnabled (pAsrc->m_pShared))
{
asrcBlockDC (pAsrc, lpBuf, dwSize);
sharedSetLeftDC (pAsrc->m_pShared, HIWORD(pAsrc->m_lLeftDC));
sharedSetRightDC (pAsrc->m_pShared, HIWORD(pAsrc->m_lRightDC));
}
if (sharedGetInputLevelRequested (pAsrc->m_pShared))
{
dwInputLevel = asrcLevel (pAsrc, lpBuf, dwSize);
sharedSetLeftInputLevel (pAsrc->m_pShared, (WORD)dwInputLevel);
sharedSetRightInputLevel (pAsrc->m_pShared, HIWORD(dwInputLevel));
sharedSetInputLevelRequested (pAsrc->m_pShared, FALSE);
pAsrc->m_nInputAge = 0;
}
else
if (pAsrc->m_nInputAge < 10)
{
pAsrc->m_nInputAge++;
dwInputLevel = asrcLevel (pAsrc, lpBuf, dwSize);
sharedSetLeftInputLevel (pAsrc->m_pShared, max (sharedGetLeftInputLevel (pAsrc->m_pShared), (WORD)dwInputLevel));
sharedSetRightInputLevel (pAsrc->m_pShared, max (sharedGetRightInputLevel (pAsrc->m_pShared), HIWORD(dwInputLevel)));
}
#ifdef ECHOCANCEL
echoRecord (&pAsrc->m_echo, lpBuf, dwSize);
#endif
return dwResult;
}
PUBLIC DWORD IAsrcWrite (PASRC pAsrc, LPVOID lpBuf, DWORD dwSize)
{
DWORD dwResult;
if (!sharedGetInitialized (pAsrc->m_pShared)) return 0;
if (asrcIsVideoOnly (pAsrc)) return 0;
#ifdef ECHOCANCEL
echoPlayback (&pAsrc->m_echo, lpBuf, dwSize);
#endif
dwResult = halXlatWriteBuffer (&pAsrc->m_hal, lpBuf, (UINT)dwSize);
return dwResult;
}
PUBLIC DWORD IAsrcMessage (PASRC pAsrc, DWORD dwMessage)
{
DWORD dwResult=0;
// check for VO in message processors.
osdepAcquireMutex ();
switch (dwMessage)
{
case WNVASRC_MESSAGE_INIT: dwResult= asrcInit (pAsrc); break;
case WNVASRC_MESSAGE_STARTUP: dwResult= asrcStartup (pAsrc); break;
case WNVASRC_MESSAGE_SHUTDOWN: dwResult= asrcShutdown (pAsrc); break;
case WNVASRC_MESSAGE_HOTINSERTION: dwResult= asrcHotInsertion (pAsrc); break;
case WNVASRC_MESSAGE_UNLOAD: dwResult= asrcUnload (pAsrc); break;
case WNVASRC_MESSAGE_SAVE: dwResult= asrcSavePersistent (pAsrc); break;
}
osdepReleaseMutex ();
return dwResult;
}
//52F900000000tCur