windows-server-2003/multimedia/dshow/vidctl/dsextend.h

//==========================================================================;
//
// dsextend.h : additional infrastructure to extend the dshow stuff so that it
// works nicely from c++
// Copyright (c) Microsoft Corporation 1995-1999.
//
/////////////////////////////////////////////////////////////////////////////

#pragma once

#ifndef DSEXTEND_H
#define DSEXTEND_H

#include <algorithm>
#include <functional>
#include <utility>
#include <vector>
#include <list>
#include <map>
#include <trace.h>
#include <throw.h>
#include <stextend.h>
#include <w32extend.h>
#include <ksextend.h>
#include <fwdseq.h>
#include <control.h>
#include <mpconfig.h>
#include <vptype.h>
#include <vpnotify.h>
#include <il21dec.h>
#include <mtype.h>
#include <tuner.h>
#include <bdaiface.h>
#include <errors.h>
#include <winerror.h>
#include <evcode.h>

struct DECLSPEC_NOVTABLE DECLSPEC_UUID("6E8D4A21-310C-11d0-B79A-00AA003767A7") IAMLine21Decoder;

#define LINE21_BY_MAGIC
#define FILTERDATA

// #define ATTEMPT_DIRECT_CONNECT
// we'd like to check to see if two filters can be connected by just trying to connect them
// this is less work and techinically more accurate since pins aren't required to enumerate all
// of the media types they potentiall could support.
// however, this exposes bugs in the filters and causes random hangs and crashes.  instead
// we manually check mediums and media types and only attempt the connection when we find a match.
// this turns out to be much more stable. 


//#define FORWARD_TRACE

const PIN_DIRECTION DOWNSTREAM = PINDIR_OUTPUT;
const PIN_DIRECTION UPSTREAM = PINDIR_INPUT;


typedef CComQIPtr<IFileSourceFilter, &IID_IFileSourceFilter> PQFileSourceFilter;
#ifndef POLYMORPHIC_TUNERS
typedef CComQIPtr<IAMTVTuner, &IID_IAMTVTuner> PQTVTuner;
//typedef CComQIPtr<ISatelliteTuner, &IID_ISatelliteTuner> PQSatelliteTuner;
#else
typedef CComQIPtr<IAMTuner, &IID_IAMTuner> PQTuner;
typedef CComQIPtr<IAMTVTuner, &IID_IAMTVTuner> PQTVTuner;
typedef CComQIPtr<IBPCSatelliteTuner, &IID_IBPCSatelliteTuner> PQSatelliteTuner;
#endif
#if 0
typedef CComQIPtr<IVideoWindow, &IID_IVideoWindow> PQVideoWindow;
typedef CComQIPtr<IBasicVideo, &IID_IBasicVideo> PQBasicVideo;
#else
typedef CComQIPtr<IVMRWindowlessControl, &IID_IVMRWindowlessControl> PQVMRWindowlessControl;
#endif

typedef CComQIPtr<IPin, &IID_IPin> PQPin;
typedef CComQIPtr<IBaseFilter, &IID_IBaseFilter> PQFilter;
typedef CComQIPtr<IFilterInfo, &IID_IFilterInfo> PQFilterInfo;
typedef CComQIPtr<IEnumPins, &IID_IEnumPins> PQEnumPins;
typedef CComQIPtr<IEnumFilters, &IID_IEnumFilters> PQEnumFilters;
typedef CComQIPtr<IBasicAudio, &IID_IBasicAudio> PQBasicAudio;
typedef CComQIPtr<IAMCrossbar, &IID_IAMCrossbar> PQCrossbarSwitch;
typedef CComQIPtr<IMediaEventEx, &IID_IMediaEventEx> PQMediaEventEx;
typedef CComQIPtr<IMediaControl, &IID_IMediaControl> PQMediaControl;
typedef CComQIPtr<IMediaPosition, &IID_IMediaPosition> PQMediaPosition;
typedef CComQIPtr<IMediaSeeking, &IID_IMediaSeeking> PQMediaSeeking;
typedef CComQIPtr<IGraphBuilder, &IID_IGraphBuilder> PQGraphBuilder;
typedef CComQIPtr<ICreateDevEnum, &IID_ICreateDevEnum> PQCreateDevEnum;
typedef CComQIPtr<IEnumMoniker, &IID_IEnumMoniker> PQEnumMoniker;
typedef CComQIPtr<IFilterMapper2, &IID_IFilterMapper2> PQFilterMapper;
typedef CComQIPtr<IEnumMediaTypes, &IID_IEnumMediaTypes> PQEnumMediaTypes;
typedef CComQIPtr<IAMAnalogVideoDecoder, &IID_IAMAnalogVideoDecoder> PQAnalogVideoDecoder;
typedef CComQIPtr<IMixerPinConfig, &IID_IMixerPinConfig> PQMixerPinConfig;
typedef CComQIPtr<IAMAudioInputMixer, &IID_IAMAudioInputMixer> PQAudioInputMixer;
typedef CComQIPtr<IAMLine21Decoder, &IID_IAMLine21Decoder> PQLine21Decoder;
typedef CComQIPtr<IVPNotify2, &IID_IVPNotify2> PQVPNotify2;
typedef CComQIPtr<ITuner> PQBDATuner;
typedef CComQIPtr<IBDA_IPSinkControl> PQBDA_IPSinkControl;
typedef CComQIPtr<IDvdControl, &IID_IDvdControl> PQDVDNavigator;
typedef CComQIPtr<IVideoFrameStep> PQVideoFrameStep;
typedef CComQIPtr<IMediaEventSink> PQMediaEventSink;
typedef CComQIPtr<IVMRMonitorConfig> PQVMRMonitorConfig;
typedef CComQIPtr<IDirectDraw7, &IID_IDirectDraw7> PQDirectDraw7;
typedef CComQIPtr<IRegisterServiceProvider, &IID_IRegisterServiceProvider> PQRegisterServiceProvider;
typedef std::vector<GUID2> MediaMajorTypeList;

#if 0
typedef std::pair<PQCrossbarSwitch, long> PQBasePoint;

inline void clear(PQBasePoint &p) {p.first.Release(); p.second = 0;}
class PQPoint : public PQBasePoint {
public:
        //PQBasePoint p;
		inline PQPoint() :  PQBasePoint(PQCrossbarSwitch(), 0) {}
        inline PQPoint(const PQBasePoint &p2) : PQBasePoint(p2) {}
        inline PQPoint(const PQPoint &p2) : PQBasePoint(p2) {}
        inline PQPoint(const PQCrossbarSwitch &s, long i) : PQBasePoint(s, i) {}
        virtual ~PQPoint() { ::clear(*this); }
        inline void clear(void) { ::clear(*this); }
};
#else
typedef std::pair<PQCrossbarSwitch, long> PQPoint;
#endif

