mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2320 lines
77 KiB
2320 lines
77 KiB
// dmobase.h - a collection of DMO base classes
|
|
|
|
// Current hierarchy:
|
|
//
|
|
// IMediaObject
|
|
// |
|
|
// +-- C1in1outDMO - generic base class for DMOs with 1 in and 1 out
|
|
// | |
|
|
// | +-- FBRDMO - base class for fixed sample size, fixed bitrate DMOs
|
|
// | | |
|
|
// | | +-- CPCMDMO - base class for PCM audio DMOs
|
|
// | |
|
|
// | +-- C1for1 - base class for single sample per buffer 1-in/1-out DMOs
|
|
// |
|
|
// +-- CGenericDMO - resonably generic base class for multi-input/output DMOs
|
|
//
|
|
|
|
#ifndef __DMOBASE_H_
|
|
#define __DMOBASE_H_
|
|
|
|
#include "dmo.h"
|
|
#include "assert.h"
|
|
#include "math.h"
|
|
|
|
//
|
|
// locking helper class
|
|
//
|
|
#ifdef DMO_NOATL
|
|
class CDMOAutoLock {
|
|
public:
|
|
CDMOAutoLock(CRITICAL_SECTION* pcs)
|
|
: m_pcs(pcs)
|
|
{
|
|
EnterCriticalSection(m_pcs);
|
|
}
|
|
~CDMOAutoLock() {
|
|
LeaveCriticalSection(m_pcs);
|
|
}
|
|
private:
|
|
CRITICAL_SECTION* m_pcs;
|
|
};
|
|
#else
|
|
class CDMOAutoLock {
|
|
public:
|
|
CDMOAutoLock(CComAutoCriticalSection* pcs)
|
|
: m_pcs(pcs)
|
|
{
|
|
m_pcs->Lock();
|
|
}
|
|
~CDMOAutoLock() {
|
|
m_pcs->Unlock();
|
|
}
|
|
private:
|
|
CComAutoCriticalSection* m_pcs;
|
|
};
|
|
#endif
|
|
|
|
|
|
//
|
|
// C1in1outDMO - generic base class for 1-input/1-output DMOs.
|
|
//
|
|
//
|
|
//
|
|
// C1in1outDMO implements all IMediaObject methods. The derived class
|
|
// customizes the DMO's behavior by overriding some or all of the following
|
|
// virtual functions:
|
|
//
|
|
// Main Streaming:
|
|
// AcceptInput // accept one new input buffer
|
|
// ProduceOutput // fill up one output buffer with new data
|
|
// AcceptingInput // check if DMO is ready for new input
|
|
// Other streaming:
|
|
// PrepareForStreaming // hook called after both types have been set
|
|
// Discontinuity // notify DMO of a discontinuity
|
|
// DoFlush // discard all data and start anew
|
|
// Mediatype negotiation:
|
|
// GetInputType // input type enumerator
|
|
// GetOutputType // output type enumerator
|
|
// CheckInputType // verifies proposed input type is acceptable
|
|
// CheckOutputType // verifies proposed output type is acceptable
|
|
// Buffer size negotiation:
|
|
// GetInputFlags // input data flow flags
|
|
// GetOutputFlags // output fata flow flags
|
|
// GetInputSizeInfo // input buffer size requirements
|
|
// GetOutputSizeInfo // output buffer size requirements
|
|
//
|
|
// This base class assumes that the derived class will not override any
|
|
// IMediaObject methods directly - the derived class should override the
|
|
// methods listed above instead.
|
|
//
|
|
//
|
|
//
|
|
// The base class provides a default implementation for each of the
|
|
// overridables listed above. However, to make a useful DMO the derived class
|
|
// probably needs to override at least the following two methods:
|
|
//
|
|
// HRESULT AcceptingInput();
|
|
// HRESULT AcceptInput(BYTE* pData,
|
|
// ULONG ulSize,
|
|
// DWORD dwFlags,
|
|
// REFERENCE_TIME rtTimestamp,
|
|
// REFERENCE_TIME rtTimelength,
|
|
// IMediaBuffer* pMediaBuffer);
|
|
// HRESULT ProduceOutput(BYTE *pData,
|
|
// ULONG ulAvail,
|
|
// ULONG* pulUsed,
|
|
// DWORD* pdwStatus,
|
|
// REFERENCE_TIME *prtTimestamp,
|
|
// REFERENCE_TIME *prtTimelength);
|
|
//
|
|
// All good DMOs should also override these (the default implementation
|
|
// simply accepts any mediatype, which in general is not good DMO behavior):
|
|
//
|
|
// HRESULT GetInputType(ULONG ulTypeIndex, DMO_MEDIA_TYPE *pmt);
|
|
// HRESULT GetOutputType(ULONG ulTypeIndex, DMO_MEDIA_TYPE *pmt);
|
|
// HRESULT CheckInputType(const DMO_MEDIA_TYPE *pmt);
|
|
// HRESULT CheckOutputType(const DMO_MEDIA_TYPE *pmt);
|
|
//
|
|
// DMOs that store data and/or state information may need to implement
|
|
//
|
|
// HRESULT PrepareForStreaming();
|
|
// HRESULT Discontinuity();
|
|
// HRESULT Flush();
|
|
//
|
|
// Finally, DMOs that make any buffer size assumptions will need to override
|
|
// these:
|
|
//
|
|
// HRESULT GetInputFlags(DWORD* pdwFlags);
|
|
// HRESULT GetOutputFlags(DWORD* pdwFlags);
|
|
// HRESULT GetInputSizeInfo(ULONG *pulSize, ULONG *pcbMaxLookahead, ULONG *pulAlignment);
|
|
// HRESULT GetOutputSizeInfo(ULONG *pulSize, ULONG *pulAlignment);
|
|
//
|
|
//
|
|
//
|
|
// The following functions are provided by this base class exclusively for use
|
|
// by the derived class. The derived class should call these to find out the
|
|
// currently set mediatype(s) whenever it needs to make a decision that
|
|
// depends on the mediatype used. Each of these returns NULL if the mediatype
|
|
// has not been set yet.
|
|
//
|
|
// DMO_MEDIA_TYPE *InputType();
|
|
// DMO_MEDIA_TYPE *OutputType().
|
|
//
|
|
|
|
#define PROLOGUE \
|
|
CDMOAutoLock l(&m_cs); \
|
|
if (ulStreamIndex >= 1) \
|
|
return DMO_E_INVALIDSTREAMINDEX
|
|
|
|
class C1in1outDMO : public IMediaObject
|
|
{
|
|
public:
|
|
C1in1outDMO() :
|
|
m_bInputTypeSet(FALSE),
|
|
m_bOutputTypeSet(FALSE),
|
|
m_bIncomplete(FALSE)
|
|
{
|
|
#ifdef DMO_NOATL
|
|
InitializeCriticalSection(&m_cs);
|
|
#endif
|
|
}
|
|
~C1in1outDMO() {
|
|
#ifdef DMO_NOATL
|
|
DeleteCriticalSection(&m_cs);
|
|
#endif
|
|
}
|
|
|
|
public:
|
|
//
|
|
// IMediaObject methods
|
|
//
|
|
STDMETHODIMP GetStreamCount(unsigned long *pulNumberOfInputStreams, unsigned long *pulNumberOfOutputStreams)
|
|
{
|
|
CDMOAutoLock l(&m_cs);
|
|
if (pulNumberOfInputStreams == NULL ||
|
|
pulNumberOfOutputStreams == NULL) {
|
|
return E_POINTER;
|
|
}
|
|
*pulNumberOfInputStreams = 1;
|
|
*pulNumberOfOutputStreams = 1;
|
|
return S_OK;
|
|
}
|
|
STDMETHODIMP GetInputStreamInfo(ULONG ulStreamIndex, DWORD *pdwFlags)
|
|
{
|
|
PROLOGUE;
|
|
return GetInputFlags(pdwFlags);
|
|
}
|
|
STDMETHODIMP GetOutputStreamInfo(ULONG ulStreamIndex, DWORD *pdwFlags)
|
|
{
|
|
PROLOGUE;
|
|
return GetOutputFlags(pdwFlags);
|
|
}
|
|
STDMETHODIMP GetInputType(ULONG ulStreamIndex, ULONG ulTypeIndex, DMO_MEDIA_TYPE *pmt) {
|
|
PROLOGUE;
|
|
return GetInputType(ulTypeIndex, pmt);
|
|
}
|
|
STDMETHODIMP GetOutputType(ULONG ulStreamIndex, ULONG ulTypeIndex, DMO_MEDIA_TYPE *pmt) {
|
|
PROLOGUE;
|
|
return GetOutputType(ulTypeIndex, pmt);
|
|
}
|
|
STDMETHODIMP GetInputCurrentType(ULONG ulStreamIndex, DMO_MEDIA_TYPE *pmt) {
|
|
PROLOGUE;
|
|
if (m_bInputTypeSet)
|
|
return MoCopyMediaType(pmt, &m_InputType);
|
|
else
|
|
return DMO_E_TYPE_NOT_SET;
|
|
}
|
|
STDMETHODIMP GetOutputCurrentType(ULONG ulStreamIndex, DMO_MEDIA_TYPE *pmt) {
|
|
PROLOGUE;
|
|
if (m_bOutputTypeSet)
|
|
return MoCopyMediaType(pmt, &m_OutputType);
|
|
else
|
|
return DMO_E_TYPE_NOT_SET;
|
|
}
|
|
STDMETHODIMP GetInputSizeInfo(ULONG ulStreamIndex, ULONG *pulSize, ULONG *pcbMaxLookahead, ULONG *pulAlignment) {
|
|
PROLOGUE;
|
|
if (!m_bInputTypeSet)
|
|
return DMO_E_TYPE_NOT_SET;
|
|
return GetInputSizeInfo(pulSize, pcbMaxLookahead, pulAlignment);
|
|
}
|
|
STDMETHODIMP GetOutputSizeInfo(ULONG ulStreamIndex, ULONG *pulSize, ULONG *pulAlignment) {
|
|
PROLOGUE;
|
|
if (!m_bOutputTypeSet)
|
|
return DMO_E_TYPE_NOT_SET;
|
|
return GetOutputSizeInfo(pulSize, pulAlignment);
|
|
}
|
|
STDMETHODIMP SetInputType(ULONG ulStreamIndex, const DMO_MEDIA_TYPE *pmt, DWORD dwFlags) {
|
|
PROLOGUE;
|
|
HRESULT hr = CheckInputType(pmt);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
if (dwFlags & DMO_SET_TYPEF_TEST_ONLY)
|
|
return NOERROR;
|
|
|
|
// Free any previous mediatype
|
|
if (m_bInputTypeSet)
|
|
MoFreeMediaType(&m_InputType);
|
|
|
|
// actually set the type
|
|
MoCopyMediaType(&m_InputType, pmt);
|
|
m_bInputTypeSet = TRUE;
|
|
|
|
if (m_bOutputTypeSet)
|
|
PrepareForStreaming();
|
|
return NOERROR;
|
|
}
|
|
STDMETHODIMP SetOutputType(ULONG ulStreamIndex, const DMO_MEDIA_TYPE *pmt, DWORD dwFlags) {
|
|
PROLOGUE;
|
|
HRESULT hr = CheckOutputType(pmt);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
if (dwFlags & DMO_SET_TYPEF_TEST_ONLY)
|
|
return NOERROR;
|
|
|
|
// Free any previous mediatype
|
|
if (m_bOutputTypeSet)
|
|
MoFreeMediaType(&m_OutputType);
|
|
|
|
// actually set the type
|
|
MoCopyMediaType(&m_OutputType, pmt);
|
|
m_bOutputTypeSet = TRUE;
|
|
|
|
if (m_bInputTypeSet)
|
|
PrepareForStreaming();
|
|
return NOERROR;
|
|
}
|
|
STDMETHODIMP GetInputStatus(
|
|
ULONG ulStreamIndex,
|
|
DWORD *pdwStatus
|
|
) {
|
|
PROLOGUE;
|
|
*pdwStatus = 0;
|
|
if (AcceptingInput() == S_OK)
|
|
*pdwStatus |= DMO_INPUT_STATUSF_ACCEPT_DATA;
|
|
return NOERROR;
|
|
|
|
}
|
|
STDMETHODIMP GetInputMaxLatency(unsigned long ulStreamIndex, REFERENCE_TIME *prtLatency) {
|
|
return E_NOTIMPL;
|
|
}
|
|
STDMETHODIMP SetInputMaxLatency(unsigned long ulStreamIndex, REFERENCE_TIME rtLatency) {
|
|
return E_NOTIMPL;
|
|
}
|
|
STDMETHODIMP Discontinuity(ULONG ulStreamIndex) {
|
|
PROLOGUE;
|
|
return Discontinuity();
|
|
}
|
|
|
|
STDMETHODIMP Flush()
|
|
{
|
|
CDMOAutoLock l(&m_cs);
|
|
DoFlush();
|
|
return NOERROR;
|
|
}
|
|
STDMETHODIMP AllocateStreamingResources() {return S_OK;}
|
|
STDMETHODIMP FreeStreamingResources() {return S_OK;}
|
|
|
|
//
|
|
// Processing methods - public entry points
|
|
//
|
|
STDMETHODIMP ProcessInput(
|
|
DWORD ulStreamIndex,
|
|
IMediaBuffer *pBuffer, // [in], must not be NULL
|
|
DWORD dwFlags, // [in] - discontinuity, timestamp, etc.
|
|
REFERENCE_TIME rtTimestamp, // [in], valid if flag set
|
|
REFERENCE_TIME rtTimelength // [in], valid if flag set
|
|
) {
|
|
PROLOGUE;
|
|
if (AcceptingInput() != S_OK)
|
|
return DMO_E_NOTACCEPTING;
|
|
if (!pBuffer)
|
|
return E_POINTER;
|
|
|
|
// deal with the IMediaBuffer so the derived class doesn't have to
|
|
BYTE *pData;
|
|
ULONG ulSize;
|
|
HRESULT hr = pBuffer->GetBufferAndLength(&pData, &ulSize);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
if (pData == NULL)
|
|
ulSize = 0;
|
|
|
|
m_bIncomplete = TRUE; // new input means we may be able to produce output
|
|
|
|
return AcceptInput(pData, ulSize, dwFlags, rtTimestamp, rtTimelength, pBuffer);
|
|
}
|
|
|
|
STDMETHODIMP ProcessOutput(
|
|
DWORD dwReserved,
|
|
DWORD ulOutputBufferCount,
|
|
DMO_OUTPUT_DATA_BUFFER *pOutputBuffers,
|
|
DWORD *pdwStatus)
|
|
{
|
|
HRESULT hr;
|
|
CDMOAutoLock l(&m_cs);
|
|
|
|
if (ulOutputBufferCount != 1)
|
|
return E_INVALIDARG;
|
|
|
|
pOutputBuffers[0].dwStatus = 0;
|
|
|
|
// deal with the IMediaBuffer so the derived class doesn't have to
|
|
BYTE *pOut;
|
|
ULONG ulSize;
|
|
ULONG ulAvail;
|
|
|
|
if (pOutputBuffers[0].pBuffer) {
|
|
hr = pOutputBuffers[0].pBuffer->GetBufferAndLength(&pOut, &ulSize);
|
|
if (FAILED(hr)) return hr;
|
|
hr = pOutputBuffers[0].pBuffer->GetMaxLength(&ulAvail);
|
|
if (FAILED(hr)) return hr;
|
|
|
|
if (ulSize) { // skip any already used portion of the buffer
|
|
if (ulSize > ulAvail)
|
|
return E_INVALIDARG;
|
|
ulAvail -= ulSize;
|
|
pOut += ulSize;
|
|
}
|
|
}
|
|
else
|
|
ulAvail = 0;
|
|
|
|
if (ulAvail) { // have output buffer - call process
|
|
ULONG ulProduced = 0;
|
|
hr = ProduceOutput(pOut,
|
|
ulAvail,
|
|
&ulProduced,
|
|
&(pOutputBuffers[0].dwStatus),
|
|
&(pOutputBuffers[0].rtTimestamp),
|
|
&(pOutputBuffers[0].rtTimelength));
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
HRESULT hrProcess = hr; // remember this in case it's S_FALSE
|
|
|
|
// remember the DMO's incomplete status
|
|
if (pOutputBuffers[0].dwStatus | DMO_OUTPUT_DATA_BUFFERF_INCOMPLETE)
|
|
m_bIncomplete = TRUE;
|
|
else
|
|
m_bIncomplete = FALSE;
|
|
|
|
if (ulProduced > ulAvail)
|
|
return E_FAIL;
|
|
|
|
hr = pOutputBuffers[0].pBuffer->SetLength(ulSize + ulProduced);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
return hrProcess;
|
|
}
|
|
else { // no output buffer - assume they just want the incomplete flag
|
|
if (m_bIncomplete)
|
|
pOutputBuffers[0].dwStatus |= DMO_OUTPUT_DATA_BUFFERF_INCOMPLETE;
|
|
return NOERROR;
|
|
}
|
|
}
|
|
|
|
protected:
|
|
//
|
|
// private methods for use by derived class
|
|
//
|
|
DMO_MEDIA_TYPE *InputType() {
|
|
if (m_bInputTypeSet)
|
|
return &m_InputType;
|
|
else
|
|
return NULL;
|
|
}
|
|
DMO_MEDIA_TYPE *OutputType() {
|
|
if (m_bOutputTypeSet)
|
|
return &m_OutputType;
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
protected:
|
|
//
|
|
// To be overriden by the derived class
|
|
//
|
|
virtual HRESULT GetInputFlags(DWORD* pdwFlags) {
|
|
*pdwFlags = 0; // default implementation assumes no lookahead
|
|
return NOERROR;
|
|
}
|
|
virtual HRESULT GetOutputFlags(DWORD* pdwFlags) {
|
|
*pdwFlags = 0;
|
|
return NOERROR;
|
|
}
|
|
|
|
virtual HRESULT GetInputType(ULONG ulTypeIndex, DMO_MEDIA_TYPE *pmt) {
|
|
return DMO_E_NO_MORE_ITEMS; // default implementation exposes no types
|
|
}
|
|
virtual HRESULT GetOutputType(ULONG ulTypeIndex, DMO_MEDIA_TYPE *pmt) {
|
|
return DMO_E_NO_MORE_ITEMS; // default implementation exposes no types
|
|
}
|
|
virtual HRESULT CheckInputType(const DMO_MEDIA_TYPE *pmt) {
|
|
if ((pmt == NULL) || ((pmt->cbFormat > 0) && (pmt->pbFormat == NULL)))
|
|
return E_POINTER;
|
|
return S_OK; // default implementation accepts anything
|
|
}
|
|
virtual HRESULT CheckOutputType(const DMO_MEDIA_TYPE *pmt) {
|
|
if ((pmt == NULL) || ((pmt->cbFormat > 0) && (pmt->pbFormat == NULL)))
|
|
return E_POINTER;
|
|
return S_OK; // default implementation accepts anything
|
|
}
|
|
|
|
virtual HRESULT GetInputSizeInfo(ULONG *pulSize, ULONG *pcbMaxLookahead, ULONG *pulAlignment) {
|
|
*pulSize = 1; // default implementation imposes no size requirements
|
|
*pcbMaxLookahead = 0; // default implementation assumes no lookahead
|
|
*pulAlignment = 1; // default implementation assumes no alignment
|
|
return NOERROR;
|
|
}
|
|
virtual HRESULT GetOutputSizeInfo(ULONG *pulSize, ULONG *pulAlignment) {
|
|
*pulSize = 1; // default implementation imposes no size requirements
|
|
*pulAlignment = 1; // default implementation assumes no alignment
|
|
return NOERROR;
|
|
}
|
|
|
|
virtual HRESULT PrepareForStreaming() {
|
|
return NOERROR;
|
|
}
|
|
virtual HRESULT AcceptingInput() {
|
|
return S_FALSE;
|
|
}
|
|
virtual HRESULT Discontinuity() {
|
|
return NOERROR;
|
|
}
|
|
virtual HRESULT DoFlush() {
|
|
return NOERROR;
|
|
}
|
|
|
|
virtual HRESULT AcceptInput(BYTE* pData,
|
|
ULONG ulSize,
|
|
DWORD dwFlags,
|
|
REFERENCE_TIME rtTimestamp,
|
|
REFERENCE_TIME rtTimelength,
|
|
IMediaBuffer* pMediaBuffer
|
|
) {
|
|
m_bIncomplete = FALSE;
|
|
return S_FALSE;
|
|
}
|
|
virtual HRESULT ProduceOutput(BYTE *pData,
|
|
ULONG ulAvail,
|
|
ULONG* pulUsed,
|
|
DWORD* pdwStatus,
|
|
REFERENCE_TIME *prtTimestamp,
|
|
REFERENCE_TIME *prtTimelength
|
|
) {
|
|
*pulUsed = 0;
|
|
return S_FALSE;
|
|
}
|
|
|
|
private:
|
|
// mediatype stuff
|
|
BOOL m_bInputTypeSet;
|
|
BOOL m_bOutputTypeSet;
|
|
DMO_MEDIA_TYPE m_InputType;
|
|
DMO_MEDIA_TYPE m_OutputType;
|
|
|
|
BOOL m_bIncomplete;
|
|
#ifdef DMO_NOATL
|
|
CRITICAL_SECTION m_cs;
|
|
#else
|
|
CComAutoCriticalSection m_cs;
|
|
#endif
|
|
};
|
|
|
|
|
|
|
|
//
|
|
// C1for1DMO - base class for 1-input/1-output DMOs which
|
|
// - work on whole samples at a time, one sample per buffer
|
|
// - produce exactly one output sample for every input sample
|
|
// - don't need to accumulate more than 1 input sample before producing
|
|
// - don't produce any additional stuff at the end
|
|
// - the output sample corresponds in time to the input sample
|
|
//
|
|
// The derived class must implement:
|
|
// HRESULT Process(BYTE* pIn,
|
|
// ULONG ulBytesIn,
|
|
// BYTE* pOut,
|
|
// ULONG* pulProduced);
|
|
// HRESULT GetSampleSizes(ULONG* pulMaxInputSampleSize,
|
|
// ULONG* pulMaxOutputSampleSize);
|
|
//
|
|
//
|
|
// The derived class should implement:
|
|
// HRESULT GetInputType(ULONG ulTypeIndex, DMO_MEDIA_TYPE *pmt);
|
|
// HRESULT GetOutputType(ULONG ulTypeIndex, DMO_MEDIA_TYPE *pmt);
|
|
// HRESULT CheckInputType(const DMO_MEDIA_TYPE *pmt);
|
|
// HRESULT CheckOutputType(const DMO_MEDIA_TYPE *pmt);
|
|
//
|
|
// The derived class may implement if it needs to:
|
|
// HRESULT Init();
|
|
//
|
|
// The following methods are implemented by the base class. The derived class
|
|
// should call these to find out if the input/output type has been set and if
|
|
// so what it was set to.
|
|
// DMO_MEDIA_TYPE *InputType();
|
|
// DMO_MEDIA_TYPE *OutputType().
|
|
//
|
|
|
|
class C1for1DMO : public C1in1outDMO
|
|
{
|
|
public:
|
|
C1for1DMO() :
|
|
m_pBuffer(NULL)
|
|
{
|
|
}
|
|
~C1for1DMO() {
|
|
if (m_pBuffer)
|
|
m_pBuffer->Release();
|
|
}
|
|
|
|
protected:
|
|
//
|
|
// Implement C1in1outDMO overridables
|
|
//
|
|
virtual HRESULT GetInputFlags(DWORD* pdwFlags) {
|
|
*pdwFlags = DMO_INPUT_STREAMF_WHOLE_SAMPLES |
|
|
DMO_INPUT_STREAMF_SINGLE_SAMPLE_PER_BUFFER;
|
|
return NOERROR;
|
|
}
|
|
virtual HRESULT GetOutputFlags(DWORD* pdwFlags) {
|
|
*pdwFlags = DMO_OUTPUT_STREAMF_WHOLE_SAMPLES |
|
|
DMO_OUTPUT_STREAMF_SINGLE_SAMPLE_PER_BUFFER;
|
|
return NOERROR;
|
|
}
|
|
|
|
HRESULT GetInputSizeInfo(ULONG *pulSize, ULONG *pcbMaxLookahead, ULONG *pulAlignment) {
|
|
HRESULT hr = GetSampleSizes(&m_ulMaxInputSize, &m_ulMaxOutputSize);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
*pulSize = m_ulMaxInputSize;
|
|
*pcbMaxLookahead = 0;
|
|
*pulAlignment = 1;
|
|
return NOERROR;
|
|
}
|
|
HRESULT GetOutputSizeInfo(ULONG *pulSize, ULONG *pulAlignment) {
|
|
HRESULT hr = GetSampleSizes(&m_ulMaxInputSize, &m_ulMaxOutputSize);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
*pulSize = m_ulMaxOutputSize;
|
|
*pulAlignment = 1;
|
|
return NOERROR;
|
|
}
|
|
HRESULT PrepareForStreaming() {
|
|
HRESULT hr = GetSampleSizes(&m_ulMaxInputSize, &m_ulMaxOutputSize);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
return Init();
|
|
}
|
|
HRESULT AcceptingInput() {
|
|
return m_pBuffer ? S_FALSE : S_OK; // accept unless holding one already
|
|
}
|
|
HRESULT AcceptInput(BYTE* pData,
|
|
ULONG ulSize,
|
|
DWORD dwFlags,
|
|
REFERENCE_TIME rtTimestamp,
|
|
REFERENCE_TIME rtTimelength,
|
|
IMediaBuffer* pMediaBuffer
|
|
) {
|
|
if (AcceptingInput() != S_OK)
|
|
return E_FAIL;
|
|
m_pData = pData;
|
|
m_ulSize = ulSize;
|
|
m_dwFlags = dwFlags;
|
|
m_rtTimestamp = rtTimestamp;
|
|
m_rtTimelength = rtTimelength;
|
|
m_pBuffer = pMediaBuffer;
|
|
pMediaBuffer->AddRef();
|
|
return NOERROR;
|
|
}
|
|
HRESULT DoFlush() {
|
|
if (m_pBuffer) {
|
|
m_pBuffer->Release();
|
|
m_pBuffer = NULL;
|
|
}
|
|
return NOERROR;
|
|
}
|
|
HRESULT ProduceOutput(BYTE *pOut,
|
|
ULONG ulAvail,
|
|
ULONG* pulUsed,
|
|
DWORD* pdwStatus,
|
|
REFERENCE_TIME *prtTimestamp,
|
|
REFERENCE_TIME *prtTimelength
|
|
) {
|
|
*pulUsed = 0;
|
|
*pdwStatus = 0;
|
|
|
|
if (!m_pBuffer)
|
|
return S_FALSE;
|
|
if (ulAvail < m_ulMaxOutputSize)
|
|
return E_INVALIDARG;
|
|
|
|
HRESULT hr = Process(m_pData,
|
|
m_ulSize,
|
|
pOut,
|
|
pulUsed);
|
|
|
|
m_pBuffer->Release();
|
|
m_pBuffer = NULL;
|
|
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
if (m_dwFlags & DMO_INPUT_DATA_BUFFERF_SYNCPOINT)
|
|
*pdwStatus |= DMO_OUTPUT_DATA_BUFFERF_SYNCPOINT;
|
|
if (m_dwFlags & DMO_INPUT_DATA_BUFFERF_TIME)
|
|
*pdwStatus |= DMO_OUTPUT_DATA_BUFFERF_TIME;
|
|
if (m_dwFlags & DMO_INPUT_DATA_BUFFERF_TIMELENGTH)
|
|
*pdwStatus |= DMO_OUTPUT_DATA_BUFFERF_SYNCPOINT;
|
|
*prtTimestamp = m_rtTimestamp;
|
|
*prtTimelength = m_rtTimelength;
|
|
|
|
if (*pulUsed == 0)
|
|
return S_FALSE;
|
|
return hr;
|
|
}
|
|
protected:
|
|
//
|
|
// To be implemented by derived class
|
|
//
|
|
virtual HRESULT Process(BYTE* pIn,
|
|
ULONG ulBytesIn,
|
|
BYTE* pOut,
|
|
ULONG* pulProduced) = 0;
|
|
virtual HRESULT GetSampleSizes(ULONG* pulMaxInputSampleSize,
|
|
ULONG* pulMaxOutputSampleSize) = 0;
|
|
virtual HRESULT Init() {return NOERROR;}
|
|
|
|
private:
|
|
IMediaBuffer* m_pBuffer;
|
|
BYTE* m_pData;
|
|
ULONG m_ulSize;
|
|
DWORD m_dwFlags;
|
|
REFERENCE_TIME m_rtTimestamp;
|
|
REFERENCE_TIME m_rtTimelength;
|
|
|
|
ULONG m_ulMaxOutputSize;
|
|
ULONG m_ulMaxInputSize;
|
|
};
|
|
|
|
|
|
//
|
|
// CFBRDMO - DMO base class for 'fixed bitrate' DMOs. More specifically,
|
|
// this base class assumes the following:
|
|
// - 1 input, 1 output;
|
|
// - both input and output consist of equally sized 'quanta';
|
|
// - input/output quantum sizes can be determined from mediatypes;
|
|
// - each output quantum can be generated independently (without looking at
|
|
// previous output quanta);
|
|
// - if multiple input quanta are needed to generate a particular output
|
|
// quantum ('window overhead'), then the range of input required has an upper
|
|
// bound derived from mediatypes on both sides (i.e., both 'lookahead'
|
|
// and 'input memory' are bounded).
|
|
//
|
|
// The derived class must implement the following virtual functions:
|
|
// HRESULT FBRProcess(DWORD cQuanta, BYTE *pIn, BYTE *pOut);
|
|
// HRESULT GetStreamingParams(
|
|
// DWORD *pdwInputQuantumSize, // in bytes
|
|
// DWORD *pdwOutputQuantumSize, // in bytes
|
|
// DWORD *pdwMaxLookahead, // in input quanta, 0 means no lookahead
|
|
// DWORD *pdwLookBehind,
|
|
// REFERENCE_TIME *prtQuantumDuration, // same for input and output quanta
|
|
// REFERENCE_TIME *prtDurationDenominator // optional, normally 1
|
|
// );
|
|
// The derived class should also implement the following:
|
|
// HRESULT GetInputType(ULONG ulTypeIndex, DMO_MEDIA_TYPE *pmt);
|
|
// HRESULT GetOutputType(ULONG ulTypeIndex, DMO_MEDIA_TYPE *pmt);
|
|
// HRESULT CheckInputType(const DMO_MEDIA_TYPE *pmt);
|
|
// HRESULT CheckOutputType(const DMO_MEDIA_TYPE *pmt);
|
|
// The derived class may need to implement the followng:
|
|
// HRESULT Init();
|
|
// HRESULT Discontinuity();
|
|
//
|
|
// The derived class may use these entry points into the base class to get
|
|
// the currently set mediatypes:
|
|
// DMO_MEDIA_TYPE *InputType();
|
|
// DMO_MEDIA_TYPE *OutputType().
|
|
//
|
|
// The sum of *pdwMaxLookahead and *pdwLoookbehind is the 'window overhead' of
|
|
// the algorithm (the window overhead is 0 if the algorithm only needs the
|
|
// current input sample).
|
|
//
|
|
// Because the non-zero window overhead case is more complicated, it is handled by a
|
|
// separate set of functions in this base class. The names of all non-zero
|
|
// window overhead functions have the 'NZWO' prefix. The names of the
|
|
// zero window overhead functions begin with 'ZWO'.
|
|
//
|
|
// A data copy on the input side is necessary in the non-zero window overhead case.
|
|
//
|
|
|
|
class CFBRDMO : public C1in1outDMO
|
|
{
|
|
public:
|
|
CFBRDMO() :
|
|
m_bParametersSet(FALSE),
|
|
m_pMediaBuffer(NULL),
|
|
m_pAllocAddr(NULL),
|
|
m_bStreaming(FALSE)
|
|
{
|
|
}
|
|
~CFBRDMO() {
|
|
/*
|
|
if (m_bStreaming)
|
|
StopStreaming();
|
|
*/
|
|
if (m_pAllocAddr)
|
|
delete[] m_pAllocAddr;
|
|
if (m_pMediaBuffer)
|
|
m_pMediaBuffer->Release();
|
|
}
|
|
|
|
protected:
|
|
//
|
|
// Implement C1in1outDMO overridables
|
|
//
|
|
HRESULT GetInputSizeInfo(ULONG *pulSize, ULONG *pcbMaxLookahead, ULONG *pulAlignment) {
|
|
if (!(InputType() && OutputType()))
|
|
return DMO_E_TYPE_NOT_SET;
|
|
//
|
|
// For efficiency reasons we might like to be fed fairly large amounts
|
|
// of data at a time, but technically all we need is one quantum.
|
|
//
|
|
*pulSize = m_ulInputQuantumSize;
|
|
*pcbMaxLookahead = 0; // this base class does not rely on HOLDS_BUFFERS
|
|
*pulAlignment = 1;
|
|
return NOERROR;
|
|
}
|
|
HRESULT GetOutputSizeInfo(ULONG *pulSize, ULONG *pulAlignment) {
|
|
if (!(InputType() && OutputType()))
|
|
return DMO_E_TYPE_NOT_SET;
|
|
*pulSize = m_ulOutputQuantumSize;
|
|
*pulAlignment = 1;
|
|
return NOERROR;
|
|
}
|
|
|
|
virtual HRESULT Discontinuity() {
|
|
m_bDiscontinuity = TRUE;
|
|
return NOERROR;
|
|
}
|
|
|
|
virtual HRESULT AcceptInput(BYTE* pData,
|
|
ULONG ulSize,
|
|
DWORD dwFlags,
|
|
REFERENCE_TIME rtTimestamp,
|
|
REFERENCE_TIME rtTimelength,
|
|
IMediaBuffer* pBuffer
|
|
) {
|
|
// Every sample is a syncpoint for mediatypes
|
|
// supported by objects of this class.
|
|
assert(dwFlags & DMO_INPUT_DATA_BUFFERF_SYNCPOINT);
|
|
BOOL bTimestamp = (dwFlags & DMO_INPUT_DATA_BUFFERF_TIME) ? TRUE : FALSE;
|
|
|
|
if (m_ulWindowOverhead)
|
|
return NZWOProcessInput(pBuffer, pData, ulSize, bTimestamp, rtTimestamp);
|
|
else
|
|
return ZWOProcessInput(pBuffer, pData, ulSize, bTimestamp, rtTimestamp);
|
|
}
|
|
virtual HRESULT ProduceOutput(BYTE *pOut,
|
|
ULONG ulAvail,
|
|
ULONG* pulUsed,
|
|
DWORD* pdwStatus,
|
|
REFERENCE_TIME *prtTimestamp,
|
|
REFERENCE_TIME *prtTimelength
|
|
) {
|
|
HRESULT hr;
|
|
if (!m_bParametersSet)
|
|
return DMO_E_TYPE_NOT_SET;
|
|
|
|
// call Discontinuity() if this is the first ProcessOutput() call
|
|
if (!m_bStreaming) {
|
|
HRESULT hr = Discontinuity();
|
|
if (FAILED(hr))
|
|
return hr;
|
|
m_bStreaming = TRUE;
|
|
}
|
|
|
|
*pdwStatus = 0;
|
|
|
|
ULONG ulInputQuantaAvailable = InputQuantaAvailable();
|
|
if (!ulInputQuantaAvailable)
|
|
return S_FALSE; // did not produce anything
|
|
|
|
ULONG ulOutputQuantaPossible = ulAvail / m_ulOutputQuantumSize;
|
|
if (!ulOutputQuantaPossible)
|
|
return E_INVALIDARG; // this would be rather lame
|
|
|
|
ULONG ulQuantaToProcess = min(ulOutputQuantaPossible, ulInputQuantaAvailable);
|
|
assert(ulQuantaToProcess > 0);
|
|
|
|
BOOL bTimestamp;
|
|
if (m_ulWindowOverhead)
|
|
hr = NZWOProcessOutput(pOut, ulQuantaToProcess, &bTimestamp, prtTimestamp);
|
|
else
|
|
hr = ZWOProcessOutput(pOut, ulQuantaToProcess, &bTimestamp, prtTimestamp);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
*pulUsed = ulQuantaToProcess * m_ulOutputQuantumSize;
|
|
|
|
*pdwStatus |= DMO_OUTPUT_DATA_BUFFERF_SYNCPOINT;
|
|
if (bTimestamp)
|
|
*pdwStatus |= DMO_OUTPUT_DATA_BUFFERF_TIME;
|
|
|
|
// any data left ?
|
|
if (InputQuantaAvailable()) // yes - set incomplete
|
|
*pdwStatus |= DMO_OUTPUT_DATA_BUFFERF_INCOMPLETE;
|
|
else if (m_bDiscontinuity) // no - process any discontinuity
|
|
DoFlush();
|
|
|
|
return NOERROR;
|
|
}
|
|
HRESULT DoFlush()
|
|
{
|
|
// reset flags
|
|
m_bDiscontinuity = FALSE;
|
|
m_bTimestamps = FALSE;
|
|
|
|
if (m_ulWindowOverhead)
|
|
NZWODiscardData();
|
|
else
|
|
ZWODiscardData();
|
|
|
|
// notify the derived class
|
|
Discontinuity();
|
|
|
|
return NOERROR;
|
|
}
|
|
HRESULT AcceptingInput() {
|
|
if (!m_bParametersSet) // uninitialized
|
|
return FALSE;
|
|
|
|
BOOL bResult;
|
|
if (m_ulWindowOverhead)
|
|
bResult = NZWOQueryAccept();
|
|
else
|
|
bResult = ZWOQueryAccept();
|
|
|
|
return bResult ? S_OK : S_FALSE;
|
|
}
|
|
// End C1in1out overridables implementation
|
|
|
|
private:
|
|
//
|
|
// Common private code (window overhead or no window overhead)
|
|
//
|
|
// returns the number of input quanta available minus any window overhead
|
|
ULONG InputQuantaAvailable() {
|
|
if (m_ulWindowOverhead)
|
|
return NZWOAvail();
|
|
else
|
|
return ZWOAvail();
|
|
}
|
|
|
|
// Private method to compute/allocate stuff once all types have been set.
|
|
HRESULT PrepareForStreaming () {
|
|
m_bParametersSet = FALSE;
|
|
// Now that both types are set, query the derived class for params
|
|
HRESULT hr;
|
|
if (FAILED(hr = GetStreamingParams(&m_ulInputQuantumSize,
|
|
&m_ulOutputQuantumSize,
|
|
&m_ulLookahead,
|
|
&m_ulLookbehind,
|
|
&m_rtDurationNumerator,
|
|
&m_rtDenominator)))
|
|
return hr;
|
|
if (!m_rtDenominator) {
|
|
assert(!"bad object - duration denominator should not be 0 !");
|
|
return E_FAIL;
|
|
}
|
|
// Attempt to reduce the fraction. Probably the most complicated number
|
|
// we will ever see is 44100 = (3 * 7 * 2 * 5) ^ 2, so trying the first
|
|
// few numbers should suffice in most cases.
|
|
DWORD dwP[] = {2,3,5,7,11,13,17,19,23,29,31};
|
|
for (DWORD c = 0; c < sizeof(dwP) / sizeof(DWORD); c++) {
|
|
while ((m_rtDurationNumerator % dwP[c] == 0) &&
|
|
(m_rtDenominator % dwP[c] == 0)) {
|
|
m_rtDurationNumerator /= dwP[c];
|
|
m_rtDenominator /= dwP[c];
|
|
}
|
|
}
|
|
|
|
// We cannot afford to have huge denominators, unfortunately, because
|
|
// we store timestamp numerators using 64 bits, so a large denominator
|
|
// could result in timestamp overflows. So if the denominator is still
|
|
// too large, reduce it anyway with loss of precision.
|
|
ULONG ulMax = 0x10000; // largest acceptable denominator value
|
|
if (m_rtDenominator >= ulMax) {
|
|
double actual_ratio = (double)m_rtDurationNumerator * (double)m_rtDenominator;
|
|
ULONG ulDenominator = 1;
|
|
// Repeatedly increase the denominator until either the actual ratio
|
|
// can be represented precisely using the denominator, or the
|
|
// denominator gets too large.
|
|
do {
|
|
double fractional_part = actual_ratio * (double)ulDenominator
|
|
- floor(actual_ratio * (double)ulDenominator);
|
|
if (fractional_part == 0)
|
|
break;
|
|
ULONG ulNewDenominator = (ULONG)floor(ulDenominator / fractional_part);
|
|
if (ulNewDenominator >= ulMax)
|
|
break;
|
|
ulDenominator = ulNewDenominator;
|
|
} while(1);
|
|
m_rtDurationNumerator = (ULONG)floor(actual_ratio * ulDenominator);
|
|
m_rtDenominator = ulDenominator;
|
|
}
|
|
|
|
m_ulWindowOverhead = m_ulLookahead + m_ulLookbehind;
|
|
if (!m_ulWindowOverhead) // No window overhead - the simple case
|
|
m_bParametersSet = TRUE;
|
|
else // The complicated case with window overhead
|
|
AllocateCircularBuffer();
|
|
|
|
m_bTimestamps = FALSE;
|
|
m_bDiscontinuity = FALSE;
|
|
|
|
if (m_bStreaming) {
|
|
//StopStreaming();
|
|
m_bStreaming = FALSE;
|
|
}
|
|
Init();
|
|
return m_bParametersSet ? NOERROR : E_FAIL;
|
|
}
|
|
// end common code
|
|
|
|
//
|
|
// zero window overhead case code
|
|
//
|
|
HRESULT ZWOProcessInput(IMediaBuffer* pBuffer,
|
|
BYTE* pData,
|
|
ULONG ulSize,
|
|
BOOL bTimestamp,
|
|
REFERENCE_TIME rtTimestamp) {
|
|
assert(!m_pMediaBuffer);
|
|
|
|
m_bTimestamp = bTimestamp;
|
|
m_rtTimestamp = rtTimestamp;
|
|
m_pData = pData;
|
|
m_ulData = ulSize;
|
|
m_ulUsed = 0;
|
|
|
|
// make sure they gave us a meaningful amount of data
|
|
if (m_ulData < m_ulInputQuantumSize)
|
|
return S_FALSE;
|
|
|
|
// save the buffer we were given
|
|
m_pMediaBuffer = pBuffer;
|
|
pBuffer->AddRef();
|
|
return NOERROR;
|
|
}
|
|
HRESULT ZWOProcessOutput(BYTE* pOut,
|
|
ULONG ulQuantaToProcess,
|
|
BOOL* pbTimestamp,
|
|
REFERENCE_TIME* prtTimestamp) {
|
|
assert(m_ulUsed % m_ulInputQuantumSize == 0);
|
|
HRESULT hr = FBRProcess(ulQuantaToProcess, m_pData + m_ulUsed, pOut);
|
|
if (FAILED(hr)) return hr;
|
|
ZWOConsume(ulQuantaToProcess);
|
|
|
|
if (m_bTimestamp) { // there was a timestamp on this input buffer
|
|
// m_rtTimestamp refers to the beginning of the input buffer.
|
|
// Extrapolate to the beginning of the area we just processed.
|
|
*prtTimestamp = m_rtTimestamp +
|
|
(m_ulUsed % m_ulInputQuantumSize) * m_rtDurationNumerator /
|
|
m_rtDenominator;
|
|
*pbTimestamp = TRUE;
|
|
}
|
|
else if (m_bTimestamps) { // there was a timestamp earlier
|
|
// bugbug: should we extrapolate from a previous timestamp ?
|
|
*pbTimestamp = FALSE;
|
|
}
|
|
else // no timestamps at all
|
|
*pbTimestamp = FALSE;
|
|
|
|
return NOERROR;
|
|
}
|
|
ULONG ZWOAvail() {
|
|
if (m_pMediaBuffer) {
|
|
assert(m_ulData - m_ulUsed > m_ulInputQuantumSize);
|
|
return (m_ulData - m_ulUsed) / m_ulInputQuantumSize;
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
void ZWOConsume(ULONG ulN) { // the zero window overhead version
|
|
assert(m_pMediaBuffer);
|
|
m_ulUsed += ulN * m_ulInputQuantumSize;
|
|
assert(m_ulData >= m_ulUsed);
|
|
if (m_ulData - m_ulUsed < m_ulInputQuantumSize) {
|
|
m_pMediaBuffer->Release();
|
|
m_pMediaBuffer = NULL;
|
|
}
|
|
}
|
|
BOOL ZWOQueryAccept() {
|
|
// accept IFF not holding something already
|
|
if (!m_pMediaBuffer)
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
void ZWODiscardData() {
|
|
if (m_pMediaBuffer) {
|
|
m_pMediaBuffer->Release();
|
|
m_pMediaBuffer = NULL;
|
|
}
|
|
}
|
|
// End zero window overhead case code
|
|
|
|
//
|
|
// Non zero window overhead case code.
|
|
//
|
|
HRESULT NZWOProcessInput(IMediaBuffer* pBuffer,
|
|
BYTE* pData,
|
|
ULONG ulSize,
|
|
BOOL bTimestamp,
|
|
REFERENCE_TIME rtTimestamp) {
|
|
if (bTimestamp) { // process the timestamp
|
|
if (!m_bTimestamps) { // this is the first timestamp we've seen
|
|
// Just getting started - initialize the timestamp to refer to
|
|
// the first input quantum for which we will actually generate
|
|
// output (the first m_ulLookbehind quanta are pure lookbehind and
|
|
// generate no output).
|
|
m_rtTimestampNumerator = rtTimestamp * m_rtDenominator
|
|
+ m_ulLookbehind * m_rtDurationNumerator;
|
|
|
|
}
|
|
else {
|
|
// We are already streaming and just got a new timestamp. Use it
|
|
// to check if our stored timestamp has somehow drifted away from
|
|
// where it should be and adjust if it is far enough off.
|
|
|
|
ULONG ulInputQuantaAvailable = InputQuantaAvailable();
|
|
if (ulInputQuantaAvailable) {
|
|
// ulInputQuantaAvailable is how far back in time the next
|
|
// quantum we would process is located relative the beginning
|
|
// of the new buffer we just received.
|
|
|
|
// Compute what the timestamp back there ought to be now.
|
|
REFERENCE_TIME rtTimestampNumerator;
|
|
rtTimestampNumerator = m_rtDenominator * rtTimestamp
|
|
- ulInputQuantaAvailable * m_rtDurationNumerator;
|
|
|
|
// Adjust the stored timestamp if it is off by more than half
|
|
// the duration of a quantum. Should also have a DbgLog here.
|
|
if ((m_rtTimestampNumerator >= rtTimestampNumerator + m_rtDurationNumerator / 2) ||
|
|
(m_rtTimestampNumerator <= rtTimestampNumerator - m_rtDurationNumerator / 2)) {
|
|
m_rtTimestampNumerator = rtTimestampNumerator;
|
|
}
|
|
}
|
|
else {
|
|
// We must still be accumulating the initial window overhead.
|
|
// Too early to need an adjustment, one would hope.
|
|
}
|
|
}
|
|
m_bTimestamps = TRUE;
|
|
}
|
|
|
|
if (BufferUsed() + ulSize > m_ulBufferAllocated)
|
|
return E_FAIL; // need a max input size to prevent this
|
|
|
|
// append to our buffer
|
|
AppendData(pData, ulSize);
|
|
|
|
// are we ready to produce now ?
|
|
if (NZWOAvail())
|
|
return NOERROR;
|
|
else
|
|
return S_FALSE; // no output can be produced yet
|
|
}
|
|
HRESULT NZWOProcessOutput(BYTE* pOut,
|
|
ULONG ulQuantaToProcess,
|
|
BOOL* pbTimestamp,
|
|
REFERENCE_TIME* prtTimestamp) {
|
|
//
|
|
// Handle any timestamps
|
|
//
|
|
if (m_bTimestamps) {
|
|
// In window overhead mode the stored timestamp refers to the input
|
|
// data immediately after lookbehind, which corresponds to the
|
|
// begining of the output buffer by definition of FDRProcess.
|
|
*prtTimestamp = m_rtTimestampNumerator / m_rtDenominator;
|
|
*pbTimestamp = TRUE;
|
|
|
|
}
|
|
else
|
|
*pbTimestamp = FALSE;
|
|
|
|
//
|
|
// Handle the data
|
|
//
|
|
HRESULT hr;
|
|
ULONG ulInputNeeded = m_ulInputQuantumSize * (ulQuantaToProcess + m_ulWindowOverhead);
|
|
assert(ulInputNeeded < BufferUsed());
|
|
if (m_ulDataHead + ulInputNeeded <= m_ulBufferAllocated) {
|
|
// No wraparound, everything is easy
|
|
hr = FBRProcess(ulQuantaToProcess,
|
|
m_pCircularBuffer + m_ulDataHead + m_ulLookbehind * m_ulInputQuantumSize,
|
|
pOut);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
NZWOConsume(ulQuantaToProcess);
|
|
}
|
|
else { // The data we want to send wraps around the end
|
|
// Q.: does it wrap around inside the window overhead area
|
|
// or inside the main data area ?
|
|
if (m_ulDataHead + m_ulWindowOverhead * m_ulInputQuantumSize < m_ulBufferAllocated) {
|
|
// The wraparound occurs inside the main data area. Advance the
|
|
// window overhead up to the wraparound point by processing some data.
|
|
ULONG ulAdvance = m_ulBufferAllocated - (m_ulDataHead + m_ulWindowOverhead * m_ulInputQuantumSize);
|
|
assert(ulAdvance % m_ulInputQuantumSize == 0);
|
|
ulAdvance /= m_ulInputQuantumSize; // convert to quanta
|
|
assert(ulAdvance > 0);
|
|
assert(ulAdvance < ulQuantaToProcess);
|
|
hr = FBRProcess(ulAdvance,
|
|
m_pCircularBuffer + m_ulDataHead + m_ulLookbehind * m_ulInputQuantumSize,
|
|
pOut);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
NZWOConsume(ulAdvance);
|
|
|
|
// Adjust stuff so that the code below can act
|
|
// as if this extra process call never happened.
|
|
pOut += m_ulOutputQuantumSize * ulAdvance;
|
|
ulQuantaToProcess -= ulAdvance;
|
|
assert(ulQuantaToProcess > 0);
|
|
|
|
// Now the wraparound point should be exactly on the boundary
|
|
// between window overhead and main data.
|
|
assert(m_ulDataHead + m_ulWindowOverhead * m_ulInputQuantumSize == m_ulBufferAllocated);
|
|
} // wraparound in main data
|
|
|
|
// When we get here, the wraparound point occurs somewhere inside
|
|
// the window overhead area or right on the border between window overhead and
|
|
// main data.
|
|
assert(m_ulDataHead + m_ulWindowOverhead * m_ulInputQuantumSize >= m_ulBufferAllocated);
|
|
ULONG ulLookaheadToCopy = m_ulBufferAllocated - m_ulDataHead;
|
|
|
|
// copy to the special area we reserved at the front
|
|
memcpy(m_pCircularBuffer - ulLookaheadToCopy,
|
|
m_pCircularBuffer + m_ulDataHead,
|
|
ulLookaheadToCopy);
|
|
|
|
// Now the block we are interested in is all in one piece
|
|
hr = FBRProcess(ulQuantaToProcess,
|
|
m_pCircularBuffer - ulLookaheadToCopy + m_ulLookbehind * m_ulInputQuantumSize,
|
|
pOut);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
NZWOConsume(ulQuantaToProcess);
|
|
} // data handling - wraparound case
|
|
return NOERROR;
|
|
}
|
|
void AllocateCircularBuffer() {
|
|
// free any previously allocated input buffer
|
|
if (m_pAllocAddr)
|
|
delete[] m_pAllocAddr;
|
|
|
|
// bugbug: need a better way to decide this number
|
|
m_ulBufferAllocated = max(m_ulInputQuantumSize * 16, 65536L);
|
|
m_ulDataHead = m_ulDataTail = 0;
|
|
|
|
// reserve room at the front for copying window overhead
|
|
ULONG ulPrefix = m_ulWindowOverhead * m_ulInputQuantumSize;
|
|
m_pAllocAddr = new BYTE[m_ulBufferAllocated + ulPrefix];
|
|
if (!m_pAllocAddr)
|
|
return;
|
|
m_pCircularBuffer = m_pAllocAddr + ulPrefix;
|
|
|
|
m_bParametersSet = TRUE;
|
|
}
|
|
BOOL NZWOQueryAccept() {
|
|
// We are using a temp input buffer. Is there room to append more ?
|
|
// The answer really depends on how much data they will try to feed
|
|
// us. Without knowing the maximum input buffer size, we will accept
|
|
// more if the input buffer is less than half full.
|
|
if (2 * BufferUsed() < m_ulBufferAllocated)
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
ULONG NZWOAvail() {
|
|
ULONG ulInputQuantaAvailable = BufferUsed() / m_ulInputQuantumSize;
|
|
if (ulInputQuantaAvailable > m_ulWindowOverhead)
|
|
return ulInputQuantaAvailable - m_ulWindowOverhead;
|
|
else
|
|
return 0;
|
|
}
|
|
void NZWOConsume(ULONG ulN) { // the window overhead version
|
|
assert(ulN * m_ulInputQuantumSize <= BufferUsed());
|
|
m_ulDataHead += ulN * m_ulInputQuantumSize;
|
|
if (m_ulDataHead > m_ulBufferAllocated) //wraparound
|
|
m_ulDataHead -= m_ulBufferAllocated;
|
|
|
|
// Advance the timestamp.
|
|
// The same denominator is used for both timestamp and duration.
|
|
m_rtTimestampNumerator += ulN * m_rtDurationNumerator;
|
|
}
|
|
ULONG BufferUsed() {
|
|
if (m_ulDataTail >= m_ulDataHead)
|
|
return m_ulDataTail - m_ulDataHead;
|
|
else
|
|
return m_ulBufferAllocated - (m_ulDataHead - m_ulDataTail);
|
|
}
|
|
void AppendData(BYTE *pData, ULONG ulSize) {
|
|
if (m_ulDataTail + ulSize <= m_ulBufferAllocated) { // no wraparound
|
|
memcpy(m_pCircularBuffer + m_ulDataTail, pData, ulSize);
|
|
m_ulDataTail += ulSize;
|
|
}
|
|
else { // wraparound
|
|
memcpy(m_pCircularBuffer + m_ulDataTail, pData, m_ulBufferAllocated - m_ulDataTail);
|
|
memcpy(m_pCircularBuffer, pData + m_ulBufferAllocated - m_ulDataTail, ulSize - (m_ulBufferAllocated - m_ulDataTail));
|
|
m_ulDataTail += ulSize;
|
|
m_ulDataTail -= m_ulBufferAllocated;
|
|
}
|
|
}
|
|
void NZWODiscardData() {
|
|
m_ulDataHead = m_ulDataTail = 0;
|
|
}
|
|
// End window overhead case code
|
|
|
|
|
|
protected:
|
|
//
|
|
// To be implemebted by the derived class
|
|
//
|
|
virtual HRESULT FBRProcess(DWORD cQuanta, BYTE *pIn, BYTE *pOut) = 0;
|
|
virtual HRESULT GetStreamingParams(
|
|
DWORD *pdwInputQuantumSize, // in bytes
|
|
DWORD *pdwOutputQuantumSize, // in bytes
|
|
DWORD *pdwMaxLookahead, // in input quanta, 0 means no lookahead
|
|
DWORD *pdwLookbehind,
|
|
REFERENCE_TIME *prtQuantumDuration, // same for input and output quanta
|
|
REFERENCE_TIME *prtDurationDenominator // optional, normally 1
|
|
) = 0;
|
|
virtual HRESULT Init() {
|
|
return NOERROR;
|
|
}
|
|
// Because AllocateStreamingResources() and FreeStreamingResources() are
|
|
// optional, we have no place to call StopStreaming() from except the
|
|
// destructor, and calling a virtual function from the destructor doesn't
|
|
// work. Without StopStreaming(), StartStreaming() is not much use either.
|
|
// We need to change the IMediaObject spec and make those
|
|
// calls mandatory. Then we can implement StartStreaming/StopStraming.
|
|
// virtual HRESULT StartStreaming() = 0;
|
|
// virtual HRESULT StopStreaming() = 0;
|
|
|
|
private:
|
|
|
|
BOOL m_bNewInput;
|
|
|
|
// streaming parameters
|
|
BOOL m_bParametersSet;
|
|
ULONG m_ulInputQuantumSize;
|
|
ULONG m_ulOutputQuantumSize;
|
|
ULONG m_ulLookahead;
|
|
ULONG m_ulLookbehind;
|
|
ULONG m_ulWindowOverhead;
|
|
REFERENCE_TIME m_rtDurationNumerator;
|
|
REFERENCE_TIME m_rtDenominator;
|
|
|
|
// streaming state
|
|
BOOL m_bTimestamps; // we have seen at least one timestamp
|
|
BOOL m_bDiscontinuity;
|
|
BOOL m_bStreaming;
|
|
|
|
// zero window overhead case input data
|
|
IMediaBuffer *m_pMediaBuffer;
|
|
BYTE *m_pData;
|
|
ULONG m_ulData;
|
|
ULONG m_ulUsed;
|
|
BOOL m_bTimestamp; // timestamp on current buffer
|
|
REFERENCE_TIME m_rtTimestamp;
|
|
|
|
// window overhead case input data
|
|
BYTE *m_pCircularBuffer;
|
|
BYTE *m_pAllocAddr;
|
|
ULONG m_ulBufferAllocated;
|
|
ULONG m_ulDataHead;
|
|
ULONG m_ulDataTail;
|
|
REFERENCE_TIME m_rtTimestampNumerator; // uses the same denominator as duration
|
|
|
|
};
|
|
|
|
|
|
// CPCMDMO - base class for PCM audio transform filters.
|
|
// Helps non-converting PCM audio transforms with mediatype negotiation.
|
|
// Based on CFBRDMO - study that first.
|
|
//
|
|
// Derived class must implement:
|
|
// FBRProcess()
|
|
// Deriver class may implement:
|
|
// Discontinuity() // default implementaion does nothing
|
|
// Init() // default implementaion does nothing
|
|
// GetPCMParams() // default implementation proposes 44100/2/16
|
|
// CheckPCMParams() // default implementation accepts any 8/16 bit format
|
|
// GetWindowParams() // default implementation assumes no lookahead/lookbehind
|
|
//
|
|
// This class conveniently provides the following data members accessible
|
|
// by the derived class:
|
|
// ULONG m_ulSamplingRate
|
|
// ULONG m_cChannels
|
|
// BOOL m_b8bit
|
|
//
|
|
#include <mmreg.h>
|
|
#include <uuids.h>
|
|
|
|
class CPCMDMO : public CFBRDMO
|
|
{
|
|
protected:
|
|
//
|
|
// implement pure virtual CFBRDMO methods
|
|
//
|
|
HRESULT GetInputType(ULONG ulTypeIndex, DMO_MEDIA_TYPE *pmt) {
|
|
if (ulTypeIndex > 0)
|
|
return DMO_E_NO_MORE_ITEMS;
|
|
return GetType(pmt, OutputType());
|
|
}
|
|
HRESULT GetOutputType(ULONG ulTypeIndex, DMO_MEDIA_TYPE *pmt) {
|
|
if (ulTypeIndex > 0)
|
|
return DMO_E_NO_MORE_ITEMS;
|
|
return GetType(pmt, InputType());
|
|
}
|
|
HRESULT CheckInputType(const DMO_MEDIA_TYPE *pmt) {
|
|
return CheckType(pmt, OutputType());
|
|
}
|
|
HRESULT CheckOutputType(const DMO_MEDIA_TYPE *pmt) {
|
|
return CheckType(pmt, InputType());
|
|
}
|
|
HRESULT Init() {
|
|
return NOERROR;
|
|
}
|
|
HRESULT Discontinuity() {
|
|
return NOERROR;
|
|
}
|
|
HRESULT GetStreamingParams(
|
|
DWORD *pdwInputQuantumSize, // in bytes
|
|
DWORD *pdwOutputQuantumSize, // in bytes
|
|
DWORD *pdwMaxLookahead, // in input quanta, 0 means no lookahead
|
|
DWORD *pdwMaxLookbehind,
|
|
REFERENCE_TIME *prtQuantumDuration, // same for input and output quanta
|
|
REFERENCE_TIME *prtDurationDenominator // optional, normally 1
|
|
) {
|
|
// Sanity check: all of this should have been taken care of by base class
|
|
DMO_MEDIA_TYPE* pmtIn = InputType();
|
|
DMO_MEDIA_TYPE* pmtOut = OutputType();
|
|
if (!pmtIn || !pmtOut)
|
|
return DMO_E_TYPE_NOT_SET;
|
|
if (CheckType(pmtIn, NULL) || CheckType(pmtOut, pmtIn))
|
|
return DMO_E_TYPE_NOT_ACCEPTED;
|
|
|
|
WAVEFORMATEX *pWave = (WAVEFORMATEX*)pmtIn->pbFormat;
|
|
|
|
m_b8bit = (pWave->wBitsPerSample == 8);
|
|
m_cChannels = pWave->nChannels;
|
|
m_ulSamplingRate = pWave->nSamplesPerSec;
|
|
|
|
*pdwInputQuantumSize = pWave->nBlockAlign;
|
|
*pdwOutputQuantumSize = pWave->nBlockAlign;
|
|
*prtQuantumDuration = 10000000; // rt units per sec
|
|
*prtDurationDenominator = pWave->nSamplesPerSec;
|
|
|
|
GetWindowParams(pdwMaxLookahead, pdwMaxLookbehind);
|
|
return NOERROR;
|
|
}
|
|
|
|
protected:
|
|
//
|
|
// Methods to be overridden by derived class
|
|
//
|
|
// We use this to get lookahead/lookbehind from the derived class
|
|
virtual void GetWindowParams(DWORD *pdwMaxLookahead,
|
|
DWORD *pdwMaxLookbehind) {
|
|
*pdwMaxLookahead = 0;
|
|
*pdwMaxLookbehind = 0;
|
|
}
|
|
// derived class can override these if it has specific requirements
|
|
virtual void GetPCMParams(BOOL* pb8bit, DWORD* pcChannels, DWORD* pdwSamplesPerSec) {
|
|
// These values are what the DMO will advertise in its media type.
|
|
// Specifying them here does not mean that this is the only acceptable
|
|
// combination - CheckPCMParams() is the ultimate authority on what we will
|
|
// accept.
|
|
*pb8bit = FALSE;
|
|
*pcChannels = 2;
|
|
*pdwSamplesPerSec = 44100;
|
|
}
|
|
virtual BOOL CheckPCMParams(BOOL b8bit, DWORD cChannels, DWORD dwSamplesPerSec) {
|
|
// Default implementation accepts anything. Override if you have specific
|
|
// requirements WRT sampling rate, number of channels, or bit depth.
|
|
return TRUE;
|
|
}
|
|
|
|
private:
|
|
//
|
|
// private helpers
|
|
//
|
|
HRESULT GetType(DMO_MEDIA_TYPE* pmt, const DMO_MEDIA_TYPE *pmtOther) {
|
|
// If the other type is set, enumerate that. Otherwise propose 44100/2/16.
|
|
if (pmtOther) {
|
|
MoCopyMediaType(pmt, pmtOther);
|
|
return NOERROR;
|
|
}
|
|
|
|
HRESULT hr = MoInitMediaType(pmt, sizeof(WAVEFORMATEX));
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
pmt->majortype = MEDIATYPE_Audio;
|
|
pmt->subtype = MEDIASUBTYPE_PCM;
|
|
pmt->formattype = FORMAT_WaveFormatEx;
|
|
|
|
WAVEFORMATEX* pWave = (WAVEFORMATEX*) pmt->pbFormat;
|
|
pWave->wFormatTag = WAVE_FORMAT_PCM;
|
|
|
|
BOOL b8bit;
|
|
DWORD cChannels;
|
|
GetPCMParams(&b8bit, &cChannels, &(pWave->nSamplesPerSec));
|
|
(pWave->nChannels) = (unsigned short)cChannels;
|
|
pWave->wBitsPerSample = b8bit ? 8 : 16;
|
|
pWave->nBlockAlign = pWave->nChannels * pWave->wBitsPerSample / 8;
|
|
pWave->nAvgBytesPerSec = pWave->nSamplesPerSec * pWave->nBlockAlign;
|
|
pWave->cbSize = 0;
|
|
|
|
return NOERROR;
|
|
}
|
|
HRESULT CheckType(const DMO_MEDIA_TYPE *pmt, DMO_MEDIA_TYPE *pmtOther) {
|
|
// verify that this is PCM with a WAVEFORMATEX format specifier
|
|
if ((pmt->majortype != MEDIATYPE_Audio) ||
|
|
(pmt->subtype != MEDIASUBTYPE_PCM) ||
|
|
(pmt->formattype != FORMAT_WaveFormatEx) ||
|
|
(pmt->cbFormat < sizeof(WAVEFORMATEX)) ||
|
|
(pmt->pbFormat == NULL))
|
|
return DMO_E_TYPE_NOT_ACCEPTED;
|
|
|
|
// If other type set, accept only if identical to that. Otherwise accept
|
|
// any standard PCM audio.
|
|
if (pmtOther) {
|
|
if (memcmp(pmt->pbFormat, pmtOther->pbFormat, sizeof(WAVEFORMATEX)))
|
|
return DMO_E_TYPE_NOT_ACCEPTED;
|
|
}
|
|
else {
|
|
WAVEFORMATEX* pWave = (WAVEFORMATEX*)pmt->pbFormat;
|
|
if ((pWave->wFormatTag != WAVE_FORMAT_PCM) ||
|
|
((pWave->wBitsPerSample != 8) && (pWave->wBitsPerSample != 16)) ||
|
|
(pWave->nBlockAlign != pWave->nChannels * pWave->wBitsPerSample / 8) ||
|
|
(pWave->nAvgBytesPerSec != pWave->nSamplesPerSec * pWave->nBlockAlign) ||
|
|
!CheckPCMParams((pWave->wBitsPerSample == 8), pWave->nChannels, pWave->nSamplesPerSec))
|
|
return DMO_E_TYPE_NOT_ACCEPTED;
|
|
}
|
|
return NOERROR;
|
|
}
|
|
|
|
protected:
|
|
// format info - the derived class may look at these (but no modify)
|
|
ULONG m_ulSamplingRate;
|
|
ULONG m_cChannels;
|
|
BOOL m_b8bit;
|
|
};
|
|
|
|
|
|
//
|
|
// CGenericDMO - generic DMO base class. This is currently the only base
|
|
// class for DMOs that have multiple inputs or multiple outputs.
|
|
//
|
|
// This base class tries to be reasonably generic. The derived class reports
|
|
// how many streams it supports and describes each stream by calling
|
|
// CreateInputStreams() and CreateOutputStreams(). Each of these functions
|
|
// takes an array of STREAMDESCRIPTOR structures, each of which poits to an
|
|
// array of FORMATENTRY structures.
|
|
//
|
|
// This base class uses CInputStream and COutputStream classes (both derived
|
|
// from CStream) to keep track of input and output stream. However, these
|
|
// objects are not visible to the derived class - the derived class only sees
|
|
// stream IDs.
|
|
//
|
|
// One limitation of the scheme use here is that the derived class cannot
|
|
// override the GetType/SetType methods individually for each stream. It must
|
|
// either (a) live with a static, finite set of types communicated via the
|
|
// STREAMDESCRIPTOR structure, or (b) override all IMediaObject type methods
|
|
// and handle type negotiation for all streams itself.
|
|
//
|
|
// Processing occurs when the base class calles DoProcess (overridden by the
|
|
// derived class). DoProcess receives an array of input buffer structs and
|
|
// an array of output buffer structs. The base class takes care of talking
|
|
// to IMediaBuffers, so the derived class only sees actual data pointers.
|
|
//
|
|
|
|
// flags used to communicate with the derived class
|
|
enum _INPUT_STATUS_FLAGS {
|
|
INPUT_STATUSF_RESIDUAL // cannot be further processed w/o additional input
|
|
};
|
|
|
|
// These are used to pass buffers between this class and the derived class.
|
|
typedef struct _INPUTBUFFER {
|
|
BYTE *pData; // [in] - if NULL, the rest are garbage
|
|
DWORD cbSize; // [in]
|
|
DWORD cbUsed; // [out]
|
|
DWORD dwFlags; // [in] - DMO_INPUT_DATA_BUFFERF_XXX
|
|
DWORD dwStatus; // [out] - INPUT_STATUSF_XXX from above
|
|
REFERENCE_TIME rtTimestamp; // [in]
|
|
REFERENCE_TIME rtTimelength; // [in]
|
|
} INPUTBUFFER, *PINPUTBUFFER;
|
|
typedef struct _OUTPUTBUFFER {
|
|
BYTE *pData; // [in]
|
|
DWORD cbSize; // [in]
|
|
DWORD cbUsed; // [out]
|
|
DWORD dwFlags; // [out] - DMO_OUTPUT_DATA_BUFFERF_XXX
|
|
REFERENCE_TIME rtTimestamp; // [out]
|
|
REFERENCE_TIME rtTimelength; // [out]
|
|
} OUTPUTBUFFER, *POUTPUTBUFFER;
|
|
|
|
// Used by derived class to describe the format supported by each stream
|
|
typedef struct _FORMATENTRY
|
|
{
|
|
const GUID *majortype;
|
|
const GUID *subtype;
|
|
const GUID *formattype;
|
|
DWORD cbFormat;
|
|
BYTE* pbFormat;
|
|
} FORMATENTRY;
|
|
|
|
// These are used by the derived class to described its streams
|
|
typedef struct _INPUTSTREAMDESCRIPTOR {
|
|
DWORD cFormats;
|
|
FORMATENTRY *pFormats;
|
|
DWORD dwMinBufferSize;
|
|
BOOL bHoldsBuffers;
|
|
DWORD dwMaxLookahead; // used if HOLDS_BUFFERS set
|
|
} INPUTSTREAMDESCRIPTOR;
|
|
typedef struct _OUTPUTSTREAMDESCRIPTOR {
|
|
DWORD cFormats;
|
|
FORMATENTRY *pFormats;
|
|
DWORD dwMinBufferSize;
|
|
} OUTPUTSTREAMDESCRIPTOR;
|
|
|
|
// Common input/output stream stuff
|
|
class CStream {
|
|
public:
|
|
DMO_MEDIA_TYPE m_MediaType;
|
|
BOOL m_bEOS;
|
|
BOOL m_bTypeSet;
|
|
|
|
DWORD m_cFormats;
|
|
FORMATENTRY *m_pFormats;
|
|
DWORD m_dwMinBufferSize;
|
|
|
|
// Should really pass in a format type list
|
|
CStream()
|
|
{
|
|
MoInitMediaType(&m_MediaType, 0);
|
|
m_bTypeSet = FALSE;
|
|
Flush();
|
|
}
|
|
~CStream()
|
|
{
|
|
MoFreeMediaType(&m_MediaType);
|
|
}
|
|
HRESULT Flush() {
|
|
m_bEOS = FALSE;
|
|
return NOERROR;
|
|
}
|
|
HRESULT StreamInfo(unsigned long *pdwFlags)
|
|
{
|
|
if (pdwFlags == NULL) {
|
|
return E_POINTER;
|
|
}
|
|
*pdwFlags = 0;
|
|
return S_OK;
|
|
}
|
|
HRESULT GetType(ULONG ulTypeIndex, DMO_MEDIA_TYPE *pmt)
|
|
{
|
|
if (ulTypeIndex >= m_cFormats) {
|
|
return E_INVALIDARG;
|
|
}
|
|
// Just return our types
|
|
MoInitMediaType(pmt, m_pFormats[ulTypeIndex].cbFormat);
|
|
pmt->majortype = *m_pFormats[ulTypeIndex].majortype;
|
|
pmt->subtype = *m_pFormats[ulTypeIndex].subtype;
|
|
pmt->formattype = *m_pFormats[ulTypeIndex].formattype;
|
|
memcpy(pmt->pbFormat, m_pFormats[ulTypeIndex].pbFormat, m_pFormats[ulTypeIndex].cbFormat);
|
|
return S_OK;
|
|
}
|
|
HRESULT GetCurrentType(DMO_MEDIA_TYPE *pmt)
|
|
{
|
|
if (NULL == pmt) {
|
|
return E_POINTER;
|
|
}
|
|
|
|
if (m_bTypeSet) {
|
|
// BUGBUG check success
|
|
MoCopyMediaType(pmt, &(m_MediaType));
|
|
return S_OK;
|
|
}
|
|
else
|
|
return DMO_E_TYPE_NOT_SET;
|
|
}
|
|
HRESULT SetType(const DMO_MEDIA_TYPE *pmt, DWORD dwFlags)
|
|
{
|
|
// Need to check this
|
|
HRESULT hr = CheckType(pmt, 0);
|
|
if (FAILED(hr)) {
|
|
return hr;
|
|
}
|
|
if (dwFlags & DMO_SET_TYPEF_TEST_ONLY) {
|
|
return NOERROR; // check konly
|
|
}
|
|
// BUGBUG - check success
|
|
MoCopyMediaType(&m_MediaType, pmt);
|
|
|
|
m_bTypeSet = TRUE;;
|
|
return S_OK;
|
|
}
|
|
HRESULT CheckType(const DMO_MEDIA_TYPE *pmt, DWORD dwFlags)
|
|
{
|
|
if (pmt == NULL) {
|
|
return E_POINTER;
|
|
}
|
|
//if (dwFlags & ~DMO_SET_TYPEF_NOT_PARTIAL)
|
|
// return E_INVALIDARG;
|
|
|
|
// Default - check GUIDs
|
|
|
|
bool bMatched = false;
|
|
for (DWORD i = 0; i < m_cFormats; i++) {
|
|
const FORMATENTRY *pFormat = &(m_pFormats[i]);
|
|
if (pmt->majortype == *(pFormat->majortype) &&
|
|
pmt->subtype == *(pFormat->subtype) &&
|
|
pmt->formattype == *(pFormat->formattype)) {
|
|
bMatched = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (bMatched) {
|
|
return S_OK;
|
|
} else {
|
|
return DMO_E_INVALIDTYPE;
|
|
}
|
|
}
|
|
HRESULT SizeInfo(ULONG *plSize, ULONG *plAlignment)
|
|
{
|
|
if (plSize == NULL || plAlignment == NULL) {
|
|
return E_POINTER;
|
|
}
|
|
|
|
*plAlignment = 1;
|
|
*plSize = m_dwMinBufferSize;
|
|
return S_OK;
|
|
}
|
|
};
|
|
|
|
// Input stream specific stuff
|
|
class CInputStream : public CStream {
|
|
public:
|
|
BOOL m_bHoldsBuffers;
|
|
DWORD m_dwMaxLookahead; // used if HOLDS_BUFFERS set
|
|
|
|
// Current input sample
|
|
IMediaBuffer *m_pMediaBuffer;
|
|
DWORD m_dwFlags; // discontinuity, etc.
|
|
REFERENCE_TIME m_rtTimestamp;
|
|
REFERENCE_TIME m_rtTimelength;
|
|
BYTE *m_pData;
|
|
DWORD m_cbSize;
|
|
DWORD m_cbUsed;
|
|
|
|
// residual
|
|
BYTE *m_pbResidual;
|
|
DWORD m_cbResidual;
|
|
DWORD m_cbResidualBuffer;
|
|
|
|
// temporary buffer for handling the residual
|
|
BYTE *m_pbTemp;
|
|
|
|
HRESULT Flush() {
|
|
if (m_pMediaBuffer) {
|
|
m_pMediaBuffer->Release();
|
|
m_pMediaBuffer = NULL;
|
|
}
|
|
return CStream::Flush();
|
|
}
|
|
CInputStream() {
|
|
m_pMediaBuffer = NULL;
|
|
m_pbResidual = NULL;
|
|
m_pbTemp = NULL;
|
|
}
|
|
~CInputStream() {
|
|
if (m_pMediaBuffer)
|
|
m_pMediaBuffer->Release();
|
|
if (m_pbResidual)
|
|
delete[] m_pbResidual;
|
|
}
|
|
HRESULT StreamInfo(DWORD *pdwFlags) {
|
|
HRESULT hr = CStream::StreamInfo(pdwFlags);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
if (m_bHoldsBuffers)
|
|
*pdwFlags |= DMO_INPUT_STREAMF_HOLDS_BUFFERS;
|
|
return NOERROR;
|
|
}
|
|
HRESULT Init(INPUTSTREAMDESCRIPTOR *pDescriptor) {
|
|
m_cFormats = pDescriptor->cFormats;
|
|
m_pFormats = pDescriptor->pFormats;
|
|
m_dwMinBufferSize = pDescriptor->dwMinBufferSize;
|
|
m_bHoldsBuffers = pDescriptor->bHoldsBuffers;
|
|
m_dwMaxLookahead = pDescriptor->dwMaxLookahead;
|
|
|
|
// Just in case Init is called multiple times:
|
|
// delete any preexisting stuff.
|
|
if (m_pMediaBuffer) {
|
|
m_pMediaBuffer->Release();
|
|
m_pMediaBuffer = NULL;
|
|
}
|
|
if (m_pbResidual) {
|
|
delete[] m_pbResidual;
|
|
m_pbResidual = NULL;
|
|
}
|
|
|
|
m_cbResidual = 0;
|
|
m_cbResidualBuffer = m_dwMinBufferSize * 2; // enough ?
|
|
m_pbResidual = new BYTE[m_cbResidualBuffer];
|
|
|
|
return NOERROR;
|
|
}
|
|
HRESULT InputStatus(DWORD *pdwStatus) {
|
|
// objects that hold buffers must implement InputStatus themselves
|
|
assert(!m_bHoldsBuffers);
|
|
*pdwStatus = 0;
|
|
if (!m_pMediaBuffer)
|
|
*pdwStatus |= DMO_INPUT_STATUSF_ACCEPT_DATA;
|
|
return NOERROR;
|
|
}
|
|
HRESULT Deliver(
|
|
IMediaBuffer *pBuffer, // [in], must not be NULL
|
|
DWORD dwFlags, // [in] - discontinuity, timestamp, etc.
|
|
REFERENCE_TIME rtTimestamp, // [in], valid if flag set
|
|
REFERENCE_TIME rtTimelength // [in], valid if flag set
|
|
) {
|
|
if (!pBuffer)
|
|
return E_POINTER;
|
|
// objects that hold buffers must implement Deliver themselves
|
|
assert(!m_bHoldsBuffers);
|
|
DWORD dwStatus = 0;
|
|
InputStatus(&dwStatus);
|
|
if (!(dwStatus & DMO_INPUT_STATUSF_ACCEPT_DATA))
|
|
return DMO_E_NOTACCEPTING;
|
|
assert(!m_pMediaBuffer); // can't hold multiple buffers
|
|
|
|
//Deal with the IMediaBuffer
|
|
HRESULT hr;
|
|
hr = pBuffer->GetBufferAndLength(&m_pData, &m_cbSize);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
if (!m_cbSize) // empty buffer
|
|
return S_FALSE; // no data
|
|
|
|
pBuffer->AddRef();
|
|
m_pMediaBuffer = pBuffer;
|
|
m_dwFlags = dwFlags;
|
|
m_rtTimestamp = rtTimestamp;
|
|
m_rtTimelength = rtTimelength;
|
|
m_cbUsed = 0;
|
|
return NOERROR;
|
|
}
|
|
|
|
//
|
|
// Fetch data from the currently held IMediaBuffer plus any residual
|
|
//
|
|
HRESULT PrepareInputBuffer(INPUTBUFFER *pBuffer)
|
|
{
|
|
// Q.: do we even have any data to give it ?
|
|
if (m_pMediaBuffer) {
|
|
// Is there a residual we need to feed first ?
|
|
if (m_cbResidual) {
|
|
// Yes, prepend the residual to the new input
|
|
|
|
// If we have used some of the input buffer by now, we
|
|
// should have also used up any residual with that.
|
|
assert(m_cbUsed == 0);
|
|
|
|
// compute how many bytes total we are going to send
|
|
pBuffer->cbSize = m_cbResidual
|
|
+ m_cbSize;
|
|
|
|
// Make sure we have at least dwMinBufferSize bytes of data.
|
|
// We really should - the input buffer alone ought to be at
|
|
// least that big.
|
|
assert(pBuffer->cbSize >
|
|
m_dwMinBufferSize);
|
|
|
|
// Is the residual buffer big enough to hold the residual plus
|
|
// all of the new buffer ?
|
|
if (pBuffer->cbSize <= m_cbResidualBuffer) {
|
|
// Yes - wonderful, we can use the residual buffer
|
|
memcpy(m_pbResidual + m_cbResidual,
|
|
m_pData,
|
|
m_cbSize);
|
|
pBuffer->pData = m_pbResidual;
|
|
}
|
|
else {
|
|
// No - allocate a sufficiently large temporary buffer.
|
|
// This is supposed to be a rare case.
|
|
m_pbTemp = new BYTE[pBuffer->cbSize];
|
|
if (m_pbTemp == NULL)
|
|
return E_OUTOFMEMORY;
|
|
// copy the residual
|
|
memcpy(m_pbTemp,
|
|
m_pbResidual,
|
|
m_cbResidual);
|
|
// append the new buffer
|
|
memcpy(m_pbTemp + m_cbResidual,
|
|
m_pData,
|
|
m_cbSize);
|
|
|
|
// set the buffer pointer to our temp buffer
|
|
pBuffer->pData = m_pbTemp;
|
|
}
|
|
|
|
// BUGBUG - is this the correct way to handle timestamps &
|
|
// discontinuities when handling a residual ?
|
|
pBuffer->dwFlags = 0;
|
|
}
|
|
else { // no residual
|
|
pBuffer->pData = m_pData + m_cbUsed;
|
|
pBuffer->cbSize = m_cbSize - m_cbUsed;
|
|
pBuffer->dwFlags = m_dwFlags;
|
|
pBuffer->rtTimestamp = m_rtTimestamp;
|
|
pBuffer->rtTimelength= m_rtTimelength;
|
|
}
|
|
pBuffer->cbUsed = 0; // derived class should set this
|
|
pBuffer->dwStatus = 0; // derived class should set this
|
|
}
|
|
else {
|
|
pBuffer->pData = NULL;
|
|
pBuffer->cbSize = 0;
|
|
}
|
|
return NOERROR;
|
|
}
|
|
|
|
//
|
|
// Save any residual and release the IMediaBuffer as appropriate.
|
|
// Returns TRUE if there is enough data left to call ProcesInput again.
|
|
//
|
|
BOOL PostProcessInputBuffer(INPUTBUFFER *pBuffer)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
// did we even give this stream anything ?
|
|
if (m_pMediaBuffer) {
|
|
// Yes, but did it eat any of it ?
|
|
if (pBuffer->cbUsed) {
|
|
// Did we even get past the residual
|
|
if (pBuffer->cbUsed > m_cbResidual) {
|
|
// Yes - reflect this in the current buffer's cbUsed.
|
|
m_cbUsed += (pBuffer->cbUsed - m_cbResidual);
|
|
m_cbResidual = 0;
|
|
}
|
|
else {
|
|
// No - just subtract from the residual.
|
|
// This is a rather strange case.
|
|
m_cbResidual -= pBuffer->cbUsed;
|
|
memmove(m_pbResidual,
|
|
m_pbResidual + pBuffer->cbUsed,
|
|
m_cbResidual);
|
|
}
|
|
}
|
|
|
|
// Is there enough left to feed again the next time ?
|
|
if ((m_cbSize - m_cbUsed <
|
|
m_dwMinBufferSize)
|
|
|| (pBuffer->dwStatus & INPUT_STATUSF_RESIDUAL)) {
|
|
// No - copy the residual and release the buffer
|
|
memcpy(m_pbResidual,
|
|
m_pData + m_cbUsed,
|
|
m_cbSize - m_cbUsed);
|
|
m_cbResidual
|
|
= pBuffer->cbSize - pBuffer->cbUsed;
|
|
m_pMediaBuffer->Release();
|
|
m_pMediaBuffer = NULL;
|
|
}
|
|
else { // Yes - need another Process call to eat remaining input
|
|
bRet = TRUE;
|
|
}
|
|
|
|
// Free any temporary buffer we may have used - rare case
|
|
if (m_pbTemp) {
|
|
delete[] m_pbTemp;
|
|
m_pbTemp = NULL;
|
|
}
|
|
}
|
|
return bRet;
|
|
}
|
|
HRESULT Discontinuity() {
|
|
// BUGBUG - implement
|
|
// m_bDiscontinuity = TRUE;
|
|
return NOERROR;
|
|
}
|
|
HRESULT SizeInfo(ULONG *pulSize,
|
|
ULONG *pulMaxLookahead,
|
|
ULONG *pulAlignment) {
|
|
HRESULT hr = CStream::SizeInfo(pulSize, pulAlignment);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
if (m_bHoldsBuffers)
|
|
*pulMaxLookahead = m_dwMaxLookahead;
|
|
else
|
|
*pulMaxLookahead = *pulSize;
|
|
return NOERROR;
|
|
}
|
|
};
|
|
|
|
// Output stream specific stuff
|
|
class COutputStream : public CStream {
|
|
public:
|
|
BOOL m_bIncomplete;
|
|
DWORD m_cbAlreadyUsed; // temp per-stream variable used during Process
|
|
|
|
HRESULT Init(OUTPUTSTREAMDESCRIPTOR *pDescriptor) {
|
|
m_cFormats = pDescriptor->cFormats;
|
|
m_pFormats = pDescriptor->pFormats;
|
|
m_dwMinBufferSize = pDescriptor->dwMinBufferSize;
|
|
return NOERROR;
|
|
}
|
|
|
|
//
|
|
// Initialize the OUTPUTBUFFER struct with info from the IMediaBuffer
|
|
//
|
|
HRESULT PrepareOutputBuffer(OUTPUTBUFFER *pBuffer, IMediaBuffer *pMediaBuffer, BOOL bNewInput)
|
|
{
|
|
//
|
|
// See if the caller supplied an output buffer
|
|
//
|
|
if (pMediaBuffer == NULL) {
|
|
// This is allowed to be NULL only if (1) the object did not set
|
|
// the INCOMPLETE flag for this stream during the last Process
|
|
// call, and (2) no new input data has been supplied to the object
|
|
// since the last Process call.
|
|
if (bNewInput)
|
|
return E_POINTER;
|
|
if (m_bIncomplete)
|
|
return E_POINTER;
|
|
|
|
// ok - initialize assuming no buffer
|
|
pBuffer->cbSize = 0;
|
|
pBuffer->pData = NULL;
|
|
}
|
|
else { // the IMediaBuffer is not NULL - deal with it
|
|
HRESULT hr;
|
|
hr = pMediaBuffer->GetMaxLength(&pBuffer->cbSize);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = pMediaBuffer->GetBufferAndLength(
|
|
&(pBuffer->pData),
|
|
&(m_cbAlreadyUsed));
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
// Check current size - should we even bother with this ?
|
|
if (m_cbAlreadyUsed) {
|
|
if (m_cbAlreadyUsed >= pBuffer->cbSize)
|
|
return E_INVALIDARG; // buffer already full ?!?
|
|
pBuffer->cbSize -= m_cbAlreadyUsed;
|
|
pBuffer->pData += m_cbAlreadyUsed;
|
|
}
|
|
}
|
|
|
|
// It is really the derived class's job to set these, but we
|
|
// will be nice to it and initialize them anyway just in case.
|
|
pBuffer->cbUsed = 0;
|
|
pBuffer->dwFlags = 0;
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
//
|
|
// Copy the OUTPUTBUFFER back into the DMO_OUTPUT_DATA_BUFFER (yawn)
|
|
//
|
|
void PostProcessOutputBuffer(OUTPUTBUFFER *pBuffer, DMO_OUTPUT_DATA_BUFFER *pDMOBuffer, BOOL bForceIncomplete) {
|
|
assert(pBuffer->cbUsed <= pBuffer->cbSize);
|
|
if (pDMOBuffer->pBuffer)
|
|
pDMOBuffer->pBuffer->SetLength(pBuffer->cbUsed + m_cbAlreadyUsed);
|
|
pDMOBuffer->dwStatus = pBuffer->dwFlags;
|
|
pDMOBuffer->rtTimestamp = pBuffer->rtTimestamp;
|
|
pDMOBuffer->rtTimelength = pBuffer->rtTimelength;
|
|
|
|
// Even if the derived class did not set INCOMPLETE, we may need to
|
|
// set it anyway if some input buffer we are holding still has
|
|
// enough data to call Process() again.
|
|
if (bForceIncomplete)
|
|
pDMOBuffer->dwStatus |= DMO_OUTPUT_DATA_BUFFERF_INCOMPLETE;
|
|
|
|
// remember this output stream's INCOMPLETE state
|
|
if (pDMOBuffer->dwStatus & DMO_OUTPUT_DATA_BUFFERF_INCOMPLETE)
|
|
m_bIncomplete = TRUE;
|
|
else
|
|
m_bIncomplete = FALSE;
|
|
}
|
|
};
|
|
|
|
// Code that goes at the beginning of every IMediaObject method
|
|
#define INPUT_STREAM_PROLOGUE \
|
|
CDMOAutoLock l(&m_cs); \
|
|
if (ulInputStreamIndex >= m_nInputStreams) \
|
|
return DMO_E_INVALIDSTREAMINDEX; \
|
|
CInputStream *pStream = &m_pInputStreams[ulInputStreamIndex]
|
|
|
|
#define OUTPUT_STREAM_PROLOGUE \
|
|
CDMOAutoLock l(&m_cs); \
|
|
if (ulOutputStreamIndex >= m_nOutputStreams) \
|
|
return DMO_E_INVALIDSTREAMINDEX; \
|
|
COutputStream *pStream = &m_pOutputStreams[ulOutputStreamIndex]
|
|
|
|
|
|
class CGenericDMO : public IMediaObject
|
|
{
|
|
public:
|
|
CGenericDMO() {
|
|
#ifdef DMO_NOATL
|
|
InitializeCriticalSection(&m_cs);
|
|
#endif
|
|
m_nInputStreams = 0;
|
|
m_nOutputStreams = 0;
|
|
}
|
|
#ifdef DMO_NOATL
|
|
~CGenericDMO() {
|
|
DeleteCriticalSection(&m_cs);
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
//
|
|
// Implement IMediaObject methods
|
|
//
|
|
STDMETHODIMP GetInputStreamInfo(ULONG ulInputStreamIndex, DWORD *pdwFlags)
|
|
{
|
|
INPUT_STREAM_PROLOGUE;
|
|
return pStream->StreamInfo(pdwFlags);
|
|
}
|
|
STDMETHODIMP GetOutputStreamInfo(ULONG ulOutputStreamIndex, DWORD *pdwFlags)
|
|
{
|
|
OUTPUT_STREAM_PROLOGUE;
|
|
return pStream->StreamInfo(pdwFlags);
|
|
}
|
|
STDMETHODIMP GetInputType(ULONG ulInputStreamIndex, ULONG ulTypeIndex, DMO_MEDIA_TYPE *pmt) {
|
|
INPUT_STREAM_PROLOGUE;
|
|
return pStream->GetType(ulTypeIndex, pmt);
|
|
}
|
|
STDMETHODIMP GetOutputType(ULONG ulOutputStreamIndex, ULONG ulTypeIndex, DMO_MEDIA_TYPE *pmt) {
|
|
OUTPUT_STREAM_PROLOGUE;
|
|
return pStream->GetType(ulTypeIndex, pmt);
|
|
}
|
|
STDMETHODIMP GetInputCurrentType(ULONG ulInputStreamIndex, DMO_MEDIA_TYPE *pmt) {
|
|
INPUT_STREAM_PROLOGUE;
|
|
return pStream->GetCurrentType(pmt);
|
|
}
|
|
STDMETHODIMP GetOutputCurrentType(ULONG ulOutputStreamIndex, DMO_MEDIA_TYPE *pmt) {
|
|
OUTPUT_STREAM_PROLOGUE;
|
|
return pStream->GetCurrentType(pmt);
|
|
}
|
|
STDMETHODIMP GetInputSizeInfo(ULONG ulInputStreamIndex, ULONG *pulSize, ULONG *pcbMaxLookahead, ULONG *pulAlignment) {
|
|
INPUT_STREAM_PROLOGUE;
|
|
return pStream->SizeInfo(pulSize, pcbMaxLookahead, pulAlignment);
|
|
}
|
|
STDMETHODIMP GetOutputSizeInfo(ULONG ulOutputStreamIndex, ULONG *pulSize, ULONG *pulAlignment) {
|
|
OUTPUT_STREAM_PROLOGUE;
|
|
return pStream->SizeInfo(pulSize, pulAlignment);
|
|
}
|
|
STDMETHODIMP SetInputType(ULONG ulInputStreamIndex, const DMO_MEDIA_TYPE *pmt, DWORD dwFlags) {
|
|
INPUT_STREAM_PROLOGUE;
|
|
return pStream->SetType(pmt, dwFlags);
|
|
}
|
|
STDMETHODIMP SetOutputType(ULONG ulOutputStreamIndex, const DMO_MEDIA_TYPE *pmt, DWORD dwFlags) {
|
|
OUTPUT_STREAM_PROLOGUE;
|
|
return pStream->SetType(pmt, dwFlags);
|
|
}
|
|
STDMETHODIMP GetInputStatus(
|
|
ULONG ulInputStreamIndex,
|
|
DWORD *pdwStatus
|
|
) {
|
|
INPUT_STREAM_PROLOGUE;
|
|
return pStream->InputStatus(pdwStatus);
|
|
}
|
|
STDMETHODIMP GetInputMaxLatency(unsigned long ulInputStreamIndex, REFERENCE_TIME *prtLatency) {
|
|
// BUGBUG - I don't know what to do with this right now.
|
|
// Punt to the derived class ?
|
|
return E_NOTIMPL;
|
|
}
|
|
STDMETHODIMP SetInputMaxLatency(unsigned long ulInputStreamIndex, REFERENCE_TIME rtLatency) {
|
|
return E_NOTIMPL;
|
|
}
|
|
STDMETHODIMP ProcessInput(
|
|
DWORD ulInputStreamIndex,
|
|
IMediaBuffer *pBuffer, // [in], must not be NULL
|
|
DWORD dwFlags, // [in] - discontinuity, timestamp, etc.
|
|
REFERENCE_TIME rtTimestamp, // [in], valid if flag set
|
|
REFERENCE_TIME rtTimelength // [in], valid if flag set
|
|
) {
|
|
INPUT_STREAM_PROLOGUE;
|
|
return pStream->Deliver(pBuffer, dwFlags, rtTimestamp, rtTimelength);
|
|
}
|
|
STDMETHODIMP Discontinuity(ULONG ulInputStreamIndex) {
|
|
INPUT_STREAM_PROLOGUE;
|
|
return pStream->Discontinuity();
|
|
}
|
|
|
|
STDMETHODIMP Flush()
|
|
{
|
|
CDMOAutoLock l(&m_cs);
|
|
|
|
// Flush all the streams
|
|
ULONG i;
|
|
for (i = 0; i < m_nInputStreams; i++) {
|
|
m_pInputStreams[i].Flush();
|
|
}
|
|
for (i = 0; i < m_nOutputStreams; i++) {
|
|
m_pOutputStreams[i].Flush();
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP AllocateStreamingResources() {return S_OK;}
|
|
STDMETHODIMP FreeStreamingResources() {return S_OK;}
|
|
|
|
STDMETHODIMP GetStreamCount(unsigned long *pulNumberOfInputStreams, unsigned long *pulNumberOfOutputStreams)
|
|
{
|
|
CDMOAutoLock l(&m_cs);
|
|
if (pulNumberOfInputStreams == NULL ||
|
|
pulNumberOfOutputStreams == NULL) {
|
|
return E_POINTER;
|
|
}
|
|
*pulNumberOfInputStreams = m_nInputStreams;
|
|
*pulNumberOfOutputStreams = m_nOutputStreams;
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP ProcessOutput(
|
|
DWORD dwReserved,
|
|
DWORD ulOutputBufferCount,
|
|
DMO_OUTPUT_DATA_BUFFER *pOutputBuffers,
|
|
DWORD *pdwStatus)
|
|
{
|
|
CDMOAutoLock l(&m_cs);
|
|
if (ulOutputBufferCount != m_nOutputStreams)
|
|
return E_INVALIDARG;
|
|
|
|
HRESULT hr;
|
|
DWORD c;
|
|
|
|
// Prepare the input buffers
|
|
for (c = 0; c < m_nInputStreams; c++) {
|
|
// objects that hold buffers must implement Process themselves
|
|
assert(!m_pInputStreams[c].m_bHoldsBuffers);
|
|
hr = m_pInputStreams[c].PrepareInputBuffer(&m_pInputBuffers[c]);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Prepare the output buffers
|
|
//
|
|
for (c = 0; c < m_nOutputStreams; c++) {
|
|
hr = m_pOutputStreams[c].PrepareOutputBuffer(&m_pOutputBuffers[c], pOutputBuffers[c].pBuffer, m_bNewInput);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
}
|
|
|
|
hr = DoProcess(m_pInputBuffers,m_pOutputBuffers);
|
|
if (FAILED(hr))
|
|
return hr; // BUGBUG - don't just "return hr", do something !
|
|
|
|
// post-process input buffers
|
|
BOOL bSomeInputStillHasData = FALSE;
|
|
for (c = 0; c < m_nInputStreams; c++) {
|
|
if (m_pInputStreams[c].PostProcessInputBuffer(&m_pInputBuffers[c]))
|
|
bSomeInputStillHasData = TRUE;
|
|
}
|
|
|
|
// post-process output buffers
|
|
for (c = 0; c < m_nOutputStreams; c++) {
|
|
m_pOutputStreams[c].PostProcessOutputBuffer(&m_pOutputBuffers[c],
|
|
&pOutputBuffers[c],
|
|
bSomeInputStillHasData);
|
|
}
|
|
|
|
m_bNewInput = FALSE;
|
|
return NOERROR;
|
|
}
|
|
|
|
protected:
|
|
//
|
|
// These are called by the derived class at initialization time
|
|
//
|
|
HRESULT CreateInputStreams(INPUTSTREAMDESCRIPTOR *pStreams, DWORD cStreams) {
|
|
CDMOAutoLock l(&m_cs);
|
|
if (pStreams == NULL) {
|
|
return E_POINTER;
|
|
}
|
|
|
|
m_pInputStreams = new CInputStream[cStreams];
|
|
|
|
if (m_pInputStreams == NULL) {
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
DWORD c;
|
|
for (c = 0; c < cStreams; c++) {
|
|
HRESULT hr = m_pInputStreams[c].Init(&(pStreams[c]));
|
|
if (FAILED(hr)) {
|
|
delete[] m_pInputStreams;
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
m_pInputBuffers = new INPUTBUFFER[cStreams];
|
|
if (!m_pInputBuffers) {
|
|
delete[] m_pInputStreams;
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
m_nInputStreams = cStreams;
|
|
return NOERROR;
|
|
}
|
|
HRESULT CreateOutputStreams(OUTPUTSTREAMDESCRIPTOR *pStreams, DWORD cStreams) {
|
|
CDMOAutoLock l(&m_cs);
|
|
if (pStreams == NULL) {
|
|
return E_POINTER;
|
|
}
|
|
|
|
m_pOutputStreams = new COutputStream[cStreams];
|
|
|
|
if (m_pOutputStreams == NULL) {
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
DWORD c;
|
|
for (c = 0; c < cStreams; c++) {
|
|
HRESULT hr = m_pOutputStreams[c].Init(&(pStreams[c]));
|
|
if (FAILED(hr)) {
|
|
delete[] m_pOutputStreams;
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
m_pOutputBuffers = new OUTPUTBUFFER[cStreams];
|
|
if (!m_pOutputBuffers) {
|
|
delete[] m_pOutputStreams;
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
m_nOutputStreams = cStreams;
|
|
return NOERROR;
|
|
}
|
|
|
|
virtual HRESULT DoProcess(INPUTBUFFER*, OUTPUTBUFFER *) = 0;
|
|
|
|
private:
|
|
|
|
ULONG m_nInputStreams;
|
|
CInputStream* m_pInputStreams;
|
|
ULONG m_nOutputStreams;
|
|
COutputStream* m_pOutputStreams;
|
|
|
|
INPUTBUFFER* m_pInputBuffers;
|
|
OUTPUTBUFFER* m_pOutputBuffers;
|
|
|
|
BOOL m_bNewInput;
|
|
#ifdef DMO_NOATL
|
|
CRITICAL_SECTION m_cs;
|
|
#else
|
|
CComAutoCriticalSection m_cs;
|
|
#endif
|
|
};
|
|
|
|
#endif // __DMOBASE_H__
|