Filter组件开发中的SDK基类分析 分类: DirectX 2014-10-09 15:50 477人阅读 评论(0) 收藏

时间:2022-07-05 19:39:14

DirectShow SDK提供了一套开发Filter的基类源代码。基于这些基类开发Filter将大大简化开发过程。

1、CBaseObject

大部分SDK类都从CBaseObject类(参见combase.h)中继承而来的。

[cpp]  view plain copy
  1. class CBaseObject  
  2. {  
  3.   
  4. private:  
  5.   
  6.     // Disable the copy constructor and assignment by default so you will get  
  7.     //   compiler errors instead of unexpected behaviour if you pass objects  
  8.     //   by value or assign objects.  
  9.     CBaseObject(const CBaseObject& objectSrc);          // no implementation  
  10.     void operator=(const CBaseObject& objectSrc);       // no implementation  
  11.   
  12. private:  
  13.     static LONG m_cObjects;     /* Total number of objects active */  
  14.   
  15. protected:  
  16. #ifdef DEBUG  
  17.     DWORD m_dwCookie;           /* Cookie identifying this object */  
  18. #endif  
  19.   
  20.   
  21. public:  
  22.   
  23.     /* These increment and decrement the number of active objects */  
  24.   
  25.     CBaseObject(const TCHAR *pName);  
  26. #ifdef UNICODE  
  27.     CBaseObject(const char *pName);  
  28. #endif  
  29.     ~CBaseObject();  
  30.   
  31.     /* Call this to find if there are any CUnknown derived objects active */  
  32.   
  33.     static LONG ObjectsActive() {  
  34.         return m_cObjects;  
  35.     };  
  36. };  

2、 CUnknown

作为COM组件(参见combase.cpp文件),最基本的当然是IUnknown接口的实现。SDK提供了CUnknown类,SDK实现了COM接口类都是直接或间接从这个类继承来的。

[cpp]  view plain copy
  1. class AM_NOVTABLE CUnknown : public INonDelegatingUnknown,  
  2.                  public CBaseObject  
  3. {  
  4. private:  
  5.     const LPUNKNOWN m_pUnknown; /* Owner of this object */  
  6.   
  7. protected:                      /* So we can override NonDelegatingRelease() */  
  8.     volatile LONG m_cRef;       /* Number of reference counts */  
  9.   
  10. public:  
  11.   
  12.     CUnknown(const TCHAR *pName, LPUNKNOWN pUnk);  
  13.     virtual ~CUnknown() {};  
  14.   
  15.     // This is redundant, just use the other constructor  
  16.     //   as we never touch the HRESULT in this anyway  
  17.     CUnknown(TCHAR *pName, LPUNKNOWN pUnk,HRESULT *phr);  
  18. #ifdef UNICODE  
  19.     CUnknown(const char *pName, LPUNKNOWN pUnk);  
  20.     CUnknown(char *pName, LPUNKNOWN pUnk,HRESULT *phr);  
  21. #endif  
  22.   
  23.     /* Return the owner of this object */  
  24.   
  25.     LPUNKNOWN GetOwner() const {  
  26.         return m_pUnknown;  
  27.     };  
  28.   
  29.     /* Called from the class factory to create a new instance, it is 
  30.        pure virtual so it must be overriden in your derived class */  
  31.   
  32.     /* static CUnknown *CreateInstance(LPUNKNOWN, HRESULT *) */  
  33.   
  34.     /* Non delegating unknown implementation */  
  35.   
  36.     STDMETHODIMP NonDelegatingQueryInterface(REFIID, void **);  
  37.     STDMETHODIMP_(ULONG) NonDelegatingAddRef();  
  38.     STDMETHODIMP_(ULONG) NonDelegatingRelease();  
  39. };  

CUnknown类从CBaseObject中继承而来,另外CUnknown类还实现了INonDelegatingUnknown接口,用于支持引用计数、接口查询、COM组件“聚合”等。

Filter组件开发中的SDK基类分析 分类: DirectX 2014-10-09 15:50 477人阅读 评论(0) 收藏

CUnknown类的使用方法如下:

(1) 从CUnknown派生一个子类,并在子类的public区加入DECLARE_IUNKNOWN宏;

(2) 重写NonDelegatingQueryInterface函数,用以支持IUnknown外的其他接口;

(3) 在子类的构造函数中调用CUnknown的构造函数。

eg:

[cpp]  view plain copy
  1. class CSeekingPassThru : public ISeekingPassThru, public CUnknown  
  2. {  
  3. public:  
  4.     static CUnknown *CreateInstance(LPUNKNOWN pUnk, HRESULT *phr);  
  5.     CSeekingPassThru(TCHAR *pName, LPUNKNOWN pUnk, HRESULT *phr);  
  6.     ~CSeekingPassThru();  
  7.   
  8.     DECLARE_IUNKNOWN;  
  9.     STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void ** ppv);  
  10.   
  11.     STDMETHODIMP Init(BOOL bSupportRendering, IPin *pPin);  
  12.   
  13. private:  
  14.     CPosPassThru              *m_pPosPassThru;  
  15. };  


 

[cpp]  view plain copy
  1. CSeekingPassThru::CSeekingPassThru( TCHAR *pName, LPUNKNOWN pUnk, HRESULT *phr )  
  2.                             : CUnknown(pName, pUnk, phr),  
  3.                             m_pPosPassThru(NULL)  
  4. {  
  5. }  

3、 CBaseFilter

最基本的Filter由CBaseFilter 类(参见amfilter.cpp)实现。

作为Filter的基本特征,CBaseFilter实现了IBaseFilter接口(IbaseFilter从IMediaFilter继承而来)。

同时CBaseFilter还实现了Filter框架(描述了各个Pin组件的情况)。

Filter组件开发中的SDK基类分析 分类: DirectX 2014-10-09 15:50 477人阅读 评论(0) 收藏

[cpp]  view plain copy
  1. class AM_NOVTABLE CBaseFilter : public CUnknown,        // Handles an IUnknown  
  2.                     public IBaseFilter,     // The Filter Interface  
  3.                     public IAMovieSetup     // For un/registration  
  4. {  
  5.   
  6. friend class CBasePin;  
  7.   
  8. protected:  
  9.     FILTER_STATE    m_State;            // current state: running, paused  
  10.     IReferenceClock *m_pClock;          // this graph's ref clock  
  11.     CRefTime        m_tStart;           // offset from stream time to reference time  
  12.     CLSID       m_clsid;            // This filters clsid  
  13.                                         // used for serialization  
  14.     CCritSec        *m_pLock;           // Object we use for locking  
  15.   
  16.     WCHAR           *m_pName;           // Full filter name  
  17.     IFilterGraph    *m_pGraph;          // Graph we belong to  
  18.     IMediaEventSink *m_pSink;           // Called with notify events  
  19.     LONG            m_PinVersion;       // Current pin version  
  20.   
  21. public:  
  22.   
  23.     CBaseFilter(  
  24.         const TCHAR *pName,     // Object description  
  25.         LPUNKNOWN pUnk,         // IUnknown of delegating object  
  26.         CCritSec  *pLock,       // Object who maintains lock  
  27.     REFCLSID   clsid);      // The clsid to be used to serialize this filter  
  28.   
  29.     CBaseFilter(  
  30.         TCHAR     *pName,       // Object description  
  31.         LPUNKNOWN pUnk,         // IUnknown of delegating object  
  32.         CCritSec  *pLock,       // Object who maintains lock  
  33.     REFCLSID   clsid,       // The clsid to be used to serialize this filter  
  34.         HRESULT   *phr);        // General OLE return code  
  35. #ifdef UNICODE  
  36.     CBaseFilter(  
  37.         const CHAR *pName,     // Object description  
  38.         LPUNKNOWN pUnk,         // IUnknown of delegating object  
  39.         CCritSec  *pLock,       // Object who maintains lock  
  40.     REFCLSID   clsid);      // The clsid to be used to serialize this filter  
  41.   
  42.     CBaseFilter(  
  43.         CHAR     *pName,       // Object description  
  44.         LPUNKNOWN pUnk,         // IUnknown of delegating object  
  45.         CCritSec  *pLock,       // Object who maintains lock  
  46.     REFCLSID   clsid,       // The clsid to be used to serialize this filter  
  47.         HRESULT   *phr);        // General OLE return code  
  48. #endif  
  49.     ~CBaseFilter();  
  50.   
  51.     DECLARE_IUNKNOWN  
  52.   
  53.     // override this to say what interfaces we support where  
  54.     STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void ** ppv);  
  55. #ifdef DEBUG  
  56.     STDMETHODIMP_(ULONG) NonDelegatingRelease();  
  57. #endif  
  58.   
  59.     //  
  60.     // --- IPersist method ---  
  61.     //  
  62.   
  63.     STDMETHODIMP GetClassID(CLSID *pClsID);  
  64.   
  65.     // --- IMediaFilter methods ---  
  66.   
  67.     STDMETHODIMP GetState(DWORD dwMSecs, FILTER_STATE *State);  
  68.   
  69.     STDMETHODIMP SetSyncSource(IReferenceClock *pClock);  
  70.   
  71.     STDMETHODIMP GetSyncSource(IReferenceClock **pClock);  
  72.   
  73.   
  74.     // override Stop and Pause so we can activate the pins.  
  75.     // Note that Run will call Pause first if activation needed.  
  76.     // Override these if you want to activate your filter rather than  
  77.     // your pins.  
  78.     STDMETHODIMP Stop();  
  79.     STDMETHODIMP Pause();  
  80.   
  81.     // the start parameter is the difference to be added to the  
  82.     // sample's stream time to get the reference time for  
  83.     // its presentation  
  84.     STDMETHODIMP Run(REFERENCE_TIME tStart);  
  85.   
  86.     // --- helper methods ---  
  87.   
  88.     // return the current stream time - ie find out what  
  89.     // stream time should be appearing now  
  90.     virtual HRESULT StreamTime(CRefTime& rtStream);  
  91.   
  92.     // Is the filter currently active?  
  93.     BOOL IsActive() {  
  94.         CAutoLock cObjectLock(m_pLock);  
  95.         return ((m_State == State_Paused) || (m_State == State_Running));  
  96.     };  
  97.   
  98.     // Is this filter stopped (without locking)  
  99.     BOOL IsStopped() {  
  100.         return (m_State == State_Stopped);  
  101.     };  
  102.   
  103.     //  
  104.     // --- IBaseFilter methods ---  
  105.     //  
  106.   
  107.     // pin enumerator  
  108.     STDMETHODIMP EnumPins(  
  109.                     IEnumPins ** ppEnum);  
  110.   
  111.   
  112.     // default behaviour of FindPin assumes pin ids are their names  
  113.     STDMETHODIMP FindPin(  
  114.         LPCWSTR Id,  
  115.         IPin ** ppPin  
  116.     );  
  117.   
  118.     STDMETHODIMP QueryFilterInfo(  
  119.                     FILTER_INFO * pInfo);  
  120.   
  121.     STDMETHODIMP JoinFilterGraph(  
  122.                     IFilterGraph * pGraph,  
  123.                     LPCWSTR pName);  
  124.   
  125.     // return a Vendor information string. Optional - may return E_NOTIMPL.  
  126.     // memory returned should be freed using CoTaskMemFree  
  127.     // default implementation returns E_NOTIMPL  
  128.     STDMETHODIMP QueryVendorInfo(  
  129.                     LPWSTR* pVendorInfo  
  130.             );  
  131.   
  132.     // --- helper methods ---  
  133.   
  134.     // send an event notification to the filter graph if we know about it.  
  135.     // returns S_OK if delivered, S_FALSE if the filter graph does not sink  
  136.     // events, or an error otherwise.  
  137.     HRESULT NotifyEvent(  
  138.         long EventCode,  
  139.         LONG_PTR EventParam1,  
  140.         LONG_PTR EventParam2);  
  141.   
  142.     // return the filter graph we belong to  
  143.     IFilterGraph *GetFilterGraph() {  
  144.         return m_pGraph;  
  145.     }  
  146.   
  147.     // Request reconnect  
  148.     // pPin is the pin to reconnect  
  149.     // pmt is the type to reconnect with - can be NULL  
  150.     // Calls ReconnectEx on the filter graph  
  151.     HRESULT ReconnectPin(IPin *pPin, AM_MEDIA_TYPE const *pmt);  
  152.   
  153.     // find out the current pin version (used by enumerators)  
  154.     virtual LONG GetPinVersion();  
  155.     void IncrementPinVersion();  
  156.   
  157.     // you need to supply these to access the pins from the enumerator  
  158.     // and for default Stop and Pause/Run activation.  
  159.     virtual int GetPinCount() PURE;  
  160.     virtual CBasePin *GetPin(int n) PURE;  
  161.   
  162.     // --- IAMovieSetup methods ---  
  163.   
  164.     STDMETHODIMP Register();    // ask filter to register itself  
  165.     STDMETHODIMP Unregister();  // and unregister itself  
  166.   
  167.     // --- setup helper methods ---  
  168.     // (override to return filters setup data)  
  169.   
  170.     virtual LPAMOVIESETUP_FILTER GetSetupData(){ return NULL; }  
  171.   
  172. };  