class CDevices;
class DSFilter;
class DSPin;
typedef std::vector< DSFilter, stl_smart_ptr_allocator<DSFilter> > DSFilterList;
typedef std::vector< DSPin, stl_smart_ptr_allocator<DSPin> > DSPinList;

typedef std::pair< DSFilter, CString> DSFilterID;
typedef std::vector< DSFilterID > DSFilterIDList;

typedef PQPoint XBarInputPoint, PQInputPoint;
typedef PQPoint XBarOutputPoint, PQOutputPoint;
typedef PQPoint XBarPoint;

typedef std::pair<XBarInputPoint, XBarOutputPoint> CIOPoint;
typedef std::list<CIOPoint> VWGraphPath;

class VWStream : public VWGraphPath {
public:
    //PQBasePoint p;
    VWStream() {}
    VWStream(const VWGraphPath &p2) : VWGraphPath(p2) {}
    VWStream(const VWStream &p2) : VWGraphPath(p2) {}
    virtual ~VWStream() {}
    void Route(void);
};

typedef std::list<VWStream> VWStreamList;

#ifdef _DEBUG
class DSREGPINMEDIUM;
class DSMediaType;
inline tostream &operator<<(tostream &dc, const DSREGPINMEDIUM &g);
inline tostream& operator<<(tostream &d, const PQPin &pin);
inline tostream &operator<<(tostream &dc, const DSREGPINMEDIUM &g);
inline tostream& operator<<(tostream &d, const PQPin &pin);
inline tostream& operator<<(tostream &d, const _AMMediaType *pmt);
#endif


// AM_MEDIA_TYPE:
//    GUID      majortype;
//    GUID      subtype;
//    BOOL      bFixedSizeSamples;
//    BOOL      bTemporalCompression;
//    ULONG     lSampleSize;
//    GUID      formattype;
//    IUnknown  *pUnk;
//    ULONG     cbFormat;

#define GUID0 0L, 0, 0, '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'
const AM_MEDIA_TYPE NULL_AMMEDIATYPE = {
    GUID0,
    GUID0,
    0,
    0,
    0L,
    GUID0,
    NULL,
    0L
};


// this is basically a CComQIPtr with allocate/copy semantics instead of
// refcount semantics and without the QI stuff.
// i don't know why they didn't just implement media types as an
// com object with an IMediaType interface instead of this weird alloc stuff

// REV2: investigate inheriting from CMediaType class in mtype.h.  but, i'm not using anything
// from the filter implementation class hierarchy.  and, i'd like to keep this interface division
// clean.  right now we only use dshow sdk \include which is the external interface stuff.
class DSMediaType {
public:
    AM_MEDIA_TYPE *p;

    inline DSMediaType() : p(NULL) {}
    DSMediaType(GUID majortype, GUID subtype = GUID_NULL, GUID formattype = GUID_NULL) : p(NULL) {
        try {
            p = CreateMediaType(&NULL_AMMEDIATYPE);
            if (p) {
                p->majortype            = majortype;
                p->subtype              = subtype;
                p->formattype           = formattype;
            }
        } catch(...) {
            TRACELM(TRACE_ERROR, "DSMediaType::DSMediaType(const DSMediaType) Exception");
        }
    }
    DSMediaType(const DSMediaType &d) : p(NULL) {
        try {
            if (d.p) {
                p = CreateMediaType(d.p);
            }
        } catch(...) {
            TRACELM(TRACE_ERROR, "DSMediaType::DSMediaType(const DSMediaType) Exception");
        }
    }
    DSMediaType(int a) : p(NULL) {}
    ~DSMediaType() {
        try {
            if (p) {
                DeleteMediaType(p);
                p = NULL;
            }
        } catch(...) {
            TRACELM(TRACE_ERROR, "DSMediaType::~DSMediaType() Exception");
        }
    }

    inline operator AM_MEDIA_TYPE*() const {return p;}
    inline AM_MEDIA_TYPE& operator*() const {_ASSERTE(p!=NULL); return *p; }
    inline AM_MEDIA_TYPE ** operator&() {ASSERT(p == NULL); return &p; }
    inline AM_MEDIA_TYPE * operator->() const {_ASSERTE(p!=NULL); return p; }
    inline DSMediaType * address(void) { return this; }
    inline const DSMediaType * const_address(void) const { return this; }
	typedef stl_smart_ptr_allocator<DSMediaType> stl_allocator;
    DSMediaType& operator=(const AM_MEDIA_TYPE &d) {
        if (&d != p) {
            try {
                if (p) {
                    DeleteMediaType(p);
                    p = NULL;
                }
                if (&d) {
                    p = CreateMediaType(&d);
                }
            } catch(...) {
                TRACELM(TRACE_ERROR, "DSMediaType::operator=(const AM_MEDIA_TYPE &) Exception");
            }
        }
        return *this;
    }
    DSMediaType& operator=(const AM_MEDIA_TYPE *pd) {
        try {
            if (pd != p) {
                if (p) {
                    DeleteMediaType(p);
                    p = NULL;
                }
                if (pd) {
                    p = CreateMediaType(pd);
                }
            }
        } catch(...) {
            TRACELM(TRACE_ERROR, "DSMediaType::operator=(const AM_MEDIA_TYPE *) Exception");
        }
        return *this;
    }
    DSMediaType& operator=(const DSMediaType &d) {
        try {
            if (d.const_address() != this) {
                if (p) {
                    DeleteMediaType(p);
                    p = NULL;
                }
                if (d.p) {
                    p = CreateMediaType(d.p);
                }
            }
        } catch(...) {
            TRACELM(TRACE_ERROR, "DSMediaType::operator=(DSMediaType &)Exception");
        }
        return *this;
    }
    DSMediaType& operator=(int d) {
        ASSERT(d == 0);
        try {
            if (p) {
                DeleteMediaType(p);
                p = NULL;
            }
        } catch(...) {
            TRACELM(TRACE_ERROR, "DSMediaType::operator=(int) Exception");
        }
        return *this;
    }

