STDMETHODIMP MFStream::EndRead(IMFAsyncResult* pResult, ULONG *pcbRead)
{
if (!pcbRead)
return E_INVALIDARG;
IUnknown *pUnk;
pResult->GetObject(&pUnk);
AsyncReadState *state = static_cast<AsyncReadState*>(pUnk);
*pcbRead = state->bytesRead();
pUnk->Release();
m_currentReadResult->Release();
m_currentReadResult = NULL;
return S_OK;
}
/** Ends an asyncronous read */
STDMETHODIMP FImfByteStream::EndRead( IMFAsyncResult* pResult, ULONG* pcbRead )
{
if( !pcbRead )
return E_INVALIDARG;
IUnknown* Unknown;
pResult->GetObject( &Unknown );
AsyncReadState* State = static_cast<AsyncReadState*>( Unknown );
*pcbRead = State->GetBytesRead( );
Unknown->Release( );
IsCurrentlyReading = false;
return S_OK;
}
STDMETHODIMP MFStream::BeginRead(BYTE *pb, ULONG cb, IMFAsyncCallback *pCallback,
IUnknown *punkState)
{
if (!pCallback || !pb)
return E_INVALIDARG;
Q_ASSERT(m_currentReadResult == NULL);
AsyncReadState *state = new (std::nothrow) AsyncReadState(pb, cb);
if (state == NULL)
return E_OUTOFMEMORY;
HRESULT hr = MFCreateAsyncResult(state, pCallback, punkState, &m_currentReadResult);
state->Release();
if (FAILED(hr))
return hr;
QCoreApplication::postEvent(this, new QEvent(QEvent::User));
return hr;
}
/** Begins an asyncronous read */
STDMETHODIMP FImfByteStream::BeginRead( BYTE* pb, ULONG cb, IMFAsyncCallback* pCallback, IUnknown* punkState )
{
HRESULT HResult = S_OK;
if( !pCallback || !pb )
return E_INVALIDARG;
IMFAsyncResult* Result = NULL;
AsyncReadState* State = new( std::nothrow ) AsyncReadState( pb, cb );
if( State == NULL )
return E_OUTOFMEMORY;
HResult = MFCreateAsyncResult( State, pCallback, punkState, &Result );
State->Release( );
if( SUCCEEDED( HResult ) )
{
IsCurrentlyReading = true;
HResult = MFPutWorkItem( MFASYNC_CALLBACK_QUEUE_STANDARD, this, Result );
Result->Release( );
}
return HResult;
}
void MFStream::doRead()
{
bool readDone = true;
IUnknown *pUnk = NULL;
HRESULT hr = m_currentReadResult->GetObject(&pUnk);
if (SUCCEEDED(hr)) {
//do actual read
AsyncReadState *state = static_cast<AsyncReadState*>(pUnk);
ULONG cbRead;
Read(state->pb(), state->cb() - state->bytesRead(), &cbRead);
pUnk->Release();
state->setBytesRead(cbRead + state->bytesRead());
if (state->cb() > state->bytesRead() && !m_stream->atEnd()) {
readDone = false;
}
}
if (readDone) {
//now inform the original caller
m_currentReadResult->SetStatus(hr);
MFInvokeCallback(m_currentReadResult);
}
}
/** Asyncronous callback */
STDMETHODIMP FImfByteStream::Invoke( IMFAsyncResult* pResult )
{
HRESULT HResult = S_OK;
IUnknown* State = NULL;
IUnknown* Unknown = NULL;
IMFAsyncResult* CallerResult = NULL;
AsyncReadState* Op = NULL;
HResult = pResult->GetState( &State );
check( SUCCEEDED( HResult ) );
HResult = State->QueryInterface( IID_PPV_ARGS( &CallerResult ) );
check( SUCCEEDED( HResult ) );
HResult = CallerResult->GetObject( &Unknown );
check( SUCCEEDED( HResult ) );
Op = static_cast<AsyncReadState*>( Unknown );
/* Do actual read */
ULONG cbRead;
Read( Op->GetBuffer( ), Op->GetCount( ) - Op->GetBytesRead( ), &cbRead );
Op->SetBytesRead( cbRead + Op->GetBytesRead( ) );
if( CallerResult )
{
CallerResult->SetStatus( HResult );
MFInvokeCallback( CallerResult );
}
if( State != NULL ) { State->Release( ); }
if( Unknown != NULL ) { Unknown->Release( ); }
if( CallerResult != NULL ){ CallerResult->Release( ); }
return S_OK;
}