You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
341 lines
12 KiB
341 lines
12 KiB
//==========================================================================;
|
|
//
|
|
// ksextend.h : additional infrastructure to extend the ks stuff so that it
|
|
// works nicely from c++
|
|
// Copyright (c) Microsoft Corporation 1995-1997.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
#pragma once
|
|
|
|
#ifndef KSEXTEND_H
|
|
#define KSEXTEND_H
|
|
|
|
#include <strmif.h>
|
|
#include <uuids.h>
|
|
|
|
#include <ks.h>
|
|
#include <ksmedia.h>
|
|
//NOTE: ksproxy won't define IKsPin without __STREAMS__ and then it requires CMediaType from
|
|
// mtype.h
|
|
#define __STREAMS__
|
|
// for some reason in the area of media types the am guys have severely blurred the distinction
|
|
// between their public client interface for apps and their internal class hierarchy for building
|
|
// filters. mtype.h and mtype.cpp should be combined and placed into \sdk\include instead of
|
|
// classes\base\include. they should also put an ifdef MMSYSTEM_H around their definitions
|
|
// that use WAVEFORMATEX, so its not necessary to put all that stuff into your app if you're not
|
|
// using it. to work around this i'm using the following hack:
|
|
#include <mtype.h>
|
|
|
|
#include <ksproxy.h>
|
|
#include <stextend.h>
|
|
#include <w32extend.h>
|
|
|
|
const int KSMEDIUM_INPUTFLAG = 0x1;
|
|
typedef unsigned char UBYTE;
|
|
|
|
typedef CComQIPtr<IKsPropertySet, &IID_IKsPropertySet> PQKSPropertySet;
|
|
typedef CComQIPtr<IKsPin, &__uuidof(IKsPin)> PQKSPin;
|
|
|
|
class KSPinMedium : public KSIDENTIFIER {
|
|
public:
|
|
KSPinMedium() { memset(this, 0, sizeof(*this)); }
|
|
KSPinMedium(REFGUID SetInit, ULONG IdInit, ULONG FlagsInit) {
|
|
Set = SetInit;
|
|
Id = IdInit;
|
|
Flags = FlagsInit;
|
|
}
|
|
KSPinMedium(const KSPinMedium &rhs) {
|
|
Set = rhs.Set;
|
|
Id = rhs.Id;
|
|
Flags = rhs.Flags;
|
|
}
|
|
KSPinMedium(const KSIDENTIFIER &rhs) {
|
|
Set = rhs.Set;
|
|
Id = rhs.Id;
|
|
Flags = rhs.Flags;
|
|
}
|
|
|
|
KSPinMedium& operator=(const KSPinMedium &rhs) {
|
|
if (&rhs != this) {
|
|
Set = rhs.Set;
|
|
Id = rhs.Id;
|
|
Flags = rhs.Flags;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
#if 0
|
|
// hopefully we can get the ks guys to fix their anonymous union problem
|
|
// so that we don't need this hack
|
|
operator KSIDENTIFIER() { return *(reinterpret_cast<KSIDENTIFIER*>(this)); }
|
|
#endif
|
|
|
|
KSPinMedium& operator=(const KSIDENTIFIER &rhs) {
|
|
if (&rhs != reinterpret_cast<KSIDENTIFIER*>(this)) {
|
|
Set = rhs.Set;
|
|
Id = rhs.Id;
|
|
Flags = rhs.Flags;
|
|
}
|
|
return *this;
|
|
}
|
|
bool operator==(const KSPinMedium &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 (Id == rhs.Id && Set == rhs.Set);
|
|
}
|
|
bool operator!=(const KSPinMedium &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);
|
|
}
|
|
};
|
|
|
|
|
|
#ifdef _DEBUG
|
|
inline tostream &operator<<(tostream &dc, const KSPinMedium &g) {
|
|
GUID2 g2(g.Set);
|
|
dc << _T("KsPinMedium( ");
|
|
g2.Dump(dc);
|
|
dc << _T(", ") << hexdump(g.Id) << _T(", ") << hexdump(g.Flags) << _T(")");
|
|
return dc;
|
|
}
|
|
#if 0
|
|
inline CDumpContext &operator<<(CDumpContext &dc, const KSPinMedium &g) {
|
|
GUID2 g2(g.Set);
|
|
dc << "KsPinMedium( ";
|
|
g2.Dump(dc);
|
|
dc << ", " << hexdump(g.Id) << ", " << hexdump(g.Flags) << ")";
|
|
return dc;
|
|
}
|
|
|
|
template<> struct equal_to<KSPinMedium> {
|
|
bool operator()(const KSPinMedium& _X, const KSPinMedium& _Y) const {
|
|
TraceDump << "equal_to<KSPinMedium> x = " << _X << " y = " << _Y;
|
|
return (_X == _Y);
|
|
}
|
|
};
|
|
#endif
|
|
|
|
#endif
|
|
|
|
const KSPinMedium NULL_MEDIUM(GUID_NULL, 0, 0);
|
|
const KSPinMedium HOST_MEMORY_MEDIUM(KSMEDIUMSETID_Standard, 0, 0);
|
|
|
|
// this is basically a CComQIPtr with appropriate CoMem* allocate/copy semantics
|
|
// instead of refcount semantics and without the QI stuff.
|
|
class PQKsMultipleItem {
|
|
public:
|
|
KSMULTIPLE_ITEM *p;
|
|
|
|
PQKsMultipleItem() : p(NULL) {}
|
|
virtual ~PQKsMultipleItem() {
|
|
if (p) {
|
|
CoTaskMemFree(p);
|
|
p = NULL;
|
|
}
|
|
}
|
|
|
|
operator KSMULTIPLE_ITEM*() const {return p;}
|
|
KSMULTIPLE_ITEM& operator*() const {_ASSERTE(p!=NULL); return *p; }
|
|
KSMULTIPLE_ITEM ** operator&() {ASSERT(p == NULL); return &p; }
|
|
KSMULTIPLE_ITEM * operator->() const {_ASSERTE(p!=NULL); return p; }
|
|
PQKsMultipleItem * address(void) { return this; }
|
|
const PQKsMultipleItem * const_address(void) const { return this; }
|
|
|
|
// this is expensive. don't do it unless you have to.
|
|
PQKsMultipleItem& operator=(const KSMULTIPLE_ITEM &d) {
|
|
if (&d != p) {
|
|
if (p) {
|
|
CoTaskMemFree(p);
|
|
}
|
|
p = reinterpret_cast<KSMULTIPLE_ITEM *>(CoTaskMemAlloc(d.Size));
|
|
memcpy(p, &d, d.Size);
|
|
}
|
|
return *this;
|
|
}
|
|
PQKsMultipleItem& operator=(const KSMULTIPLE_ITEM *pd) {
|
|
if (pd != p) {
|
|
if (p) {
|
|
CoTaskMemFree(p);
|
|
}
|
|
p = reinterpret_cast<KSMULTIPLE_ITEM *>(CoTaskMemAlloc(pd->Size));
|
|
memcpy(p, pd, pd->Size);
|
|
}
|
|
return *this;
|
|
}
|
|
PQKsMultipleItem& operator=(const PQKsMultipleItem &d) {
|
|
if (d.const_address() != this) {
|
|
if (p) {
|
|
CoTaskMemFree(p);
|
|
}
|
|
p = reinterpret_cast<KSMULTIPLE_ITEM *>(CoTaskMemAlloc(d.p->Size));
|
|
memcpy(p, d.p, d.p->Size);
|
|
}
|
|
return *this;
|
|
}
|
|
PQKsMultipleItem& operator=(int d) {
|
|
if (p) {
|
|
CoTaskMemFree(p);
|
|
p = NULL;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
#if 0
|
|
bool operator==(const PQKsMultipleItem &d) const {
|
|
return p->majortype == d.p->majortype &&
|
|
(p->subtype == GUID_NULL || d.p->subtype == GUID_NULL || p->subtype == d.p->subtype);
|
|
}
|
|
bool operator!=(const PQKsMultipleItem &d) const {
|
|
return !(*this == d);
|
|
}
|
|
#endif
|
|
|
|
private:
|
|
// i don't want spend the time to do a layered refcounted implementation here
|
|
// but since these are CoTaskMem alloc'd we can't have multiple ref's without
|
|
// a high risk of leaks. so we're just going to disallow the copy constructor
|
|
// since copying is expensive anyway. we will allow explicit assignment which will
|
|
// do a copy
|
|
|
|
PQKsMultipleItem(const PQKsMultipleItem &d);
|
|
|
|
};
|
|
|
|
// this is a stl based template for containing KSMULTIPLEITEM lists
|
|
// i've only implemented the stuff i need for certain of the stl predicates so this
|
|
// isn't a complete collection with a true random access or bidirectional iterator
|
|
// furthermore this won't work correctly with hterogeneous KSMULTIPLEITEM lists it
|
|
// also won't work right for KSMI lists that have sizes and count headers in the sub items.
|
|
// it could be easily extended to do all of these things but i don't have time and all
|
|
// i need it for is mediums
|
|
|
|
// Base is smart pointer wrapper class being contained in this container
|
|
// Base_Inner is actual wrapped class that the smart pointer class contains
|
|
template<class Value_Type, class Allocator = std::allocator<Value_Type> > class KsMultipleItem_Sequence : public PQKsMultipleItem {
|
|
public:
|
|
|
|
typedef typename Allocator::value_type value_type;
|
|
typedef typename Allocator::size_type size_type;
|
|
typedef typename Allocator::difference_type difference_type;
|
|
typedef Allocator allocator_type;
|
|
typedef typename Allocator::pointer value_ptr;
|
|
typedef typename Allocator::const_pointer value_cptr;
|
|
typedef typename Allocator::reference reference;
|
|
typedef typename Allocator::const_reference const_reference;
|
|
|
|
|
|
// CLASS iterator
|
|
class iterator;
|
|
friend class iterator;
|
|
class iterator : public std::_Bidit<Value_Type, difference_type> {
|
|
public:
|
|
iterator(KsMultipleItem_Sequence<Value_Type, Allocator> *outerinit = NULL, value_type *currentinit = NULL) :
|
|
outer(outerinit), current(currentinit) {}
|
|
iterator(iterator &e) : current(e.current), outer(e.outer) {}
|
|
reference operator*() const {return *current;}
|
|
value_ptr operator->() const {return current; }
|
|
iterator& operator++() {
|
|
if (current) {
|
|
current++;
|
|
if (current >= reinterpret_cast<value_type *>(reinterpret_cast<UBYTE *>(outer->p) + outer->p->Size)) {
|
|
current = NULL;
|
|
}
|
|
} else {
|
|
current = reinterpret_cast<value_type *>(const_cast<UBYTE *>(reinterpret_cast<const UBYTE *>(outer->p)) + sizeof(KSMULTIPLE_ITEM));
|
|
}
|
|
return *this;
|
|
}
|
|
iterator& operator++(int) {
|
|
iterator Tmp = *this;
|
|
++*this;
|
|
return Tmp;
|
|
}
|
|
iterator& operator--() {
|
|
if (current) {
|
|
current--;
|
|
if (current < reinterpret_cast<value_type *>(const_cast<UBYTE *>(reinterpret_cast<const UBYTE *>(outer->p)) + sizeof(KSMULTIPLE_ITEM))) {
|
|
current = NULL;
|
|
}
|
|
} else {
|
|
current = reinterpret_cast<value_type *>(reinterpret_cast<UBYTE *>(outer->p) + (outer->p->Size - sizeof(value_type)));
|
|
}
|
|
return (*this);
|
|
}
|
|
iterator operator--(int) {
|
|
iterator _Tmp = *this;
|
|
--*this;
|
|
return (_Tmp);
|
|
}
|
|
bool operator==(const iterator& rhs) const
|
|
{return (current == rhs.current); }
|
|
bool operator!=(const iterator& rhs) const
|
|
{return (!(*this == rhs)); }
|
|
protected:
|
|
value_type *current;
|
|
const KsMultipleItem_Sequence<Value_Type, Allocator> *outer;
|
|
};
|
|
// CLASS const_iterator
|
|
class const_iterator;
|
|
friend class const_iterator;
|
|
class const_iterator : public iterator {
|
|
public:
|
|
const_iterator(const KsMultipleItem_Sequence<Value_Type, Allocator> *outerinit = NULL, value_type *currentinit = NULL) {
|
|
outer = outerinit;
|
|
current = currentinit;
|
|
}
|
|
const_iterator(const_iterator &e) {
|
|
current = e.current;
|
|
outer = e.outer;
|
|
}
|
|
const_reference operator*() const {return iterator::operator*(); }
|
|
value_cptr operator->() const {return iterator::operator->(); }
|
|
const_iterator& operator++() { iterator::operator++(); return *this;}
|
|
const_iterator operator++(int) {
|
|
const_iterator Tmp = *this;
|
|
++*this;
|
|
return (Tmp);
|
|
}
|
|
const_iterator& operator--() {iterator::operator--(); return (*this); }
|
|
const_iterator operator--(int) {
|
|
const_iterator Tmp = *this;
|
|
--*this;
|
|
return (Tmp);
|
|
}
|
|
bool operator==(const const_iterator& rhs) const
|
|
{return iterator::operator==(rhs); }
|
|
bool operator!=(const const_iterator& rhs) const
|
|
{return (!(*this == rhs)); }
|
|
};
|
|
|
|
KsMultipleItem_Sequence() {}
|
|
virtual ~KsMultipleItem_Sequence() {}
|
|
iterator begin() {
|
|
return iterator(this, ((p->Count) ? reinterpret_cast<value_ptr>(reinterpret_cast<UBYTE *>(p) + sizeof(KSMULTIPLE_ITEM)) : NULL));
|
|
}
|
|
const_iterator begin() const {
|
|
return const_iterator(this, ((p->Count) ? reinterpret_cast<value_ptr>(reinterpret_cast<UBYTE *>(p) + sizeof(KSMULTIPLE_ITEM)) : NULL));
|
|
}
|
|
iterator end() { return iterator(); }
|
|
const_iterator end() const { return const_iterator(); }
|
|
size_type size() const {
|
|
return p->Count;
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
// no copy constructor, its too expensive. see PQKsMultiple item for further details
|
|
KsMultipleItem_Sequence(KsMultipleItem_Sequence &a);
|
|
KsMultipleItem_Sequence(PQKsMultipleItem &a);
|
|
|
|
};
|
|
|
|
typedef KsMultipleItem_Sequence<KSPinMedium> KSMediumList;
|
|
|
|
|
|
#endif
|
|
// end of file - ksextend.h
|