CBaseFilter类的使用方法如下:

(1) 声明一个新类是从CBaseFilter中继承而来;

(2) 在新类中定义Filter上的Pin的实例(Pin从CBasePin类继承而来);

(3) 实现纯虚函数CBaseFilter::GetPin,用于返回Filter上各个Pin的对象指针;

(4) 实现纯虚函数CBaseFilter::GetPinCount,用于返回Filter上Pin 的数量;

(5) 考虑如何处理从输入Pin进来的Sample数据。

eg:

[cpp]  view plain copy
  1. //  
  2. // The filter object itself. Supports IBaseFilter through  
  3. // CBaseFilter and also IFileSourceFilter directly in this object  
  4. // CAsyncReader类实现了一个Filter,它从CBaseFilter派生,实现了仅含一个输出  
  5. // Pin(CAsyncOutputPin类的实例)的Source filter框架。  
  6. class CAsyncReader : public CBaseFilter  
  7. {  
  8.   
  9. protected:  
  10.     // filter-wide lock  
  11.     CCritSec m_csFilter;  
  12.   
  13.     // all i/o done here  
  14.     CAsyncIo m_Io;  
  15.   
  16.     // (2)在新类中定义Filter上的Pin的实例(Pin从CBasePin类继承而来);  
  17.     // our output pin  
  18.     CAsyncOutputPin m_OutputPin;  
  19.   
  20.     // Type we think our data is  
  21.     CMediaType m_mt;  
  22.   
  23. public:  
  24.           
  25.     // construction / destruction  
  26.   
  27.     CAsyncReader(  
  28.         TCHAR *pName,  
  29.         LPUNKNOWN pUnk,  
  30.         CAsyncStream *pStream, // 它是Filter获取数据的源  
  31.         HRESULT *phr);  
  32.   
  33.     ~CAsyncReader();  
  34.   
  35.   
  36.     //(3) 实现纯虚函数CBaseFilter::GetPin,用于返回Filter上各个Pin的对象指针;  
  37.     //(4) 实现纯虚函数CBaseFilter::GetPinCount,用于返回Filter上Pin 的数量;  
  38.     int GetPinCount();  
  39.     CBasePin *GetPin(int n);  
  40.   
  41.     // --- Access our media type  
  42.     const CMediaType *LoadType() const  
  43.     {  
  44.         return &m_mt;  
  45.     }  
  46.   
  47.     virtual HRESULT Connect(  
  48.         IPin * pReceivePin,  
  49.         const AM_MEDIA_TYPE *pmt   // optional media type  
  50.     )  
  51.     {  
  52.         return m_OutputPin.CBasePin::Connect(pReceivePin, pmt);  
  53.     }  
  54. };  


还有SDK类的CSource、CBaseRenderer、 CTracsformFilter都是从CBaseFilter继承来的,实现开发Filter时,

使用这些子类作为Filter类。

4、CBasePin

Filter  上最基本的Pin由CBasePin类(参见 amfilter.h)实现。

作为Pin的基本特征,CBasePin实现了IPin接口。CBasePin设计了Pin 的整个连接过程。

另外,这个类还实现了IQualityControl接口,该接口用于质量控制

