git.oblomov.eu Git - wine/blob - dlls/quartz/basefilt.h

   1 /*
   2  * Copyright (C) Hidenori TAKESHIMA
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #ifndef WINE_DSHOW_BASEFILT_H
  20 #define WINE_DSHOW_BASEFILT_H
  21
  22 /*
  23  * The following interfaces must be used as a part of aggregation.
  24  * The punkControl must not be NULL since all IUnknown methods are
  25  * implemented only for aggregation.
  26  */
  27
  28 /*
  29  * implements IBaseFilter (internal)
  30  *
  31  * a base class for implementing IBaseFilter.
  32  */
  33
  34 #include "complist.h"
  35 #include "mtype.h"
  36
  37 typedef struct CBaseFilterHandlers      CBaseFilterHandlers;
  38 typedef struct CBasePinHandlers CBasePinHandlers;
  39
  40 typedef struct CBaseFilterImpl
  41 {
  42         /* IPersist - IMediaFilter - IBaseFilter */
  43         ICOM_VFIELD(IBaseFilter);
  44
  45         /* IUnknown fields */
  46         IUnknown*       punkControl;
  47         /* IBaseFilter fields */
  48         const CBaseFilterHandlers*      pHandlers;
  49         CRITICAL_SECTION        csFilter;
  50         const CLSID*    pclsidFilter;
  51         QUARTZ_CompList*        pInPins;        /* a list of IPin-s. */
  52         QUARTZ_CompList*        pOutPins;       /* a list of IPin-s. */
  53         IFilterGraph*   pfg;
  54         DWORD   cbNameGraph;
  55         WCHAR*  pwszNameGraph;
  56         IReferenceClock*        pClock;
  57         REFERENCE_TIME  rtStart;
  58         FILTER_STATE    fstate;
  59         BOOL    bIntermediateState; /* if set, fstate is ignored. */
  60 } CBaseFilterImpl;
  61
  62 struct CBaseFilterHandlers
  63 {
  64         HRESULT (*pOnActive)( CBaseFilterImpl* pImpl );
  65         HRESULT (*pOnInactive)( CBaseFilterImpl* pImpl );
  66         HRESULT (*pOnStop)( CBaseFilterImpl* pImpl );
  67 };
  68
  69
  70 HRESULT CBaseFilterImpl_InitIBaseFilter(
  71         CBaseFilterImpl* This, IUnknown* punkControl,
  72         const CLSID* pclsidFilter, LPCWSTR lpwszNameGraph,
  73         const CBaseFilterHandlers* pHandlers );
  74 void CBaseFilterImpl_UninitIBaseFilter( CBaseFilterImpl* This );
  75
  76
  77 HRESULT CBaseFilterImpl_MediaEventNotify(
  78         CBaseFilterImpl* This, long lEvent,LONG_PTR lParam1,LONG_PTR lParam2);
  79
  80
  81 /*
  82  * Implements IPin, IMemInputPin, and IQualityControl. (internal)
  83  *
  84  * a base class for implementing IPin.
  85  */
  86
  87 typedef struct OutputPinAsyncImpl OutputPinAsyncImpl;
  88
  89 typedef struct CPinBaseImpl
  90 {
  91         /* IPin */
  92         ICOM_VFIELD(IPin);
  93
  94         /* IUnknown fields */
  95         IUnknown*       punkControl;
  96         /* IPin fields */
  97         const CBasePinHandlers* pHandlers;
  98         DWORD   cbIdLen;
  99         WCHAR*  pwszId;
 100         BOOL    bOutput;
 101
 102         /* you can change AcceptTypes while pcsPin has been hold */
 103         const AM_MEDIA_TYPE*    pmtAcceptTypes;
 104         ULONG   cAcceptTypes;
 105
 106         CRITICAL_SECTION*       pcsPin;
 107         CRITICAL_SECTION*       pcsPinReceive;
 108         CBaseFilterImpl*        pFilter;
 109         IPin*   pPinConnectedTo;
 110         IMemInputPin*   pMemInputPinConnectedTo;
 111         AM_MEDIA_TYPE*  pmtConn;
 112         OutputPinAsyncImpl* pAsyncOut; /* for asynchronous output */
 113 } CPinBaseImpl;
 114
 115 typedef struct CMemInputPinBaseImpl
 116 {
 117         /* IMemInputPin */
 118         ICOM_VFIELD(IMemInputPin);
 119
 120         /* IUnknown fields */
 121         IUnknown*       punkControl;
 122         /* IMemInputPin fields */
 123         CPinBaseImpl*   pPin;
 124         IMemAllocator*  pAllocator;
 125         BOOL    bReadonly;
 126 } CMemInputPinBaseImpl;
 127
 128 typedef struct CQualityControlPassThruImpl
 129 {
 130         /* IQualityControl */
 131         ICOM_VFIELD(IQualityControl);
 132
 133         /* IUnknown fields */
 134         IUnknown*       punkControl;
 135         /* IQualityControl fields */
 136         CPinBaseImpl*   pPin;
 137         IQualityControl*        pControl;
 138 } CQualityControlPassThruImpl;
 139
 140
 141 struct CBasePinHandlers
 142 {
 143         HRESULT (*pOnPreConnect)( CPinBaseImpl* pImpl, IPin* pPin );
 144         HRESULT (*pOnPostConnect)( CPinBaseImpl* pImpl, IPin* pPin );
 145         HRESULT (*pOnDisconnect)( CPinBaseImpl* pImpl );
 146         HRESULT (*pCheckMediaType)( CPinBaseImpl* pImpl, const AM_MEDIA_TYPE* pmt );
 147         HRESULT (*pQualityNotify)( CPinBaseImpl* pImpl, IBaseFilter* pFilter, Quality q );
 148         HRESULT (*pReceive)( CPinBaseImpl* pImpl, IMediaSample* pSample );
 149         HRESULT (*pReceiveCanBlock)( CPinBaseImpl* pImpl );
 150         HRESULT (*pEndOfStream)( CPinBaseImpl* pImpl );
 151         HRESULT (*pBeginFlush)( CPinBaseImpl* pImpl );
 152         HRESULT (*pEndFlush)( CPinBaseImpl* pImpl );
 153         HRESULT (*pNewSegment)( CPinBaseImpl* pImpl, REFERENCE_TIME rtStart, REFERENCE_TIME rtStop, double rate );
 154 };
 155
 156
 157
 158 HRESULT CPinBaseImpl_InitIPin(
 159         CPinBaseImpl* This, IUnknown* punkControl,
 160         CRITICAL_SECTION* pcsPin,
 161         CRITICAL_SECTION* pcsPinReceive,
 162         CBaseFilterImpl* pFilter, LPCWSTR pwszId,
 163         BOOL bOutput,
 164         const CBasePinHandlers* pHandlers );
 165 void CPinBaseImpl_UninitIPin( CPinBaseImpl* This );
 166
 167
 168 HRESULT CMemInputPinBaseImpl_InitIMemInputPin(
 169         CMemInputPinBaseImpl* This, IUnknown* punkControl,
 170         CPinBaseImpl* pPin );
 171 void CMemInputPinBaseImpl_UninitIMemInputPin(
 172         CMemInputPinBaseImpl* This );
 173
 174
 175 HRESULT CQualityControlPassThruImpl_InitIQualityControl(
 176         CQualityControlPassThruImpl* This, IUnknown* punkControl,
 177         CPinBaseImpl* pPin );
 178 void CQualityControlPassThruImpl_UninitIQualityControl(
 179         CQualityControlPassThruImpl* This );
 180
 181
 182 HRESULT CPinBaseImpl_SendSample( CPinBaseImpl* This, IMediaSample* pSample );
 183 HRESULT CPinBaseImpl_SendReceiveCanBlock( CPinBaseImpl* This );
 184 HRESULT CPinBaseImpl_SendEndOfStream( CPinBaseImpl* This );
 185 HRESULT CPinBaseImpl_SendBeginFlush( CPinBaseImpl* This );
 186 HRESULT CPinBaseImpl_SendEndFlush( CPinBaseImpl* This );
 187 HRESULT CPinBaseImpl_SendNewSegment( CPinBaseImpl* This, REFERENCE_TIME rtStart, REFERENCE_TIME rtStop, double rate );
 188
 189
 190 /***************************************************************************
 191  *
 192  *      handlers for output pins.
 193  *
 194  */
 195
 196 HRESULT OutputPinSync_Receive( CPinBaseImpl* pImpl, IMediaSample* pSample );
 197 HRESULT OutputPinSync_ReceiveCanBlock( CPinBaseImpl* pImpl );
 198 HRESULT OutputPinSync_EndOfStream( CPinBaseImpl* pImpl );
 199 HRESULT OutputPinSync_BeginFlush( CPinBaseImpl* pImpl );
 200 HRESULT OutputPinSync_EndFlush( CPinBaseImpl* pImpl );
 201 HRESULT OutputPinSync_NewSegment( CPinBaseImpl* pImpl, REFERENCE_TIME rtStart, REFERENCE_TIME rtStop, double rate );
 202
 203 /***************************************************************************
 204  *
 205  *      handlers for output pins (async).
 206  *
 207  */
 208
 209 HRESULT OutputPinAsync_OnActive( CPinBaseImpl* pImpl );
 210 HRESULT OutputPinAsync_OnInactive( CPinBaseImpl* pImpl );
 211 HRESULT OutputPinAsync_Receive( CPinBaseImpl* pImpl, IMediaSample* pSample );
 212 HRESULT OutputPinAsync_ReceiveCanBlock( CPinBaseImpl* pImpl );
 213 HRESULT OutputPinAsync_EndOfStream( CPinBaseImpl* pImpl );
 214 HRESULT OutputPinAsync_BeginFlush( CPinBaseImpl* pImpl );
 215 HRESULT OutputPinAsync_EndFlush( CPinBaseImpl* pImpl );
 216 HRESULT OutputPinAsync_NewSegment( CPinBaseImpl* pImpl, REFERENCE_TIME rtStart, REFERENCE_TIME rtStop, double rate );
 217
 218
 219
 220 #endif  /* WINE_DSHOW_BASEFILT_H */