    inline bool operator==(const DSMediaType &d) const {
        if (!p && !d.p) {
            // both null then they're the same
            return true;
        }
        if (!p || !d.p) {
            // if either one null but not both then they aren't the same
            return false;
        }
        TRACELSM(TRACE_DETAIL, (dbgDump << "DSMediaType::operator==() this = " << *this << " d = " << d), "");
        return p->majortype == d.p->majortype &&
               (p->subtype == GUID_NULL || d.p->subtype == GUID_NULL || p->subtype == d.p->subtype);
    }
    inline bool operator==(const AM_MEDIA_TYPE &d) const {
        if (!p && !&d) {
            return true;
        }
        return p && (&d) && p->majortype == d.majortype &&
               (p->subtype == GUID_NULL || d.subtype == GUID_NULL || p->subtype == d.subtype);
    }
    inline bool operator==(const AM_MEDIA_TYPE *d) const {
        if (!p && !d) {
            return true;
        }
        return p && d && p->majortype == d->majortype &&
               (p->subtype == GUID_NULL || d->subtype == GUID_NULL || p->subtype == d->subtype);
    }
    inline bool operator!=(const DSMediaType &d) const {
        return !(*this == d);
    }
    inline bool operator!() const {
        return (p == NULL);
    }
    inline bool MatchingMajor(const AM_MEDIA_TYPE *prhs) const {
		if (!p && !prhs) {
			return true;
		}
        TRACELSM(TRACE_DETAIL, (dbgDump << "DSMediaType::MatchingMajor() this = " << *this << "\rprhs = " << prhs), "");
        return p && prhs && p->majortype == prhs->majortype;
    }
    inline bool MatchingMajor(const DSMediaType &rhs) const {
        return MatchingMajor(rhs.p);
    }

#ifdef _DEBUG
	inline tostream& operator<<(tostream &d) {
		d << p;
		if (p) {
			d << _T(" major = ") << GUID2(p->majortype) << _T(" sub = ") << GUID2(p->subtype);
		}
		return d;
	}
#endif
};

class DSFilterMoniker : public W32Moniker {
public:
    inline DSFilterMoniker() {}
    inline DSFilterMoniker(const PQMoniker &a) : W32Moniker(a) {}
    inline DSFilterMoniker(const W32Moniker &a) : W32Moniker(a) {}
    inline DSFilterMoniker(IMoniker *p) : W32Moniker(p) {}
    inline DSFilterMoniker(IUnknown *p) : W32Moniker(p) {}
    inline DSFilterMoniker(const DSFilterMoniker &a) : W32Moniker(a) {}

    CComBSTR GetName() const {
        CComVariant vName;
        vName.vt = VT_BSTR;
        HRESULT hr = (GetPropertyBag())->Read(OLESTR("FriendlyName"), &vName, NULL);
        if (FAILED(hr)) {
            TRACELM(TRACE_ERROR, "DSFilterMoniker::GetName() can't read friendly name");
            return CComBSTR();
        }
        USES_CONVERSION;
        ASSERT(vName.vt == VT_BSTR);
        CComBSTR Name(vName.bstrVal);
        return Name;
    }
    DSFilter GetFilter() const;
};

typedef Forward_Sequence<
    PQCreateDevEnum,
    PQEnumMoniker,
    DSFilterMoniker,
    ICreateDevEnum,
    IEnumMoniker,
    IMoniker*> DSDeviceSequence;

typedef Forward_Sequence<
    PQFilterMapper,
    PQEnumMoniker,
    DSFilterMoniker,
    IFilterMapper2,
    IEnumMoniker,
    IMoniker*> DSFilterMapperSequence;

typedef Forward_Sequence<
    PQPin,
    PQEnumMediaTypes,
    DSMediaType,
    IPin,
    IEnumMediaTypes,
    AM_MEDIA_TYPE*> DSPinSequence;

class DSGraph;

class DSPin : public DSPinSequence {
public:
    DSPin() {}
    DSPin(const PQPin &a) : DSPinSequence(a) {}
    DSPin(IPin *p) : DSPinSequence(p) {}
    DSPin(IUnknown *p) : DSPinSequence(p) {}
    DSPin(const DSPin &a) : DSPinSequence(a) {}

    CString GetName() const {
        CString csPinName;
        PIN_INFO pinfo;
        HRESULT hr = (*this)->QueryPinInfo(&pinfo);
        if (SUCCEEDED(hr)) {
            csPinName = pinfo.achName;
            if (pinfo.pFilter) pinfo.pFilter->Release();
        }
        return csPinName;
    }

    PIN_DIRECTION GetDirection() const {
        PIN_DIRECTION pin1dir;
        HRESULT hr = (*this)->QueryDirection(&pin1dir);
        if (FAILED(hr)) {
            TRACELM(TRACE_ERROR, "DSPin::GetDirection() can't call QueryDirection");
            THROWCOM(E_UNEXPECTED);
        }
        return pin1dir;
    }

    bool IsConnected() const {
        return GetConnection() != DSPin();
    }

	bool IsRenderable() {
		CString csName(GetName());
		if (!csName.IsEmpty() && csName.GetAt(0) == '~') {
			return false;
		}
		return true;
	}
    bool IsInput() const {
        return GetDirection() == PINDIR_INPUT;
    }
    static inline bool IsInput(const DSPin pin) {
        PIN_DIRECTION pin1dir = pin.GetDirection();
        return pin1dir == PINDIR_INPUT;
    }
    bool IsKsProxied() const;
    HRESULT GetMediums(KSMediumList &MediumList) const {
        TRACELSM(TRACE_DETAIL, (dbgDump << "DSPin::GetMediums() " << this), "");
        PQKSPin pin(*this);
        if (!pin) {
            TRACELM(TRACE_DETAIL, "DSPin::GetMedium() can't get IKsPin");
            return E_FAIL;
        }
        HRESULT hr = pin->KsQueryMediums(&MediumList);
        // undone: in win64 mediumlist.size is really __int64.  fix output operator for
        // that type and remove cast
        TRACELSM(TRACE_DETAIL, (dbgDump <<
            "DSPin::GetMediums() hr = " <<
            hr <<
            " size = " <<
            (long) MediumList.size()), "");
        return hr;
    }

    static inline bool HasCategory(DSPin& pin, const GUID2 &clsCategory, const PIN_DIRECTION pd) {
        return pin.HasCategory(clsCategory, pd);
    }

    static inline bool HasCategory(DSPin& pin, const GUID2 &clsCategory) {
        return pin.HasCategory(clsCategory);
    }

    void GetCategory(CLSID &clsCategory) const {
        ULONG outcount;

        PQKSPropertySet ps(*this);
        if (!ps) {
            TRACELM(TRACE_ERROR, "DSPin::GetCategory() can't get IKsPropertySet");
            clsCategory = GUID_NULL;
            return;
        }

        HRESULT hr = ps->Get(AMPROPSETID_Pin, AMPROPERTY_PIN_CATEGORY,
                             NULL, 0, &clsCategory, sizeof(clsCategory), &outcount);
        if (FAILED(hr)) {
            TRACELSM(TRACE_ERROR, (dbgDump << "DSPin::GetCategory() can't get pin category hr = " << hr), "");
            clsCategory = GUID_NULL;
        }
        return;
    }
    DSPin GetConnection(void) const {
        DSPin pConn;
        HRESULT hr = (*this)->ConnectedTo(&pConn);
        if (FAILED(hr) || !pConn) {
            return DSPin();
        }
#ifdef _DEBUG
        DSPin pConn2;
        hr = pConn->ConnectedTo(&pConn2);
        if (FAILED(hr) || pConn2.IsEqualObject(*this)) {
            TRACELSM(TRACE_DETAIL, (dbgDump << "DSPin::GetConnection() " << *this << " is Connected to " << pConn << " but not vice versa"), "");
        }
#endif
        return pConn;
    }
    DSMediaType GetConnectionMediaType(void) const {
        DSMediaType amt(GUID_NULL);
        HRESULT hr = (*this)->ConnectionMediaType(amt);
        if (SUCCEEDED(hr)) {
            return amt;
        } else {
            return DSMediaType();
        }
    }
    DSGraph GetGraph(void) const;
    DSFilter GetFilter(void) const;

