ksproxy.cpp File Reference

#include "precomp.h"

Include dependency graph for ksproxy.cpp:

Go to the source code of this file.

Functions
KSDDKAPI HRESULT WINAPI	KsSynchronousDeviceControl (HANDLE Handle, ULONG IoControl, PVOID InBuffer, ULONG InLength, PVOID OutBuffer, ULONG OutLength, PULONG BytesReturned)
KSDDKAPI HRESULT WINAPI	KsResolveRequiredAttributes (PKSDATARANGE DataRange, KSMULTIPLE_ITEM *Attributes OPTIONAL)
KSDDKAPI HRESULT WINAPI	KsOpenDefaultDevice (REFGUID Category, ACCESS_MASK Access, PHANDLE DeviceHandle)
KSDDKAPI HRESULT WINAPI	KsGetMultiplePinFactoryItems (HANDLE FilterHandle, ULONG PinFactoryId, ULONG PropertyId, PVOID *Items)
KSDDKAPI HRESULT WINAPI	KsGetMediaTypeCount (HANDLE FilterHandle, ULONG PinFactoryId, ULONG *MediaTypeCount)
KSDDKAPI HRESULT WINAPI	KsGetMediaType (int Position, AM_MEDIA_TYPE *AmMediaType, HANDLE FilterHandle, ULONG PinFactoryId)
KSDDKAPI HRESULT WINAPI	DllUnregisterServer (void)
KSDDKAPI HRESULT WINAPI	DllRegisterServer (void)
KSDDKAPI HRESULT WINAPI	DllGetClassObject (REFCLSID rclsid, REFIID riid, LPVOID *ppv)
KSDDKAPI HRESULT WINAPI	DllCanUnloadNow (void)

Variables
const GUID	CLSID_KsClockForwarder = {0x877e4351, 0x6fea, 0x11d0, {0xb8, 0x63, 0x00, 0xaa, 0x00, 0xa2, 0x16, 0xa1}}
const GUID	CLSID_KsQualityForwarder = {0xe05592e4, 0xc0b5, 0x11d0, {0xa4, 0x39, 0x00, 0xa0, 0xc9, 0x22, 0x31, 0x96}}
const GUID	CLSID_KsIBasicAudioInterfaceHandler = {0xb9f8ac3e, 0x0f71, 0x11d2, {0xb7, 0x2c, 0x00, 0xc0, 0x4f, 0xb6, 0xbd, 0x3d}}
static INTERFACE_TABLE	InterfaceTable []

Function Documentation

DllCanUnloadNow()

KSDDKAPI HRESULT WINAPI DllCanUnloadNow

(

void

)

Definition at line 441 of file ksproxy.cpp.

{
    return S_OK;
}

DllGetClassObject()

KSDDKAPI HRESULT WINAPI DllGetClassObject	(	REFCLSID	rclsid,
		REFIID	riid,
		LPVOID *	ppv
	)

Definition at line 404 of file ksproxy.cpp.

{
    UINT i;
    HRESULT hres = E_OUTOFMEMORY;
    IClassFactory * pcf = NULL;
 
    if (!ppv)
        return E_INVALIDARG;
 
    *ppv = NULL;
 
    for (i = 0; InterfaceTable[i].riid; i++)
    {
        if (IsEqualIID(*InterfaceTable[i].riid, rclsid))
        {
            pcf = CClassFactory_fnConstructor(InterfaceTable[i].lpfnCI, NULL, NULL);
            break;
        }
    }
 
    if (!pcf)
    {
        return CLASS_E_CLASSNOTAVAILABLE;
    }
 
    hres = pcf->QueryInterface(riid, ppv);
    pcf->Release();
 
    return hres;
}

DllRegisterServer()

KSDDKAPI HRESULT WINAPI DllRegisterServer

(

void

)

Definition at line 364 of file ksproxy.cpp.

