1049 lines
22 KiB
C
1049 lines
22 KiB
C
/*
|
|
* Audio Renderer (CLSID_AudioRender)
|
|
*
|
|
* FIXME
|
|
* - implement IReferenceClock.
|
|
*
|
|
* Copyright (C) Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "wingdi.h"
|
|
#include "winuser.h"
|
|
#include "mmsystem.h"
|
|
#include "winerror.h"
|
|
#include "strmif.h"
|
|
#include "control.h"
|
|
#include "vfwmsgs.h"
|
|
#include "uuids.h"
|
|
#include "evcode.h"
|
|
|
|
#include "wine/debug.h"
|
|
WINE_DEFAULT_DEBUG_CHANNEL(quartz);
|
|
|
|
#include "quartz_private.h"
|
|
#include "audren.h"
|
|
#include "seekpass.h"
|
|
|
|
|
|
static const WCHAR QUARTZ_AudioRender_Name[] =
|
|
{ 'A','u','d','i','o',' ','R','e','n','d','e','r',0 };
|
|
static const WCHAR QUARTZ_AudioRenderPin_Name[] =
|
|
{ 'I','n',0 };
|
|
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* CAudioRendererImpl waveOut methods (internal)
|
|
*
|
|
*/
|
|
|
|
static
|
|
HRESULT QUARTZ_HRESULT_From_MMRESULT( MMRESULT mr )
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
switch ( mr )
|
|
{
|
|
case MMSYSERR_NOERROR:
|
|
hr = S_OK;
|
|
break;
|
|
case MMSYSERR_NOMEM:
|
|
hr = E_OUTOFMEMORY;
|
|
break;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
void CAudioRendererImpl_waveOutEventCallback(
|
|
HWAVEOUT hwo, UINT uMsg,
|
|
DWORD dwInstance, DWORD dwParam1, DWORD dwParam2 )
|
|
{
|
|
CAudioRendererImpl* This = (CAudioRendererImpl*)dwInstance;
|
|
|
|
if ( uMsg == WOM_DONE )
|
|
SetEvent( This->m_hEventRender );
|
|
}
|
|
|
|
static
|
|
void CAudioRendererImpl_waveOutReset(
|
|
CAudioRendererImpl* This )
|
|
{
|
|
if ( !This->m_fWaveOutInit )
|
|
return;
|
|
|
|
waveOutReset( This->m_hWaveOut );
|
|
SetEvent( This->m_hEventRender );
|
|
}
|
|
|
|
static
|
|
void CAudioRendererImpl_waveOutUninit(
|
|
CAudioRendererImpl* This )
|
|
{
|
|
DWORD i;
|
|
|
|
TRACE("(%p)\n",This);
|
|
|
|
if ( !This->m_fWaveOutInit )
|
|
return;
|
|
|
|
waveOutReset( This->m_hWaveOut );
|
|
SetEvent( This->m_hEventRender );
|
|
|
|
for ( i = 0; i < WINE_QUARTZ_WAVEOUT_COUNT; i++ )
|
|
{
|
|
if ( This->m_hdr[i].dwFlags & WHDR_PREPARED )
|
|
{
|
|
waveOutUnprepareHeader(
|
|
This->m_hWaveOut,
|
|
&This->m_hdr[i], sizeof(WAVEHDR) );
|
|
This->m_hdr[i].dwFlags = 0;
|
|
}
|
|
if ( This->m_hdr[i].lpData != NULL )
|
|
{
|
|
QUARTZ_FreeMem( This->m_hdr[i].lpData );
|
|
This->m_hdr[i].lpData = NULL;
|
|
}
|
|
}
|
|
|
|
waveOutClose( This->m_hWaveOut );
|
|
This->m_hWaveOut = (HWAVEOUT)NULL;
|
|
if ( This->m_hEventRender != (HANDLE)NULL )
|
|
{
|
|
CloseHandle( This->m_hEventRender );
|
|
This->m_hEventRender = (HANDLE)NULL;
|
|
}
|
|
|
|
This->m_fWaveOutInit = FALSE;
|
|
}
|
|
|
|
static
|
|
HRESULT CAudioRendererImpl_waveOutInit(
|
|
CAudioRendererImpl* This, WAVEFORMATEX* pwfx )
|
|
{
|
|
MMRESULT mr;
|
|
HRESULT hr;
|
|
DWORD i;
|
|
DWORD dwBlockSize;
|
|
|
|
if ( This->m_fWaveOutInit )
|
|
return NOERROR;
|
|
|
|
if ( pwfx == NULL )
|
|
return E_POINTER;
|
|
if ( pwfx->nBlockAlign == 0 )
|
|
return E_INVALIDARG;
|
|
|
|
This->m_hEventRender = (HANDLE)NULL;
|
|
This->m_hWaveOut = (HWAVEOUT)NULL;
|
|
This->m_dwBlockSize = 0;
|
|
This->m_phdrCur = NULL;
|
|
ZeroMemory( &This->m_hdr, sizeof(This->m_hdr) );
|
|
|
|
|
|
mr = waveOutOpen(
|
|
&This->m_hWaveOut, WAVE_MAPPER, pwfx,
|
|
(DWORD)CAudioRendererImpl_waveOutEventCallback, (DWORD)This,
|
|
CALLBACK_FUNCTION );
|
|
hr = QUARTZ_HRESULT_From_MMRESULT( mr );
|
|
if ( FAILED(hr) )
|
|
return hr;
|
|
This->m_fWaveOutInit = TRUE;
|
|
|
|
This->m_hEventRender = CreateEventA(
|
|
NULL, TRUE, TRUE, NULL );
|
|
if ( This->m_hEventRender == (HANDLE)NULL )
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto err;
|
|
}
|
|
|
|
dwBlockSize = pwfx->nAvgBytesPerSec / pwfx->nBlockAlign;
|
|
if ( dwBlockSize == 0 )
|
|
dwBlockSize = 1;
|
|
dwBlockSize *= pwfx->nBlockAlign;
|
|
This->m_dwBlockSize = dwBlockSize;
|
|
|
|
for ( i = 0; i < WINE_QUARTZ_WAVEOUT_COUNT; i++ )
|
|
{
|
|
This->m_hdr[i].lpData = (CHAR*)QUARTZ_AllocMem( dwBlockSize );
|
|
if ( This->m_hdr[i].lpData == NULL )
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto err;
|
|
}
|
|
mr = waveOutPrepareHeader(
|
|
This->m_hWaveOut,
|
|
&This->m_hdr[i], sizeof(WAVEHDR) );
|
|
hr = QUARTZ_HRESULT_From_MMRESULT( mr );
|
|
if ( FAILED(hr) )
|
|
goto err;
|
|
This->m_hdr[i].dwFlags |= WHDR_DONE;
|
|
This->m_hdr[i].dwBufferLength = dwBlockSize;
|
|
This->m_hdr[i].dwUser = i;
|
|
}
|
|
|
|
return S_OK;
|
|
err:
|
|
CAudioRendererImpl_waveOutUninit(This);
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT CAudioRendererImpl_waveOutPause( CAudioRendererImpl* This )
|
|
{
|
|
if ( !This->m_fWaveOutInit )
|
|
return E_UNEXPECTED;
|
|
|
|
return QUARTZ_HRESULT_From_MMRESULT( waveOutPause(
|
|
This->m_hWaveOut ) );
|
|
}
|
|
|
|
static HRESULT CAudioRendererImpl_waveOutRun( CAudioRendererImpl* This )
|
|
{
|
|
if ( !This->m_fWaveOutInit )
|
|
return E_UNEXPECTED;
|
|
|
|
return QUARTZ_HRESULT_From_MMRESULT( waveOutRestart(
|
|
This->m_hWaveOut ) );
|
|
}
|
|
|
|
static
|
|
WAVEHDR* CAudioRendererImpl_waveOutGetBuffer(
|
|
CAudioRendererImpl* This )
|
|
{
|
|
DWORD i;
|
|
|
|
if ( !This->m_fWaveOutInit )
|
|
return NULL;
|
|
|
|
if ( This->m_phdrCur != NULL )
|
|
return This->m_phdrCur;
|
|
|
|
for ( i = 0; i < WINE_QUARTZ_WAVEOUT_COUNT; i++ )
|
|
{
|
|
if ( This->m_hdr[i].dwFlags & WHDR_DONE )
|
|
{
|
|
This->m_phdrCur = &(This->m_hdr[i]);
|
|
This->m_phdrCur->dwFlags &= ~WHDR_DONE;
|
|
This->m_phdrCur->dwBufferLength = 0;
|
|
return This->m_phdrCur;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static
|
|
HRESULT CAudioRendererImpl_waveOutWriteData(
|
|
CAudioRendererImpl* This,
|
|
const BYTE* pData, DWORD cbData, DWORD* pcbWritten )
|
|
{
|
|
DWORD cbAvail;
|
|
|
|
*pcbWritten = 0;
|
|
|
|
if ( !This->m_fWaveOutInit )
|
|
return E_UNEXPECTED;
|
|
|
|
if ( cbData == 0 )
|
|
return S_OK;
|
|
|
|
if ( CAudioRendererImpl_waveOutGetBuffer(This) == NULL )
|
|
return S_FALSE;
|
|
|
|
cbAvail = This->m_dwBlockSize - This->m_phdrCur->dwBufferLength;
|
|
if ( cbAvail > cbData )
|
|
cbAvail = cbData;
|
|
memcpy( This->m_phdrCur->lpData, pData, cbAvail );
|
|
pData += cbAvail;
|
|
cbData -= cbAvail;
|
|
This->m_phdrCur->dwBufferLength += cbAvail;
|
|
|
|
*pcbWritten = cbAvail;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
static
|
|
HRESULT CAudioRendererImpl_waveOutFlush(
|
|
CAudioRendererImpl* This )
|
|
{
|
|
MMRESULT mr;
|
|
HRESULT hr;
|
|
|
|
if ( !This->m_fWaveOutInit )
|
|
return E_UNEXPECTED;
|
|
if ( This->m_phdrCur == NULL )
|
|
return E_UNEXPECTED;
|
|
|
|
if ( This->m_phdrCur->dwBufferLength == 0 )
|
|
return S_OK;
|
|
|
|
mr = waveOutWrite(
|
|
This->m_hWaveOut,
|
|
This->m_phdrCur, sizeof(WAVEHDR) );
|
|
hr = QUARTZ_HRESULT_From_MMRESULT( mr );
|
|
if ( FAILED(hr) )
|
|
return hr;
|
|
|
|
This->m_phdrCur = NULL;
|
|
return S_OK;
|
|
}
|
|
|
|
#if 0
|
|
/* FIXME: Not used for now */
|
|
|
|
static
|
|
HRESULT CAudioRendererImpl_waveOutGetVolume(
|
|
CAudioRendererImpl* This,
|
|
DWORD* pdwLeft, DWORD* pdwRight )
|
|
{
|
|
MMRESULT mr;
|
|
HRESULT hr;
|
|
DWORD dwVol;
|
|
|
|
if ( !This->m_fWaveOutInit )
|
|
return E_UNEXPECTED;
|
|
|
|
mr = waveOutGetVolume(
|
|
This->m_hWaveOut, &dwVol );
|
|
hr = QUARTZ_HRESULT_From_MMRESULT( mr );
|
|
if ( FAILED(hr) )
|
|
return hr;
|
|
|
|
*pdwLeft = LOWORD(dwVol);
|
|
*pdwRight = HIWORD(dwVol);
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
#endif
|
|
|
|
static
|
|
HRESULT CAudioRendererImpl_waveOutSetVolume(
|
|
CAudioRendererImpl* This,
|
|
DWORD dwLeft, DWORD dwRight )
|
|
{
|
|
MMRESULT mr;
|
|
DWORD dwVol;
|
|
|
|
if ( !This->m_fWaveOutInit )
|
|
return E_UNEXPECTED;
|
|
|
|
dwVol = dwLeft | (dwRight<<16);
|
|
|
|
mr = waveOutSetVolume(
|
|
This->m_hWaveOut, dwVol );
|
|
return QUARTZ_HRESULT_From_MMRESULT( mr );
|
|
}
|
|
|
|
static HRESULT CAudioRendererImpl_UpdateVolume( CAudioRendererImpl* This )
|
|
{
|
|
HRESULT hr;
|
|
long leftlevel;
|
|
long rightlevel;
|
|
|
|
if ( This->m_lAudioBalance >= 0 )
|
|
{
|
|
leftlevel = This->m_lAudioVolume - This->m_lAudioBalance;
|
|
rightlevel = This->m_lAudioVolume;
|
|
}
|
|
else
|
|
{
|
|
leftlevel = This->m_lAudioVolume;
|
|
rightlevel = This->m_lAudioVolume + This->m_lAudioBalance;
|
|
}
|
|
leftlevel = QUARTZ_DBToAmpFactor( leftlevel );
|
|
rightlevel = QUARTZ_DBToAmpFactor( rightlevel );
|
|
|
|
hr = CAudioRendererImpl_waveOutSetVolume(
|
|
This, (DWORD)leftlevel, (DWORD)rightlevel );
|
|
if ( hr == E_UNEXPECTED )
|
|
hr = S_OK;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* CAudioRendererImpl methods
|
|
*
|
|
*/
|
|
|
|
|
|
static HRESULT CAudioRendererImpl_OnActive( CBaseFilterImpl* pImpl )
|
|
{
|
|
CAudioRendererImpl_THIS(pImpl,basefilter);
|
|
HRESULT hr;
|
|
|
|
TRACE( "(%p)\n", This );
|
|
|
|
if ( This->pPin->pin.pmtConn == NULL )
|
|
return NOERROR;
|
|
|
|
This->m_fInFlush = FALSE;
|
|
|
|
hr = CAudioRendererImpl_waveOutRun(This);
|
|
if ( FAILED(hr) )
|
|
return hr;
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
static HRESULT CAudioRendererImpl_OnInactive( CBaseFilterImpl* pImpl )
|
|
{
|
|
CAudioRendererImpl_THIS(pImpl,basefilter);
|
|
WAVEFORMATEX* pwfx;
|
|
HRESULT hr;
|
|
|
|
TRACE( "(%p)\n", This );
|
|
|
|
if ( This->pPin->pin.pmtConn == NULL )
|
|
return NOERROR;
|
|
|
|
pwfx = (WAVEFORMATEX*)This->pPin->pin.pmtConn->pbFormat;
|
|
if ( pwfx == NULL )
|
|
return E_FAIL;
|
|
|
|
This->m_fInFlush = FALSE;
|
|
|
|
hr = CAudioRendererImpl_waveOutInit(This,pwfx);
|
|
if ( FAILED(hr) )
|
|
return hr;
|
|
|
|
hr = CAudioRendererImpl_waveOutPause(This);
|
|
if ( FAILED(hr) )
|
|
return hr;
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
static HRESULT CAudioRendererImpl_OnStop( CBaseFilterImpl* pImpl )
|
|
{
|
|
CAudioRendererImpl_THIS(pImpl,basefilter);
|
|
|
|
TRACE( "(%p)\n", This );
|
|
|
|
This->m_fInFlush = TRUE;
|
|
|
|
CAudioRendererImpl_waveOutUninit(This);
|
|
|
|
This->m_fInFlush = FALSE;
|
|
|
|
TRACE("returned\n" );
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
static const CBaseFilterHandlers filterhandlers =
|
|
{
|
|
CAudioRendererImpl_OnActive, /* pOnActive */
|
|
CAudioRendererImpl_OnInactive, /* pOnInactive */
|
|
CAudioRendererImpl_OnStop, /* pOnStop */
|
|
};
|
|
|
|
/***************************************************************************
|
|
*
|
|
* CAudioRendererPinImpl methods
|
|
*
|
|
*/
|
|
|
|
static HRESULT CAudioRendererPinImpl_OnDisconnect( CPinBaseImpl* pImpl )
|
|
{
|
|
CAudioRendererPinImpl_THIS(pImpl,pin);
|
|
|
|
TRACE("(%p)\n",This);
|
|
|
|
if ( This->meminput.pAllocator != NULL )
|
|
{
|
|
IMemAllocator_Decommit(This->meminput.pAllocator);
|
|
IMemAllocator_Release(This->meminput.pAllocator);
|
|
This->meminput.pAllocator = NULL;
|
|
}
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
static HRESULT CAudioRendererPinImpl_CheckMediaType( CPinBaseImpl* pImpl, const AM_MEDIA_TYPE* pmt )
|
|
{
|
|
CAudioRendererPinImpl_THIS(pImpl,pin);
|
|
const WAVEFORMATEX* pwfx;
|
|
|
|
TRACE("(%p,%p)\n",This,pmt);
|
|
|
|
if ( !IsEqualGUID( &pmt->majortype, &MEDIATYPE_Audio ) )
|
|
{
|
|
TRACE("not audio\n");
|
|
return E_FAIL;
|
|
}
|
|
if ( !IsEqualGUID( &pmt->subtype, &MEDIASUBTYPE_NULL ) &&
|
|
!IsEqualGUID( &pmt->subtype, &MEDIASUBTYPE_PCM ) )
|
|
{
|
|
TRACE("not PCM\n");
|
|
return E_FAIL;
|
|
}
|
|
if ( !IsEqualGUID( &pmt->formattype, &FORMAT_WaveFormatEx ) )
|
|
{
|
|
TRACE("not WAVE\n");
|
|
return E_FAIL;
|
|
}
|
|
|
|
TRACE("testing WAVE header\n");
|
|
|
|
if ( pmt->cbFormat < (sizeof(WAVEFORMATEX)-sizeof(WORD)) )
|
|
return E_FAIL;
|
|
|
|
pwfx = (const WAVEFORMATEX*)pmt->pbFormat;
|
|
if ( pwfx == NULL )
|
|
return E_FAIL;
|
|
if ( pwfx->wFormatTag != 1 )
|
|
return E_FAIL;
|
|
|
|
TRACE("returned successfully.\n");
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
static HRESULT CAudioRendererPinImpl_Receive( CPinBaseImpl* pImpl, IMediaSample* pSample )
|
|
{
|
|
CAudioRendererPinImpl_THIS(pImpl,pin);
|
|
HRESULT hr;
|
|
BYTE* pData = NULL;
|
|
DWORD dwDataLength;
|
|
DWORD dwWritten;
|
|
|
|
TRACE( "(%p,%p)\n",This,pSample );
|
|
|
|
if ( !This->pRender->m_fWaveOutInit )
|
|
return E_UNEXPECTED;
|
|
if ( pSample == NULL )
|
|
return E_POINTER;
|
|
|
|
hr = IMediaSample_GetPointer( pSample, &pData );
|
|
if ( FAILED(hr) )
|
|
return hr;
|
|
dwDataLength = (DWORD)IMediaSample_GetActualDataLength( pSample );
|
|
|
|
while ( 1 )
|
|
{
|
|
TRACE("trying to write %lu bytes\n",dwDataLength);
|
|
|
|
if ( This->pRender->m_fInFlush )
|
|
return S_FALSE;
|
|
|
|
ResetEvent( This->pRender->m_hEventRender );
|
|
hr = CAudioRendererImpl_waveOutWriteData(
|
|
This->pRender,pData,dwDataLength,&dwWritten);
|
|
if ( FAILED(hr) )
|
|
break;
|
|
if ( hr == S_FALSE )
|
|
{
|
|
WaitForSingleObject( This->pRender->m_hEventRender, INFINITE );
|
|
continue;
|
|
}
|
|
pData += dwWritten;
|
|
dwDataLength -= dwWritten;
|
|
hr = CAudioRendererImpl_waveOutFlush(This->pRender);
|
|
if ( FAILED(hr) )
|
|
break;
|
|
if ( dwDataLength == 0 )
|
|
break;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT CAudioRendererPinImpl_ReceiveCanBlock( CPinBaseImpl* pImpl )
|
|
{
|
|
CAudioRendererPinImpl_THIS(pImpl,pin);
|
|
|
|
TRACE( "(%p)\n", This );
|
|
|
|
/* might block. */
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT CAudioRendererPinImpl_EndOfStream( CPinBaseImpl* pImpl )
|
|
{
|
|
CAudioRendererPinImpl_THIS(pImpl,pin);
|
|
|
|
FIXME( "(%p)\n", This );
|
|
|
|
This->pRender->m_fInFlush = FALSE;
|
|
|
|
/* FIXME - don't notify twice until stopped or seeked. */
|
|
return CBaseFilterImpl_MediaEventNotify(
|
|
&This->pRender->basefilter, EC_COMPLETE,
|
|
(LONG_PTR)S_OK, (LONG_PTR)(IBaseFilter*)(This->pRender) );
|
|
}
|
|
|
|
static HRESULT CAudioRendererPinImpl_BeginFlush( CPinBaseImpl* pImpl )
|
|
{
|
|
CAudioRendererPinImpl_THIS(pImpl,pin);
|
|
|
|
TRACE( "(%p)\n", This );
|
|
|
|
This->pRender->m_fInFlush = TRUE;
|
|
CAudioRendererImpl_waveOutReset(This->pRender);
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
static HRESULT CAudioRendererPinImpl_EndFlush( CPinBaseImpl* pImpl )
|
|
{
|
|
CAudioRendererPinImpl_THIS(pImpl,pin);
|
|
|
|
TRACE( "(%p)\n", This );
|
|
|
|
This->pRender->m_fInFlush = FALSE;
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
static HRESULT CAudioRendererPinImpl_NewSegment( CPinBaseImpl* pImpl, REFERENCE_TIME rtStart, REFERENCE_TIME rtStop, double rate )
|
|
{
|
|
CAudioRendererPinImpl_THIS(pImpl,pin);
|
|
|
|
FIXME( "(%p)\n", This );
|
|
|
|
This->pRender->m_fInFlush = FALSE;
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
static const CBasePinHandlers pinhandlers =
|
|
{
|
|
NULL, /* pOnPreConnect */
|
|
NULL, /* pOnPostConnect */
|
|
CAudioRendererPinImpl_OnDisconnect, /* pOnDisconnect */
|
|
CAudioRendererPinImpl_CheckMediaType, /* pCheckMediaType */
|
|
NULL, /* pQualityNotify */
|
|
CAudioRendererPinImpl_Receive, /* pReceive */
|
|
CAudioRendererPinImpl_ReceiveCanBlock, /* pReceiveCanBlock */
|
|
CAudioRendererPinImpl_EndOfStream, /* pEndOfStream */
|
|
CAudioRendererPinImpl_BeginFlush, /* pBeginFlush */
|
|
CAudioRendererPinImpl_EndFlush, /* pEndFlush */
|
|
CAudioRendererPinImpl_NewSegment, /* pNewSegment */
|
|
};
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* new/delete CAudioRendererImpl
|
|
*
|
|
*/
|
|
|
|
/* can I use offsetof safely? - FIXME? */
|
|
static QUARTZ_IFEntry FilterIFEntries[] =
|
|
{
|
|
{ &IID_IPersist, offsetof(CAudioRendererImpl,basefilter)-offsetof(CAudioRendererImpl,unk) },
|
|
{ &IID_IMediaFilter, offsetof(CAudioRendererImpl,basefilter)-offsetof(CAudioRendererImpl,unk) },
|
|
{ &IID_IBaseFilter, offsetof(CAudioRendererImpl,basefilter)-offsetof(CAudioRendererImpl,unk) },
|
|
{ &IID_IBasicAudio, offsetof(CAudioRendererImpl,basaud)-offsetof(CAudioRendererImpl,unk) },
|
|
};
|
|
|
|
static HRESULT CAudioRendererImpl_OnQueryInterface(
|
|
IUnknown* punk, const IID* piid, void** ppobj )
|
|
{
|
|
CAudioRendererImpl_THIS(punk,unk);
|
|
|
|
if ( This->pSeekPass == NULL )
|
|
return E_NOINTERFACE;
|
|
|
|
if ( IsEqualGUID( &IID_IMediaPosition, piid ) ||
|
|
IsEqualGUID( &IID_IMediaSeeking, piid ) )
|
|
{
|
|
TRACE( "IMediaSeeking(or IMediaPosition) is queried\n" );
|
|
return IUnknown_QueryInterface( (IUnknown*)(&This->pSeekPass->unk), piid, ppobj );
|
|
}
|
|
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
static void QUARTZ_DestroyAudioRenderer(IUnknown* punk)
|
|
{
|
|
CAudioRendererImpl_THIS(punk,unk);
|
|
|
|
TRACE( "(%p)\n", This );
|
|
|
|
if ( This->pPin != NULL )
|
|
{
|
|
IUnknown_Release(This->pPin->unk.punkControl);
|
|
This->pPin = NULL;
|
|
}
|
|
if ( This->pSeekPass != NULL )
|
|
{
|
|
IUnknown_Release((IUnknown*)&This->pSeekPass->unk);
|
|
This->pSeekPass = NULL;
|
|
}
|
|
|
|
CAudioRendererImpl_UninitIBasicAudio(This);
|
|
CBaseFilterImpl_UninitIBaseFilter(&This->basefilter);
|
|
|
|
DeleteCriticalSection( &This->m_csReceive );
|
|
}
|
|
|
|
HRESULT QUARTZ_CreateAudioRenderer(IUnknown* punkOuter,void** ppobj)
|
|
{
|
|
CAudioRendererImpl* This = NULL;
|
|
HRESULT hr;
|
|
|
|
TRACE("(%p,%p)\n",punkOuter,ppobj);
|
|
|
|
This = (CAudioRendererImpl*)
|
|
QUARTZ_AllocObj( sizeof(CAudioRendererImpl) );
|
|
if ( This == NULL )
|
|
return E_OUTOFMEMORY;
|
|
This->pSeekPass = NULL;
|
|
This->pPin = NULL;
|
|
This->m_fInFlush = FALSE;
|
|
This->m_lAudioVolume = 0;
|
|
This->m_lAudioBalance = 0;
|
|
This->m_fWaveOutInit = FALSE;
|
|
This->m_hEventRender = (HANDLE)NULL;
|
|
|
|
QUARTZ_IUnkInit( &This->unk, punkOuter );
|
|
This->qiext.pNext = NULL;
|
|
This->qiext.pOnQueryInterface = &CAudioRendererImpl_OnQueryInterface;
|
|
QUARTZ_IUnkAddDelegation( &This->unk, &This->qiext );
|
|
|
|
hr = CBaseFilterImpl_InitIBaseFilter(
|
|
&This->basefilter,
|
|
This->unk.punkControl,
|
|
&CLSID_AudioRender,
|
|
QUARTZ_AudioRender_Name,
|
|
&filterhandlers );
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
hr = CAudioRendererImpl_InitIBasicAudio(This);
|
|
if ( FAILED(hr) )
|
|
{
|
|
CBaseFilterImpl_UninitIBaseFilter(&This->basefilter);
|
|
}
|
|
}
|
|
|
|
if ( FAILED(hr) )
|
|
{
|
|
QUARTZ_FreeObj(This);
|
|
return hr;
|
|
}
|
|
|
|
This->unk.pEntries = FilterIFEntries;
|
|
This->unk.dwEntries = sizeof(FilterIFEntries)/sizeof(FilterIFEntries[0]);
|
|
This->unk.pOnFinalRelease = QUARTZ_DestroyAudioRenderer;
|
|
|
|
InitializeCriticalSection( &This->m_csReceive );
|
|
|
|
hr = QUARTZ_CreateAudioRendererPin(
|
|
This,
|
|
&This->basefilter.csFilter,
|
|
&This->m_csReceive,
|
|
&This->pPin );
|
|
if ( SUCCEEDED(hr) )
|
|
hr = QUARTZ_CompList_AddComp(
|
|
This->basefilter.pInPins,
|
|
(IUnknown*)&This->pPin->pin,
|
|
NULL, 0 );
|
|
if ( SUCCEEDED(hr) )
|
|
hr = QUARTZ_CreateSeekingPassThruInternal(
|
|
(IUnknown*)&(This->unk), &This->pSeekPass,
|
|
TRUE, (IPin*)&(This->pPin->pin) );
|
|
|
|
if ( FAILED(hr) )
|
|
{
|
|
IUnknown_Release( This->unk.punkControl );
|
|
return hr;
|
|
}
|
|
|
|
*ppobj = (void*)&(This->unk);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* new/delete CAudioRendererPinImpl
|
|
*
|
|
*/
|
|
|
|
/* can I use offsetof safely? - FIXME? */
|
|
static QUARTZ_IFEntry PinIFEntries[] =
|
|
{
|
|
{ &IID_IPin, offsetof(CAudioRendererPinImpl,pin)-offsetof(CAudioRendererPinImpl,unk) },
|
|
{ &IID_IMemInputPin, offsetof(CAudioRendererPinImpl,meminput)-offsetof(CAudioRendererPinImpl,unk) },
|
|
};
|
|
|
|
static void QUARTZ_DestroyAudioRendererPin(IUnknown* punk)
|
|
{
|
|
CAudioRendererPinImpl_THIS(punk,unk);
|
|
|
|
TRACE( "(%p)\n", This );
|
|
|
|
CPinBaseImpl_UninitIPin( &This->pin );
|
|
CMemInputPinBaseImpl_UninitIMemInputPin( &This->meminput );
|
|
}
|
|
|
|
HRESULT QUARTZ_CreateAudioRendererPin(
|
|
CAudioRendererImpl* pFilter,
|
|
CRITICAL_SECTION* pcsPin,
|
|
CRITICAL_SECTION* pcsPinReceive,
|
|
CAudioRendererPinImpl** ppPin)
|
|
{
|
|
CAudioRendererPinImpl* This = NULL;
|
|
HRESULT hr;
|
|
|
|
TRACE("(%p,%p,%p,%p)\n",pFilter,pcsPin,pcsPinReceive,ppPin);
|
|
|
|
This = (CAudioRendererPinImpl*)
|
|
QUARTZ_AllocObj( sizeof(CAudioRendererPinImpl) );
|
|
if ( This == NULL )
|
|
return E_OUTOFMEMORY;
|
|
|
|
QUARTZ_IUnkInit( &This->unk, NULL );
|
|
This->pRender = pFilter;
|
|
|
|
hr = CPinBaseImpl_InitIPin(
|
|
&This->pin,
|
|
This->unk.punkControl,
|
|
pcsPin, pcsPinReceive,
|
|
&pFilter->basefilter,
|
|
QUARTZ_AudioRenderPin_Name,
|
|
FALSE,
|
|
&pinhandlers );
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
hr = CMemInputPinBaseImpl_InitIMemInputPin(
|
|
&This->meminput,
|
|
This->unk.punkControl,
|
|
&This->pin );
|
|
if ( FAILED(hr) )
|
|
{
|
|
CPinBaseImpl_UninitIPin( &This->pin );
|
|
}
|
|
}
|
|
|
|
if ( FAILED(hr) )
|
|
{
|
|
QUARTZ_FreeObj(This);
|
|
return hr;
|
|
}
|
|
|
|
This->unk.pEntries = PinIFEntries;
|
|
This->unk.dwEntries = sizeof(PinIFEntries)/sizeof(PinIFEntries[0]);
|
|
This->unk.pOnFinalRelease = QUARTZ_DestroyAudioRendererPin;
|
|
|
|
*ppPin = This;
|
|
|
|
TRACE("returned successfully.\n");
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* CAudioRendererImpl::IBasicAudio
|
|
*
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
IBasicAudio_fnQueryInterface(IBasicAudio* iface,REFIID riid,void** ppobj)
|
|
{
|
|
CAudioRendererImpl_THIS(iface,basaud);
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
return IUnknown_QueryInterface(This->unk.punkControl,riid,ppobj);
|
|
}
|
|
|
|
static ULONG WINAPI
|
|
IBasicAudio_fnAddRef(IBasicAudio* iface)
|
|
{
|
|
CAudioRendererImpl_THIS(iface,basaud);
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
return IUnknown_AddRef(This->unk.punkControl);
|
|
}
|
|
|
|
static ULONG WINAPI
|
|
IBasicAudio_fnRelease(IBasicAudio* iface)
|
|
{
|
|
CAudioRendererImpl_THIS(iface,basaud);
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
return IUnknown_Release(This->unk.punkControl);
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
IBasicAudio_fnGetTypeInfoCount(IBasicAudio* iface,UINT* pcTypeInfo)
|
|
{
|
|
CAudioRendererImpl_THIS(iface,basaud);
|
|
|
|
FIXME("(%p)->()\n",This);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
IBasicAudio_fnGetTypeInfo(IBasicAudio* iface,UINT iTypeInfo, LCID lcid, ITypeInfo** ppobj)
|
|
{
|
|
CAudioRendererImpl_THIS(iface,basaud);
|
|
|
|
FIXME("(%p)->()\n",This);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
IBasicAudio_fnGetIDsOfNames(IBasicAudio* iface,REFIID riid, LPOLESTR* ppwszName, UINT cNames, LCID lcid, DISPID* pDispId)
|
|
{
|
|
CAudioRendererImpl_THIS(iface,basaud);
|
|
|
|
FIXME("(%p)->()\n",This);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
IBasicAudio_fnInvoke(IBasicAudio* iface,DISPID DispId, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarRes, EXCEPINFO* pExcepInfo, UINT* puArgErr)
|
|
{
|
|
CAudioRendererImpl_THIS(iface,basaud);
|
|
|
|
FIXME("(%p)->()\n",This);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
static HRESULT WINAPI
|
|
IBasicAudio_fnput_Volume(IBasicAudio* iface,long lVol)
|
|
{
|
|
CAudioRendererImpl_THIS(iface,basaud);
|
|
HRESULT hr;
|
|
|
|
TRACE("(%p)->(%ld)\n",This,lVol);
|
|
|
|
if ( lVol > 0 || lVol < -10000 )
|
|
return E_INVALIDARG;
|
|
|
|
EnterCriticalSection( &This->basefilter.csFilter );
|
|
This->m_lAudioVolume = lVol;
|
|
hr = CAudioRendererImpl_UpdateVolume( This );
|
|
LeaveCriticalSection( &This->basefilter.csFilter );
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
IBasicAudio_fnget_Volume(IBasicAudio* iface,long* plVol)
|
|
{
|
|
CAudioRendererImpl_THIS(iface,basaud);
|
|
|
|
TRACE("(%p)->(%p)\n",This,plVol);
|
|
|
|
if ( plVol == NULL )
|
|
return E_POINTER;
|
|
|
|
EnterCriticalSection( &This->basefilter.csFilter );
|
|
*plVol = This->m_lAudioVolume;
|
|
LeaveCriticalSection( &This->basefilter.csFilter );
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
IBasicAudio_fnput_Balance(IBasicAudio* iface,long lBalance)
|
|
{
|
|
CAudioRendererImpl_THIS(iface,basaud);
|
|
HRESULT hr;
|
|
|
|
TRACE("(%p)->(%ld)\n",This,lBalance);
|
|
|
|
if ( lBalance > 0 || lBalance < -10000 )
|
|
return E_INVALIDARG;
|
|
|
|
EnterCriticalSection( &This->basefilter.csFilter );
|
|
This->m_lAudioBalance = lBalance;
|
|
hr = CAudioRendererImpl_UpdateVolume( This );
|
|
LeaveCriticalSection( &This->basefilter.csFilter );
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
IBasicAudio_fnget_Balance(IBasicAudio* iface,long* plBalance)
|
|
{
|
|
CAudioRendererImpl_THIS(iface,basaud);
|
|
|
|
TRACE("(%p)->(%p)\n",This,plBalance);
|
|
|
|
if ( plBalance == NULL )
|
|
return E_POINTER;
|
|
|
|
EnterCriticalSection( &This->basefilter.csFilter );
|
|
*plBalance = This->m_lAudioBalance;
|
|
LeaveCriticalSection( &This->basefilter.csFilter );
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
static ICOM_VTABLE(IBasicAudio) ibasicaudio =
|
|
{
|
|
ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
|
|
/* IUnknown fields */
|
|
IBasicAudio_fnQueryInterface,
|
|
IBasicAudio_fnAddRef,
|
|
IBasicAudio_fnRelease,
|
|
/* IDispatch fields */
|
|
IBasicAudio_fnGetTypeInfoCount,
|
|
IBasicAudio_fnGetTypeInfo,
|
|
IBasicAudio_fnGetIDsOfNames,
|
|
IBasicAudio_fnInvoke,
|
|
/* IBasicAudio fields */
|
|
IBasicAudio_fnput_Volume,
|
|
IBasicAudio_fnget_Volume,
|
|
IBasicAudio_fnput_Balance,
|
|
IBasicAudio_fnget_Balance,
|
|
};
|
|
|
|
|
|
HRESULT CAudioRendererImpl_InitIBasicAudio( CAudioRendererImpl* This )
|
|
{
|
|
TRACE("(%p)\n",This);
|
|
ICOM_VTBL(&This->basaud) = &ibasicaudio;
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
void CAudioRendererImpl_UninitIBasicAudio( CAudioRendererImpl* This )
|
|
{
|
|
TRACE("(%p)\n",This);
|
|
}
|
|
|