    bool HasCategory(const GUID2 &clsCategory, const PIN_DIRECTION pd) const;
    bool HasCategory(const GUID2 &clsCategory) const;
    HRESULT Connect(DSPin ConnectTo, const AM_MEDIA_TYPE *pMediaType = NULL);
    HRESULT IntelligentConnect(DSPin ConnectTo, const AM_MEDIA_TYPE *pMediaType = NULL) {
		// undone: implement this via igb2, currently we're just connecting directly via graph mgr.
		return Connect(ConnectTo, pMediaType);
	}
    HRESULT IntelligentConnect(DSFilter& Filter1, DSFilterList &intermediates, const DWORD dwFlags = 0, const PIN_DIRECTION pd = DOWNSTREAM);
    HRESULT Disconnect(void);
    bool CanRoute(const DSPin pin2) const;

protected:
    bool Routable(const DSPin pin2) const;
};

typedef Forward_Sequence<
    PQFilter,
    PQEnumPins,
    DSPin,
    IBaseFilter ,
    IEnumPins,
    IPin*> DSFilterSequence;

inline bool _cdecl operator==(const CString &cs, const DSFilterSequence& pF);
inline bool _cdecl operator==(const CLSID &cls, const DSFilterSequence& pF);

class DSFilter : public DSFilterSequence {
public:
    DSFilter() {}
    DSFilter(const PQFilter &a) : DSFilterSequence(a) {}
    DSFilter(const DSFilterSequence &a) : DSFilterSequence(a) {}
    DSFilter(IBaseFilter *p) : DSFilterSequence(p) {}
    DSFilter(IUnknown *p) : DSFilterSequence(p) {}
    DSFilter(const DSFilter &a) : DSFilterSequence(a) {}
    DSFilter(REFCLSID rclsid, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL) : DSFilterSequence(rclsid, pUnkOuter, dwClsContext) {}
    DSGraph GetGraph(void);
    void GetPinCounts(ULONG &ulIn, ULONG &ulOut) const;
    ULONG PinCount(PIN_DIRECTION pd) {
        ULONG in, out;
        GetPinCounts(in, out);
        if (pd == PINDIR_INPUT) {
            return in;
        } else {
            return out;
        }
    }
	ULONG OutputPinCount() const {
		ULONG in, out;
		GetPinCounts(in, out);
		return out;
	}
	ULONG InputPinCount() const {
		ULONG in, out;
		GetPinCounts(in, out);
		return in;
	}
	bool HasFreePins(PIN_DIRECTION pd) const {
		int count = 0;
		for (iterator i = begin(); i != end(); ++i) {
			DSPin p(*i);
			if (p.GetDirection() != pd) {
				continue;
			}
			if (p.IsConnected()) {
				continue;
			}
			++count;
		}
		return !!count;
	}
    bool IsKsProxied() const {
        CLSID cls;
        HRESULT hr = (*this)->GetClassID(&cls);
        if (FAILED(hr)) {
            TRACELM(TRACE_ERROR, "DSFilter::IsKsProxied() can't get class id");
            return false;  // if it doesn't have a clsid it can't be the proxy
        }
#pragma warning(disable: 4800)
        return (cls == CLSID_Proxy);
#pragma warning(default: 4800)
    }
#if 0
    DSFilter *operator&() {  // using vector instead of list so don't need this
        return this;
    }
#endif
    bool IsXBar() const;
    CString GetName(void) const;
	DSPin FirstPin(PIN_DIRECTION pd = PINDIR_INPUT) const {
		for (DSFilter::iterator i = begin(); i != end(); ++i) {
			if ((*i).GetDirection() == pd) {
				return *i;
			}
		}
		return DSPin();
	}
    GUID2 ClassID() const {
        PQPersist p(*this);
        GUID2 g;
        p->GetClassID(&g);
        return g;
    }
};

typedef Forward_Sequence<
    PQGraphBuilder,
    PQEnumFilters,
    DSFilter,
    IGraphBuilder,
    IEnumFilters,
    IBaseFilter*> DSGraphContainer;

typedef std_arity3pmf<
                ICreateDevEnum, REFCLSID, IEnumMoniker **, ULONG, HRESULT
        > DSDevicesMFType;

typedef std_bndr_mf_1_3<DSDevicesMFType> DSDevicesFetchType;

class DSDevices : public DSDeviceSequence {
public:
    DSDevicesFetchType * Fetch;
    DSDevices(DSDeviceSequence &p, REFCLSID clsid) :  Fetch(NULL), DSDeviceSequence(p) {
        SetFetch(clsid);
    }
    DSDevices(PQCreateDevEnum &p, REFCLSID clsid) : Fetch(NULL), DSDeviceSequence(p) {
        SetFetch(clsid);
    }
    DSDevices(DSDevices &d) : DSDeviceSequence(d) {
        SetFetch((d.Fetch)->arg1val);
    }
    virtual DSDeviceSequence::FetchType * GetFetch() const { return Fetch; }
    ~DSDevices() { if (Fetch) delete Fetch; }
protected:
    // NOTE: this invalidates all currently outstanding iterators
    // don't use outside of construction
    void SetFetch(REFCLSID clsid) {
        if (Fetch) {
            delete Fetch;
        }
        Fetch =
            new DSDevicesFetchType(std_arity3_member(&ICreateDevEnum::CreateClassEnumerator),
                                   clsid,
                                   0);
    }

};

typedef std_arity15pmf<
                IFilterMapper2,
                IEnumMoniker **,           // enumerator returned
                DWORD,                   // 0 flags
                BOOL,                // don't match wildcards
                DWORD,                   // at least this merit needed
                BOOL,              // need at least one input pin
                DWORD,               // input media type count
                const GUID *,               // input major+sub pair array
                const REGPINMEDIUM *,      // input medium
                const CLSID*,             // input pin category
                BOOL,                   // must the input be rendered?
                BOOL,             // need at least one output pin
                DWORD,              // output media type count
                const GUID *,             // output major type
                const REGPINMEDIUM *,     // output medium
                const CLSID*,             // output pin category
                HRESULT
        > DSFilterMapperMFType;

typedef std_bndr_mf_2_3_4_5_6_7_8_9_10_11_12_13_14_15<DSFilterMapperMFType> DSFilterMapperFetchType;