{
    ULONG Index = 0;
    LPOLESTR pStr;
    HRESULT hr = S_OK;
    HKEY hClass, hKey, hSubKey;
    static LPCWSTR ModuleName = L"ksproxy.ax";
    static LPCWSTR ThreadingModel = L"Both";
 
    if (RegOpenKeyExW(HKEY_CLASSES_ROOT, L"CLSID", 0, KEY_WRITE, &hClass) != ERROR_SUCCESS)
        return E_FAIL;
 
    do
    {
        hr = StringFromCLSID(*InterfaceTable[Index].riid, &pStr);
        if (FAILED(hr))
            break;
 
        if (RegCreateKeyExW(hClass, pStr, 0, 0, 0, KEY_WRITE, NULL, &hKey, 0) == ERROR_SUCCESS)
        {
            if (RegCreateKeyExW(hKey, L"InprocServer32", 0, 0, 0, KEY_WRITE, NULL, &hSubKey, 0) == ERROR_SUCCESS)
            {
                RegSetValueExW(hSubKey, 0, 0, REG_SZ, (const BYTE*)ModuleName, (wcslen(ModuleName) + 1) * sizeof(WCHAR));
                RegSetValueExW(hSubKey, L"ThreadingModel", 0, REG_SZ, (const BYTE*)ThreadingModel, (wcslen(ThreadingModel) + 1) * sizeof(WCHAR));
                RegCloseKey(hSubKey);
            }
            RegCloseKey(hKey);
        }
 
        CoTaskMemFree(pStr);
        Index++;
    }while(InterfaceTable[Index].lpfnCI != 0);
 
    RegCloseKey(hClass);
    return hr;
}

DllUnregisterServer()

KSDDKAPI HRESULT WINAPI DllUnregisterServer

(

void

)

Definition at line 335 of file ksproxy.cpp.

{
    ULONG Index = 0;
    LPOLESTR pStr;
    HRESULT hr = S_OK;
    HKEY hClass;
 
    if (RegOpenKeyExW(HKEY_CLASSES_ROOT, L"CLSID", 0, KEY_SET_VALUE, &hClass) != ERROR_SUCCESS)
        return E_FAIL;
 
    do
    {
        hr = StringFromCLSID(*InterfaceTable[Index].riid, &pStr);
        if (FAILED(hr))
            break;
 
        RegDeleteKeyW(hClass, pStr);
        CoTaskMemFree(pStr);
        Index++;
    }while(InterfaceTable[Index].lpfnCI != 0);
 
    RegCloseKey(hClass);
    return hr;
}

KsGetMediaType()

KSDDKAPI HRESULT WINAPI KsGetMediaType	(	int	Position,
		AM_MEDIA_TYPE *	AmMediaType,
		HANDLE	FilterHandle,
		ULONG	PinFactoryId
	)

Definition at line 250 of file ksproxy.cpp.

{
    HRESULT hr;
    PKSMULTIPLE_ITEM ItemList;
    int i = 0;
    PKSDATAFORMAT DataFormat;
 
    if (Position < 0)
        return E_INVALIDARG;
 
    // get current supported ranges
    hr = KsGetMultiplePinFactoryItems(FilterHandle, PinFactoryId, KSPROPERTY_PIN_CONSTRAINEDDATARANGES, (PVOID*)&ItemList);
    if (FAILED(hr))
    {
        // get standard dataranges
        hr = KsGetMultiplePinFactoryItems(FilterHandle, PinFactoryId, KSPROPERTY_PIN_DATARANGES, (PVOID*)&ItemList);
 
        //check for success
        if (FAILED(hr))
            return hr;
    }
 
    if ((ULONG)Position >= ItemList->Count)
    {
        // out of bounds
        CoTaskMemFree(ItemList);
        return MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NO_MORE_ITEMS);
    }
 
    // goto first datarange
    DataFormat = (PKSDATAFORMAT)(ItemList + 1);
 
    while(i != Position)
    {
        // goto next format;
        DataFormat = (PKSDATAFORMAT)(ULONG_PTR)(DataFormat + DataFormat->FormatSize);
        i++;
    }
 
 
    DataFormat->FormatSize -= sizeof(KSDATAFORMAT);
    if (DataFormat->FormatSize)
    {
         // copy extra format buffer
        AmMediaType->pbFormat = (BYTE*)CoTaskMemAlloc(DataFormat->FormatSize);
        if (!AmMediaType->pbFormat)
        {
            // not enough memory
            CoTaskMemFree(ItemList);
            return E_OUTOFMEMORY;
        }
        // copy format buffer
        CopyMemory(AmMediaType->pbFormat, (DataFormat + 1), DataFormat->FormatSize);
        AmMediaType->cbFormat = DataFormat->FormatSize;
    }
    else
    {
        // no format buffer
        AmMediaType->pbFormat = NULL;
        AmMediaType->cbFormat = 0;
    }
 
    // copy type info
    CopyMemory(&AmMediaType->majortype, &DataFormat->MajorFormat, sizeof(GUID));
    CopyMemory(&AmMediaType->subtype, &DataFormat->SubFormat, sizeof(GUID));
    CopyMemory(&AmMediaType->formattype, &DataFormat->Specifier, sizeof(GUID));
    AmMediaType->bTemporalCompression = FALSE; //FIXME verify
    AmMediaType->pUnk = NULL; //FIXME
    AmMediaType->lSampleSize = DataFormat->SampleSize;
    AmMediaType->bFixedSizeSamples = (AmMediaType->lSampleSize) ? TRUE : FALSE;
 
    // free dataformat list
    CoTaskMemFree(ItemList);
 
    return NOERROR;
}