[cpp]  view plain copy
  1. class  AM_NOVTABLE CBasePin : public CUnknown, public IPin, public IQualityControl  
  2. {  
  3.   
  4. protected:  
  5.   
  6.     WCHAR *         m_pName;                // This pin's name  
  7.     IPin            *m_Connected;               // Pin we have connected to  
  8.     PIN_DIRECTION   m_dir;                      // Direction of this pin  
  9.     CCritSec        *m_pLock;                   // Object we use for locking  
  10.     bool            m_bRunTimeError;            // Run time error generated  
  11.     bool            m_bCanReconnectWhenActive;  // OK to reconnect when active  
  12.     bool            m_bTryMyTypesFirst;         // When connecting enumerate  
  13.                                                 // this pin's types first  
  14.     CBaseFilter    *m_pFilter;                  // Filter we were created by  
  15.     IQualityControl *m_pQSink;                  // Target for Quality messages  
  16.     LONG            m_TypeVersion;              // Holds current type version  
  17.     CMediaType      m_mt;                       // Media type of connection  
  18.   
  19.     CRefTime        m_tStart;                   // time from NewSegment call  
  20.     CRefTime        m_tStop;                    // time from NewSegment  
  21.     double          m_dRate;                    // rate from NewSegment  
  22.   
  23. #ifdef DEBUG  
  24.     LONG            m_cRef;                     // Ref count tracing  
  25. #endif  
  26.   
  27.     // displays pin connection information  
  28.   
  29. #ifdef DEBUG  
  30.     void DisplayPinInfo(IPin *pReceivePin);  
  31.     void DisplayTypeInfo(IPin *pPin, const CMediaType *pmt);  
  32. #else  
  33.     void DisplayPinInfo(IPin *pReceivePin) {};  
  34.     void DisplayTypeInfo(IPin *pPin, const CMediaType *pmt) {};  
  35. #endif  
  36.   
  37.     // used to agree a media type for a pin connection  
  38.   
  39.     // given a specific media type, attempt a connection (includes  
  40.     // checking that the type is acceptable to this pin)  
  41.     HRESULT  
  42.     AttemptConnection(  
  43.         IPin* pReceivePin,      // connect to this pin  
  44.         const CMediaType* pmt   // using this type  
  45.     );  
  46.   
  47.     // try all the media types in this enumerator - for each that  
  48.     // we accept, try to connect using ReceiveConnection.  
  49.     HRESULT TryMediaTypes(  
  50.                         IPin *pReceivePin,      // connect to this pin  
  51.                         const CMediaType *pmt,        // proposed type from Connect  
  52.                         IEnumMediaTypes *pEnum);    // try this enumerator  
  53.   
  54.     // establish a connection with a suitable mediatype. Needs to  
  55.     // propose a media type if the pmt pointer is null or partially  
  56.     // specified - use TryMediaTypes on both our and then the other pin's  
  57.     // enumerator until we find one that works.  
  58.     HRESULT AgreeMediaType(  
  59.                         IPin *pReceivePin,      // connect to this pin  
  60.                         const CMediaType *pmt);       // proposed type from Connect  
  61.   
  62. public:  
  63.   
  64.     CBasePin(  
  65.         TCHAR *pObjectName,         // Object description  
  66.         CBaseFilter *pFilter,       // Owning filter who knows about pins  
  67.         CCritSec *pLock,            // Object who implements the lock  
  68.         HRESULT *phr,               // General OLE return code  
  69.         LPCWSTR pName,              // Pin name for us  
  70.         PIN_DIRECTION dir);         // Either PINDIR_INPUT or PINDIR_OUTPUT  
  71. #ifdef UNICODE  
  72.     CBasePin(  
  73.         CHAR *pObjectName,         // Object description  
  74.         CBaseFilter *pFilter,       // Owning filter who knows about pins  
  75.         CCritSec *pLock,            // Object who implements the lock  
  76.         HRESULT *phr,               // General OLE return code  
  77.         LPCWSTR pName,              // Pin name for us  
  78.         PIN_DIRECTION dir);         // Either PINDIR_INPUT or PINDIR_OUTPUT  
  79. #endif  
  80.     virtual ~CBasePin();  
  81.   
  82.     DECLARE_IUNKNOWN  
  83.   
  84.     STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void ** ppv);  
  85.     STDMETHODIMP_(ULONG) NonDelegatingRelease();  
  86.     STDMETHODIMP_(ULONG) NonDelegatingAddRef();  
  87.   
  88.     // --- IPin methods ---  
  89.   
  90.     // take lead role in establishing a connection. Media type pointer  
  91.     // may be null, or may point to partially-specified mediatype  
  92.     // (subtype or format type may be GUID_NULL).  
  93.     STDMETHODIMP Connect(  
  94.         IPin * pReceivePin,  
  95.         const AM_MEDIA_TYPE *pmt   // optional media type  
  96.     );  
  97.   
  98.     // (passive) accept a connection from another pin  
  99.     STDMETHODIMP ReceiveConnection(  
  100.         IPin * pConnector,      // this is the initiating connecting pin  
  101.         const AM_MEDIA_TYPE *pmt   // this is the media type we will exchange  
  102.     );  
  103.   
  104.     STDMETHODIMP Disconnect();  
  105.   
  106.     STDMETHODIMP ConnectedTo(IPin **pPin);  
  107.   
  108.     STDMETHODIMP ConnectionMediaType(AM_MEDIA_TYPE *pmt);  
  109.   
  110.     STDMETHODIMP QueryPinInfo(  
  111.         PIN_INFO * pInfo  
  112.     );  
  113.   
  114.     STDMETHODIMP QueryDirection(  
  115.         PIN_DIRECTION * pPinDir  
  116.     );  
  117.   
  118.     STDMETHODIMP QueryId(  
  119.         LPWSTR * Id  
  120.     );  
  121.   
  122.     // does the pin support this media type  
  123.     STDMETHODIMP QueryAccept(  
  124.         const AM_MEDIA_TYPE *pmt  
  125.     );  
  126.   
  127.     // return an enumerator for this pins preferred media types  
  128.     STDMETHODIMP EnumMediaTypes(  
  129.         IEnumMediaTypes **ppEnum  
  130.     );  
  131.   
  132.     // return an array of IPin* - the pins that this pin internally connects to  
  133.     // All pins put in the array must be AddReffed (but no others)  
  134.     // Errors: "Can't say" - FAIL, not enough slots - return S_FALSE  
  135.     // Default: return E_NOTIMPL  
  136.     // The filter graph will interpret NOT_IMPL as any input pin connects to  
  137.     // all visible output pins and vice versa.  
  138.     // apPin can be NULL if nPin==0 (not otherwise).  
  139.     STDMETHODIMP QueryInternalConnections(  
  140.         IPin* *apPin,     // array of IPin*  
  141.         ULONG *nPin       // on input, the number of slots  
  142.                           // on output  the number of pins  
  143.     ) { return E_NOTIMPL; }  
  144.   
  145.     // Called when no more data will be sent  
  146.     STDMETHODIMP EndOfStream(void);  
  147.   
  148.     // Begin/EndFlush still PURE  
  149.   
  150.     // NewSegment notifies of the start/stop/rate applying to the data  
  151.     // about to be received. Default implementation records data and  
  152.     // returns S_OK.  
  153.     // Override this to pass downstream.  
  154.     STDMETHODIMP NewSegment(  
  155.                     REFERENCE_TIME tStart,  
  156.                     REFERENCE_TIME tStop,  
  157.                     double dRate);  
  158.   
  159.     //================================================================================  
  160.     // IQualityControl methods  
  161.     //================================================================================  
  162.   
  163.     STDMETHODIMP Notify(IBaseFilter * pSender, Quality q);  
  164.   
  165.     STDMETHODIMP SetSink(IQualityControl * piqc);  
  166.   
  167.     // --- helper methods ---  
  168.   
  169.     // Returns true if the pin is connected. false otherwise.  
  170.     BOOL IsConnected(void) {return (m_Connected != NULL); };  
  171.     // Return the pin this is connected to (if any)  
  172.     IPin * GetConnected() { return m_Connected; };  
  173.   
  174.     // Check if our filter is currently stopped  
  175.     BOOL IsStopped() {  
  176.         return (m_pFilter->m_State == State_Stopped);  
  177.     };  
  178.   
  179.     // find out the current type version (used by enumerators)  
  180.     virtual LONG GetMediaTypeVersion();  
  181.     void IncrementTypeVersion();  
  182.   
  183.     // switch the pin to active (paused or running) mode  
  184.     // not an error to call this if already active  
  185.     virtual HRESULT Active(void);  
  186.   
  187.     // switch the pin to inactive state - may already be inactive  
  188.     virtual HRESULT Inactive(void);  
  189.   
  190.     // Notify of Run() from filter  
  191.     virtual HRESULT Run(REFERENCE_TIME tStart);  
  192.   
  193.     // check if the pin can support this specific proposed type and format  
  194.     virtual HRESULT CheckMediaType(const CMediaType *) PURE;  
  195.   
  196.     // set the connection to use this format (previously agreed)  
  197.     virtual HRESULT SetMediaType(const CMediaType *);  
  198.   
  199.     // check that the connection is ok before verifying it  
  200.     // can be overridden eg to check what interfaces will be supported.  
  201.     virtual HRESULT CheckConnect(IPin *);  
  202.   
  203.     // Set and release resources required for a connection  
  204.     virtual HRESULT BreakConnect();  
  205.     virtual HRESULT CompleteConnect(IPin *pReceivePin);  
  206.   
  207.     // returns the preferred formats for a pin  
  208.     virtual HRESULT GetMediaType(int iPosition,CMediaType *pMediaType);  
  209.   
  210.     // access to NewSegment values  
  211.     REFERENCE_TIME CurrentStopTime() {  
  212.         return m_tStop;  
  213.     }  
  214.     REFERENCE_TIME CurrentStartTime() {  
  215.         return m_tStart;  
  216.     }  
  217.     double CurrentRate() {  
  218.         return m_dRate;  
  219.     }  
  220.   
  221.     //  Access name  
  222.     LPWSTR Name() { return m_pName; };  
  223.   
  224.     //  Can reconnectwhen active?  
  225.     void SetReconnectWhenActive(bool bCanReconnect)  
  226.     {  
  227.         m_bCanReconnectWhenActive = bCanReconnect;  
  228.     }  
  229.   
  230.     bool CanReconnectWhenActive()  
  231.     {  
  232.         return m_bCanReconnectWhenActive;  
  233.     }  
  234.   
  235. protected:  
  236.     STDMETHODIMP DisconnectInternal();  
  237. };  


在CBasePin实现的成员函数中,有3个与Filter的状态转换相对应

[cpp]  view plain copy
  1. // 转换pin到活动状态(暂停或运行)  
  2.   // not an error to call this if already active  
  3.   virtual HRESULT Active(void);  
  4.   
  5.   // 转换pin到不活动状态 - 可能已经处于非活动状态  
  6.   virtual HRESULT Inactive(void);  
  7.   
  8.   // 通知运行filter 的 Run()  
  9.   virtual HRESULT Run(REFERENCE_TIME tStart);  


 

我们来看一下Filter的Stop的实现,实际上就是调用Filter的所有pin的Inactive函数

[cpp]  view plain copy
  1. STDMETHODIMP  
  2. CBaseFilter::Stop()  
  3. {  
  4.     CAutoLock cObjectLock(m_pLock);  
  5.     HRESULT hr = NOERROR;  
  6.   
  7.     // 通知所有pin改变状态  
  8.     if (m_State != State_Stopped) {  
  9.         int cPins = GetPinCount();  
  10.         for (int c = 0; c < cPins; c++) {  
  11.   
  12.             CBasePin *pPin = GetPin(c);  
  13.   
  14.             // Disconnected pins are not activated - this saves pins worrying  
  15.             // about this state themselves. We ignore the return code to make  
  16.             // sure everyone is inactivated regardless. The base input pin  
  17.             // class can return an error if it has no allocator but Stop can  
  18.             // be used to resync the graph state after something has gone bad  
  19.             // 仅在完成连接的pin上调用Inactive函数  
  20.             // 如果Inactive函数返回一个错误值,则暂时忽略,  
  21.             // 以便所有Pin都有机会被调用Inactive  
  22.             if (pPin->IsConnected()) {  
  23.                 HRESULT hrTmp = pPin->Inactive();  
  24.                 if (FAILED(hrTmp) && SUCCEEDED(hr)) {  
  25.                     hr = hrTmp;  
  26.                 }  
  27.             }  
  28.         }  
  29.     }  
  30.   
  31.   
  32.     m_State = State_Stopped;  
  33.     return hr;  
  34. }  

 

在实际开发Filter的过程中,很有可能重写CBasePin::Inactive、 CBasePin::Active和CBasePin::Run这3个函数,以进行必要的初始化、释放资源等。

CBasePin类的使用方法如下:

(1) 从CBasePin派生一个子类;

(2) 实现纯虚函数CBasePIn::CheckMediaType,进行Pin连接时的媒体类型检查;

(3) 实现纯虚函数CBasePin::GetMediaType,提供Pin上的首选媒体类型。

(4) 实现IPin::BeginFlush和IPin::EndFlush两个函数。

(5) 可能需要重写的函数包括

CBasePin::Active()  实现资源分配

CBasePin::Inactive  实现资源释放

CBasePin::Run  在Filter运行前进行一些初始化

CBasePin::CheckConnect  连接时检查,如查询对方Pin上是否支持某个特殊接口

CBasePin::BreakConnect 断开连接,并进行必要的资源释放