class DSFilterMapper : public DSFilterMapperSequence {
public:
    DSFilterMapperFetchType *Fetch;

protected:
    // NOTE: this invalidates all currently outstanding iterators
    // don't use outside of construction
    void SetFetch(
        DWORD dwFlags,                   // 0
        BOOL bExactMatch,                // don't match wildcards
        DWORD dwMerit,                   // at least this merit needed
        BOOL  bInputNeeded,              // need at least one input pin
        DWORD cInputTypes,               // Number of input types to match
                                        // Any match is OK
        const GUID *pInputTypes, // input major+subtype pair array
        const REGPINMEDIUM *pMedIn,      // input medium
        const CLSID *pPinCategoryIn,     // input pin category
        BOOL  bRender,                   // must the input be rendered?
        BOOL  bOutputNeeded,             // need at least one output pin
        DWORD cOutputTypes,              // Number of output types to match
                                       // Any match is OK
        const GUID *pOutputTypes, // output major+subtype pair array
        const REGPINMEDIUM *pMedOut,     // output medium
        const CLSID *pPinCategoryOut     // output pin category
   ) {
        if (Fetch) {
            delete Fetch;
        }
        Fetch =
            new DSFilterMapperFetchType(std_arity15_member(&IFilterMapper2::EnumMatchingFilters),
                                        dwFlags,                   // 0
                                        bExactMatch,
                                        dwMerit,
                                        bInputNeeded,
                                        cInputTypes,               // Number of input types to match
                                        pInputTypes, // input major+subtype pair array
                                                    // Any match is OK
                                        pMedIn,
                                        pPinCategoryIn,
                                        bRender,
                                        bOutputNeeded,
                                        cOutputTypes,      // Number of output types to match
                                                           // Any match is OK
                                        pOutputTypes, // output major+subtype pair array
                                        pMedOut,
                                        pPinCategoryOut
                                       );
    }

public:
    DSFilterMapper(PQFilterMapper &p,
                   DWORD dwFlags,                   // 0
                   BOOL bExactMatch,                // don't match wildcards
                   DWORD dwMerit,                   // at least this merit needed
                   BOOL  bInputNeeded,              // need at least one input pin
                   DWORD cInputTypes,               // Number of input types to match
                                                    // Any match is OK
                   const GUID *pInputTypes, // input major+subtype pair array
                   const REGPINMEDIUM *pMedIn,      // input medium
                   const CLSID* pInCat,             // input pin category
                   BOOL  bRender,                   // must the input be rendered?
                   BOOL  bOutputNeeded,             // need at least one output pin
                   DWORD cOutputTypes,              // Number of output types to match
                                                   // Any match is OK
                   const GUID *pOutputTypes, // output major+subtype pair array
                   const REGPINMEDIUM *pMedOut,     // output medium
                   const CLSID* pOutCat             // output pin category
                  ) : Fetch(NULL), DSFilterMapperSequence(p) {
        SetFetch(
                 dwFlags,                   // 0
                 bExactMatch,
                 dwMerit,
                 bInputNeeded,
                 cInputTypes,               // Number of input types to match
                                                    // Any match is OK
                 pInputTypes, // input major+subtype pair array
                 pMedIn,
                 pInCat,
                 bRender,
                 bOutputNeeded,
                 cOutputTypes,              // Number of output types to match
                                                   // Any match is OK
                 pOutputTypes, // output major+subtype pair array
                 pMedOut,
                 pOutCat
                );
    }

    DSFilterMapper(DSFilterMapperSequence &p,
                   DWORD dwFlags,                   // 0
                   BOOL bExactMatch,                // don't match wildcards
                   DWORD dwMerit,                   // at least this merit needed
                   BOOL  bInputNeeded,              // need at least one input pin
                   DWORD cInputTypes,               // Number of input types to match
                                                    // Any match is OK
                   const GUID *pInputTypes, // input major+subtype pair array
                   const REGPINMEDIUM *pMedIn,      // input medium
                   const CLSID* pInCat,             // input pin category
                   BOOL  bRender,                   // must the input be rendered?
                   BOOL  bOutputNeeded,             // need at least one output pin
                   DWORD cOutputTypes,              // Number of output types to match
                                                   // Any match is OK
                   const GUID *pOutputTypes, // output major+subtype pair array
                   const REGPINMEDIUM *pMedOut,     // output medium
                   const CLSID* pOutCat             // output pin category
                  ) :  Fetch(NULL), DSFilterMapperSequence(p) {
        SetFetch(
                 dwFlags,                   // 0
                 bExactMatch,
                 dwMerit,
                 bInputNeeded,
                 cInputTypes,               // Number of input types to match
                                                    // Any match is OK
                 pInputTypes, // input major+subtype pair array
                 pMedIn,
                 pInCat,
                 bRender,
                 bOutputNeeded,
                 cOutputTypes,              // Number of output types to match
                                                   // Any match is OK
                 pOutputTypes, // output major+subtype pair array
                 pMedOut,
                 pOutCat
                );
    }

    DSFilterMapper(DSFilterMapper &d) : DSFilterMapperSequence(d) {
        SetFetch((d.Fetch)->arg2val, (d.Fetch)->arg3val, (d.Fetch)->arg4val, (d.Fetch)->arg5val,
                 (d.Fetch)->arg6val, (d.Fetch)->arg7val, (d.Fetch)->arg8val, (d.Fetch)->arg9val,
                 (d.Fetch)->arg10val, (d.Fetch)->arg11val, (d.Fetch)->arg12val,
                 (d.Fetch)->arg13val, (d.Fetch)->arg14val, (d.Fetch)->arg15val
                );
    }
    virtual DSFilterMapperSequence::FetchType *GetFetch() const { return Fetch; }
    ~DSFilterMapper() { if (Fetch) delete Fetch; }
};


class DSREGPINMEDIUM : public REGPINMEDIUM {
public:
    DSREGPINMEDIUM() { memset(this, 0, sizeof(*this)); }
    DSREGPINMEDIUM(REFGUID SetInit, ULONG IdInit, ULONG FlagsInit) {
        clsMedium = SetInit;
        dw1 = IdInit;
        dw2 = FlagsInit;
    }
    DSREGPINMEDIUM(DSREGPINMEDIUM &rhs) {
        clsMedium = rhs.clsMedium;
        dw1 = rhs.dw1;
        dw2 = rhs.dw2;
    }
    DSREGPINMEDIUM(KSPinMedium &rhs) {
        clsMedium = rhs.Set;
        dw1 = rhs.Id;
        dw2 = rhs.Flags;
    }