Referenced by CInputPin::CInputPin(), COutputPin::COutputPin(), CInputPin::EnumMediaTypes(), and COutputPin::EnumMediaTypes().

KsGetMediaTypeCount()

KSDDKAPI HRESULT WINAPI KsGetMediaTypeCount	(	HANDLE	FilterHandle,
		ULONG	PinFactoryId,
		ULONG *	MediaTypeCount
	)

Definition at line 216 of file ksproxy.cpp.

{
    PKSMULTIPLE_ITEM MultipleItem;
    HRESULT hr;
 
    /* try get constrained data ranges */
    hr = KsGetMultiplePinFactoryItems(FilterHandle, PinFactoryId, KSPROPERTY_PIN_CONSTRAINEDDATARANGES, (PVOID*)&MultipleItem);
 
    /* check for failure*/
    if (FAILED(hr))
    {
        /* try getting default data ranges */
        hr = KsGetMultiplePinFactoryItems(FilterHandle, PinFactoryId, KSPROPERTY_PIN_DATARANGES, (PVOID*)&MultipleItem);
    }
 
    if (SUCCEEDED(hr))
    {
        /* store number of media types */
        *MediaTypeCount = MultipleItem->Count;
 
        /* free memory */
        CoTaskMemFree(MultipleItem);
    }
 
    /* done */
    return hr;
}

Referenced by CInputPin::EnumMediaTypes(), and COutputPin::EnumMediaTypes().

KsGetMultiplePinFactoryItems()

KSDDKAPI HRESULT WINAPI KsGetMultiplePinFactoryItems	(	HANDLE	FilterHandle,
		ULONG	PinFactoryId,
		ULONG	PropertyId,
		PVOID *	Items
	)

Definition at line 154 of file ksproxy.cpp.

{
    KSP_PIN Property;
    ULONG BytesReturned, NumData;
    HRESULT hResult;
 
    /* zero pin property */
    RtlZeroMemory(&Property, sizeof(KSP_PIN));
    Property.Property.Set = KSPROPSETID_Pin;
    Property.Property.Id = PropertyId;
    Property.Property.Flags = KSPROPERTY_TYPE_GET;
    Property.PinId = PinFactoryId;
 
    /* query pin factory */
    hResult = KsSynchronousDeviceControl(FilterHandle, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSP_PIN), NULL, 0, &BytesReturned);
 
    if (hResult == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_INSUFFICIENT_BUFFER))
    {
        /* buffer too small */
        hResult = KsSynchronousDeviceControl(FilterHandle, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSP_PIN), (PVOID)&NumData, sizeof(ULONG), &BytesReturned);
 
        if (SUCCEEDED(hResult))
        {
            /* store required data size */
            BytesReturned = NumData;
            hResult = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_MORE_DATA);
        }
    }
 
    if (hResult == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_MORE_DATA))
    {
        /* allocate data */
        *Items = CoTaskMemAlloc(BytesReturned);
 
        if (!*Items)
        {
            /* no memory */
            return E_OUTOFMEMORY;
        }
 
        /* retry querying property */
        hResult = KsSynchronousDeviceControl(FilterHandle, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSP_PIN), (PVOID)*Items, BytesReturned, &BytesReturned);
 
        /* check for success */
        if (FAILED(hResult))
        {
            /* free memory */
            CoTaskMemFree(*Items);
        }
    }
 
    /* done */
    return hResult;
}