CBasePin::CompleteConnect  完成连接时被调用,可以在这个函数中获得当前连接的媒体类型参数

CBasePin::EndOfStream 当上流数据全部传送完毕后被调用。

                    如果这个是Transform Filter,则将EndOfStream继续入下传送;

                   如果是Renderer Filter,需要向Filter Graph Manager发送一个EC_COMPLETE事件

CBasePin::Noftify  直接响应质量控制。

eg:

[cpp]  view plain copy
  1. // CAsyncOutputPin实现了一个输出Pin  
  2. // 继承自IAsyncReader、CBasePin,这是对拉模式的Source Filter的基本要求  
  3. /* IAsyncReader接口方法及描述如下: 
  4. BeginFlush  放弃所有正在进行的数据读取 
  5. EndFlush    与BeginFlush配对,标示Flush过程结束 
  6. Length      得到数据总长度和当前可以读取的长度 
  7. RequestAlloctor 要求一个输入Pin上的Sample管理器 
  8. Request     发出一个数据请求 
  9. SyncReadAligned 同步读取数据(边界对齐) 
  10. SyncRead    同步读取数据 
  11. WaitForNext 等待一个请求的完成 
  12. ====================================================================== 
  13. 可以看出CAsyOutputPin类上实现的IAsyncReader的各个接口方法,都“委托” 
  14. 给了CAsyncIo类对象的同名成员函数 
  15. */  
  16. class CAsyncOutputPin  
  17.   : public IAsyncReader,   
  18.     public CBasePin  
  19. {  
  20. protected:  
  21.     CAsyncReader* m_pReader;  
  22.     CAsyncIo * m_pIo;  
  23.   
  24.     //  This is set every time we're asked to return an IAsyncReader  
  25.     //  interface  
  26.     //  This allows us to know if the downstream pin can use  
  27.     //  this transport, otherwise we can hook up to thinks like the  
  28.     //  dump filter and nothing happens  
  29.     BOOL         m_bQueriedForAsyncReader;  
  30.   
  31.     HRESULT InitAllocator(IMemAllocator **ppAlloc);  
  32.   
  33. public:  
  34.     // constructor and destructor  
  35.     CAsyncOutputPin(  
  36.         HRESULT * phr,  
  37.         CAsyncReader *pReader,  
  38.         CAsyncIo *pIo,  
  39.         CCritSec * pLock);  
  40.   
  41.     ~CAsyncOutputPin();  
  42.   
  43.     // --- CUnknown ---  
  44.   
  45.     // need to expose IAsyncReader  
  46.     DECLARE_IUNKNOWN  
  47.     STDMETHODIMP NonDelegatingQueryInterface(REFIID, void**);  
  48.   
  49.     // --- IPin methods ---  
  50.     STDMETHODIMP Connect(  
  51.         IPin * pReceivePin,  
  52.         const AM_MEDIA_TYPE *pmt   // optional media type  
  53.     );  
  54.   
  55.     // --- CBasePin methods ---  
  56.   
  57.     // return the types we prefer - this will return the known  
  58.     // file type  
  59.     HRESULT GetMediaType(int iPosition, CMediaType *pMediaType);  
  60.   
  61.     // can we support this type?  
  62.     HRESULT CheckMediaType(const CMediaType* pType);  
  63.   
  64.     // Clear the flag so we see if IAsyncReader is queried for  
  65.     HRESULT CheckConnect(IPin *pPin)  
  66.     {  
  67.         m_bQueriedForAsyncReader = FALSE;  
  68.         return CBasePin::CheckConnect(pPin);  
  69.     }  
  70.   
  71.     // See if it was asked for  
  72.     HRESULT CompleteConnect(IPin *pReceivePin)  
  73.     {  
  74.         if (m_bQueriedForAsyncReader) {  
  75.             return CBasePin::CompleteConnect(pReceivePin);  
  76.         } else {  
  77.   
  78. #ifdef VFW_E_NO_TRANSPORT  
  79.             return VFW_E_NO_TRANSPORT;  
  80. #else  
  81.             return E_FAIL;  
  82. #endif  
  83.         }  
  84.     }  
  85.   
  86.     //  Remove our connection status  
  87.     HRESULT BreakConnect()  
  88.     {  
  89.         m_bQueriedForAsyncReader = FALSE;  
  90.         return CBasePin::BreakConnect();  
  91.     }  
  92.   
  93.     // --- IAsyncReader methods ---  
  94.     // pass in your preferred allocator and your preferred properties.  
  95.     // method returns the actual allocator to be used. Call GetProperties  
  96.     // on returned allocator to learn alignment and prefix etc chosen.  
  97.     // this allocator will be not be committed and decommitted by  
  98.     // the async reader, only by the consumer.  
  99.     STDMETHODIMP RequestAllocator(  
  100.                       IMemAllocator* pPreferred,  
  101.                       ALLOCATOR_PROPERTIES* pProps,  
  102.                       IMemAllocator ** ppActual);  
  103.   
  104.     // queue a request for data.  
  105.     // media sample start and stop times contain the requested absolute  
  106.     // byte position (start inclusive, stop exclusive).  
  107.     // may fail if sample not obtained from agreed allocator.  
  108.     // may fail if start/stop position does not match agreed alignment.  
  109.     // samples allocated from source pin's allocator may fail  
  110.     // GetPointer until after returning from WaitForNext.  
  111.     STDMETHODIMP Request(  
  112.                      IMediaSample* pSample,  
  113.                      DWORD_PTR dwUser);         // user context  
  114.   
  115.     // block until the next sample is completed or the timeout occurs.  
  116.     // timeout (millisecs) may be 0 or INFINITE. Samples may not  
  117.     // be delivered in order. If there is a read error of any sort, a  
  118.     // notification will already have been sent by the source filter,  
  119.     // and STDMETHODIMP will be an error.  
  120.     STDMETHODIMP WaitForNext(  
  121.                       DWORD dwTimeout,  
  122.                       IMediaSample** ppSample,  // completed sample  
  123.                       DWORD_PTR * pdwUser);     // user context  
  124.   
  125.     // sync read of data. Sample passed in must have been acquired from  
  126.     // the agreed allocator. Start and stop position must be aligned.  
  127.     // equivalent to a Request/WaitForNext pair, but may avoid the  
  128.     // need for a thread on the source filter.  
  129.     STDMETHODIMP SyncReadAligned(  
  130.                       IMediaSample* pSample);  
  131.   
  132.   
  133.     // sync read. works in stopped state as well as run state.  
  134.     // need not be aligned. Will fail if read is beyond actual total  
  135.     // length.  
  136.     STDMETHODIMP SyncRead(  
  137.                       LONGLONG llPosition,  // absolute file position  
  138.                       LONG lLength,         // nr bytes required  
  139.                       BYTE* pBuffer);       // write data here  
  140.   
  141.     // return total length of stream, and currently available length.  
  142.     // reads for beyond the available length but within the total length will  
  143.     // normally succeed but may block for a long period.  
  144.     STDMETHODIMP Length(  
  145.                       LONGLONG* pTotal,  
  146.                       LONGLONG* pAvailable);  
  147.   
  148.     // cause all outstanding reads to return, possibly with a failure code  
  149.     // (VFW_E_TIMEOUT) indicating they were cancelled.  
  150.     // these are defined on IAsyncReader and IPin  
  151.     STDMETHODIMP BeginFlush(void);  
  152.     STDMETHODIMP EndFlush(void);  
  153.   
  154. };  

5、 CBaseInputPin和CBaseOutputPin

 从CBasePin类派生的,也是很基本的输入或输出pin。

它们的实现可参见 amfilter.cpp

CBaseInputPin实现了IMemInputPin(用于推模式的数据传送),

CBaseOutputPin主要完成了传送数据所使用的Sample管理器(Allocator)的协商,并重写了CBasePin::Active(用于实际的Sample内存分配)

以及CBasePin::Inactive(用于Sample内存的释放)

Filter组件开发中的SDK基类分析 分类: DirectX 2014-10-09 15:50 477人阅读 评论(0) 收藏