    DSREGPINMEDIUM& operator=(const KSPinMedium &rhs) {
        if (reinterpret_cast<const REGPINMEDIUM *>(&rhs) != this) {
            clsMedium = rhs.Set;
            dw1 = rhs.Id;
            dw2 = rhs.Flags;
        }
        return *this;
    }
    DSREGPINMEDIUM& operator=(const DSREGPINMEDIUM &rhs) {
        if (&rhs != this) {
            clsMedium = rhs.clsMedium;
            dw1 = rhs.dw1;
            dw2 = rhs.dw2;
        }
        return *this;
    }
    bool operator==(const DSREGPINMEDIUM &rhs) const {
        // NOTE: at some point there will be a flag in Flags to
        // indicate whether or not Id is significant for this object
        // at that point this method will need to change
        return (dw1 == rhs.dw1 && clsMedium == rhs.clsMedium);
    }
    bool operator!=(const DSREGPINMEDIUM &rhs) const {
        // NOTE: at some point there will be a flag in Flags to
        // indicate whether or not Id is significant for this object
        // at that point this method will need to change
        return !(*this == rhs);
    }
};

const long DEFAULT_GRAPH_STATE_TIMEOUT = 5000;

class DSGraph : public DSGraphContainer {
public:
    DSGraph() {}
    DSGraph(const DSGraph &a) : DSGraphContainer(a) {}
    DSGraph(const PQGraphBuilder &a) : DSGraphContainer(a) {}
    DSGraph(const DSGraphContainer &a) : DSGraphContainer(a) {}
    DSGraph(IGraphBuilder *p) : DSGraphContainer(p) {}
    DSGraph(IUnknown *p) : DSGraphContainer(p) {}

    HRESULT AddToROT(DWORD *pdwObjectRegistration);
    void RemoveFromROT(DWORD dwObjectRegistration);

    // graph operation
    inline OAFilterState GetState(long timeout = DEFAULT_GRAPH_STATE_TIMEOUT) {
        PQMediaControl pMC(*this);
        if(!pMC) {
            THROWCOM(E_UNEXPECTED);
        }
        OAFilterState state;
        HRESULT hr = pMC->GetState(timeout, &state);
        if (hr == VFW_S_CANT_CUE) {
            state = State_Paused;
        } else 	if (hr == VFW_S_STATE_INTERMEDIATE) {
            THROWCOM(HRESULT_FROM_WIN32(ERROR_INVALID_STATE));
        } else 	if (FAILED(hr)) {
            TRACELSM(TRACE_ERROR, (dbgDump << "DSGraph::GetState() can't get graph state hr = " << hr), "");
            THROWCOM(hr);
		}
        return state;
    }
    inline bool IsPlaying() {
        try {
            return GetState() == State_Running;
        } catch(...) {
            return false;
        }
    }
    inline bool IsPaused() {
        try {
            return GetState() == State_Paused;
        } catch(...) {
            return false;
        }
    }
    inline bool IsStopped() {
        try {
            return GetState() == State_Stopped;
        } catch(...) {
            return false;
        }
    }

    // graph building helpers
    HRESULT Connect(DSFilter &pStart, DSFilter &pStop, DSFilterList &Added, const DWORD dwFlags = 0, PIN_DIRECTION pFilter1Direction = DOWNSTREAM);
    bool Connect(DSFilter &pFilter1, DSFilterMoniker &pMoniker, DSFilter &pAdded, DSFilterList &NewIntermediateFilters, const DWORD dwFlags = 0, PIN_DIRECTION pFilter1Direction = DOWNSTREAM);

    typedef bool (DSGraph::*ConnectPred_t)(DSPin&, DSFilter&, DWORD dwFlags);
    typedef arity5pmf<DSGraph, DSPin&, DSFilterMoniker&, DSFilter&, DSFilterIDList &, ConnectPred_t, bool> LoadCheck_t;
    typedef arity5pmf<DSGraph, DSPin&, DSFilter&, DSFilter&, DSFilterIDList &, ConnectPred_t, bool> ConnectCheck_t;

    bool DisconnectPin(DSPin &pPin, const bool fRecurseInputs, const bool fRecurseOutputs);
    bool DisconnectFilter(DSFilter &pFilter, const bool fRecurseInputs, const bool fRecurseOutputs);
    bool RemoveFilter(DSFilter &pFilter);

    bool IsConnectable(DSPin &pPin1, DSFilter &Mapper, DSFilter &Destination, DSFilterIDList &NewFilters, const DWORD dwFlags, ConnectPred_t ConnPred);
    bool IsLoadable(DSPin &pPin1, DSFilterMoniker &Mapper, DSFilter &Destination, DSFilterIDList &IntermediateFilters, const DWORD dwFlags, ConnectPred_t ConnPred);
    bool IsPinConnected(const DSPin &pPin1, const DSFilter &pFDestination, DSFilterIDList &IntermediateFilters, const PIN_DIRECTION destdir) const;


    // generic recursive build functions
#ifdef ATTEMPT_DIRECT_CONNECT    
	bool ConnectPinDirect(DSPin &pPin, DSFilter &pFilter2, DWORD dwFlags);
#else
    bool HasMediaType(const DSMediaType &LeftMedia, const DSPin &pPinRight) const;
    bool HasMedium(const KSPinMedium &Medium1, const DSPin &pPin2) const;
    bool HasUnconnectedMedium(const DSPin &pPinLeft, const DSPin &pPin2, int& cUseable) const;
    bool HasUnconnectedMediaType(const DSPin &pPinLeft, const DSPin &pPin2, DWORD dwFlags) const;
    bool ConnectPinByMedium(DSPin &pPin, DSFilter &pFilter2, DWORD dwFlags);
    bool ConnectPinByMediaType(DSPin &pPin1, DSFilter &pFilter1, DWORD dwFlags);
#endif
    bool FindPinByMedium(DSPin &pPin, DSFilter &pFilter2, DSFilterIDList &InterediateFilters, const DWORD dwFlags);
    bool LoadPinByMedium(KSPinMedium &medium, DSPin &pPinLeft, DSFilter &pFilter2, DSFilterIDList &IntermediateFilters, const DWORD dwFlags);
    bool LoadPinByAnyMedium(DSPin &pPin, DSFilter &pFilter2, DSFilterIDList &IntermediateFilters, const DWORD dwFlags);
    bool FindPinByMediaType(DSPin &pPin, DSFilter &pFilter2, DSFilterIDList &InterediateFilters, const DWORD dwFlags);
    bool LoadPinByMediaType(DSPin &pPin1, DSFilter &pFilter1, DSFilterIDList &IntermediatesAdded, const DWORD dwFlags, const DWORD dwMerit);
    bool LoadPinByAnyMediaType(DSPin &pPin, DSFilter &pFilter2, DSFilterIDList &IntermediateFilters, const DWORD dwFlags);

	enum {
		RENDER_ALL_PINS = 0x01,
		IGNORE_EXISTING_CONNECTIONS = 0x02,
		DO_NOT_LOAD = 0x04,
        ATTEMPT_MERIT_DO_NOT_USE = 0x08,
		ATTEMPT_MERIT_UNLIKELY = 0x10,
		ALLOW_WILDCARDS = 0x20,
        IGNORE_MEDIATYPE_ERRORS = 0x40,
        DONT_TERMINATE_ON_RENDERER= 0x80,
        BIDIRECTIONAL_MEDIATYPE_MATCHING = 0x100,
	}; // render flags