Referenced by CInputPin::CheckFormat(), COutputPin::CheckFormat(), KsGetMediaType(), KsGetMediaTypeCount(), CInputPin::KsQueryInterfaces(), COutputPin::KsQueryInterfaces(), CInputPin::KsQueryMediums(), and COutputPin::KsQueryMediums().

KsOpenDefaultDevice()

KSDDKAPI HRESULT WINAPI KsOpenDefaultDevice	(	REFGUID	Category,
		ACCESS_MASK	Access,
		PHANDLE	DeviceHandle
	)

Definition at line 101 of file ksproxy.cpp.

{
    HDEVINFO hList;
    SP_DEVICE_INTERFACE_DATA DeviceInterfaceData;
    PSP_DEVICE_INTERFACE_DETAIL_DATA_W DeviceInterfaceDetailData;
    WCHAR Path[MAX_PATH+sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W)];
 
    /* open device list */
    hList = SetupDiGetClassDevsW(&Category, NULL, NULL, DIGCF_DEVICEINTERFACE  | DIGCF_PRESENT);
 
    if (hList == INVALID_HANDLE_VALUE)
    {
        /* failed */
        return MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, GetLastError());
    }
 
    /* setup parameters */
    DeviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
 
    if (SetupDiEnumDeviceInterfaces(hList, NULL, &Category, 0, &DeviceInterfaceData))
    {
        /* setup interface data struct */
        DeviceInterfaceDetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA_W)Path;
        DeviceInterfaceDetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W);
 
        /* get device interface details */
        if (SetupDiGetDeviceInterfaceDetailW(hList, &DeviceInterfaceData, DeviceInterfaceDetailData, sizeof(Path), NULL, NULL))
        {
            /* open device */
            *DeviceHandle = CreateFileW(DeviceInterfaceDetailData->DevicePath, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED | FILE_ATTRIBUTE_NORMAL, NULL);
 
            if (*DeviceHandle != INVALID_HANDLE_VALUE)
            {
                /* operation succeeded */
                SetupDiDestroyDeviceInfoList(hList);
                return NOERROR;
            }
        }
    }
 
    /* free device list */
    SetupDiDestroyDeviceInfoList(hList);
 
    /* failed */
    return MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, GetLastError());
}

Referenced by CKsClockForwarder_Constructor(), and CKsQualityForwarder_Constructor().

KsResolveRequiredAttributes()

KSDDKAPI HRESULT WINAPI KsResolveRequiredAttributes	(	PKSDATARANGE	DataRange,
		KSMULTIPLE_ITEM *Attributes	OPTIONAL
	)

Definition at line 90 of file ksproxy.cpp.

{
    //UNIMPLEMENTED
    return NOERROR;
}

KsSynchronousDeviceControl()

KSDDKAPI HRESULT WINAPI KsSynchronousDeviceControl	(	HANDLE	Handle,
		ULONG	IoControl,
		PVOID	InBuffer,
		ULONG	InLength,
		PVOID	OutBuffer,
		ULONG	OutLength,
		PULONG	BytesReturned
	)

Definition at line 34 of file ksproxy.cpp.

{
    OVERLAPPED Overlapped;
    DWORD Transferred;
 
    /* zero overlapped */
    RtlZeroMemory(&Overlapped, sizeof(OVERLAPPED));
 
    /* create notification event */
    Overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
 
    if (!Overlapped.hEvent)
    {
        /* failed */
        return MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, GetLastError());
    }
 
    if (!DeviceIoControl(Handle, IoControl, InBuffer, InLength, OutBuffer, OutLength, BytesReturned, &Overlapped))
    {
        /* operation failed */
        if (GetLastError() != ERROR_IO_PENDING)
        {
            /* failed */
            CloseHandle(Overlapped.hEvent);
            return MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, GetLastError());
        }
    }
 
    /* get result of pending operation */
    if (!GetOverlappedResult(Handle, &Overlapped, &Transferred, TRUE))
    {
        /* failed */
        CloseHandle(Overlapped.hEvent);
        return MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, GetLastError());
    }
 
    /* store number of bytes transferred */
    *BytesReturned = Transferred;
 
    /* close event object */
    CloseHandle(Overlapped.hEvent);
 
    /* done */
    return NOERROR;
}