[cpp]  view plain copy
  1. class AM_NOVTABLE CBaseInputPin : public CBasePin,  
  2.                                   public IMemInputPin  
  3. {  
  4.   
  5. protected:  
  6.   
  7.     IMemAllocator *m_pAllocator;    // Default memory allocator  
  8.   
  9.     // allocator is read-only, so received samples  
  10.     // cannot be modified (probably only relevant to in-place  
  11.     // transforms  
  12.     BYTE m_bReadOnly;  
  13.   
  14.     // in flushing state (between BeginFlush and EndFlush)  
  15.     // if TRUE, all Receives are returned with S_FALSE  
  16.     BYTE m_bFlushing;  
  17.   
  18.     // Sample properties - initalized in Receive  
  19.     AM_SAMPLE2_PROPERTIES m_SampleProps;  
  20.   
  21. public:  
  22.   
  23.     CBaseInputPin(  
  24.         TCHAR *pObjectName,  
  25.         CBaseFilter *pFilter,  
  26.         CCritSec *pLock,  
  27.         HRESULT *phr,  
  28.         LPCWSTR pName);  
  29. #ifdef UNICODE  
  30.     CBaseInputPin(  
  31.         CHAR *pObjectName,  
  32.         CBaseFilter *pFilter,  
  33.         CCritSec *pLock,  
  34.         HRESULT *phr,  
  35.         LPCWSTR pName);  
  36. #endif  
  37.     virtual ~CBaseInputPin();  
  38.   
  39.     DECLARE_IUNKNOWN  
  40.   
  41.     // override this to publicise our interfaces  
  42.     STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void **ppv);  
  43.   
  44.     // return the allocator interface that this input pin  
  45.     // would like the output pin to use  
  46.     STDMETHODIMP GetAllocator(IMemAllocator ** ppAllocator);  
  47.   
  48.     // tell the input pin which allocator the output pin is actually  
  49.     // going to use.  
  50.     STDMETHODIMP NotifyAllocator(  
  51.                     IMemAllocator * pAllocator,  
  52.                     BOOL bReadOnly);  
  53.   
  54.     // do something with this media sample  
  55.     STDMETHODIMP Receive(IMediaSample *pSample);  
  56.   
  57.     // do something with these media samples  
  58.     STDMETHODIMP ReceiveMultiple (  
  59.         IMediaSample **pSamples,  
  60.         long nSamples,  
  61.         long *nSamplesProcessed);  
  62.   
  63.     // See if Receive() blocks  
  64.     STDMETHODIMP ReceiveCanBlock();  
  65.   
  66.     // Default handling for BeginFlush - call at the beginning  
  67.     // of your implementation (makes sure that all Receive calls  
  68.     // fail). After calling this, you need to free any queued data  
  69.     // and then call downstream.  
  70.     STDMETHODIMP BeginFlush(void);  
  71.   
  72.     // default handling for EndFlush - call at end of your implementation  
  73.     // - before calling this, ensure that there is no queued data and no thread  
  74.     // pushing any more without a further receive, then call downstream,  
  75.     // then call this method to clear the m_bFlushing flag and re-enable  
  76.     // receives  
  77.     STDMETHODIMP EndFlush(void);  
  78.   
  79.     // this method is optional (can return E_NOTIMPL).  
  80.     // default implementation returns E_NOTIMPL. Override if you have  
  81.     // specific alignment or prefix needs, but could use an upstream  
  82.     // allocator  
  83.     STDMETHODIMP GetAllocatorRequirements(ALLOCATOR_PROPERTIES*pProps);  
  84.   
  85.     // Release the pin's allocator.  
  86.     HRESULT BreakConnect();  
  87.   
  88.     // helper method to check the read-only flag  
  89.     BOOL IsReadOnly() {  
  90.         return m_bReadOnly;  
  91.     };  
  92.   
  93.     // helper method to see if we are flushing  
  94.     BOOL IsFlushing() {  
  95.         return m_bFlushing;  
  96.     };  
  97.   
  98.     //  Override this for checking whether it's OK to process samples  
  99.     //  Also call this from EndOfStream.  
  100.     virtual HRESULT CheckStreaming();  
  101.   
  102.     // Pass a Quality notification on to the appropriate sink  
  103.     HRESULT PassNotify(Quality& q);  
  104.   
  105.   
  106.     //================================================================================  
  107.     // IQualityControl methods (from CBasePin)  
  108.     //================================================================================  
  109.   
  110.     STDMETHODIMP Notify(IBaseFilter * pSender, Quality q);  
  111.   
  112.     // no need to override:  
  113.     // STDMETHODIMP SetSink(IQualityControl * piqc);  
  114.   
  115.   
  116.     // switch the pin to inactive state - may already be inactive  
  117.     virtual HRESULT Inactive(void);  
  118.   
  119.     // Return sample properties pointer  
  120.     AM_SAMPLE2_PROPERTIES * SampleProps() {  
  121.         ASSERT(m_SampleProps.cbData != 0);  
  122.         return &m_SampleProps;  
  123.     }  
  124.   
  125. };  


 

 

[cpp]  view plain copy
  1. class  AM_NOVTABLE CBaseOutputPin : public CBasePin  
  2. {  
  3.   
  4. protected:  
  5.   
  6.     IMemAllocator *m_pAllocator;  
  7.     IMemInputPin *m_pInputPin;        // interface on the downstreaminput pin  
  8.                                       // set up in CheckConnect when we connect.  
  9.   
  10. public:  
  11.   
  12.     CBaseOutputPin(  
  13.         TCHAR *pObjectName,  
  14.         CBaseFilter *pFilter,  
  15.         CCritSec *pLock,  
  16.         HRESULT *phr,  
  17.         LPCWSTR pName);  
  18. #ifdef UNICODE  
  19.     CBaseOutputPin(  
  20.         CHAR *pObjectName,  
  21.         CBaseFilter *pFilter,  
  22.         CCritSec *pLock,  
  23.         HRESULT *phr,  
  24.         LPCWSTR pName);  
  25. #endif  
  26.     // override CompleteConnect() so we can negotiate an allocator  
  27.     virtual HRESULT CompleteConnect(IPin *pReceivePin);  
  28.   
  29.     // negotiate the allocator and its buffer size/count and other properties  
  30.     // Calls DecideBufferSize to set properties  
  31.     virtual HRESULT DecideAllocator(IMemInputPin * pPin, IMemAllocator ** pAlloc);  
  32.   
  33.     // override this to set the buffer size and count. Return an error  
  34.     // if the size/count is not to your liking.  
  35.     // The allocator properties passed in are those requested by the  
  36.     // input pin - use eg the alignment and prefix members if you have  
  37.     // no preference on these.  
  38.     virtual HRESULT DecideBufferSize(  
  39.         IMemAllocator * pAlloc,  
  40.         ALLOCATOR_PROPERTIES * ppropInputRequest  
  41.     ) PURE;  
  42.   
  43.     // returns an empty sample buffer from the allocator  
  44.     virtual HRESULT GetDeliveryBuffer(IMediaSample ** ppSample,  
  45.                                       REFERENCE_TIME * pStartTime,  
  46.                                       REFERENCE_TIME * pEndTime,  
  47.                                       DWORD dwFlags);  
  48.   
  49.     // deliver a filled-in sample to the connected input pin  
  50.     // note - you need to release it after calling this. The receiving  
  51.     // pin will addref the sample if it needs to hold it beyond the  
  52.     // call.  
  53.     virtual HRESULT Deliver(IMediaSample *);  
  54.   
  55.     // override this to control the connection  
  56.     virtual HRESULT InitAllocator(IMemAllocator **ppAlloc);  
  57.     HRESULT CheckConnect(IPin *pPin);  
  58.     HRESULT BreakConnect();  
  59.   
  60.     // override to call Commit and Decommit  
  61.     HRESULT Active(void);  
  62.     HRESULT Inactive(void);  
  63.   
  64.     // we have a default handling of EndOfStream which is to return  
  65.     // an error, since this should be called on input pins only  
  66.     STDMETHODIMP EndOfStream(void);  
  67.   
  68.     // called from elsewhere in our filter to pass EOS downstream to  
  69.     // our connected input pin  
  70.     virtual HRESULT DeliverEndOfStream(void);  
  71.   
  72.     // same for Begin/EndFlush - we handle Begin/EndFlush since it  
  73.     // is an error on an output pin, and we have Deliver methods to  
  74.     // call the methods on the connected pin  
  75.     STDMETHODIMP BeginFlush(void);  
  76.     STDMETHODIMP EndFlush(void);  
  77.     virtual HRESULT DeliverBeginFlush(void);  
  78.     virtual HRESULT DeliverEndFlush(void);  
  79.   
  80.     // deliver NewSegment to connected pin - you will need to  
  81.     // override this if you queue any data in your output pin.  
  82.     virtual HRESULT DeliverNewSegment(  
  83.                         REFERENCE_TIME tStart,  
  84.                         REFERENCE_TIME tStop,  
  85.                         double dRate);  
  86.   
  87.     //================================================================================  
  88.     // IQualityControl methods  
  89.     //================================================================================  
  90.   
  91.     // All inherited from CBasePin and not overridden here.  
  92.     // STDMETHODIMP Notify(IBaseFilter * pSender, Quality q);  
  93.     // STDMETHODIMP SetSink(IQualityControl * piqc);  
  94. };  


 CBaseInputPin类的使用方法(派生一个子类,并且至少需要重写以下函数)如下:

(1) CBaseInputPin::BeginFlush

(2) CBaseInputPin::EndFlush

(3) CBaseInputPin::Receive

(4) CBaseInputPin::CheckMediaType

(5) CBaseInputPin::GetMediaType

eg:

[cpp]  view plain copy
  1. class CRendererInputPin : public CBaseInputPin  
  2. {  
  3. protected:  
  4.   
  5.     CBaseRenderer *m_pRenderer;  
  6.   
  7. public:  
  8.   
  9.     CRendererInputPin(CBaseRenderer *pRenderer,  
  10.                       HRESULT *phr,  
  11.                       LPCWSTR Name);  
  12.   
  13.     // Overriden from the base pin classes  
  14.   
  15.     HRESULT BreakConnect();  
  16.     HRESULT CompleteConnect(IPin *pReceivePin);  
  17.     HRESULT SetMediaType(const CMediaType *pmt);  
  18.     HRESULT CheckMediaType(const CMediaType *pmt);  
  19.     HRESULT Active();  
  20.     HRESULT Inactive();  
  21.   
  22.     // Add rendering behaviour to interface functions  
  23.   
  24.     STDMETHODIMP QueryId(LPWSTR *Id);  
  25.     STDMETHODIMP EndOfStream();  
  26.     STDMETHODIMP BeginFlush();  
  27.     STDMETHODIMP EndFlush();  
  28.     STDMETHODIMP Receive(IMediaSample *pMediaSample);  
  29.   
  30.     // Helper  
  31.     IMemAllocator inline *Allocator() const  
  32.     {  
  33.         return m_pAllocator;  
  34.     }  
  35. };  


 

CBaseOutputPin类的使用方法(派生一个子类,并且最少需要重写以下函数)如下:

(1) 重写CBasePin::CheckMediaType进行连接时媒体类型的检查;

(2) 实现纯虚函数CBaseOutputPin::DecideBufferSize,决定Sample内存的大小;

(3) 重写CBasePin::GetMediaType, 提供Pin 上的首选媒体类型。

 

