[PATCH] wmvcore: Add WMReader stubs.
Jefferson Carpenter
jeffersoncarpenter2 at gmail.com
Wed Mar 29 18:18:56 CDT 2017
Adds most of the interfaces needed by IMesh in bug 42416. Interfaces in
that bug report that are not in this patch are
56a86897-0ad4-11ce-b03a-0020af0ba770
5c938aeb-6378-479e-bfd5-eafba63dc6e9
7af7d5ed-4ef9-48da-a4b6-8ea7eb38f5cc
as those guids are not documented on this page:
https://msdn.microsoft.com/en-us/library/windows/desktop/dd743266(v=vs.85).aspx
FIXME statements in the new stub functions only output the WMReader
pointer, none of the passed arguments. This is because I do not yet
have an editor macro to generate the format strings.
I have not written unit tests for this code. I would like to add some
wmvcore tests, but am not very familiar with Wine's build system
autotools, and have not been able to get tests to compile and run.
Tested in Rise of Legends. The added interfaces are queried.
Signed-off-by: Jefferson Carpenter
---
dlls/wmvcore/wmvcore_main.c | 1234 +++++++++++++++++++++++++++++++++++++++++++
include/wmsdkidl.idl | 658 +++++++++++++++++++++++
2 files changed, 1892 insertions(+)
diff --git a/dlls/wmvcore/wmvcore_main.c b/dlls/wmvcore/wmvcore_main.c
index d196079698e7..1f382c90d1e0 100644
--- a/dlls/wmvcore/wmvcore_main.c
+++ b/dlls/wmvcore/wmvcore_main.c
@@ -59,6 +59,15 @@ HRESULT WINAPI WMCreateEditor(IWMMetadataEditor **editor)
typedef struct {
IWMReader IWMReader_iface;
IWMReaderAdvanced6 IWMReaderAdvanced6_iface;
+ IWMDRMReader3 IWMDRMReader3_iface;
+ IWMHeaderInfo3 IWMHeaderInfo3_iface;
+ IWMPacketSize2 IWMPacketSize2_iface;
+ IWMProfile3 IWMProfile3_iface;
+ IWMReaderAccelerator IWMReaderAccelerator_iface;
+ IWMReaderTimecode IWMReaderTimecode_iface;
+ IWMReaderNetworkConfig2 IWMReaderNetworkConfig2_iface;
+ IWMReaderStreamClock IWMReaderStreamClock_iface;
+ IWMReaderTypeNegotiation IWMReaderTypeNegotiation_iface;
LONG ref;
} WMReader;
@@ -95,6 +104,48 @@ static HRESULT WINAPI WMReader_QueryInterface(IWMReader *iface, REFIID riid, voi
}else if(IsEqualGUID(riid, &IID_IWMReaderAdvanced6)) {
TRACE("(%p)->(IID_IWMReaderAdvanced6 %p)\n", This, ppv);
*ppv = &This->IWMReaderAdvanced6_iface;
+ }else if(IsEqualGUID(riid, &IID_IWMDRMReader)) {
+ TRACE("(%p)->(IID_IWMDRMReader %p)\n", This, ppv);
+ *ppv = &This->IWMDRMReader3_iface;
+ }else if(IsEqualGUID(riid, &IID_IWMDRMReader2)) {
+ TRACE("(%p)->(IID_IWMDRMReader2 %p)\n", This, ppv);
+ *ppv = &This->IWMDRMReader3_iface;
+ }else if(IsEqualGUID(riid, &IID_IWMHeaderInfo)) {
+ TRACE("(%p)->(IID_IWMHeaderInfo %p)\n", This, ppv);
+ *ppv = &This->IWMHeaderInfo3_iface;
+ }else if(IsEqualGUID(riid, &IID_IWMHeaderInfo2)) {
+ TRACE("(%p)->(IID_IWMHeaderInfo2 %p)\n", This, ppv);
+ *ppv = &This->IWMHeaderInfo3_iface;
+ }else if(IsEqualGUID(riid, &IID_IWMHeaderInfo3)) {
+ TRACE("(%p)->(IID_IWMHeaderInfo3 %p)\n", This, ppv);
+ *ppv = &This->IWMHeaderInfo3_iface;
+ }else if(IsEqualGUID(riid, &IID_IWMPacketSize)) {
+ TRACE("(%p)->(IID_IWMPacketSize %p)\n", This, ppv);
+ *ppv = &This->IWMPacketSize2_iface;
+ }else if(IsEqualGUID(riid, &IID_IWMPacketSize2)) {
+ TRACE("(%p)->(IID_IWMPacketSize2 %p)\n", This, ppv);
+ *ppv = &This->IWMPacketSize2_iface;
+ }else if(IsEqualGUID(riid, &IID_IWMProfile)) {
+ TRACE("(%p)->(IID_IWMProfile %p)\n", This, ppv);
+ *ppv = &This->IWMProfile3_iface;
+ }else if(IsEqualGUID(riid, &IID_IWMProfile2)) {
+ TRACE("(%p)->(IID_IWMProfile2 %p)\n", This, ppv);
+ *ppv = &This->IWMProfile3_iface;
+ }else if(IsEqualGUID(riid, &IID_IWMProfile3)) {
+ TRACE("(%p)->(IID_IWMProfile3 %p)\n", This, ppv);
+ *ppv = &This->IWMProfile3_iface;
+ }else if(IsEqualGUID(riid, &IID_IWMReaderNetworkConfig)) {
+ TRACE("(%p)->(IID_IWMReaderNetworkConfig %p)\n", This, ppv);
+ *ppv = &This->IWMReaderNetworkConfig2_iface;
+ }else if(IsEqualGUID(riid, &IID_IWMReaderNetworkConfig2)) {
+ TRACE("(%p)->IID_IWMReaderNetworkConfig2 %p)\n", This, ppv);
+ *ppv = &This->IWMReaderNetworkConfig2_iface;
+ }else if(IsEqualGUID(riid, &IID_IWMReaderStreamClock)) {
+ TRACE("(%p)->IID_IWMReaderStreamClock %p)\n", This, ppv);
+ *ppv = &This->IWMReaderStreamClock_iface;
+ }else if(IsEqualGUID(riid, &IID_IWMReaderTypeNegotiation)) {
+ TRACE("(%p)->IID_IWMReaderTypeNegotiation %p)\n", This, ppv);
+ *ppv = &This->IWMReaderTypeNegotiation_iface;
}else {
*ppv = NULL;
FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
@@ -649,6 +700,1180 @@ static const IWMReaderAdvanced6Vtbl WMReaderAdvanced6Vtbl = {
WMReaderAdvanced6_SetProtextStreamSamples
};
+static inline WMReader *impl_from_IWMDRMReader3(IWMDRMReader3 *iface)
+{
+ return CONTAINING_RECORD(iface, WMReader, IWMDRMReader3_iface);
+}
+
+static HRESULT WINAPI WMDRMReader_QueryInterface(IWMDRMReader3 *iface, REFIID riid, void **ppv)
+{
+ WMReader *This = impl_from_IWMDRMReader3(iface);
+ return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
+}
+
+static ULONG WINAPI WMDRMReader_AddRef(IWMDRMReader3 *iface)
+{
+ WMReader *This = impl_from_IWMDRMReader3(iface);
+ return IWMReader_AddRef(&This->IWMReader_iface);
+}
+
+static ULONG WINAPI WMDRMReader_Release(IWMDRMReader3 *iface)
+{
+ WMReader *This = impl_from_IWMDRMReader3(iface);
+ return IWMReader_Release(&This->IWMReader_iface);
+}
+
+static HRESULT WINAPI WMDRMReader_AcquireLicense(IWMDRMReader3 *iface, DWORD dwFlags) {
+ WMReader *This = impl_from_IWMDRMReader3(iface);
+ FIXME("(%p)->(WMDRMReader_AcquireLicense)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMDRMReader_CancelIndividualization(IWMDRMReader3 *iface) {
+ WMReader *This = impl_from_IWMDRMReader3(iface);
+ FIXME("(%p)->(WMDRMReader_CancelIndividualization)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMDRMReader_CancelLicenseAcquisition(IWMDRMReader3 *iface) {
+ WMReader *This = impl_from_IWMDRMReader3(iface);
+ FIXME("(%p)->(WMDRMReader_CancelLicenseAcquisition)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMDRMReader_CancelMonitorLicenseAcquisition(IWMDRMReader3 *iface) {
+ WMReader *This = impl_from_IWMDRMReader3(iface);
+ FIXME("(%p)->(WMDRMReader_CancelMonitorLicenseAcquisition)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMDRMReader_GetDRMProperty(IWMDRMReader3 *iface, LPCWSTR pwstrName, WMT_ATTR_DATATYPE *pdwType, BYTE *pValue, WORD *pcbLength) {
+ WMReader *This = impl_from_IWMDRMReader3(iface);
+ FIXME("(%p)->(WMDRMReader_GetDRMProperty)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMDRMReader_Individualize(IWMDRMReader3 *iface, DWORD dwFlags) {
+ WMReader *This = impl_from_IWMDRMReader3(iface);
+ FIXME("(%p)->(WMDRMReader_Individualize)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMDRMReader_MonitorLicenseAcquisition(IWMDRMReader3 *iface) {
+ WMReader *This = impl_from_IWMDRMReader3(iface);
+ FIXME("(%p)->(WMDRMReader_MonitorLicenseAcquisition)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMDRMReader_SetDRMProperty(IWMDRMReader3 *iface, LPCWSTR pwstrName, WMT_ATTR_DATATYPE dwType, const BYTE *pValue, WORD cbLength) {
+ WMReader *This = impl_from_IWMDRMReader3(iface);
+ FIXME("(%p)->(WMDRMReader_SetDRMProperty)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMDRMReader2_GetCopyOutputLevels(IWMDRMReader3 *iface, DRM_COPY_OPL *pCopyOPL, DWORD *pcbLength, DWORD *pdwMinAppComplianceLevel)
+{
+ WMReader *This = impl_from_IWMDRMReader3(iface);
+ FIXME("(%p)->(WMDRMReader_GetCopyOutputLevels)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMDRMReader2_GetPlayOutputLevels(IWMDRMReader3 *iface, DRM_PLAY_OPL *pPlayOPL, DWORD *pcbLength, DWORD *pdwMinAppComplianceLevel)
+{
+ WMReader *This = impl_from_IWMDRMReader3(iface);
+ FIXME("(%p)->(WMDRMReader_GetPlayOutputLevels)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMDRMReader2_SetEvaluateOutputLevelLicenses(IWMDRMReader3 *iface, BOOL fEvaluate)
+{
+ WMReader *This = impl_from_IWMDRMReader3(iface);
+ FIXME("(%p)->(WMDRMReader_SetEvaluateOutputLevelLicenses)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMDRMReader2_TryNextLicense(IWMDRMReader3 *iface)
+{
+ WMReader *This = impl_from_IWMDRMReader3(iface);
+ FIXME("(%p)->(WMDRMReader_TryNextLicense)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMDRMReader3_GetInclusionList(IWMDRMReader3 *iface, GUID **ppGuids, DWORD *pcGuids)
+{
+ WMReader *This = impl_from_IWMDRMReader3(iface);
+ FIXME("(%p)->(WMDRMReader_GetInclusionList)\n", This);
+ return E_NOTIMPL;
+}
+
+static const IWMDRMReader3Vtbl WMDRMReader3Vtbl = {
+ WMDRMReader_QueryInterface,
+ WMDRMReader_AddRef,
+ WMDRMReader_Release,
+ WMDRMReader_AcquireLicense,
+ WMDRMReader_CancelIndividualization,
+ WMDRMReader_CancelLicenseAcquisition,
+ WMDRMReader_CancelMonitorLicenseAcquisition,
+ WMDRMReader_GetDRMProperty,
+ WMDRMReader_Individualize,
+ WMDRMReader_MonitorLicenseAcquisition,
+ WMDRMReader_SetDRMProperty,
+ WMDRMReader2_GetCopyOutputLevels,
+ WMDRMReader2_GetPlayOutputLevels,
+ WMDRMReader2_SetEvaluateOutputLevelLicenses,
+ WMDRMReader2_TryNextLicense,
+ WMDRMReader3_GetInclusionList,
+};
+
+static inline WMReader *impl_from_IWMHeaderInfo3(IWMHeaderInfo3 *iface)
+{
+ return CONTAINING_RECORD(iface, WMReader, IWMHeaderInfo3_iface);
+}
+
+static HRESULT WINAPI WMHeaderInfo_QueryInterface(IWMHeaderInfo3 *iface, REFIID riid, void **ppv)
+{
+ WMReader *This = impl_from_IWMHeaderInfo3(iface);
+ return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
+}
+
+static ULONG WINAPI WMHeaderInfo_AddRef(IWMHeaderInfo3 *iface)
+{
+ WMReader *This = impl_from_IWMHeaderInfo3(iface);
+ return IWMReader_AddRef(&This->IWMReader_iface);
+}
+
+static ULONG WINAPI WMHeaderInfo_Release(IWMHeaderInfo3 *iface)
+{
+ WMReader *This = impl_from_IWMHeaderInfo3(iface);
+ return IWMReader_Release(&This->IWMReader_iface);
+}
+
+static HRESULT WINAPI WMHeaderInfo_AddMarker(IWMHeaderInfo3 *iface, WCHAR *pwszMarkerName, QWORD cnsMarkerTime)
+{
+ WMReader *This = impl_from_IWMHeaderInfo3(iface);
+ FIXME("(%p)->(WMHeaderInfo_AddMarker)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMHeaderInfo_AddScript(IWMHeaderInfo3 *iface, WCHAR *pwszType, WCHAR *pwszCommand, QWORD cnsScriptTime)
+{
+ WMReader *This = impl_from_IWMHeaderInfo3(iface);
+ FIXME("(%p)->(WMHeaderInfo_AddScript)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMHeaderInfo_GetAttributeByIndex(IWMHeaderInfo3 *iface, WORD wIndex, WORD *pwStreamNum, WCHAR *pwszName, WORD *pcchNameLen, WMT_ATTR_DATATYPE *pType, BYTE *pValue, WORD *pcbLength)
+{
+ WMReader *This = impl_from_IWMHeaderInfo3(iface);
+ FIXME("(%p)->(WMHeaderInfo_GetAttributeByIndex)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMHeaderInfo_GetAttributeByName(IWMHeaderInfo3 *iface, WORD *pwStreamNum, LPCWSTR pszName, WMT_ATTR_DATATYPE *pType, BYTE *pValue, WORD *pcbLength)
+{
+ WMReader *This = impl_from_IWMHeaderInfo3(iface);
+ FIXME("(%p)->(WMHeaderInfo_GetAttributeByName)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMHeaderInfo_GetAttributeCount(IWMHeaderInfo3 *iface, WORD wStreamNum, WORD *pcAttributes)
+{
+ WMReader *This = impl_from_IWMHeaderInfo3(iface);
+ FIXME("(%p)->(WMHeaderInfo_GetAttributeCount)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMHeaderInfo_GetMarker(IWMHeaderInfo3 *iface, WORD wIndex, WCHAR *pwszMarkerName, WORD *pcchMarkerNameLen, QWORD *pcnsMarkerTime)
+{
+ WMReader *This = impl_from_IWMHeaderInfo3(iface);
+ FIXME("(%p)->(WMHeaderInfo_GetMarker)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMHeaderInfo_GetMarkerCount(IWMHeaderInfo3 *iface, WORD *pcMarkers)
+{
+ WMReader *This = impl_from_IWMHeaderInfo3(iface);
+ FIXME("(%p)->(WMHeaderInfo_GetMarkerCount)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMHeaderInfo_GetScript(IWMHeaderInfo3 *iface, WORD wIndex, WCHAR *pwszType, WORD *pcchTypeLen, WCHAR *pwszCommand, WORD *pcchCommandLen, QWORD *pcnsScriptTime)
+{
+ WMReader *This = impl_from_IWMHeaderInfo3(iface);
+ FIXME("(%p)->(WMHeaderInfo_GetScript)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMHeaderInfo_GetScriptCount(IWMHeaderInfo3 *iface, WORD *pcScripts)
+{
+ WMReader *This = impl_from_IWMHeaderInfo3(iface);
+ FIXME("(%p)->(WMHeaderInfo_GetScriptCount)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMHeaderInfo_RemoveMarker(IWMHeaderInfo3 *iface, WORD wIndex)
+{
+ WMReader *This = impl_from_IWMHeaderInfo3(iface);
+ FIXME("(%p)->(WMHeaderInfo_RemoveMarker)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMHeaderInfo_RemoveScript(IWMHeaderInfo3 *iface, WORD wIndex)
+{
+ WMReader *This = impl_from_IWMHeaderInfo3(iface);
+ FIXME("(%p)->(WMHeaderInfo_RemoveScript)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMHeaderInfo_SetAttribute(IWMHeaderInfo3 *iface, WORD wStreamNum, LPCWSTR pszName, WMT_ATTR_DATATYPE Type, const BYTE *pValue, WORD cbLength)
+{
+ WMReader *This = impl_from_IWMHeaderInfo3(iface);
+ FIXME("(%p)->(WMHeaderInfo_SetAttribute)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMHeaderInfo2_GetCodecInfo(IWMHeaderInfo3 *iface, DWORD wIndex, WORD *pcchName, WCHAR *pwszName, WORD *pcchDescription, WCHAR *pwszDescription, WMT_CODEC_INFO_TYPE *pCodecType, WORD *pcbCodecInfo, BYTE *pbCodecInfo)
+{
+ WMReader *This = impl_from_IWMHeaderInfo3(iface);
+ FIXME("(%p)->(WMHeaderInfo2_GetCodecInfo)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMHeaderInfo2_GetCodecInfoCount(IWMHeaderInfo3 *iface, DWORD *pcCodecInfos)
+{
+ WMReader *This = impl_from_IWMHeaderInfo3(iface);
+ FIXME("(%p)->(WMHeaderInfo2_GetCodecInfoCount)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMHeaderInfo3_AddAttribute(IWMHeaderInfo3 *iface, WORD wStreamNum, LPCWSTR pszName, WORD *pwIndex, WMT_ATTR_DATATYPE Type, WORD wLangIndex, const BYTE *pValue, DWORD dwLength)
+{
+ WMReader *This = impl_from_IWMHeaderInfo3(iface);
+ FIXME("(%p)->(WMHeaderInfo3_AddAttribute)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMHeaderInfo3_AddCodecInfo(IWMHeaderInfo3 *iface, WCHAR *pwszName, WCHAR *pwszDescription, WMT_CODEC_INFO_TYPE codecType, WORD cbCodecInfo, BYTE *pbCodecInfo)
+{
+ WMReader *This = impl_from_IWMHeaderInfo3(iface);
+ FIXME("(%p)->(WMHeaderInfo3_AddCodecInfo)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMHeaderInfo3_DeleteAttribute(IWMHeaderInfo3 *iface, WORD wStreamNum, WORD wIndex)
+{
+ WMReader *This = impl_from_IWMHeaderInfo3(iface);
+ FIXME("(%p)->(WMHeaderInfo3_DeleteAttribute)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMHeaderInfo3_GetAttributeByIndexEx(IWMHeaderInfo3 *iface, WORD wStreamNum, WORD wIndex, LPWSTR pwszName, WORD *pwNameLen, WMT_ATTR_DATATYPE *pType, WORD *pwLangIndex, BYTE *pValue, DWORD *pdwDataLength)
+{
+ WMReader *This = impl_from_IWMHeaderInfo3(iface);
+ FIXME("(%p)->(WMHeaderInfo3_GetAttributeByIndexEx)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMHeaderInfo3_GetAttributeCountEx(IWMHeaderInfo3 *iface, WORD wStreamNum, WORD *pcAttributes)
+{
+ WMReader *This = impl_from_IWMHeaderInfo3(iface);
+ FIXME("(%p)->(WMHeaderInfo3_GetAttributeCountEx)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMHeaderInfo3_GetAttributeIndices(IWMHeaderInfo3 *iface, WORD wStreamNum, LPCWSTR pwszName, WORD *pwLangIndex, WORD *pwIndices, WORD *pwCount)
+{
+ WMReader *This = impl_from_IWMHeaderInfo3(iface);
+ FIXME("(%p)->(WMHeaderInfo3_GetAttributeIndices)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMHeaderInfo3_ModifyAttribute(IWMHeaderInfo3 *iface, WORD wStreamNum, WORD wIndex, WMT_ATTR_DATATYPE Type, WORD wLangIndex, const BYTE *pValue, DWORD dwLength)
+{
+ WMReader *This = impl_from_IWMHeaderInfo3(iface);
+ FIXME("(%p)->(WMHeaderInfo3_ModifyAttribute)\n", This);
+ return E_NOTIMPL;
+}
+
+
+static const IWMHeaderInfo3Vtbl WMHeaderInfo3Vtbl = {
+ WMHeaderInfo_QueryInterface,
+ WMHeaderInfo_AddRef,
+ WMHeaderInfo_Release,
+ WMHeaderInfo_AddMarker,
+ WMHeaderInfo_AddScript,
+ WMHeaderInfo_GetAttributeByIndex,
+ WMHeaderInfo_GetAttributeByName,
+ WMHeaderInfo_GetAttributeCount,
+ WMHeaderInfo_GetMarker,
+ WMHeaderInfo_GetMarkerCount,
+ WMHeaderInfo_GetScript,
+ WMHeaderInfo_GetScriptCount,
+ WMHeaderInfo_RemoveMarker,
+ WMHeaderInfo_RemoveScript,
+ WMHeaderInfo_SetAttribute,
+ WMHeaderInfo2_GetCodecInfo,
+ WMHeaderInfo2_GetCodecInfoCount,
+ WMHeaderInfo3_AddAttribute,
+ WMHeaderInfo3_AddCodecInfo,
+ WMHeaderInfo3_DeleteAttribute,
+ WMHeaderInfo3_GetAttributeByIndexEx,
+ WMHeaderInfo3_GetAttributeCountEx,
+ WMHeaderInfo3_GetAttributeIndices,
+ WMHeaderInfo3_ModifyAttribute,
+};
+
+static inline WMReader *impl_from_IWMPacketSize2(IWMPacketSize2 *iface)
+{
+ return CONTAINING_RECORD(iface, WMReader, IWMPacketSize2_iface);
+}
+
+static HRESULT WINAPI WMPacketSize_QueryInterface(IWMPacketSize2 *iface, REFIID riid, void **ppv)
+{
+ WMReader *This = impl_from_IWMPacketSize2(iface);
+ return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
+}
+
+static ULONG WINAPI WMPacketSize_AddRef(IWMPacketSize2 *iface)
+{
+ WMReader *This = impl_from_IWMPacketSize2(iface);
+ return IWMReader_AddRef(&This->IWMReader_iface);
+}
+
+static ULONG WINAPI WMPacketSize_Release(IWMPacketSize2 *iface)
+{
+ WMReader *This = impl_from_IWMPacketSize2(iface);
+ return IWMReader_Release(&This->IWMReader_iface);
+}
+
+static HRESULT WINAPI WMPacketSize_GetMaxPacketSize(IWMPacketSize2 *iface, DWORD *pdwMaxPacketSize)
+{
+ WMReader *This = impl_from_IWMPacketSize2(iface);
+ FIXME("(%p)->(WMPacketSize_GetMaxPacketSize)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMPacketSize_SetMaxPacketSize(IWMPacketSize2 *iface, DWORD dwMaxPacketSize)
+{
+ WMReader *This = impl_from_IWMPacketSize2(iface);
+ FIXME("(%p)->(WMPacketSize_SetMaxPacketSize)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMPacketSize2_GetMinPacketSize(IWMPacketSize2 *iface, DWORD *pdwMinPacketSize)
+{
+ WMReader *This = impl_from_IWMPacketSize2(iface);
+ FIXME("(%p)->(WMPacketSize_GetMinPacketSize)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMPacketSize2_SetMinPacketSize(IWMPacketSize2 *iface, DWORD dwMinPacketSize)
+{
+ WMReader *This = impl_from_IWMPacketSize2(iface);
+ FIXME("(%p)->(WMPacketSize_SetMinPacketSize)\n", This);
+ return E_NOTIMPL;
+}
+
+static const IWMPacketSize2Vtbl WMPacketSize2Vtbl = {
+ WMPacketSize_QueryInterface,
+ WMPacketSize_AddRef,
+ WMPacketSize_Release,
+ WMPacketSize_GetMaxPacketSize,
+ WMPacketSize_SetMaxPacketSize,
+ WMPacketSize2_GetMinPacketSize,
+ WMPacketSize2_SetMinPacketSize,
+};
+
+static inline WMReader *impl_from_IWMProfile3(IWMProfile3 *iface)
+{
+ return CONTAINING_RECORD(iface, WMReader, IWMProfile3_iface);
+}
+
+static HRESULT WINAPI WMProfile_QueryInterface(IWMProfile3 *iface, REFIID riid, void **ppv)
+{
+ WMReader *This = impl_from_IWMProfile3(iface);
+ return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
+}
+
+static ULONG WINAPI WMProfile_AddRef(IWMProfile3 *iface)
+{
+ WMReader *This = impl_from_IWMProfile3(iface);
+ return IWMReader_AddRef(&This->IWMReader_iface);
+}
+
+static ULONG WINAPI WMProfile_Release(IWMProfile3 *iface)
+{
+ WMReader *This = impl_from_IWMProfile3(iface);
+ return IWMReader_Release(&This->IWMReader_iface);
+}
+
+static HRESULT WINAPI WMProfile_GetVersion(IWMProfile3 *iface, WMT_VERSION *pdwVersion) {
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile_GetVersion)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile_GetName(IWMProfile3 *iface, WCHAR *pwszName, DWORD *pcchName) {
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile_GetName)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile_SetName(IWMProfile3 *iface, const WCHAR *pwszName) {
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile_SetName)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile_GetDescription(IWMProfile3 *iface, WCHAR *pwszDescription, DWORD *pcchDescription) {
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile_GetDescription)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile_SetDescription(IWMProfile3 *iface, const WCHAR *pwszDescription) {
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile_SetDescription)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile_GetStreamCount(IWMProfile3 *iface, DWORD *pcStreams) {
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile_GetStreamCount)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile_GetStream(IWMProfile3 *iface, DWORD dwStreamIndex, IWMStreamConfig **ppConfig) {
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile_GetStream)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile_GetStreamByNumber(IWMProfile3 *iface, WORD wStreamNum, IWMStreamConfig **ppConfig) {
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile_GetStreamByNumber)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile_RemoveStream(IWMProfile3 *iface, IWMStreamConfig *pConfig) {
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile_RemoveStream)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile_RemoveStreamByNumber(IWMProfile3 *iface, WORD wStreamNum) {
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile_RemoveStreamByNumber)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile_AddStream(IWMProfile3 *iface, IWMStreamConfig *pConfig) {
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile_AddStream)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile_ReconfigStream(IWMProfile3 *iface, IWMStreamConfig *pConfig) {
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile_ReconfigStream)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile_CreateNewStream(IWMProfile3 *iface, REFGUID guidStreamType, IWMStreamConfig **ppConfig) {
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile_CreateNewStream)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile_GetMutualExclusionCount(IWMProfile3 *iface, DWORD *pcME) {
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile_GetMutualExclusionCount)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile_GetMutualExclusion(IWMProfile3 *iface, DWORD dwMEIndex, IWMMutualExclusion **ppME) {
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile_GetMutualExclusion)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile_RemoveMutualExclusion(IWMProfile3 *iface, IWMMutualExclusion *pME) {
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile_RemoveMutualExclusion)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile_AddMutualExclusion(IWMProfile3 *iface, IWMMutualExclusion *pME) {
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile_AddMutualExclusion)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile_CreateNewMutualExclusion(IWMProfile3 *iface, IWMMutualExclusion **ppME) {
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile_CreateNewMutualExclusion)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile2_GetProfileID(IWMProfile3 *iface, GUID *pguidID)
+{
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile2_GetProfileID)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile3_AddBandwidthSharing(IWMProfile3 *iface, IWMBandwidthSharing *pBS)
+{
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile3_AddBandwidthSharing)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile3_CreateNewBandwidthSharing(IWMProfile3 *iface, IWMBandwidthSharing **ppBS)
+{
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile3_CreateNewBandwidthSharing)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile3_CreateNewStreamPrioritization(IWMProfile3 *iface, IWMStreamPrioritization **ppSP)
+{
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile3_CreateNewStreamPrioritization)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile3_GetBandwidthSharing(IWMProfile3 *iface, DWORD dwBSIndex, IWMBandwidthSharing **ppBS)
+{
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile3_GetBandwidthSharing)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile3_GetBandwidthSharingCount(IWMProfile3 *iface, DWORD *pcBS)
+{
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile3_GetBandwidthSharingCount)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile3_GetExpectedPacketCount(IWMProfile3 *iface, QWORD msDuration, QWORD *pcPackets)
+{
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile3_GetExpectedPacketCount)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile3_GetStorageFormat(IWMProfile3 *iface, WMT_STORAGE_FORMAT *pnStorageFormat)
+{
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile3_GetStorageFormat)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile3_GetStreamPrioritization(IWMProfile3 *iface, IWMStreamPrioritization **ppSP)
+{
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile3_GetStreamPrioritization)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile3_RemoveBandwidthSharing(IWMProfile3 *iface, IWMBandwidthSharing *pBS)
+{
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile3_RemoveBandwidthSharing)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile3_RemoveStreamPrioritization(IWMProfile3 *iface)
+{
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile3_RemoveStreamPrioritization)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile3_SetStorageFormat(IWMProfile3 *iface, WMT_STORAGE_FORMAT nStorageFormat)
+{
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile3_SetStorageFormat)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMProfile3_SetStreamPrioritization(IWMProfile3 *iface, IWMStreamPrioritization *pSP)
+{
+ WMReader *This = impl_from_IWMProfile3(iface);
+ FIXME("(%p)->(WMProfile3_SetStreamPrioritization)\n", This);
+ return E_NOTIMPL;
+}
+
+static const IWMProfile3Vtbl WMProfile3Vtbl = {
+ WMProfile_QueryInterface,
+ WMProfile_AddRef,
+ WMProfile_Release,
+ WMProfile_GetVersion,
+ WMProfile_GetName,
+ WMProfile_SetName,
+ WMProfile_GetDescription,
+ WMProfile_SetDescription,
+ WMProfile_GetStreamCount,
+ WMProfile_GetStream,
+ WMProfile_GetStreamByNumber,
+ WMProfile_RemoveStream,
+ WMProfile_RemoveStreamByNumber,
+ WMProfile_AddStream,
+ WMProfile_ReconfigStream,
+ WMProfile_CreateNewStream,
+ WMProfile_GetMutualExclusionCount,
+ WMProfile_GetMutualExclusion,
+ WMProfile_RemoveMutualExclusion,
+ WMProfile_AddMutualExclusion,
+ WMProfile_CreateNewMutualExclusion,
+ WMProfile2_GetProfileID,
+ WMProfile3_AddBandwidthSharing,
+ WMProfile3_CreateNewBandwidthSharing,
+ WMProfile3_CreateNewStreamPrioritization,
+ WMProfile3_GetBandwidthSharing,
+ WMProfile3_GetBandwidthSharingCount,
+ WMProfile3_GetExpectedPacketCount,
+ WMProfile3_GetStorageFormat,
+ WMProfile3_GetStreamPrioritization,
+ WMProfile3_RemoveBandwidthSharing,
+ WMProfile3_RemoveStreamPrioritization,
+ WMProfile3_SetStorageFormat,
+ WMProfile3_SetStreamPrioritization
+};
+
+static inline WMReader *impl_from_IWMReaderAccelerator(IWMReaderAccelerator *iface)
+{
+ return CONTAINING_RECORD(iface, WMReader, IWMReaderAccelerator_iface);
+}
+
+static HRESULT WINAPI WMReaderAccelerator_QueryInterface(IWMReaderAccelerator *iface, REFIID riid, void **ppv)
+{
+ WMReader *This = impl_from_IWMReaderAccelerator(iface);
+ return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
+}
+
+static ULONG WINAPI WMReaderAccelerator_AddRef(IWMReaderAccelerator *iface)
+{
+ WMReader *This = impl_from_IWMReaderAccelerator(iface);
+ return IWMReader_AddRef(&This->IWMReader_iface);
+}
+
+static ULONG WINAPI WMReaderAccelerator_Release(IWMReaderAccelerator *iface)
+{
+ WMReader *This = impl_from_IWMReaderAccelerator(iface);
+ return IWMReader_Release(&This->IWMReader_iface);
+}
+
+static HRESULT WINAPI WMReaderAccelerator_GetCodecInterface(IWMReaderAccelerator *iface, DWORD dwOutputNum, REFIID riid, void **ppvCodecInterface)
+{
+ WMReader *This = impl_from_IWMReaderAccelerator(iface);
+ FIXME("(%p)->(WMReaderAccelerator_GetCodecInterface)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMReaderAccelerator_Notify(IWMReaderAccelerator *iface, DWORD dwOutputNum, WM_MEDIA_TYPE *pSubtype)
+{
+ WMReader *This = impl_from_IWMReaderAccelerator(iface);
+ FIXME("(%p)->(WMReaderAccelerator_Notify)\n", This);
+ return E_NOTIMPL;
+}
+
+static const IWMReaderAcceleratorVtbl WMReaderAcceleratorVtbl = {
+ WMReaderAccelerator_QueryInterface,
+ WMReaderAccelerator_AddRef,
+ WMReaderAccelerator_Release,
+ WMReaderAccelerator_GetCodecInterface,
+ WMReaderAccelerator_Notify,
+};
+
+static inline WMReader *impl_from_IWMReaderTimecode(IWMReaderTimecode *iface)
+{
+ return CONTAINING_RECORD(iface, WMReader, IWMReaderTimecode_iface);
+}
+
+static HRESULT WINAPI WMReaderTimecode_QueryInterface(IWMReaderTimecode *iface, REFIID riid, void **ppv)
+{
+ WMReader *This = impl_from_IWMReaderTimecode(iface);
+ return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
+}
+
+static ULONG WINAPI WMReaderTimecode_AddRef(IWMReaderTimecode *iface)
+{
+ WMReader *This = impl_from_IWMReaderTimecode(iface);
+ return IWMReader_AddRef(&This->IWMReader_iface);
+}
+
+static ULONG WINAPI WMReaderTimecode_Release(IWMReaderTimecode *iface)
+{
+ WMReader *This = impl_from_IWMReaderTimecode(iface);
+ return IWMReader_Release(&This->IWMReader_iface);
+}
+
+static HRESULT WINAPI WMReaderTimecode_GetTimecodeRangeBounds(IWMReaderTimecode *iface, WORD wStreamNum, WORD wRangeNum, DWORD *pStartTimecode, DWORD *pEndTimecode)
+{
+ WMReader *This = impl_from_IWMReaderTimecode(iface);
+ FIXME("(%p)->(WMReaderTimecode_GetTimecodeRangeBounds)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMReaderTimecode_GetTimecodeRangeCount(IWMReaderTimecode *iface, WORD wStreamNum, WORD *pwRangeCount)
+{
+ WMReader *This = impl_from_IWMReaderTimecode(iface);
+ FIXME("(%p)->(WMReaderTimecode_GetTimecodeRangeCount)\n", This);
+ return E_NOTIMPL;
+}
+
+static const IWMReaderTimecodeVtbl WMReaderTimecodeVtbl = {
+ WMReaderTimecode_QueryInterface,
+ WMReaderTimecode_AddRef,
+ WMReaderTimecode_Release,
+ WMReaderTimecode_GetTimecodeRangeBounds,
+ WMReaderTimecode_GetTimecodeRangeCount,
+};
+
+static inline WMReader *impl_from_IWMReaderNetworkConfig2(IWMReaderNetworkConfig2 *iface)
+{
+ return CONTAINING_RECORD(iface, WMReader, IWMReaderNetworkConfig2_iface);
+}
+
+static HRESULT WINAPI WMReaderNetworkConfig_QueryInterface(IWMReaderNetworkConfig2 *iface, REFIID riid, void **ppv)
+{
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
+}
+
+static ULONG WINAPI WMReaderNetworkConfig_AddRef(IWMReaderNetworkConfig2 *iface)
+{
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ return IWMReader_AddRef(&This->IWMReader_iface);
+}
+
+static ULONG WINAPI WMReaderNetworkConfig_Release(IWMReaderNetworkConfig2 *iface)
+{
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ return IWMReader_Release(&This->IWMReader_iface);
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_AddLoggingUrl(IWMReaderNetworkConfig2 *iface, LPCWSTR pwszUrl) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_AddLoggingUrl)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_GetBufferingTime(IWMReaderNetworkConfig2 *iface, QWORD *pcnsBufferingTime) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_GetBufferingTime)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_GetConnectionBandwidth(IWMReaderNetworkConfig2 *iface, DWORD *pdwConnectionBandwidth) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_GetConnectionBandwidth)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_GetEnableHTTP(IWMReaderNetworkConfig2 *iface, BOOL *pfEnableHTTP) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_GetEnableHTTP)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_GetEnableMulticast(IWMReaderNetworkConfig2 *iface, BOOL *pfEnableMulticast) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_GetEnableMulticast)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_GetEnableTCP(IWMReaderNetworkConfig2 *iface, BOOL *pfEnableTCP) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_GetEnableTCP)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_GetEnableUDP(IWMReaderNetworkConfig2 *iface, BOOL *pfEnableUDP) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_GetEnableUDP)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_GetForceRerunAutoProxyDetection(IWMReaderNetworkConfig2 *iface, BOOL *pfForceRerunDetection) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_GetForceRerunAutoProxyDetection)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_GetLoggingUrl(IWMReaderNetworkConfig2 *iface, DWORD dwIndex, LPWSTR pwszUrl, DWORD *pcchUrl) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_GetLoggingUrl)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_GetLoggingUrlCount(IWMReaderNetworkConfig2 *iface, DWORD *pdwUrlCount) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_GetLoggingUrlCount)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_GetNumProtocolsSupported(IWMReaderNetworkConfig2 *iface, DWORD *pcProtocols) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_GetNumProtocolsSupported)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_GetProxyBypassForLocal(IWMReaderNetworkConfig2 *iface, LPCWSTR pwszProtocol, BOOL *pfBypassForLocal) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_GetProxyBypassForLocal)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_GetProxyExceptionList(IWMReaderNetworkConfig2 *iface, LPCWSTR pwszProtocol, WCHAR *pwszExceptionList, DWORD *pcchExceptionList) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_GetProxyExceptionList)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_GetProxyHostName(IWMReaderNetworkConfig2 *iface, LPCWSTR pwszProtocol, WCHAR *pwszHostName, DWORD *pcchHostName) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_GetProxyHostName)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_GetProxyPort(IWMReaderNetworkConfig2 *iface, LPCWSTR pwszProtocol, DWORD *pdwPort) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_GetProxyPort)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_GetProxySettings(IWMReaderNetworkConfig2 *iface, LPCWSTR pwszProtocol, WMT_PROXY_SETTINGS *pProxySetting) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_GetProxySettings)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_GetSupportedProtocolName(IWMReaderNetworkConfig2 *iface, DWORD dwProtocolNum, WCHAR *pwszProtocolName, DWORD *pcchProtocolName) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_GetSupportedProtocolName)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_GetUDPPortRanges(IWMReaderNetworkConfig2 *iface, WM_PORT_NUMBER_RANGE *pRangeArray, DWORD *pcRanges) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_GetUDPPortRanges)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_ResetLoggingUrlList(IWMReaderNetworkConfig2 *iface) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_ResetLoggingUrlList)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_ResetProtocolRollover(IWMReaderNetworkConfig2 *iface) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_ResetProtocolRollover)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_SetBufferingTime(IWMReaderNetworkConfig2 *iface, QWORD cnsBufferingTime) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_SetBufferingTime)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_SetConnectionBandwidth(IWMReaderNetworkConfig2 *iface, DWORD dwConnectionBandwidth) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_SetConnectionBandwidth)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_SetEnableHTTP(IWMReaderNetworkConfig2 *iface, BOOL fEnableHTTP) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_SetEnableHTTP)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_SetEnableMulticast(IWMReaderNetworkConfig2 *iface, BOOL fEnableMulticast) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_SetEnableMulticast)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_SetEnableTCP(IWMReaderNetworkConfig2 *iface, BOOL fEnableTCP) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_SetEnableTCP)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_SetEnableUDP(IWMReaderNetworkConfig2 *iface, BOOL fEnableUDP) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_SetEnableUDP)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_SetForceRerunAutoProxyDetection(IWMReaderNetworkConfig2 *iface, BOOL fForceRerunDetection) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_SetForceRerunAutoProxyDetection)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_SetProxyBypassForLocal(IWMReaderNetworkConfig2 *iface, LPCWSTR pwszProtocol, BOOL fBypassForLocal) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_SetProxyBypassForLocal)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_SetProxyExceptionList(IWMReaderNetworkConfig2 *iface, LPCWSTR pwszProtocol, LPCWSTR pwszExceptionList) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_SetProxyExceptionList)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_SetProxyHostName(IWMReaderNetworkConfig2 *iface, LPCWSTR pwszProtocol, LPCWSTR pwszHostName) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_SetProxyHostName)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_SetProxyPort(IWMReaderNetworkConfig2 *iface, LPCWSTR pwszProtocol, DWORD dwPort) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_SetProxyPort)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_SetProxySettings(IWMReaderNetworkConfig2 *iface, LPCWSTR pwszProtocol, WMT_PROXY_SETTINGS ProxySetting) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_SetProxySettings)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig_SetUDPPortRanges(IWMReaderNetworkConfig2 *iface, WM_PORT_NUMBER_RANGE *pRangeArray, DWORD cRanges) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig_SetUDPPortRanges)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig2_GetAcceleratedStreamingDuration(IWMReaderNetworkConfig2 *iface, QWORD *pcnsAccelDuration) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig2_GetAcceleratedStreamingDuration)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig2_GetAutoReconnectLimit(IWMReaderNetworkConfig2 *iface, DWORD *pdwAutoReconnectLimit) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig2_GetAutoReconnectLimit)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig2_GetEnableContentCaching(IWMReaderNetworkConfig2 *iface, BOOL *pfEnableContentCaching) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig2_GetEnableContentCaching)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig2_GetEnableFastCache(IWMReaderNetworkConfig2 *iface, BOOL *pfEnableFastCache) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig2_GetEnableFastCache)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig2_GetEnableResends(IWMReaderNetworkConfig2 *iface, BOOL *pfEnableResends) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig2_GetEnableResends)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig2_GetEnableThinning(IWMReaderNetworkConfig2 *iface, BOOL *pfEnableThinning) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig2_GetEnableThinning)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig2_GetMaxNetPacketSize(IWMReaderNetworkConfig2 *iface, DWORD *pdwMaxNetPacketSize) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig2_GetMaxNetPacketSize)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig2_SetAcceleratedStreamingDuration(IWMReaderNetworkConfig2 *iface, QWORD cnsAccelDuration) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig2_SetAcceleratedStreamingDuration)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig2_SetAutoReconnectLimit(IWMReaderNetworkConfig2 *iface, DWORD dwAutoReconnectLimit) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig2_SetAutoReconnectLimit)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig2_SetEnableContentCaching(IWMReaderNetworkConfig2 *iface, BOOL fEnableContentCaching) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig2_SetEnableContentCaching)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig2_SetEnableFastCache(IWMReaderNetworkConfig2 *iface, BOOL fEnableFastCache) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig2_SetEnableFastCache)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig2_SetEnableResends(IWMReaderNetworkConfig2 *iface, BOOL fEnableResends) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig2_SetEnableResends)\n", This);
+ return E_NOTIMPL;
+}
+
+static WINAPI HRESULT WMReaderNetworkConfig2_SetEnableThinning(IWMReaderNetworkConfig2 *iface, BOOL fEnableThinning) {
+ WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
+ FIXME("(%p)->(WMReaderNetworkConfig2_SetEnableThinning)\n", This);
+ return E_NOTIMPL;
+}
+
+static const IWMReaderNetworkConfig2Vtbl WMReaderNetworkConfig2Vtbl = {
+ WMReaderNetworkConfig_QueryInterface,
+ WMReaderNetworkConfig_AddRef,
+ WMReaderNetworkConfig_Release,
+ WMReaderNetworkConfig_AddLoggingUrl,
+ WMReaderNetworkConfig_GetBufferingTime,
+ WMReaderNetworkConfig_GetConnectionBandwidth,
+ WMReaderNetworkConfig_GetEnableHTTP,
+ WMReaderNetworkConfig_GetEnableMulticast,
+ WMReaderNetworkConfig_GetEnableTCP,
+ WMReaderNetworkConfig_GetEnableUDP,
+ WMReaderNetworkConfig_GetForceRerunAutoProxyDetection,
+ WMReaderNetworkConfig_GetLoggingUrl,
+ WMReaderNetworkConfig_GetLoggingUrlCount,
+ WMReaderNetworkConfig_GetNumProtocolsSupported,
+ WMReaderNetworkConfig_GetProxyBypassForLocal,
+ WMReaderNetworkConfig_GetProxyExceptionList,
+ WMReaderNetworkConfig_GetProxyHostName,
+ WMReaderNetworkConfig_GetProxyPort,
+ WMReaderNetworkConfig_GetProxySettings,
+ WMReaderNetworkConfig_GetSupportedProtocolName,
+ WMReaderNetworkConfig_GetUDPPortRanges,
+ WMReaderNetworkConfig_ResetLoggingUrlList,
+ WMReaderNetworkConfig_ResetProtocolRollover,
+ WMReaderNetworkConfig_SetBufferingTime,
+ WMReaderNetworkConfig_SetConnectionBandwidth,
+ WMReaderNetworkConfig_SetEnableHTTP,
+ WMReaderNetworkConfig_SetEnableMulticast,
+ WMReaderNetworkConfig_SetEnableTCP,
+ WMReaderNetworkConfig_SetEnableUDP,
+ WMReaderNetworkConfig_SetForceRerunAutoProxyDetection,
+ WMReaderNetworkConfig_SetProxyBypassForLocal,
+ WMReaderNetworkConfig_SetProxyExceptionList,
+ WMReaderNetworkConfig_SetProxyHostName,
+ WMReaderNetworkConfig_SetProxyPort,
+ WMReaderNetworkConfig_SetProxySettings,
+ WMReaderNetworkConfig_SetUDPPortRanges,
+ WMReaderNetworkConfig2_GetAcceleratedStreamingDuration,
+ WMReaderNetworkConfig2_GetAutoReconnectLimit,
+ WMReaderNetworkConfig2_GetEnableContentCaching,
+ WMReaderNetworkConfig2_GetEnableFastCache,
+ WMReaderNetworkConfig2_GetEnableResends,
+ WMReaderNetworkConfig2_GetEnableThinning,
+ WMReaderNetworkConfig2_GetMaxNetPacketSize,
+ WMReaderNetworkConfig2_SetAcceleratedStreamingDuration,
+ WMReaderNetworkConfig2_SetAutoReconnectLimit,
+ WMReaderNetworkConfig2_SetEnableContentCaching,
+ WMReaderNetworkConfig2_SetEnableFastCache,
+ WMReaderNetworkConfig2_SetEnableResends,
+ WMReaderNetworkConfig2_SetEnableThinning
+};
+
+static inline WMReader *impl_from_IWMReaderStreamClock(IWMReaderStreamClock *iface)
+{
+ return CONTAINING_RECORD(iface, WMReader, IWMReaderStreamClock_iface);
+}
+
+static HRESULT WINAPI WMReaderStreamClock_QueryInterface(IWMReaderStreamClock *iface, REFIID riid, void **ppv)
+{
+ WMReader *This = impl_from_IWMReaderStreamClock(iface);
+ return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
+}
+
+static ULONG WINAPI WMReaderStreamClock_AddRef(IWMReaderStreamClock *iface)
+{
+ WMReader *This = impl_from_IWMReaderStreamClock(iface);
+ return IWMReader_AddRef(&This->IWMReader_iface);
+}
+
+static ULONG WINAPI WMReaderStreamClock_Release(IWMReaderStreamClock *iface)
+{
+ WMReader *This = impl_from_IWMReaderStreamClock(iface);
+ return IWMReader_Release(&This->IWMReader_iface);
+}
+
+static HRESULT WINAPI WMReaderStreamClock_GetTime(IWMReaderStreamClock *iface, QWORD *pcnsNow)
+{
+ WMReader *This = impl_from_IWMReaderStreamClock(iface);
+ FIXME("(%p)->(WMReaderStreamClock_GetTime)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMReaderStreamClock_KillTimer(IWMReaderStreamClock *iface, DWORD dwTimerId)
+{
+ WMReader *This = impl_from_IWMReaderStreamClock(iface);
+ FIXME("(%p)->(WMReaderStreamClock_KillTimer)\n", This);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI WMReaderStreamClock_SetTimer(IWMReaderStreamClock *iface, QWORD cnsWhen, void *pvParam, DWORD *pdwTimerId)
+{
+ WMReader *This = impl_from_IWMReaderStreamClock(iface);
+ FIXME("(%p)->(WMReaderStreamClock_SetTimer)\n", This);
+ return E_NOTIMPL;
+}
+
+static const IWMReaderStreamClockVtbl WMReaderStreamClockVtbl = {
+ WMReaderStreamClock_QueryInterface,
+ WMReaderStreamClock_AddRef,
+ WMReaderStreamClock_Release,
+ WMReaderStreamClock_GetTime,
+ WMReaderStreamClock_KillTimer,
+ WMReaderStreamClock_SetTimer,
+};
+
+static inline WMReader *impl_from_IWMReaderTypeNegotiation(IWMReaderTypeNegotiation *iface)
+{
+ return CONTAINING_RECORD(iface, WMReader, IWMReaderTypeNegotiation_iface);
+}
+
+static HRESULT WINAPI WMReaderTypeNegotiation_QueryInterface(IWMReaderTypeNegotiation *iface, REFIID riid, void **ppv)
+{
+ WMReader *This = impl_from_IWMReaderTypeNegotiation(iface);
+ return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
+}
+
+static ULONG WINAPI WMReaderTypeNegotiation_AddRef(IWMReaderTypeNegotiation *iface)
+{
+ WMReader *This = impl_from_IWMReaderTypeNegotiation(iface);
+ return IWMReader_AddRef(&This->IWMReader_iface);
+}
+
+static ULONG WINAPI WMReaderTypeNegotiation_Release(IWMReaderTypeNegotiation *iface)
+{
+ WMReader *This = impl_from_IWMReaderTypeNegotiation(iface);
+ return IWMReader_Release(&This->IWMReader_iface);
+}
+
+static HRESULT WINAPI WMReaderTypeNegotiation_TryOutputProps(IWMReaderTypeNegotiation *iface, DWORD dwOutputNum, IWMOutputMediaProps *pOutput)
+{
+ WMReader *This = impl_from_IWMReaderTypeNegotiation(iface);
+ FIXME("(%p)->(WMReaderTypeNegotiation_TryOutputProps)\n", This);
+ return E_NOTIMPL;
+}
+
+static const IWMReaderTypeNegotiationVtbl WMReaderTypeNegotiationVtbl = {
+ WMReaderTypeNegotiation_QueryInterface,
+ WMReaderTypeNegotiation_AddRef,
+ WMReaderTypeNegotiation_Release,
+ WMReaderTypeNegotiation_TryOutputProps,
+};
+
HRESULT WINAPI WMCreateReader(IUnknown *reserved, DWORD rights, IWMReader **ret_reader)
{
WMReader *reader;
@@ -661,6 +1886,15 @@ HRESULT WINAPI WMCreateReader(IUnknown *reserved, DWORD rights, IWMReader **ret_
reader->IWMReader_iface.lpVtbl = &WMReaderVtbl;
reader->IWMReaderAdvanced6_iface.lpVtbl = &WMReaderAdvanced6Vtbl;
+ reader->IWMDRMReader3_iface.lpVtbl = &WMDRMReader3Vtbl;
+ reader->IWMHeaderInfo3_iface.lpVtbl = &WMHeaderInfo3Vtbl;
+ reader->IWMPacketSize2_iface.lpVtbl = &WMPacketSize2Vtbl;
+ reader->IWMProfile3_iface.lpVtbl = &WMProfile3Vtbl;
+ reader->IWMReaderAccelerator_iface.lpVtbl = &WMReaderAcceleratorVtbl;
+ reader->IWMReaderTimecode_iface.lpVtbl = &WMReaderTimecodeVtbl;
+ reader->IWMReaderNetworkConfig2_iface.lpVtbl = &WMReaderNetworkConfig2Vtbl;
+ reader->IWMReaderStreamClock_iface.lpVtbl = &WMReaderStreamClockVtbl;
+ reader->IWMReaderTypeNegotiation_iface.lpVtbl = &WMReaderTypeNegotiationVtbl;
reader->ref = 1;
*ret_reader = &reader->IWMReader_iface;
diff --git a/include/wmsdkidl.idl b/include/wmsdkidl.idl
index 0606be190710..4a45a562ee96 100644
--- a/include/wmsdkidl.idl
+++ b/include/wmsdkidl.idl
@@ -83,6 +83,52 @@ typedef struct _WMReaderClientInfo
WCHAR *wszPlayerUserAgent;
} WM_READER_CLIENTINFO;
+typedef struct _WMStreamPrioritizationRecord {
+ WORD wStreamNumber;
+ BOOL fMandatory;
+} WM_STREAM_PRIORITY_RECORD;
+
+
+typedef struct _WM_PORT_NUMBER_RANGE {
+ WORD wPortBegin;
+ WORD wPortEnd;
+} WM_PORT_NUMBER_RANGE;
+
+typedef struct _DRM_MINIMUM_OUTPUT_PROTECTION_LEVELS {
+ WORD wCompressedDigitalVideo;
+ WORD wUncompressedDigitalVideo;
+ WORD wAnalogVideo;
+ WORD wCompressedDigitalAudio;
+ WORD wUncompressedDigitalAudio;
+} DRM_MINIMUM_OUTPUT_PROTECTION_LEVELS;
+
+typedef struct _DRM_OPL_OUTPUT_IDS {
+ WORD cIds;
+ GUID *rgIds;
+} DRM_OPL_OUTPUT_IDS;
+
+typedef struct _DRM_VIDEO_OUTPUT_PROTECTION {
+ GUID guidId;
+ BYTE bConfigData;
+} DRM_VIDEO_OUTPUT_PROTECTION;
+
+typedef struct _DRM_VIDEO_OUTPUT_PROTECTION_IDS {
+ WORD cEntries;
+ DRM_VIDEO_OUTPUT_PROTECTION *rgVop;
+} DRM_VIDEO_OUTPUT_PROTECTION_IDS;
+
+typedef struct _DRM_COPY_OPL {
+ WORD wMinimumCopyLevel;
+ DRM_OPL_OUTPUT_IDS oplIdIncludes;
+ DRM_OPL_OUTPUT_IDS oplIdExcludes;
+} DRM_COPY_OPL;
+
+typedef struct _DRM_PLAY_OPL {
+ DRM_MINIMUM_OUTPUT_PROTECTION_LEVELS minOPL;
+ DRM_OPL_OUTPUT_IDS oplIdReserved;
+ DRM_VIDEO_OUTPUT_PROTECTION_IDS vopi;
+} DRM_PLAY_OPL;
+
typedef enum WMT_ATTR_DATATYPE
{
WMT_TYPE_DWORD = 0,
@@ -183,6 +229,25 @@ typedef enum tagWMT_OFFSET_FORMAT
WMT_OFFSET_FORMAT_100NS_APPROXIMATE
} WMT_OFFSET_FORMAT;
+typedef enum WMT_PROXY_SETTINGS {
+ WMT_PROXY_SETTING_NONE = 0,
+ WMT_PROXY_SETTING_MANUAL = 1,
+ WMT_PROXY_SETTING_AUTO = 2,
+ WMT_PROXY_SETTING_BROWSER = 3,
+ WMT_PROXY_SETTING_MAX = 4
+} WMT_PROXY_SETTINGS;
+
+typedef enum WMT_CODEC_INFO_TYPE {
+ WMT_CODECINFO_AUDIO = 0,
+ WMT_CODECINFO_VIDEO = 1,
+ WMT_CODECINFO_UNKNOWN = 0XFFFFFFFF
+} WMT_CODEC_INFO_TYPE;
+
+typedef enum tagWMT_STORAGE_FORMAT {
+ WMT_Storage_Format_MP3 = 0,
+ WMT_Storage_Format_V1 = 1
+} WMT_STORAGE_FORMAT;
+
typedef LPCWSTR LPCWSTR_WMSDK_TYPE_SAFE;
[
@@ -277,6 +342,46 @@ interface IWMStreamConfig : IUnknown
[
object,
+ uuid(ad694af1-f8d9-42f8-bc47-70311b0c4f9e),
+ pointer_default(unique),
+ local
+]
+interface IWMBandwidthSharing : IUnknown
+{
+ HRESULT GetBandwidth(
+ [out] DWORD *pdwBitrate,
+ [out] DWORD *pmsBufferWindow);
+
+ HRESULT GetType(
+ [out] GUID *pguidType);
+
+ HRESULT SetBandwidth(
+ [in] DWORD dwBitrate,
+ [in] DWORD msBufferWindow);
+
+ HRESULT SetType(
+ [in] REFGUID guidType);
+}
+
+[
+ object,
+ uuid(8c1c6090-f9a8-4748-8ec3-dd1108ba1e77),
+ pointer_default(unique),
+ local
+]
+interface IWMStreamPrioritization : IUnknown
+{
+ HRESULT GetPriorityRecords(
+ [out] WM_STREAM_PRIORITY_RECORD *pRecordArray,
+ [in, out] WORD *pcRecords);
+
+ HRESULT SetPriorityRecords(
+ [in] WM_STREAM_PRIORITY_RECORD *pRecordArray,
+ [in] WORD cRecords);
+}
+
+[
+ object,
uuid(96406bdb-2b2b-11d3-b36b-00c04f6108ff),
pointer_default(unique),
local
@@ -346,6 +451,64 @@ interface IWMProfile : IUnknown
[
object,
+ uuid(07e72d33-d94e-4be7-8843-60ae5ff7e5f5),
+ pointer_default(unique),
+ local
+]
+interface IWMProfile2 : IWMProfile
+{
+ HRESULT GetProfileID(
+ [out] GUID *pguidID);
+}
+
+[
+ object,
+ uuid(00ef96cc-a461-4546-8bcd-c9a28f0e06f5),
+ pointer_default(unique),
+ local
+]
+interface IWMProfile3 : IWMProfile2
+{
+ HRESULT AddBandwidthSharing(
+ [in] IWMBandwidthSharing *pBS);
+
+ HRESULT CreateNewBandwidthSharing(
+ [out] IWMBandwidthSharing **ppBS);
+
+ HRESULT CreateNewStreamPrioritization(
+ [out] IWMStreamPrioritization **ppSP);
+
+ HRESULT GetBandwidthSharing(
+ [in] DWORD dwBSIndex,
+ [out] IWMBandwidthSharing **ppBS);
+
+ HRESULT GetBandwidthSharingCount(
+ [out] DWORD *pcBS);
+
+ HRESULT GetExpectedPacketCount(
+ [in] QWORD msDuration,
+ [out] QWORD *pcPackets);
+
+ HRESULT GetStorageFormat(
+ [out] WMT_STORAGE_FORMAT *pnStorageFormat);
+
+ HRESULT GetStreamPrioritization(
+ [out] IWMStreamPrioritization **ppSP);
+
+ HRESULT RemoveBandwidthSharing(
+ [in] IWMBandwidthSharing *pBS);
+
+ HRESULT RemoveStreamPrioritization();
+
+ HRESULT SetStorageFormat(
+ [in] WMT_STORAGE_FORMAT nStorageFormat);
+
+ HRESULT SetStreamPrioritization(
+ [in] IWMStreamPrioritization *pSP);
+}
+
+[
+ object,
uuid(d16679f2-6ca0-472d-8d31-2f5d55aee155),
pointer_default(unique),
local
@@ -1016,6 +1179,501 @@ interface IWMWriterAdvanced3 : IWMWriterAdvanced2
HRESULT SetNonBlocking();
}
+[
+ object,
+ uuid(96406bec-2b2b-11d3-b36b-00c04f6108ff),
+ pointer_default(unique),
+ local
+]
+interface IWMReaderNetworkConfig : IUnknown
+{
+ HRESULT AddLoggingUrl(
+ [in] LPCWSTR pwszUrl);
+
+ HRESULT GetBufferingTime(
+ [out] QWORD *pcnsBufferingTime);
+
+ HRESULT GetConnectionBandwidth(
+ [out] DWORD *pdwConnectionBandwidth);
+
+ HRESULT GetEnableHTTP(
+ [out] BOOL *pfEnableHTTP);
+
+ HRESULT GetEnableMulticast(
+ [out] BOOL *pfEnableMulticast);
+
+ HRESULT GetEnableTCP(
+ [out] BOOL *pfEnableTCP);
+
+ HRESULT GetEnableUDP(
+ [out] BOOL *pfEnableUDP);
+
+ HRESULT GetForceRerunAutoProxyDetection(
+ [out] BOOL *pfForceRerunDetection);
+
+ HRESULT GetLoggingUrl(
+ [in] DWORD dwIndex,
+ [out] LPWSTR pwszUrl,
+ [in, out] DWORD *pcchUrl);
+
+ HRESULT GetLoggingUrlCount(
+ [out] DWORD *pdwUrlCount);
+
+ HRESULT GetNumProtocolsSupported(
+ [out] DWORD *pcProtocols);
+
+ HRESULT GetProxyBypassForLocal(
+ [in] LPCWSTR pwszProtocol,
+ [out] BOOL *pfBypassForLocal);
+
+ HRESULT GetProxyExceptionList(
+ [in] LPCWSTR pwszProtocol,
+ [out] WCHAR *pwszExceptionList,
+ [in, out] DWORD *pcchExceptionList);
+
+ HRESULT GetProxyHostName(
+ [in] LPCWSTR pwszProtocol,
+ [out] WCHAR *pwszHostName,
+ [in, out] DWORD *pcchHostName);
+
+ HRESULT GetProxyPort(
+ [in] LPCWSTR pwszProtocol,
+ [out] DWORD *pdwPort);
+
+ HRESULT GetProxySettings(
+ [in] LPCWSTR pwszProtocol,
+ [out] WMT_PROXY_SETTINGS *pProxySetting);
+
+ HRESULT GetSupportedProtocolName(
+ [in] DWORD dwProtocolNum,
+ [out] WCHAR *pwszProtocolName,
+ [in, out] DWORD *pcchProtocolName);
+
+ HRESULT GetUDPPortRanges(
+ [out] WM_PORT_NUMBER_RANGE *pRangeArray,
+ [in, out] DWORD *pcRanges);
+
+ HRESULT ResetLoggingUrlList();
+
+ HRESULT ResetProtocolRollover();
+
+ HRESULT SetBufferingTime(
+ [in] QWORD cnsBufferingTime);
+
+ HRESULT SetConnectionBandwidth(
+ [in] DWORD dwConnectionBandwidth);
+
+ HRESULT SetEnableHTTP(
+ [in] BOOL fEnableHTTP);
+
+ HRESULT SetEnableMulticast(
+ [in] BOOL fEnableMulticast);
+
+ HRESULT SetEnableTCP(
+ [in] BOOL fEnableTCP);
+
+ HRESULT SetEnableUDP(
+ [in] BOOL fEnableUDP);
+
+ HRESULT SetForceRerunAutoProxyDetection(
+ [in] BOOL fForceRerunDetection);
+
+ HRESULT SetProxyBypassForLocal(
+ [in] LPCWSTR pwszProtocol,
+ [in] BOOL fBypassForLocal);
+
+ HRESULT SetProxyExceptionList(
+ [in] LPCWSTR pwszProtocol,
+ [in] LPCWSTR pwszExceptionList);
+
+ HRESULT SetProxyHostName(
+ [in] LPCWSTR pwszProtocol,
+ [in] LPCWSTR pwszHostName);
+
+ HRESULT SetProxyPort(
+ [in] LPCWSTR pwszProtocol,
+ [in] DWORD dwPort);
+
+ HRESULT SetProxySettings(
+ [in] LPCWSTR pwszProtocol,
+ [in] WMT_PROXY_SETTINGS ProxySetting);
+
+ HRESULT SetUDPPortRanges(
+ [in] WM_PORT_NUMBER_RANGE *pRangeArray,
+ [in] DWORD cRanges);
+}
+
+[
+ object,
+ uuid(d979a853-042b-4050-8387-c939db22013f),
+ pointer_default(unique),
+ local
+]
+interface IWMReaderNetworkConfig2 : IWMReaderNetworkConfig
+{
+ HRESULT GetAcceleratedStreamingDuration(
+ [out] QWORD *pcnsAccelDuration);
+
+ HRESULT GetAutoReconnectLimit(
+ [out] DWORD *pdwAutoReconnectLimit);
+
+ HRESULT GetEnableContentCaching(
+ [out] BOOL *pfEnableContentCaching);
+
+ HRESULT GetEnableFastCache(
+ [out] BOOL *pfEnableFastCache);
+
+ HRESULT GetEnableResends(
+ [out] BOOL *pfEnableResends);
+
+ HRESULT GetEnableThinning(
+ [out] BOOL *pfEnableThinning);
+
+ HRESULT GetMaxNetPacketSize(
+ [out] DWORD *pdwMaxNetPacketSize);
+
+ HRESULT SetAcceleratedStreamingDuration(
+ [in] QWORD cnsAccelDuration);
+
+ HRESULT SetAutoReconnectLimit(
+ [in] DWORD dwAutoReconnectLimit);
+
+ HRESULT SetEnableContentCaching(
+ [in] BOOL fEnableContentCaching);
+
+ HRESULT SetEnableFastCache(
+ [in] BOOL fEnableFastCache);
+
+ HRESULT SetEnableResends(
+ [in] BOOL fEnableResends);
+
+ HRESULT SetEnableThinning(
+ [in] BOOL fEnableThinning);
+}
+
+[
+ object,
+ uuid(96406bed-2b2b-11d3-b36b-00c04f6108ff),
+ pointer_default(unique),
+ local
+]
+interface IWMReaderStreamClock : IUnknown
+{
+ HRESULT GetTime(
+ [out] QWORD *pcnsNow);
+
+ HRESULT KillTimer(
+ [in] DWORD dwTimerId);
+
+ HRESULT SetTimer(
+ [in] QWORD cnsWhen,
+ [in] void *pvParam,
+ [out] DWORD *pdwTimerId);
+}
+
+[
+ object,
+ uuid(cdfb97ab-188f-40b3-b643-5b7903975c59),
+ pointer_default(unique),
+ local
+]
+interface IWMPacketSize : IUnknown
+{
+ HRESULT GetMaxPacketSize(
+ [out] DWORD *pdwMaxPacketSize);
+
+ HRESULT SetMaxPacketSize(
+ [in] DWORD dwMaxPacketSize);
+}
+
+[
+ object,
+ uuid(8bfc2b9e-b646-4233-a877-1c6a079669dc),
+ pointer_default(unique),
+ local
+]
+interface IWMPacketSize2 : IWMPacketSize
+{
+ HRESULT GetMinPacketSize(
+ [out] DWORD *pdwMinPacketSize);
+
+ HRESULT SetMinPacketSize(
+ [in] DWORD dwMinPacketSize);
+}
+
+[
+ object,
+ uuid(d2827540-3ee7-432c-b14c-dc17f085d3b3),
+ pointer_default(unique),
+ local
+]
+interface IWMDRMReader : IUnknown
+{
+ HRESULT AcquireLicense(
+ [in] DWORD dwFlags);
+
+ HRESULT CancelIndividualization();
+
+ HRESULT CancelLicenseAcquisition();
+
+ HRESULT CancelMonitorLicenseAcquisition();
+
+ HRESULT GetDRMProperty(
+ [in] LPCWSTR pwstrName,
+ [out] WMT_ATTR_DATATYPE *pdwType,
+ [out] BYTE *pValue,
+ [out] WORD *pcbLength);
+
+ HRESULT Individualize(
+ [in] DWORD dwFlags);
+
+ HRESULT MonitorLicenseAcquisition();
+
+ HRESULT SetDRMProperty(
+ [in] LPCWSTR pwstrName,
+ [in] WMT_ATTR_DATATYPE dwType,
+ [in] const BYTE *pValue,
+ [in] WORD cbLength);
+}
+
+[
+ object,
+ uuid(befe7a75-9f1d-4075-b9d9-a3c37bda49a0),
+ pointer_default(unique),
+ local
+]
+interface IWMDRMReader2 : IWMDRMReader
+{
+ HRESULT GetCopyOutputLevels(
+ [out] DRM_COPY_OPL *pCopyOPL,
+ [in, out] DWORD *pcbLength,
+ [out] DWORD *pdwMinAppComplianceLevel);
+
+ HRESULT GetPlayOutputLevels(
+ [out] DRM_PLAY_OPL *pPlayOPL,
+ [in, out] DWORD *pcbLength,
+ [out] DWORD *pdwMinAppComplianceLevel);
+
+ HRESULT SetEvaluateOutputLevelLicenses(
+ [in] BOOL fEvaluate);
+
+ HRESULT TryNextLicense();
+}
+
+[
+ object,
+ uuid(f28c0300-9baa-4477-a846-1744d9cbf533),
+ pointer_default(unique),
+ local
+]
+interface IWMDRMReader3 : IWMDRMReader2
+{
+ HRESULT GetInclusionList(
+ [out] GUID **ppGuids,
+ [out] DWORD *pcGuids);
+}
+
+[
+ object,
+ uuid(BDDC4D08-944D-4D52-A612-46C3FDA07DD4),
+ pointer_default(unique),
+ local
+]
+interface IWMReaderAccelerator : IUnknown
+{
+ HRESULT GetCodecInterface(
+ [in] DWORD dwOutputNum,
+ [in] REFIID riid,
+ [out] void **ppvCodecInterface);
+
+ HRESULT Notify(
+ [in] DWORD dwOutputNum,
+ [in] WM_MEDIA_TYPE *pSubtype);
+}
+
+[
+ object,
+ uuid(F369E2F0-E081-4FE6-8450-B810B2F410D1),
+ pointer_default(unique),
+ local
+]
+interface IWMReaderTimecode : IUnknown
+{
+ HRESULT GetTimecodeRangeBounds(
+ [in] WORD wStreamNum,
+ [in] WORD wRangeNum,
+ [out] DWORD *pStartTimecode,
+ [out] DWORD *pEndTimecode);
+
+ HRESULT GetTimecodeRangeCount(
+ [in] WORD wStreamNum,
+ [out] WORD *pwRangeCount);
+}
+
+[
+ object,
+ uuid(96406bda-2b2b-11d3-b36b-00c04f6108ff),
+ pointer_default(unique),
+ local
+]
+interface IWMHeaderInfo : IUnknown
+{
+ HRESULT AddMarker(
+ [in] WCHAR *pwszMarkerName,
+ [in] QWORD cnsMarkerTime);
+
+ HRESULT AddScript(
+ [in] WCHAR *pwszType,
+ [in] WCHAR *pwszCommand,
+ [in] QWORD cnsScriptTime);
+
+ HRESULT GetAttributeByIndex(
+ [in] WORD wIndex,
+ [in] WORD *pwStreamNum,
+ [out] WCHAR *pwszName,
+ [in, out] WORD *pcchNameLen,
+ [out] WMT_ATTR_DATATYPE *pType,
+ [out] BYTE *pValue,
+ [in, out] WORD *pcbLength);
+
+ HRESULT GetAttributeByName(
+ [in, out] WORD *pwStreamNum,
+ [in] LPCWSTR pszName,
+ [out] WMT_ATTR_DATATYPE *pType,
+ [out] BYTE *pValue,
+ [in, out] WORD *pcbLength);
+
+ HRESULT GetAttributeCount(
+ [in] WORD wStreamNum,
+ [out] WORD *pcAttributes);
+
+ HRESULT GetMarker(
+ [in] WORD wIndex,
+ [out] WCHAR *pwszMarkerName,
+ [in] WORD *pcchMarkerNameLen,
+ [out] QWORD *pcnsMarkerTime);
+
+ HRESULT GetMarkerCount(
+ [out] WORD *pcMarkers);
+
+ HRESULT GetScript(
+ [in] WORD wIndex,
+ [out] WCHAR *pwszType,
+ [in, out] WORD *pcchTypeLen,
+ [out] WCHAR *pwszCommand,
+ [in, out] WORD *pcchCommandLen,
+ [out] QWORD *pcnsScriptTime);
+
+ HRESULT GetScriptCount(
+ [out] WORD *pcScripts);
+
+ HRESULT RemoveMarker(
+ [in] WORD wIndex);
+
+ HRESULT RemoveScript(
+ [in] WORD wIndex);
+
+ HRESULT SetAttribute(
+ [in] WORD wStreamNum,
+ [in] LPCWSTR pszName,
+ [in] WMT_ATTR_DATATYPE Type,
+ [in] const BYTE *pValue,
+ [in] WORD cbLength);
+}
+
+[
+ object,
+ uuid(15cf9781-454e-482e-b393-85fae487a810),
+ pointer_default(unique),
+ local
+]
+interface IWMHeaderInfo2 : IWMHeaderInfo
+{
+ HRESULT GetCodecInfo(
+ [in] DWORD wIndex,
+ [in, out] WORD *pcchName,
+ [out] WCHAR *pwszName,
+ [in, out] WORD *pcchDescription,
+ [out] WCHAR *pwszDescription,
+ [out] WMT_CODEC_INFO_TYPE *pCodecType,
+ [in, out] WORD *pcbCodecInfo,
+ [out] BYTE *pbCodecInfo);
+
+ HRESULT GetCodecInfoCount(
+ [out] DWORD *pcCodecInfos);
+}
+
+[
+ object,
+ uuid(15CC68E3-27CC-4ecd-B222-3F5D02D80BD5),
+ pointer_default(unique),
+ local
+]
+interface IWMHeaderInfo3 : IWMHeaderInfo2
+{
+ HRESULT AddAttribute(
+ [in] WORD wStreamNum,
+ [in] LPCWSTR pszName,
+ [out] WORD *pwIndex,
+ [in] WMT_ATTR_DATATYPE Type,
+ [in] WORD wLangIndex,
+ [in] const BYTE *pValue,
+ [in] DWORD dwLength);
+
+ HRESULT AddCodecInfo(
+ [in] WCHAR *pwszName,
+ [in] WCHAR *pwszDescription,
+ [in] WMT_CODEC_INFO_TYPE codecType,
+ [in] WORD cbCodecInfo,
+ [in] BYTE *pbCodecInfo);
+
+ HRESULT DeleteAttribute(
+ [in] WORD wStreamNum,
+ [in] WORD wIndex);
+
+ HRESULT GetAttributeByIndexEx(
+ [in] WORD wStreamNum,
+ [in] WORD wIndex,
+ [out] LPWSTR pwszName,
+ [in, out] WORD *pwNameLen,
+ [out] WMT_ATTR_DATATYPE *pType,
+ [out] WORD *pwLangIndex,
+ [out] BYTE *pValue,
+ [in, out] DWORD *pdwDataLength);
+
+ HRESULT GetAttributeCountEx(
+ [in] WORD wStreamNum,
+ [out] WORD *pcAttributes);
+
+ HRESULT GetAttributeIndices(
+ [in] WORD wStreamNum,
+ [in] LPCWSTR pwszName,
+ [in] WORD *pwLangIndex,
+ [out] WORD *pwIndices,
+ [in, out] WORD *pwCount);
+
+ HRESULT ModifyAttribute(
+ [in] WORD wStreamNum,
+ [in] WORD wIndex,
+ [in] WMT_ATTR_DATATYPE Type,
+ [in] WORD wLangIndex,
+ [in] const BYTE *pValue,
+ [in] DWORD dwLength);
+}
+
+[
+ object,
+ uuid(fdbe5592-81a1-41ea-93bd-735cad1adc05),
+ pointer_default(unique),
+ local
+]
+interface IWMReaderTypeNegotiation : IUnknown
+{
+ HRESULT TryOutputProps(
+ [in] DWORD dwOutputNum,
+ [in] IWMOutputMediaProps *pOutput);
+}
+
cpp_quote("HRESULT WINAPI WMCreateWriter(IUnknown*,IWMWriter**);")
cpp_quote("HRESULT WINAPI WMCreateReader(IUnknown*,DWORD,IWMReader**);")
--
2.12.0
More information about the wine-patches
mailing list