Referenced by CKsProxy::AdvisePeriodic(), CKsProxy::AdviseTime(), CBDADeviceControl::CheckChanges(), CBDADeviceControl::CommitChanges(), CKsProxy::ConvertTimeFormat(), CBDADeviceControl::CreateTopology(), CKsProxy::GetAvailable(), CKsProxy::GetCapabilities(), CBDADeviceControl::GetControlNode(), CKsProxy::GetCurrentPosition(), CKsProxy::GetDuration(), CKsProxy::GetMediaSeekingFormats(), CBDADeviceControl::GetNodeDescriptors(), CBDADeviceControl::GetNodeInterfaces(), CBDADeviceControl::GetNodeTypes(), CKsProxy::GetNumberOfPins(), CKsProxy::GetPinCommunication(), CKsProxy::GetPinDataflow(), CBDAPinControl::GetPinID(), CKsProxy::GetPinInstanceCount(), CKsProxy::GetPinName(), CBDAPinControl::GetPinType(), CBDADeviceControl::GetPinTypes(), CKsProxy::GetPreroll(), CKsProxy::GetStopPosition(), CInputPin::GetSupportedSets(), COutputPin::GetSupportedSets(), CKsProxy::GetSupportedSets(), CKsProxy::GetTime(), CKsProxy::GetTimeFormat(), CInputPin::KsEvent(), CKsNode::KsEvent(), COutputPin::KsEvent(), CKsProxy::KsEvent(), KsGetMultiplePinFactoryItems(), CInputPin::KsMethod(), CKsNode::KsMethod(), COutputPin::KsMethod(), CKsProxy::KsMethod(), CInputPin::KsProperty(), CKsNode::KsProperty(), COutputPin::KsProperty(), CKsProxy::KsProperty(), CKsProxy::PerformClockProperty(), CKsClockForwarder::SetClockState(), CKsProxy::SetPinState(), CKsProxy::SetPositions(), CKsProxy::SetSyncSource(), CKsProxy::SetTimeFormat(), CBDADeviceControl::StartChanges(), and CKsProxy::Unadvise().

Variable Documentation

CLSID_KsClockForwarder

const GUID CLSID_KsClockForwarder = {0x877e4351, 0x6fea, 0x11d0, {0xb8, 0x63, 0x00, 0xaa, 0x00, 0xa2, 0x16, 0xa1}}

Definition at line 14 of file ksproxy.cpp.

CLSID_KsIBasicAudioInterfaceHandler

const GUID CLSID_KsIBasicAudioInterfaceHandler = {0xb9f8ac3e, 0x0f71, 0x11d2, {0xb7, 0x2c, 0x00, 0xc0, 0x4f, 0xb6, 0xbd, 0x3d}}

Definition at line 16 of file ksproxy.cpp.

CLSID_KsQualityForwarder

const GUID CLSID_KsQualityForwarder = {0xe05592e4, 0xc0b5, 0x11d0, {0xa4, 0x39, 0x00, 0xa0, 0xc9, 0x22, 0x31, 0x96}}

Definition at line 15 of file ksproxy.cpp.

InterfaceTable

INTERFACE_TABLE InterfaceTable[]

static

Initial value:

=
{
    {&MEDIATYPE_Audio, CKsDataTypeHandler_Constructor},
    {&KSINTERFACESETID_Standard, CKsInterfaceHandler_Constructor},
    {&CLSID_KsClockForwarder, CKsClockForwarder_Constructor},
    {&CLSID_KsQualityForwarder, CKsQualityForwarder_Constructor},
    {&IID_IVPConfig, CVPConfig_Constructor},
    {&IID_IVPVBIConfig, CVPVBIConfig_Constructor},
    {&CLSID_KsIBasicAudioInterfaceHandler, CKsBasicAudio_Constructor},
    {&CLSID_Proxy, CKsProxy_Constructor},
    {NULL, NULL}
}

Definition at line 18 of file ksproxy.cpp.

Referenced by DllGetClassObject(), DllRegisterServer(), and DllUnregisterServer().