[cpp]  view plain copy
  1. class CTransformOutputPin : public CBaseOutputPin  
  2. {  
  3.     friend class CTransformFilter;  
  4.   
  5. protected:  
  6.     CTransformFilter *m_pTransformFilter;  
  7.   
  8. public:  
  9.   
  10.     // implement IMediaPosition by passing upstream  
  11.     IUnknown * m_pPosition;  
  12.   
  13.     CTransformOutputPin(  
  14.         TCHAR *pObjectName,  
  15.         CTransformFilter *pTransformFilter,  
  16.         HRESULT * phr,  
  17.         LPCWSTR pName);  
  18. #ifdef UNICODE  
  19.     CTransformOutputPin(  
  20.         CHAR *pObjectName,  
  21.         CTransformFilter *pTransformFilter,  
  22.         HRESULT * phr,  
  23.         LPCWSTR pName);  
  24. #endif  
  25.     ~CTransformOutputPin();  
  26.   
  27.     // override to expose IMediaPosition  
  28.     STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void **ppv);  
  29.   
  30.     // --- CBaseOutputPin ------------  
  31.   
  32.     STDMETHODIMP QueryId(LPWSTR * Id)  
  33.     {  
  34.         return AMGetWideString(L"Out", Id);  
  35.     }  
  36.   
  37.     // Grab and release extra interfaces if required  
  38.   
  39.     HRESULT CheckConnect(IPin *pPin);  
  40.     HRESULT BreakConnect();  
  41.     HRESULT CompleteConnect(IPin *pReceivePin);  
  42.   
  43.     // check that we can support this output type  
  44.     HRESULT CheckMediaType(const CMediaType* mtOut);  
  45.   
  46.     // set the connection media type  
  47.     HRESULT SetMediaType(const CMediaType *pmt);  
  48.   
  49.     // called from CBaseOutputPin during connection to ask for  
  50.     // the count and size of buffers we need.  
  51.     HRESULT DecideBufferSize(  
  52.                 IMemAllocator * pAlloc,  
  53.                 ALLOCATOR_PROPERTIES *pProp);  
  54.   
  55.     // returns the preferred formats for a pin  
  56.     HRESULT GetMediaType(int iPosition,CMediaType *pMediaType);  
  57.   
  58.     // inherited from IQualityControl via CBasePin  
  59.     STDMETHODIMP Notify(IBaseFilter * pSender, Quality q);  
  60.   
  61.     // Media type  
  62. public:  
  63.     CMediaType& CurrentMediaType() { return m_mt; };  
  64. };  


 ===================================================================

如果开发的是一个Transform Filter,Filter的父类很多时候都是选择CTransformFilter或CTransInPlaceFilter,这种Filter的开发相对简单。

但有时,Filter框架不得不选择CBaseFilter、 CBaseInputPin、CBaseOutputFilter等类来实现,这就有点麻烦了。

这时候可以参考CTransformFilter、CTransformInputPin、CTransformOutputPin对上述3上基类的使用,以此来指导Filter的开发。

 ===================================================================

6、 CSource

DirectShow SDK还提供了其他更加实用的Filter类,如:

CSource、CTransformFilter、CTransInPlaceFilter、CVideoTransformFilter、 CBaseRender、CBase Video Render等。

它们的继承关系如图:

Filter组件开发中的SDK基类分析 分类: DirectX 2014-10-09 15:50 477人阅读 评论(0) 收藏

如上图所示,CSource类(参见source.cpp的实现)直接从CaseFilter中继承而来,一般作为推模式Source Filter的父类

CSource类的使用方法如下:

(1)从CSource类中派生一个新的Filter类;

(2)在新的Filter类的构造函数中创建各个CSourceStream类实例(CSourceStream类的构造函数会自动将该Pin加入Filter中,并在析构函数中自动删除);

(3)使用CSource::pStateLock函数返回的同步对象进行Filter对象上的多线程同步。

注意: 使用CSource作为Filter父类的Filter未必就是Source Filter。在有些开发Transform Filter的应用中,输出Pin需要使用独立的线程。(即与输入Pin上传送数据

              不同的线程)传关,也可以考虑使用CSource。

eg: 参照我的另一篇文章:  

[cpp]  view plain copy
  1. class CPushSourceBitmap : public CSource  
  2. {  
  3.   
  4. private:  
  5.     // Constructor is private because you have to use CreateInstance  
  6.     CPushSourceBitmap(IUnknown *pUnk, HRESULT *phr);  
  7.     ~CPushSourceBitmap();  
  8.   
  9.     CPushPinBitmap *m_pPin;  
  10.   
  11. public:  
  12.     static CUnknown * WINAPI CreateInstance(IUnknown *pUnk, HRESULT *phr);    
  13.   
  14. };  

 

[cpp]  view plain copy
  1. CPushSourceBitmap::CPushSourceBitmap(IUnknown *pUnk, HRESULT *phr)  
  2.            : CSource(NAME("PushSourceBitmap"), pUnk, CLSID_PushSourceBitmap)  
  3. {  
  4.     // The pin magically adds itself to our pin array.  
  5.     m_pPin = new CPushPinBitmap(phr, this);  
  6.   
  7.     if (phr)  
  8.     {  
  9.         if (m_pPin == NULL)  
  10.             *phr = E_OUTOFMEMORY;  
  11.         else  
  12.             *phr = S_OK;  
  13.     }    
  14. }  


7 、  CSourceStream

CSource实际上继承自CBaseFilter,提供了一个“推”数据的能力,这种Filter至少有一个输出

Pin采用了CSourecStream类(或CSourceStream的子类)。如下图所示:

CSourceStream上实现了一个线程(CSourceStream从CAMThread类继承而来),Sample数据就是靠这个线程向一线Filter发送的。

Filter组件开发中的SDK基类分析 分类: DirectX 2014-10-09 15:50 477人阅读 评论(0) 收藏

CSourceStream类的使用方法如下:

(1)从CSourceStream派生一个输出Pin类;

(2)重写CSourceStream::GetMediaType,提供输出Pin上的首选媒体类型;

(3)重写CSourceStream::CheckMediaType,进行连续时媒体类型的检查;(可选

(4)实现CBaseOutPin::DecideBufferSize,决定Sample内存的大小;

(5)实现CSourceStream::FillBuffer,为即将传送出去的Sample 填充数据;

(6)可选地实现CSourceStream::OnThreadCreate、CSourceSream::OnThreadDestroy、CSourceStream::OnThreadStartPlay等函数,

进行适当时节的初始化、资源管理等操作。

eg: 参照我的另一篇文章:  

[cpp]  view plain copy
  1. class CPushPinBitmap : public CSourceStream  
  2. {  
  3. protected:  
  4.   
  5.     int m_FramesWritten;                // To track where we are in the file  
  6.     BOOL m_bZeroMemory;                 // Do we need to clear the buffer?  
  7.     CRefTime m_rtSampleTime;            // The time stamp for each sample  
  8.   
  9.     BITMAPINFO *m_pBmi;                 // Pointer to the bitmap header  
  10.     DWORD       m_cbBitmapInfo;         // Size of the bitmap header  
  11.       
  12.     // File opening variables   
  13.     HANDLE m_hFile;                     // Handle returned from CreateFile  
  14.     BYTE * m_pFile;                     // Points to beginning of file buffer  
  15.     BYTE * m_pImage;                    // Points to pixel bits                                        
  16.   
  17.     int m_iFrameNumber;  
  18.     const REFERENCE_TIME m_rtFrameLength;  
  19.   
  20.     CCritSec m_cSharedState;            // Protects our internal state  
  21.     CImageDisplay m_Display;            // Figures out our media type for us  
  22.   
  23. public:  
  24.   
  25.     CPushPinBitmap(HRESULT *phr, CSource *pFilter);  
  26.     ~CPushPinBitmap();  
  27.   
  28.     // Override the version that offers exactly one media type  
  29.     HRESULT GetMediaType(CMediaType *pMediaType);  
  30.     HRESULT DecideBufferSize(IMemAllocator *pAlloc, ALLOCATOR_PROPERTIES *pRequest);  
  31.     HRESULT FillBuffer(IMediaSample *pSample);  
  32.       
  33.     // Quality control  
  34.     // Not implemented because we aren't going in real time.  
  35.     // If the file-writing filter slows the graph down, we just do nothing, which means  
  36.     // wait until we're unblocked. No frames are ever dropped.  
  37.     STDMETHODIMP Notify(IBaseFilter *pSelf, Quality q)  
  38.     {  
  39.         return E_FAIL;  
  40.     }  
  41.   
  42. };  


8、 CTransformFilter

 CTransformFilter类是开发Transform Filter最基本的类,也是最常用到的类。结构如下:

它有一个输入Pin和一个输出Pin,分别使用CTransformInputPin类和CTransformOutputPin类。

Filter组件开发中的SDK基类分析 分类: DirectX 2014-10-09 15:50 477人阅读 评论(0) 收藏

 

Filter组件开发中的SDK基类分析 分类: DirectX 2014-10-09 15:50 477人阅读 评论(0) 收藏

从图4.8和图4.9可以看出,

CTransformFilter从CBaseFilter继承而来,

CTransformInputPin从CBaseInputPin继承而来,

CTransformOutputPin从CBaseOutputPin继承而来。另个,在CTransformOutputPin上还实现了IMdiaSeeking 和 IMediaPosition接口。

(其实,CTransformOutputPin并没有真正实现各个Seek操作。在实际的Seek操作请发生时,CTransformOutpPin会将这些操作请求转发给上一级Filter的输出Pin)。

CTransformFilter实现的最大特征是,它将Pin上必须实现的函数都“委托”到了Filter上(Pin上必须实现的函数在Filter上有类似的函数定义)。

一般无须重写输入和输出Pin类,而只须在Filter上实现相应的函数就行了)。

提示:CTransformFilter默认在GetPin函数实现中创建输入和输出Pin。因此,如果重写了自己的输入或输出Pin类,需要重写GetPin函数。

CTransformFilter类的使用方法(派生一个Filter子类,且最少需要重写以下函数):

(1)CTransformFilter::CheckInputType

(2)CTransformFilter::CheckTransform

(3)CTransformFilter::DecideBufferSize

(4)CTransformFilter::GetMeiaType

(5)CTransformFilter::Transform

eg:CVideoTransformFilter虽然没有实现上面五个函数,但CVideoTransformFilter 的继承类去实现它们。