    bool ConnectPin(DSPin &pPin1, DSFilter &pFilter2, DSFilterIDList &NewFilters, const DWORD dwFlags, PIN_DIRECTION pin1dir);
    bool ConnectPin(DSPin &pPin1, DSFilter &pFilter2, DSFilterList &NewFilters, const DWORD dwFlags, PIN_DIRECTION pin1dir) {
		DSFilterIDList AddedIDs;
		bool rc = ConnectPin(pPin1, pFilter2, AddedIDs, dwFlags, pin1dir);
		if (rc) {
			for (DSFilterIDList::iterator i = AddedIDs.begin(); i != AddedIDs.end(); ++i) {
				NewFilters.push_back((*i).first);
			}
		}
		return rc;
	}
    DSFilter LoadFilter(const DSFilterMoniker &pM, CString &csName);
    DSFilter AddMoniker(const DSFilterMoniker &pM);
    HRESULT AddFilter(DSFilter &pFilter, CString &csName);
    DSFilter AddFilter(const CLSID &cls, CString &csName);
    bool ConnectFilters(DSFilter &pFilter1, DSFilter &pFilter2, DSFilterIDList &NewIntermediateFilters, const DWORD dwFlags = 0, PIN_DIRECTION pFilter1Direction = DOWNSTREAM);
    int BuildGraphPath(const DSFilter& pStart, const DSFilter& pStop,
                       VWStream &path, MediaMajorTypeList& MediaList, PIN_DIRECTION direction, const DSPin &InitialInput);

    HRESULT SetMediaEventNotificationWindow(HWND h, UINT msg, long lInstance) {
        // If windowless, WM_MEDIAEVENT is processed by the timer in OnTimer
        PQMediaEventEx pme(*this);
        if (!pme) {
            return E_UNEXPECTED;
        }
        HRESULT hr = pme->CancelDefaultHandling(EC_STATE_CHANGE);
        ASSERT(SUCCEEDED(hr));

        return pme->SetNotifyWindow((OAHWND) h, msg, lInstance);

    }
};

class DSXBarPin : public DSPin {
public:
    DSXBarPin() {}
    DSXBarPin(const DSPin &p) : DSPin(p) {
        PQCrossbarSwitch px1(GetFilter());
        if (!px1) {
            THROWCOM(E_FAIL);
        }
    }
    DSXBarPin(const PQPin &p) : DSPin(p) {
        PQCrossbarSwitch px1(GetFilter());
        if (!px1) {
            THROWCOM(E_FAIL);
        }
    }
    DSXBarPin(const DSXBarPin &p) : DSPin(p) {
        PQCrossbarSwitch px1(GetFilter());
        if (!px1) {
            THROWCOM(E_FAIL);
        }
    }
    DSXBarPin(IUnknown *p) : DSPin(p) {
        PQCrossbarSwitch px1(GetFilter());
        if (!px1) {
            THROWCOM(E_FAIL);
        }
    }
    DSXBarPin(IAMCrossbar *p) : DSPin(p) {
        PQCrossbarSwitch px1(GetFilter());
        if (!px1) {
            THROWCOM(E_FAIL);
        }
    }

#if 0
    static const DSXBarPin Find(const CPinPoints &pinpoints, const PQPoint &point, PIN_DIRECTION pindir);
#endif


//    static DSPin DSPinFromIndex(const DSFilter XBar, const ULONG index);
    const PQPoint GetPoint() const;
    bool CanRoute(const DSXBarPin pin2) const;
#if 0
    void GetRelations(const CPinPoints &pinpoint,
                      CString &csName, CString &csType, CString &csRelName) const;
#endif
};

inline DSFilter DSFilterMoniker::GetFilter() const {
    DSFilter pFilter;
    HRESULT hr = (*this)->BindToObject(0, 0, __uuidof(IBaseFilter), reinterpret_cast<LPVOID *>(&pFilter));
    if (FAILED(hr)) {
        // undone: it would be useful to dump the mkr display name here....
        TRACELSM(TRACE_ERROR, (dbgDump << "DSFilterMoniker::GetFilter() can't bind to object.  hr = " << hexdump(hr)), "");
        return DSFilter();
    }
    return pFilter;
}

#ifdef _DEBUG
//void WINAPI DumpGraph(IFilterGraph *pGraph, DWORD dwLevel);
inline tostream &operator<<(tostream &dc, const DSREGPINMEDIUM &g) {
    //TRACELM(TRACE_DETAIL, "operator<<(tostream, DSREGPINMEDIUM)");
        const GUID2 g2(g.clsMedium);
        dc << _T("DSREGPINMEDIUM( ") << g2 << _T(", ") << hexdump(g.dw1) << _T(", ") << hexdump(g.dw2) << _T(")");
        return dc;
}
inline tostream& operator<<(tostream &d, const PQPin &pin) {
    const CString csPinName(const DSPin(pin).GetName());

    d << (csPinName.IsEmpty() ? CString(_T("**** UNKNOWN PIN NAME ****")) : csPinName) << " " << reinterpret_cast<void *>(pin.p);
    return d;
}

inline tostream& operator<<(tostream &d, const DSFilter &filt) {
    d << filt.GetName() << _T(" ") << reinterpret_cast<void *>(filt.p);
    return d;
}

inline tostream& operator<<(tostream &d, const _AMMediaType *pamt) {
    d << reinterpret_cast<const void *>(pamt);
    if (pamt) {
        d << _T(" major = ") << GUID2(pamt->majortype) << _T(" sub = ") << GUID2(pamt->subtype);
	}
    return d;
}
inline tostream& operator<<(tostream &d, const PQPoint &p) {
    const DSFilter pF(p.first);
    d << _T("PQPoint( ") << pF << _T(", ") << p.second << _T(")");
    return d;
}

inline tostream& operator<<(tostream &d, const CIOPoint &p) {
    d << _T("CIOPoint( ") << p.first << _T(", ") << p.second << _T(")");
    return d;
}

void DumpMediaTypes(DSPin &p1, DSPin &p2);
#endif

inline bool _cdecl operator==(const CString &cs, const DSFilterSequence& pF) {
    // filter name
    FILTER_INFO fi;
    HRESULT hr = pF->QueryFilterInfo(&fi);
    if (SUCCEEDED(hr)) {
        USES_CONVERSION;
        if (fi.pGraph) fi.pGraph->Release();
        return (cs == OLE2T(fi.achName));
    }
    return false;
}
inline bool _cdecl operator!=(const CString &cs, const DSFilterSequence& pF) {
    return !(cs == pF);
}
inline bool _cdecl operator==(const DSFilterSequence& pF, const CString &cs) {
    return (cs == pF);
}
inline bool _cdecl operator!=(const DSFilterSequence& pF, const CString &cs) {
    return !(cs == pF);
}