[cpp]  view plain copy
  1. class CVideoTransformFilter : public CTransformFilter  
  2. {  
  3.   public:  
  4.   
  5.     CVideoTransformFilter(TCHAR *, LPUNKNOWN, REFCLSID clsid);  
  6.     ~CVideoTransformFilter();  
  7.     HRESULT EndFlush();  
  8.   
  9.     // =================================================================  
  10.     // ----- override these bits ---------------------------------------  
  11.     // =================================================================  
  12.     // The following methods are in CTransformFilter which is inherited.  
  13.     // They are mentioned here for completeness  
  14.     //  
  15.     // These MUST be supplied in a derived class  
  16.     //  
  17.     // NOTE:  
  18.     // virtual HRESULT Transform(IMediaSample * pIn, IMediaSample *pOut);  
  19.     // virtual HRESULT CheckInputType(const CMediaType* mtIn) PURE;  
  20.     // virtual HRESULT CheckTransform  
  21.     //     (const CMediaType* mtIn, const CMediaType* mtOut) PURE;  
  22.     // static CCOMObject * CreateInstance(LPUNKNOWN, HRESULT *);  
  23.     // virtual HRESULT DecideBufferSize  
  24.     //     (IMemAllocator * pAllocator, ALLOCATOR_PROPERTIES *pprop) PURE;  
  25.     // virtual HRESULT GetMediaType(int iPosition, CMediaType *pMediaType) PURE;  
  26.     //  
  27.     // These MAY also be overridden  
  28.     //  
  29.     // virtual HRESULT StopStreaming();  
  30.     // virtual HRESULT SetMediaType(PIN_DIRECTION direction,const CMediaType *pmt);  
  31.     // virtual HRESULT CheckConnect(PIN_DIRECTION dir,IPin *pPin);  
  32.     // virtual HRESULT BreakConnect(PIN_DIRECTION dir);  
  33.     // virtual HRESULT CompleteConnect(PIN_DIRECTION direction,IPin *pReceivePin);  
  34.     // virtual HRESULT EndOfStream(void);  
  35.     // virtual HRESULT BeginFlush(void);  
  36.     // virtual HRESULT EndFlush(void);  
  37.     // virtual HRESULT NewSegment  
  38.     //     (REFERENCE_TIME tStart,REFERENCE_TIME tStop,double dRate);  
  39. #ifdef PERF  
  40.   
  41.     // If you override this - ensure that you register all these ids  
  42.     // as well as any of your own,  
  43.     virtual void RegisterPerfId() {  
  44.         m_idSkip        = MSR_REGISTER(TEXT("Video Transform Skip frame"));  
  45.         m_idFrameType   = MSR_REGISTER(TEXT("Video transform frame type"));  
  46.         m_idLate        = MSR_REGISTER(TEXT("Video Transform Lateness"));  
  47.         m_idTimeTillKey = MSR_REGISTER(TEXT("Video Transform Estd. time to next key"));  
  48.         CTransformFilter::RegisterPerfId();  
  49.     }  
  50. #endif  
  51.   
  52.   protected:  
  53.   
  54.     // =========== QUALITY MANAGEMENT IMPLEMENTATION ========================  
  55.     // Frames are assumed to come in three types:  
  56.     // Type 1: an AVI key frame or an MPEG I frame.  
  57.     //        This frame can be decoded with no history.  
  58.     //        Dropping this frame means that no further frame can be decoded  
  59.     //        until the next type 1 frame.  
  60.     //        Type 1 frames are sync points.  
  61.     // Type 2: an AVI non-key frame or an MPEG P frame.  
  62.     //        This frame cannot be decoded unless the previous type 1 frame was  
  63.     //        decoded and all type 2 frames since have been decoded.  
  64.     //        Dropping this frame means that no further frame can be decoded  
  65.     //        until the next type 1 frame.  
  66.     // Type 3: An MPEG B frame.  
  67.     //        This frame cannot be decoded unless the previous type 1 or 2 frame  
  68.     //        has been decoded AND the subsequent type 1 or 2 frame has also  
  69.     //        been decoded.  (This requires decoding the frames out of sequence).  
  70.     //        Dropping this frame affects no other frames.  This implementation  
  71.     //        does not allow for these.  All non-sync-point frames are treated  
  72.     //        as being type 2.  
  73.     //  
  74.     // The spacing of frames of type 1 in a file is not guaranteed.  There MUST  
  75.     // be a type 1 frame at (well, near) the start of the file in order to start  
  76.     // decoding at all.  After that there could be one every half second or so,  
  77.     // there could be one at the start of each scene (aka "cut", "shot") or  
  78.     // there could be no more at all.  
  79.     // If there is only a single type 1 frame then NO FRAMES CAN BE DROPPED  
  80.     // without losing all the rest of the movie.  There is no way to tell whether  
  81.     // this is the case, so we find that we are in the gambling business.  
  82.     // To try to improve the odds, we record the greatest interval between type 1s  
  83.     // that we have seen and we bet on things being no worse than this in the  
  84.     // future.  
  85.   
  86.     // You can tell if it's a type 1 frame by calling IsSyncPoint().  
  87.     // there is no architected way to test for a type 3, so you should override  
  88.     // the quality management here if you have B-frames.  
  89.   
  90.     int m_nKeyFramePeriod; // the largest observed interval between type 1 frames  
  91.                            // 1 means every frame is type 1, 2 means every other.  
  92.   
  93.     int m_nFramesSinceKeyFrame; // Used to count frames since the last type 1.  
  94.                                 // becomes the new m_nKeyFramePeriod if greater.  
  95.   
  96.     BOOL m_bSkipping;           // we are skipping to the next type 1 frame  
  97.   
  98. #ifdef PERF  
  99.     int m_idFrameType;          // MSR id Frame type.  1=Key, 2="non-key"  
  100.     int m_idSkip;               // MSR id skipping  
  101.     int m_idLate;               // MSR id lateness  
  102.     int m_idTimeTillKey;        // MSR id for guessed time till next key frame.  
  103. #endif  
  104.   
  105.     virtual HRESULT StartStreaming();  
  106.   
  107.     HRESULT AbortPlayback(HRESULT hr);  // if something bad happens  
  108.   
  109.     HRESULT Receive(IMediaSample *pSample);  
  110.   
  111.     HRESULT AlterQuality(Quality q);  
  112.   
  113.     BOOL ShouldSkipFrame(IMediaSample * pIn);  
  114.   
  115.     int m_itrLate;              // lateness from last Quality message  
  116.                                 // (this overflows at 214 secs late).  
  117.     int m_tDecodeStart;         // timeGetTime when decode started.  
  118.     int m_itrAvgDecode;         // Average decode time in reference units.  
  119.   
  120.     BOOL m_bNoSkip;             // debug - no skipping.  
  121.   
  122.     // We send an EC_QUALITY_CHANGE notification to the app if we have to degrade.  
  123.     // We send one when we start degrading, not one for every frame, this means  
  124.     // we track whether we've sent one yet.  
  125.     BOOL m_bQualityChanged;  
  126.   
  127.     // When non-zero, don't pass anything to renderer until next keyframe  
  128.     // If there are few keys, give up and eventually draw something  
  129.     int m_nWaitForKey;  
  130. };  


 

9、 CTransInPlaceFilter

CTransInPlaceFilter是一个“就地”处理的Transform Filter类。结构如下:

与CTransformFilter,CTransInPlaceFilter也有一个输入Pin和一个输出Pin,但使用CTransInPlaceOutputPin类

Filter组件开发中的SDK基类分析 分类: DirectX 2014-10-09 15:50 477人阅读 评论(0) 收藏

Filter组件开发中的SDK基类分析 分类: DirectX 2014-10-09 15:50 477人阅读 评论(0) 收藏

 

CTransInPlaceFilter的输入和输出Pin上一般使用相同的媒体类型进行连接,并且使用同一个Sample管理器(如果Filter实现时要修改Sample数据,

而协商达成一致的Sample管理器只读的,那么CTransInPlaceFilter的输入和输出Pin将不得不使用各自的Sample管理器)。

CTransInPlaceFilter类要实现上述的目标,主要依赖于CTransInPlaceFilter::CompleteConnect、CTransInPlaceInputPin::GetAllocator和

CTransInPlaceInputPin::NotifyAlocator的函数实现。代码如下:

[cpp]  view plain copy
  1. // 当输入或输出Pin完成连接时被调用,  
  2. // 经过一个反复重连的过程,来达到输入和输出Pin使用相同的媒体类型的目的  
  3. HRESULT CTransInPlaceFilter::CompleteConnect(PIN_DIRECTION dir,IPin *pReceivePin)  
  4. {  
  5.     UNREFERENCED_PARAMETER(pReceivePin);  
  6.     ASSERT(m_pInput);  
  7.     ASSERT(m_pOutput);  
  8.   
  9.     // if we are not part of a graph, then don't indirect the pointer  
  10.     // this probably prevents use of the filter without a filtergraph  
  11.     if (!m_pGraph) {  
  12.         return VFW_E_NOT_IN_GRAPH;  
  13.     }  
  14.   
  15.     // Always reconnect the input to account for buffering changes  
  16.     //  
  17.     // Because we don't get to suggest a type on ReceiveConnection  
  18.     // we need another way of making sure the right type gets used.  
  19.     //  
  20.     // One way would be to have our EnumMediaTypes return our output  
  21.     // connection type first but more deterministic and simple is to  
  22.     // call ReconnectEx passing the type we want to reconnect with  
  23.     // via the base class ReconeectPin method.  
  24.   
  25.     // 当输出Pin调用该函数(并且此时输入Pin已连上)时,使用输出Pin上的媒体类型对  
  26.     // 输入Pin进行重连接  
  27.     if (dir == PINDIR_OUTPUT) {  
  28.         if( m_pInput->IsConnected() ) {  
  29.             return ReconnectPin( m_pInput, &m_pOutput->CurrentMediaType() );  
  30.         }  
  31.         return NOERROR;  
  32.     }  
  33.   
  34.     ASSERT(dir == PINDIR_INPUT);  
  35.   
  36.     // Reconnect output if necessary  
  37.   
  38.     // 当输入Pin调用该函数(并且此时输出Pin已连上)时,如果输入和输出Pin上使用的  
  39.     // 媒体类型不一致,则使用输入Pin上的媒体类型对输出Pin进行重新连接  
  40.     if( m_pOutput->IsConnected() ) {  
  41.   
  42.         if (  m_pInput->CurrentMediaType()  
  43.            != m_pOutput->CurrentMediaType()  
  44.            ) {  
  45.             return ReconnectPin( m_pOutput, &m_pInput->CurrentMediaType() );  
  46.         }  
  47.     }  
  48.     return NOERROR;  
  49.   
  50. // ComnpleteConnect  


 

[cpp]  view plain copy
  1. // 当上一级Filter的输出Pin要求我们的输入Pin提供Sample管理器时,  
  2. // 如果我们的输出Pin已连接上,则可以取出输出Pin上的Sample管理器提供给上一级  
  3. // Filter,以此达到我们的输入和输出Pin使用同一个Sample管理器的目的  
  4. STDMETHODIMP CTransInPlaceInputPin::GetAllocator(IMemAllocator ** ppAllocator)  
  5. {  
  6.     CheckPointer(ppAllocator,E_POINTER);  
  7.     ValidateReadWritePtr(ppAllocator,sizeof(IMemAllocator *));  
  8.     CAutoLock cObjectLock(m_pLock);  
  9.   
  10.     HRESULT hr;  
  11.   
  12.     if ( m_pTIPFilter->m_pOutput->IsConnected() ) {  
  13.         //  Store the allocator we got  
  14.         hr = m_pTIPFilter->OutputPin()->ConnectedIMemInputPin()  
  15.                                         ->GetAllocator( ppAllocator );  
  16.         if (SUCCEEDED(hr)) {  
  17.             m_pTIPFilter->OutputPin()->SetAllocator( *ppAllocator );  
  18.         }  
  19.     }  
  20.     else {  
  21.         //  Help upstream filter (eg TIP filter which is having to do a copy)  
  22.         //  by providing a temp allocator here - we'll never use  
  23.         //  this allocator because when our output is connected we'll  
  24.         //  reconnect this pin  
  25.         hr = CTransformInputPin::GetAllocator( ppAllocator );  
  26.     }  
  27.     return hr;  
  28.   
  29. // GetAllocator  


 

[cpp]  view plain copy
  1. // 上一级Filter调用该函数,告知输入Pin上到底使用哪一个Sample管理器  
  2. // 如果设置进来的Sample管理器是只读的,而我们在Filter中又想修改数据,  
  3. // 则我们的Filter不得不最终使用不同的Sample管理器  
  4. STDMETHODIMP  
  5. CTransInPlaceInputPin::NotifyAllocator(  
  6.     IMemAllocator * pAllocator,  
  7.     BOOL bReadOnly)  
  8. {  
  9.     HRESULT hr = S_OK;  
  10.     CheckPointer(pAllocator,E_POINTER);  
  11.     ValidateReadPtr(pAllocator,sizeof(IMemAllocator));  
  12.   
  13.     CAutoLock cObjectLock(m_pLock);  
  14.   
  15.     m_bReadOnly = bReadOnly;  
  16.     //  If we modify data then don't accept the allocator if it's  
  17.     //  the same as the output pin's allocator  
  18.   
  19.     //  If our output is not connected just accept the allocator  
  20.     //  We're never going to use this allocator because when our  
  21.     //  output pin is connected we'll reconnect this pin  
  22.     if (!m_pTIPFilter->OutputPin()->IsConnected()) {  
  23.         return CTransformInputPin::NotifyAllocator(pAllocator, bReadOnly);  
  24.     }  
  25.   
  26.     //  If the allocator is read-only and we're modifying data  
  27.     //  and the allocator is the same as the output pin's  
  28.     //  then reject  
  29.     if (bReadOnly && m_pTIPFilter->m_bModifiesData) {  
  30.         IMemAllocator *pOutputAllocator =  
  31.             m_pTIPFilter->OutputPin()->PeekAllocator();  
  32.   
  33.         //  Make sure we have an output allocator  
  34.         if (pOutputAllocator == NULL) {  
  35.             hr = m_pTIPFilter->OutputPin()->ConnectedIMemInputPin()->  
  36.                                       GetAllocator(&pOutputAllocator);  
  37.             if(FAILED(hr)) {  
  38.                 hr = CreateMemoryAllocator(&pOutputAllocator);  
  39.             }  
  40.             if (SUCCEEDED(hr)) {  
  41.                 m_pTIPFilter->OutputPin()->SetAllocator(pOutputAllocator);  
  42.                 pOutputAllocator->Release();  
  43.             }  
  44.         }  
  45.         if (pAllocator == pOutputAllocator) {  
  46.             hr = E_FAIL;  
  47.         } else if(SUCCEEDED(hr)) {  
  48.             //  Must copy so set the allocator properties on the output  
  49.             ALLOCATOR_PROPERTIES Props, Actual;  
  50.             hr = pAllocator->GetProperties(&Props);  
  51.             if (SUCCEEDED(hr)) {  
  52.                 hr = pOutputAllocator->SetProperties(&Props, &Actual);  
  53.             }  
  54.             if (SUCCEEDED(hr)) {  
  55.                 if (  (Props.cBuffers > Actual.cBuffers)  
  56.                    || (Props.cbBuffer > Actual.cbBuffer)  
  57.                    || (Props.cbAlign  > Actual.cbAlign)  
  58.                    ) {  
  59.                     hr =  E_FAIL;  
  60.                 }  
  61.             }  
  62.   
  63.             //  Set the allocator on the output pin  
  64.             if (SUCCEEDED(hr)) {  
  65.                 hr = m_pTIPFilter->OutputPin()->ConnectedIMemInputPin()  
  66.                                        ->NotifyAllocator( pOutputAllocator, FALSE );  
  67.             }  
  68.         }  
  69.     } else {  
  70.         hr = m_pTIPFilter->OutputPin()->ConnectedIMemInputPin()  
  71.                                    ->NotifyAllocator( pAllocator, bReadOnly );  
  72.         if (SUCCEEDED(hr)) {  
  73.             m_pTIPFilter->OutputPin()->SetAllocator( pAllocator );  
  74.         }  
  75.     }  
  76.   
  77.     if (SUCCEEDED(hr)) {  
  78.   
  79.         // It's possible that the old and the new are the same thing.  
  80.         // AddRef before release ensures that we don't unload it.  
  81.         pAllocator->AddRef();  
  82.   
  83.         if( m_pAllocator != NULL )  
  84.             m_pAllocator->Release();  
  85.   
  86.         m_pAllocator = pAllocator;    // We have an allocator for the input pin  
  87.     }  
  88.   
  89.     return hr;  
  90.   
  91. // NotifyAllocator  

CTransInPlaceFilter类定义了一个成员变量m_bModifiesData ,用于指示我们在Filter中是否会修改Saple 数据。

这个变量在CTransInPlaceFilter构造函数调用时被默认初始化为true。如果我们确定不会在Filter中修改Sample数据,

那么,将m_bModifiesData设置为false, 可以保证输入和输出Pin连接完成后使用同一个Sample管理器。

 

10、 CVideoTransformFilter

CVieoTransformFilter是一个实现了视频的质量控制的Transform Filter类。其结构如下:

Filter组件开发中的SDK基类分析 分类: DirectX 2014-10-09 15:50 477人阅读 评论(0) 收藏

CVieoTransformFilter通过输入Pin上的Receive 函数接收Sample时,能够根据质量消息决定是否丢帧。这个类主要是为开发AVI解码Filter而设计的。

CVieoTransformFilter类的使用基本上与CTransformFilter相同。

 

11、 CBaseRenderer

CBaseRender是最基本的实现Renderer Filter的类。它默认实现了一个使用CRendererInputPin类的输入Pin(Renderer Filter没有输出Pin)。

这两个类的结构如下:

Filter组件开发中的SDK基类分析 分类: DirectX 2014-10-09 15:50 477人阅读 评论(0) 收藏

从图中可以看出,CBaseRenderer从CBaseFilter继承而来。另外,CBaseRenderer上还实现了IMediaSeekin和IMediaPosition接口。

CRendererInputPin从CBaseInputPin 继承而来,它把各个主要函数调用都“委托”到Filter上。值得注意的是,当输入Pin接收到EndOfStream调用时,

Renderer Filter 有责任向Filter Graph Manager发送一个EC_COMPLETE事件。

CBaseRenderer类的使用方法(派生一个子类,并至少实现如下函数)如下:

(1)CBaseRenderer::CheckMediaType,用于检查输入Pin连接用的媒体类型;

(2)CBaseRenderer::DoRenderSample,处理当前的Sample。

提示:CBaseRenderer实际上是为了用于播放的Render Filter设计的,对于Sample的安排比较复杂

如果我们要开发Renderer Filter不播放Sample(比如写文件的Filter、或者负责网络的Filter),Fitler的基类可以选择CBaseFilter,而此时输入Pin最

好选择CRenderedInputPin类派生。

 

12、CBaseVideoRenderer

CBaseVideoRenderer是一个实现Video Renderer类的基类,结构如下:

Filter组件开发中的SDK基类分析 分类: DirectX 2014-10-09 15:50 477人阅读 评论(0) 收藏

CBaseVideoRenderer在CBaseRenderer的基础上增加了IQualityControl和IQualProp接口的实现。

其中IQualityControl用于视频质量控制,IQualProp用于在Filter属性页显示一些实时性能参数。CBaseVideoRenderer类的使用方法基本上与CBaseRenderer相同。

 

在DirectShow SDK基类库中,除了上述Filter和Pin类外,还有很多工具类,有了这些类的支持,我们开发Fitler或DirectShow应用程序会更加轻松。

这些类包括: CPullPin、 COutputQueue、  CSourceSeeking  、CEnumPins、 CEnumMediaTypes  、CMemAllocator 、 CMediaSample  、

CBaseReferenceClock  、CMediaType、 CBasePropertyPage  等。

版权声明:本文为博主原创文章,未经博主允许不得转载。