inline bool _cdecl operator==(const CLSID &cls, const DSFilterSequence& pF) {
    // filter name
    CLSID cid;
    HRESULT hr = pF->GetClassID(&cid);
    if (SUCCEEDED(hr)) {
#pragma warning(disable: 4800)
        return (cid == cls);
#pragma warning(default: 4800)
    }
    return false;
}

inline bool _cdecl operator!=(const CLSID &cls, const DSFilterSequence& pF) {
    return !(cls == pF);
}
inline bool _cdecl operator==(const DSFilterSequence& pF, const CLSID &cls) {
    return (cls == pF);
}

inline bool _cdecl operator!=(const DSFilterSequence& pF, const CLSID &cls) {
    return !(cls == pF);
}


typedef enum {
    tempAMPROPERTY_OvMixerOwner = 0x01  //use AMOVMIXEROWNER
} tempAMPROPERTY_NOTIFYOWNER;

typedef enum {
    tempAM_OvMixerOwner_Unknown = 0x01,
    tempAM_OvMixerOwner_BPC = 0x02
} tempAMOVMIXEROWNER;

inline bool DSPin::IsKsProxied() const {
    return GetFilter().IsKsProxied();
}
inline bool DSFilter::IsXBar() const {
    PQCrossbarSwitch px(*this);
	TRACELSM(TRACE_PAINT, (dbgDump << "DSFilter::IsXBar() " << *this << " is " << ((!px) ? " not " : "")), "crossbar");
    return !!px;
}


void CtorStaticDSExtendFwdSeqPMFs(void);
void DtorStaticDSExtendFwdSeqPMFs(void);

bool IsVideoFilter(const DSFilter& f);
bool IsVideoPin(const DSPin& p);

inline PIN_DIRECTION OppositeDirection(PIN_DIRECTION pd) {
	if (pd == PINDIR_INPUT) {
		return PINDIR_OUTPUT;
	} else {
		return PINDIR_INPUT;
	}
}

inline bool IsVideoMediaType(const DSMediaType& mt) {
    GUID2 g(mt.p->majortype);
    if ((g == MEDIATYPE_Video) || (g == MEDIATYPE_AnalogVideo)) {
        return true;
    }
    return false;
}

inline bool IsAnalogVideoCapture(const DSFilter &f) {
    return !!PQAnalogVideoDecoder(f);
}

inline bool IsIPSink(const DSFilter &f) {
    return !!PQBDA_IPSinkControl(f);
}

inline bool IsVPM(const DSFilter &f) {
    return f.ClassID() == CLSID_VideoPortManager;
}

inline bool IsVideoRenderer(const DSFilter &f) {
    return f.ClassID() == CLSID_VideoMixingRenderer;
}

inline bool IsDigitalAudioRenderer(const DSFilter &f) {
    return f.ClassID() == CLSID_DSoundRender;
}

inline bool IsAnalogVideoCaptureViewingPin(const DSPin &p) {
    GUID2 pincat;
    p.GetCategory(pincat);
    return (pincat == PIN_CATEGORY_VIDEOPORT || pincat == PIN_CATEGORY_CAPTURE);
}

inline bool IsAnalogVideoCapturePreviewPin(const DSPin &p) {
    GUID2 pincat;
    p.GetCategory(pincat);
    return (pincat == PIN_CATEGORY_PREVIEW);
}

inline bool IsDVDNavigator(const DSFilter &f) {
    return !!PQDVDNavigator(f);
}

inline bool IsL21Decoder(const DSFilter &f) {
    return !!PQLine21Decoder(f);
}

inline bool IsDVDNavigatorVideoOutPin(const DSPin &p) {
    
    DSPin::iterator iMediaType;
    for (iMediaType = p.begin(); iMediaType != p.end(); ++iMediaType) {
        DSMediaType mt(*iMediaType);
        if ((mt.p->majortype == MEDIATYPE_MPEG2_PES ||
             mt.p->majortype == MEDIATYPE_DVD_ENCRYPTED_PACK ) &&
             mt.p->subtype == MEDIASUBTYPE_MPEG2_VIDEO)
            return true;
        
        // elementary stream
        if ((mt.p->majortype == MEDIATYPE_Video)  &&
            (mt.p->subtype == MEDIASUBTYPE_MPEG2_VIDEO ||
             mt.p->subtype == MEDIASUBTYPE_RGB8   ||
             mt.p->subtype == MEDIASUBTYPE_RGB565 ||
             mt.p->subtype == MEDIASUBTYPE_RGB555 ||
             mt.p->subtype == MEDIASUBTYPE_RGB24  ||
             mt.p->subtype == MEDIASUBTYPE_RGB32))
             return true;
    }

    return false;
}

inline bool IsDVDNavigatorSubpictureOutPin(const DSPin &p) {
    
    DSPin::iterator iMediaType;
    for (iMediaType = p.begin(); iMediaType != p.end(); ++iMediaType) {
        DSMediaType mt(*iMediaType);
        if ((mt.p->majortype == MEDIATYPE_MPEG2_PES ||
             mt.p->majortype == MEDIATYPE_DVD_ENCRYPTED_PACK ) &&
             mt.p->subtype == MEDIASUBTYPE_DVD_SUBPICTURE)
            return true;

        // elementary stream
        if ((mt.p->majortype == MEDIATYPE_Video)  &&
             mt.p->subtype == MEDIASUBTYPE_DVD_SUBPICTURE)
            return true;
    }

    return false;
}

///////// DSPin
inline  HRESULT DSPin::IntelligentConnect(DSFilter& Filter1, DSFilterList &intermediates, const DWORD dwFlags, const PIN_DIRECTION pd) {
	bool rc = GetGraph().ConnectPin(*this, Filter1, intermediates, dwFlags, pd);
	if (rc) {
		return NOERROR;
	}
	return E_FAIL;
}

inline DSFilter DSPin::GetFilter(void) const {
    PIN_INFO pinfo;

    HRESULT hr = (*this)->QueryPinInfo(&pinfo);
    if (FAILED(hr)) {
        return DSFilter();
    }
    DSFilter pRet;
    pRet.p = pinfo.pFilter;  // directly transfer ownership of ref count

    return pRet;
}

inline DSGraph DSPin::GetGraph(void) const {
    DSFilter f = GetFilter();
    return f.GetGraph();
}

inline bool DSPin::HasCategory(const GUID2 &clsCategory) const {
    TRACELSM(TRACE_DETAIL, (dbgDump << "DSPin::IsPinCategory() pin = " << this), "");
    GUID2 pincat2;
    GetCategory(pincat2);
    return clsCategory == pincat2;
}

#endif
// end of file - dsextend.h