diff --git a/mingw-w64-crt/revstamp.h b/mingw-w64-crt/revstamp.h
index 75bbbe6..93ca9a3 100644
--- a/mingw-w64-crt/revstamp.h
+++ b/mingw-w64-crt/revstamp.h
@@ -1,4 +1,4 @@
 /* Do not edit. Autogenerated.  */
-#define __MINGW_W64_REV	"4936"
-#define __MINGW_W64_REV_STAMP "2012-04-03"
+#define __MINGW_W64_REV	"4963"
+#define __MINGW_W64_REV_STAMP "2012-04-23"
 
diff --git a/mingw-w64-headers/include/ChangeLog b/mingw-w64-headers/include/ChangeLog
index c76eab7..01a505f 100644
--- a/mingw-w64-headers/include/ChangeLog
+++ b/mingw-w64-headers/include/ChangeLog
@@ -1,3 +1,22 @@
+2012-04-23  Ozkan Sezer  <sezeroz@gmail.com>
+
+	Merge from the trunk revs. 4961/4962:
+	2012-04-23  Stefan Sundin  <recover89@gmail.com>
+	* adhoc.h, audioengineendpoint.h, bdaiface.h, dvbsiparser.h, dwrite.h,
+	dxvahd.h, evr.h, fsrm.h, fsrmquota.h, fsrmreports.h, fsrmscreen.h,
+	functiondiscoveryapi.h, functiondiscoverynotification.h,
+	identitystore.h, locationapi.h, mfapi.h, mfidl.h, mfobjects.h,
+	mfplay.h, mfreadwrite.h, mftransform.h, mpeg2data.h, mpeg2psiparser.h,
+	msrdc.h, ndhelper.h, opmapi.h, portabledeviceconnectapi.h,
+	rdpencomapi.h, strmif.h, tuner.h, vsadmin.h, vsbackup.h, vsmgmt.h,
+	vsprov.h, vss.h, vswriter.h, winsync.h, wmcontainer.h, wsdattachment.h,
+	wsdbase.h, wsdclient.h, wsddisco.h, wsdhost.h, wsdxml.h: Fix incorrect
+	references for pVtbl to lpVtbl.
+	* adhoc.h (IDot11AdHocInterfaceNotificationSink): Fix
+	OnConnectionStatusChange.
+	2012-04-23  Kai Tietz  <ktietz@redhat.com>
+	* endpointvolume.h (IAudioEndpointVolume): Fix. (PR/3520095)
+
 2012-02-24  Ozkan Sezer  <sezeroz@gmail.com>
 
 	Merge from the trunk revs. 4790, 4807, 4809, 4815, 4816 and
diff --git a/mingw-w64-headers/include/adhoc.h b/mingw-w64-headers/include/adhoc.h
index 033de9e..7684f77 100644
--- a/mingw-w64-headers/include/adhoc.h
+++ b/mingw-w64-headers/include/adhoc.h
@@ -63,10 +63,10 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDot11AdHocInterfaceNotificationSink_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDot11AdHocInterfaceNotificationSink_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDot11AdHocInterfaceNotificationSink_Release(This) (This)->pVtbl->Release(This)
-#define IDot11AdHocInterf
+#define IDot11AdHocInterfaceNotificationSink_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDot11AdHocInterfaceNotificationSink_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDot11AdHocInterfaceNotificationSink_Release(This) (This)->lpVtbl->Release(This)
+#define IDot11AdHocInterfaceNotificationSink_OnConnectionStatusChange(This,eStatus) (This)->lpVtbl->OnConnectionStatusChange(This,eStatus)
 #endif /*COBJMACROS*/
 
 #undef  INTERFACE
@@ -99,9 +99,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDot11AdHocInterface_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDot11AdHocInterface_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDot11AdHocInterface_Release(This) (This)->pVtbl->Release(This)
+#define IDot11AdHocInterface_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDot11AdHocInterface_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDot11AdHocInterface_Release(This) (This)->lpVtbl->Release(This)
 #define IDot11AdHocInterface_GetDeviceSignature(This,pSignature) (This)->lpVtbl->GetDeviceSignature(This,pSignature)
 #define IDot11AdHocInterface_GetFriendlyName(This,ppszName) (This)->lpVtbl->GetFriendlyName(This,ppszName)
 #define IDot11AdHocInterface_IsDot11d(This,pf11d) (This)->lpVtbl->IsDot11d(This,pf11d)
@@ -139,9 +139,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDot11AdHocManager_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDot11AdHocManager_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDot11AdHocManager_Release(This) (This)->pVtbl->Release(This)
+#define IDot11AdHocManager_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDot11AdHocManager_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDot11AdHocManager_Release(This) (This)->lpVtbl->Release(This)
 #define IDot11AdHocManager_CreateNetwork(This,Name,Password,GeographicalId,pInterface,pSecurity,pContextGuid,pIAdHoc) (This)->lpVtbl->CreateNetwork(This,Name,Password,GeographicalId,pInterface,pSecurity,pContextGuid,pIAdHoc)
 #define IDot11AdHocManager_CommitCreatedNetwork(This,pIAdHoc,fSaveProfile,fMakeSavedProfileUserSpecific) (This)->lpVtbl->CommitCreatedNetwork(This,pIAdHoc,fSaveProfile,fMakeSavedProfileUserSpecific)
 #define IDot11AdHocManager_GetIEnumDot11AdHocNetworks(This,pContextGuid,ppEnum) (This)->lpVtbl->GetIEnumDot11AdHocNetworks(This,pContextGuid,ppEnum)
@@ -174,9 +174,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDot11AdHocManagerNotificationSink_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDot11AdHocManagerNotificationSink_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDot11AdHocManagerNotificationSink_Release(This) (This)->pVtbl->Release(This)
+#define IDot11AdHocManagerNotificationSink_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDot11AdHocManagerNotificationSink_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDot11AdHocManagerNotificationSink_Release(This) (This)->lpVtbl->Release(This)
 #define IDot11AdHocManagerNotificationSink_OnNetworkAdd(This,pIAdHocNetwork) (This)->lpVtbl->OnNetworkAdd(This,pIAdHocNetwork)
 #define IDot11AdHocManagerNotificationSink_OnNetworkRemove(This,Signature) (This)->lpVtbl->OnNetworkRemove(This,Signature)
 #define IDot11AdHocManagerNotificationSink_OnInterfaceAdd(This,pIAdHocInterface) (This)->lpVtbl->OnInterfaceAdd(This,pIAdHocInterface)
@@ -216,9 +216,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDot11AdHocNetwork_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDot11AdHocNetwork_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDot11AdHocNetwork_Release(This) (This)->pVtbl->Release(This)
+#define IDot11AdHocNetwork_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDot11AdHocNetwork_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDot11AdHocNetwork_Release(This) (This)->lpVtbl->Release(This)
 #define IDot11AdHocNetwork_GetStatus(This,eStatus) (This)->lpVtbl->GetStatus(This,eStatus)
 #define IDot11AdHocNetwork_GetSSID(This,ppszwSSID) (This)->lpVtbl->GetSSID(This,ppszwSSID)
 #define IDot11AdHocNetwork_HasProfile(This,pf11d) (This)->lpVtbl->HasProfile(This,pf11d)
@@ -256,9 +256,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDot11AdHocNetworkNotificationSink_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDot11AdHocNetworkNotificationSink_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDot11AdHocNetworkNotificationSink_Release(This) (This)->pVtbl->Release(This)
+#define IDot11AdHocNetworkNotificationSink_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDot11AdHocNetworkNotificationSink_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDot11AdHocNetworkNotificationSink_Release(This) (This)->lpVtbl->Release(This)
 #define IDot11AdHocNetworkNotificationSink_OnStatusChange(This,eStatus) (This)->lpVtbl->OnStatusChange(This,eStatus)
 #define IDot11AdHocNetworkNotificationSink_OnConnectFail(This,eFailReason) (This)->lpVtbl->OnConnectFail(This,eFailReason)
 #endif /*COBJMACROS*/
@@ -286,9 +286,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDot11AdHocSecuritySettings_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDot11AdHocSecuritySettings_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDot11AdHocSecuritySettings_Release(This) (This)->pVtbl->Release(This)
+#define IDot11AdHocSecuritySettings_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDot11AdHocSecuritySettings_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDot11AdHocSecuritySettings_Release(This) (This)->lpVtbl->Release(This)
 #define IDot11AdHocSecuritySettings_GetDot11AuthAlgorithm(This,pAuth) (This)->lpVtbl->GetDot11AuthAlgorithm(This,pAuth)
 #define IDot11AdHocSecuritySettings_GetDot11CipherAlgorithm(This,pCipher) (This)->lpVtbl->GetDot11CipherAlgorithm(This,pCipher)
 #endif /*COBJMACROS*/
@@ -318,9 +318,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IEnumDot11AdHocInterfaces_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IEnumDot11AdHocInterfaces_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IEnumDot11AdHocInterfaces_Release(This) (This)->pVtbl->Release(This)
+#define IEnumDot11AdHocInterfaces_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IEnumDot11AdHocInterfaces_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IEnumDot11AdHocInterfaces_Release(This) (This)->lpVtbl->Release(This)
 #define IEnumDot11AdHocInterfaces_Next(This,cElt,rgElt,pcEltFetched) (This)->lpVtbl->Next(This,cElt,rgElt,pcEltFetched)
 #define IEnumDot11AdHocInterfaces_Skip(This,cElt) (This)->lpVtbl->Skip(This,cElt)
 #define IEnumDot11AdHocInterfaces_Reset() (This)->lpVtbl->Reset(This)
@@ -352,9 +352,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IEnumDot11AdHocNetworks_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IEnumDot11AdHocNetworks_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IEnumDot11AdHocNetworks_Release(This) (This)->pVtbl->Release(This)
+#define IEnumDot11AdHocNetworks_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IEnumDot11AdHocNetworks_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IEnumDot11AdHocNetworks_Release(This) (This)->lpVtbl->Release(This)
 #define IEnumDot11AdHocNetworks_Next(This,cElt,rgElt,pcEltFetched) (This)->lpVtbl->Next(This,cElt,rgElt,pcEltFetched)
 #define IEnumDot11AdHocNetworks_Skip(This,cElt) (This)->lpVtbl->Skip(This,cElt)
 #define IEnumDot11AdHocNetworks_Reset() (This)->lpVtbl->Reset(This)
@@ -386,9 +386,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IEnumDot11AdHocSecuritySettings_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IEnumDot11AdHocSecuritySettings_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IEnumDot11AdHocSecuritySettings_Release(This) (This)->pVtbl->Release(This)
+#define IEnumDot11AdHocSecuritySettings_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IEnumDot11AdHocSecuritySettings_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IEnumDot11AdHocSecuritySettings_Release(This) (This)->lpVtbl->Release(This)
 #define IEnumDot11AdHocSecuritySettings_Next(This,cElt,rgElt,pcEltFetched) (This)->lpVtbl->Next(This,cElt,rgElt,pcEltFetched)
 #define IEnumDot11AdHocSecuritySettings_Skip(This,cElt) (This)->lpVtbl->Skip(This,cElt)
 #define IEnumDot11AdHocSecuritySettings_Reset() (This)->lpVtbl->Reset(This)
diff --git a/mingw-w64-headers/include/audioengineendpoint.h b/mingw-w64-headers/include/audioengineendpoint.h
index f43dc72..9fcded2 100644
--- a/mingw-w64-headers/include/audioengineendpoint.h
+++ b/mingw-w64-headers/include/audioengineendpoint.h
@@ -111,9 +111,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IAudioDeviceEndpoint_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IAudioDeviceEndpoint_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IAudioDeviceEndpoint_Release(This) (This)->pVtbl->Release(This)
+#define IAudioDeviceEndpoint_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IAudioDeviceEndpoint_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IAudioDeviceEndpoint_Release(This) (This)->lpVtbl->Release(This)
 #define IAudioDeviceEndpoint_GetEventDrivenCapable(This,pbIsEventCapable) (This)->lpVtbl->GetEventDrivenCapable(This,pbIsEventCapable)
 #define IAudioDeviceEndpoint_GetRTCaps(This,pbIsRTCapable) (This)->lpVtbl->GetRTCaps(This,pbIsRTCapable)
 #define IAudioDeviceEndpoint_SetBuffer(This,MaxPeriod,u32LatencyCoefficient) (This)->lpVtbl->SetBuffer(This,MaxPeriod,u32LatencyCoefficient)
@@ -146,9 +146,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IAudioEndpoint_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IAudioEndpoint_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IAudioEndpoint_Release(This) (This)->pVtbl->Release(This)
+#define IAudioEndpoint_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IAudioEndpoint_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IAudioEndpoint_Release(This) (This)->lpVtbl->Release(This)
 #define IAudioEndpoint_GetFrameFormat(This,ppFormat) (This)->lpVtbl->GetFrameFormat(This,ppFormat)
 #define IAudioEndpoint_GetFramesPerPacket(This,pFramesPerPacket) (This)->lpVtbl->GetFramesPerPacket(This,pFramesPerPacket)
 #define IAudioEndpoint_GetLatency(This,pLatency) (This)->lpVtbl->GetLatency(This,pLatency)
@@ -180,9 +180,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IAudioEndpointControl_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IAudioEndpointControl_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IAudioEndpointControl_Release(This) (This)->pVtbl->Release(This)
+#define IAudioEndpointControl_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IAudioEndpointControl_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IAudioEndpointControl_Release(This) (This)->lpVtbl->Release(This)
 #define IAudioEndpointControl_Reset() (This)->lpVtbl->Reset(This)
 #define IAudioEndpointControl_Start() (This)->lpVtbl->Start(This)
 #define IAudioEndpointControl_Stop() (This)->lpVtbl->Stop(This)
@@ -213,9 +213,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IAudioEndpointRT_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IAudioEndpointRT_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IAudioEndpointRT_Release(This) (This)->pVtbl->Release(This)
+#define IAudioEndpointRT_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IAudioEndpointRT_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IAudioEndpointRT_Release(This) (This)->lpVtbl->Release(This)
 #define IAudioEndpointRT_GetCurrentPadding(This,pPadding,pAeCurrentPosition) (This)->lpVtbl->GetCurrentPadding(This,pPadding,pAeCurrentPosition)
 #define IAudioEndpointRT_ProcessingComplete() (This)->lpVtbl->ProcessingComplete(This)
 #define IAudioEndpointRT_SetPinActive() (This)->lpVtbl->SetPinActive(This)
@@ -264,9 +264,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IAudioEndpointVolumeEx_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IAudioEndpointVolumeEx_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IAudioEndpointVolumeEx_Release(This) (This)->pVtbl->Release(This)
+#define IAudioEndpointVolumeEx_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IAudioEndpointVolumeEx_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IAudioEndpointVolumeEx_Release(This) (This)->lpVtbl->Release(This)
 #define IAudioEndpointVolumeEx_GetChannelCount(This,pnChannelCount) (This)->lpVtbl->GetChannelCount(This,pnChannelCount)
 #define IAudioEndpointVolumeEx_GetChannelVolumeLevel(This,nChannel,pfLevelDB) (This)->lpVtbl->GetChannelVolumeLevel(This,nChannel,pfLevelDB)
 #define IAudioEndpointVolumeEx_GetChannelVolumeLevelScalar(This,nChannel,pfLevel) (This)->lpVtbl->GetChannelVolumeLevelScalar(This,nChannel,pfLevel)
@@ -312,9 +312,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IAudioInputEndpointRT_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IAudioInputEndpointRT_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IAudioInputEndpointRT_Release(This) (This)->pVtbl->Release(This)
+#define IAudioInputEndpointRT_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IAudioInputEndpointRT_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IAudioInputEndpointRT_Release(This) (This)->lpVtbl->Release(This)
 #define IAudioInputEndpointRT_GetInputDataPointer(This,pAeTimeStamp) (This)->lpVtbl->GetInputDataPointer(This,pAeTimeStamp)
 #define IAudioInputEndpointRT_PulseEndpoint() (This)->lpVtbl->PulseEndpoint(This)
 #define IAudioInputEndpointRT_ReleaseInputDataPointer(This,u32FrameCount,pDataPointer) (This)->lpVtbl->ReleaseInputDataPointer(This,u32FrameCount,pDataPointer)
@@ -344,9 +344,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IAudioOutputEndpointRT_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IAudioOutputEndpointRT_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IAudioOutputEndpointRT_Release(This) (This)->pVtbl->Release(This)
+#define IAudioOutputEndpointRT_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IAudioOutputEndpointRT_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IAudioOutputEndpointRT_Release(This) (This)->lpVtbl->Release(This)
 #define IAudioOutputEndpointRT_GetOutputDataPointer(This,u32FrameCount,pAeTimeStamp) (This)->lpVtbl->GetOutputDataPointer(This,u32FrameCount,pAeTimeStamp)
 #define IAudioOutputEndpointRT_PulseEndpoint() (This)->lpVtbl->PulseEndpoint(This)
 #define IAudioOutputEndpointRT_ReleaseOutputDataPointer(This,pConnectionProperty) (This)->lpVtbl->ReleaseOutputDataPointer(This,pConnectionProperty)
diff --git a/mingw-w64-headers/include/bdaiface.h b/mingw-w64-headers/include/bdaiface.h
index b921ad2..5a8a2ab 100644
--- a/mingw-w64-headers/include/bdaiface.h
+++ b/mingw-w64-headers/include/bdaiface.h
@@ -173,9 +173,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IBDA_ConditionalAccessEx_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IBDA_ConditionalAccessEx_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IBDA_ConditionalAccessEx_Release(This) (This)->pVtbl->Release(This)
+#define IBDA_ConditionalAccessEx_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IBDA_ConditionalAccessEx_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IBDA_ConditionalAccessEx_Release(This) (This)->lpVtbl->Release(This)
 #define IBDA_ConditionalAccessEx_CheckEntitlementToken(This,ulDialogRequest,bstrLanguage,RequestType,ulcbEntitlementTokenLen,pbEntitlementToken,pulDescrambleStatus) (This)->lpVtbl->CheckEntitlementToken(This,ulDialogRequest,bstrLanguage,RequestType,ulcbEntitlementTokenLen,pbEntitlementToken,pulDescrambleStatus)
 #define IBDA_ConditionalAccessEx_CloseMmiDialog(This,ulDialogRequest,bstrLanguage,ulDialogNumber,ReasonCode,pulSessionResult) (This)->lpVtbl->CloseMmiDialog(This,ulDialogRequest,bstrLanguage,ulDialogNumber,ReasonCode,pulSessionResult)
 #define IBDA_ConditionalAccessEx_CreateDialogRequestNumber(This,pulDialogRequestNumber) (This)->lpVtbl->CreateDialogRequestNumber(This,pulDialogRequestNumber)
@@ -207,9 +207,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IBDA_DRIDRMService_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IBDA_DRIDRMService_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IBDA_DRIDRMService_Release(This) (This)->pVtbl->Release(This)
+#define IBDA_DRIDRMService_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IBDA_DRIDRMService_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IBDA_DRIDRMService_Release(This) (This)->lpVtbl->Release(This)
 #define IBDA_DRIDRMService_GetDRMStatus(This,pbstrDrmUuidList,DrmUuid) (This)->lpVtbl->GetDRMStatus(This,pbstrDrmUuidList,DrmUuid)
 #define IBDA_DRIDRMService_GetPairingStatus(This,penumPairingStatus) (This)->lpVtbl->GetPairingStatus(This,penumPairingStatus)
 #define IBDA_DRIDRMService_SetDRM(This,puuidNewDrm) (This)->lpVtbl->SetDRM(This,puuidNewDrm)
@@ -241,9 +241,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IBDA_Encoder_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IBDA_Encoder_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IBDA_Encoder_Release(This) (This)->pVtbl->Release(This)
+#define IBDA_Encoder_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IBDA_Encoder_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IBDA_Encoder_Release(This) (This)->lpVtbl->Release(This)
 #define IBDA_Encoder_EnumAudioCapability(This,FmtIndex,MethodID,AlgorithmType,SamplingRate,BitDepth,NumChannels) (This)->lpVtbl->EnumAudioCapability(This,FmtIndex,MethodID,AlgorithmType,SamplingRate,BitDepth,NumChannels)
 #define IBDA_Encoder_EnumVideoCapability(This,FmtIndex,MethodID,AlgorithmType,VerticalSize,HorizontalSize,AspectRatio,FrameRateCode,ProgressiveSequence) (This)->lpVtbl->EnumVideoCapability(This,FmtIndex,MethodID,AlgorithmType,VerticalSize,HorizontalSize,AspectRatio,FrameRateCode,ProgressiveSequence)
 #define IBDA_Encoder_GetState(This,AudioBitrateMax,AudioBitrateMin,AudioBitrateMode,AudioBitrateStepping,AudioBitrate,AudioMethodID,AvailableAudioPrograms,AudioProgram,VideoBitrateMax,VideoBitrateMin,VideoBitrateMode,VideoBitrate,VideoBitrateStepping,VideoMethodID,SignalSourceID,SignalFormat,SignalLock,SignalLevel,SignalToNoiseRatio) (This)->lpVtbl->GetState(This,AudioBitrateMax,AudioBitrateMin,AudioBitrateMode,AudioBitrateStepping,AudioBitrate,AudioMethodID,AvailableAudioPrograms,AudioProgram,VideoBitrateMax,VideoBitrateMin,VideoBitrateMode,VideoBitrate,VideoBitrateStepping,VideoMethodID,SignalSourceID,SignalFormat,SignalLock,SignalLevel,SignalToNoiseRatio)
@@ -268,9 +268,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IBDA_EventingService_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IBDA_EventingService_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IBDA_EventingService_Release(This) (This)->pVtbl->Release(This)
+#define IBDA_EventingService_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IBDA_EventingService_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IBDA_EventingService_Release(This) (This)->lpVtbl->Release(This)
 #define IBDA_EventingService_CompleteEvent(This,ulEventID,ulEventResult) (This)->lpVtbl->CompleteEvent(This,ulEventID,ulEventResult)
 #endif /*COBJMACROS*/
 
@@ -302,9 +302,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IBDA_FDC_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IBDA_FDC_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IBDA_FDC_Release(This) (This)->pVtbl->Release(This)
+#define IBDA_FDC_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IBDA_FDC_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IBDA_FDC_Release(This) (This)->lpVtbl->Release(This)
 #define IBDA_FDC_AddPid(This,PidsToAdd,RemainingFilterEntries) (This)->lpVtbl->AddPid(This,PidsToAdd,RemainingFilterEntries)
 #define IBDA_FDC_AddTid(This,TidsToAdd,CurrentTidList) (This)->lpVtbl->AddTid(This,TidsToAdd,CurrentTidList)
 #define IBDA_FDC_GetStatus(This,CurrentBitrate,CarrierLock,CurrentFrequency,CurrentSpectrumInversion,CurrentPIDList,CurrentTIDList,Overflow) (This)->lpVtbl->GetStatus(This,CurrentBitrate,CarrierLock,CurrentFrequency,CurrentSpectrumInversion,CurrentPIDList,CurrentTIDList,Overflow)
@@ -341,9 +341,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IBDA_GuideDataDeliveryService_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IBDA_GuideDataDeliveryService_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IBDA_GuideDataDeliveryService_Release(This) (This)->pVtbl->Release(This)
+#define IBDA_GuideDataDeliveryService_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IBDA_GuideDataDeliveryService_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IBDA_GuideDataDeliveryService_Release(This) (This)->lpVtbl->Release(This)
 #define IBDA_GuideDataDeliveryService_GetGuideData(This,pulcbBufferLen,pbBuffer,pulGuideDataPercentageProgress) (This)->lpVtbl->GetGuideData(This,pulcbBufferLen,pbBuffer,pulGuideDataPercentageProgress)
 #define IBDA_GuideDataDeliveryService_GetGuideDataType(This,pguidDataType) (This)->lpVtbl->GetGuideDataType(This,pguidDataType)
 #define IBDA_GuideDataDeliveryService_GetServiceInfoFromTuneXml(This,bstrTuneXml,pbstrServiceDescription) (This)->lpVtbl->GetServiceInfoFromTuneXml(This,bstrTuneXml,pbstrServiceDescription)
@@ -369,9 +369,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IBDA_ISDBConditionalAccess_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IBDA_ISDBConditionalAccess_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IBDA_ISDBConditionalAccess_Release(This) (This)->pVtbl->Release(This)
+#define IBDA_ISDBConditionalAccess_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IBDA_ISDBConditionalAccess_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IBDA_ISDBConditionalAccess_Release(This) (This)->lpVtbl->Release(This)
 #define IBDA_ISDBConditionalAccess_SetIsdbCasRequest(This,ulRequestId,ulcbRequestBufferLen,pbRequestBuffer) (This)->lpVtbl->SetIsdbCasRequest(This,ulRequestId,ulcbRequestBufferLen,pbRequestBuffer)
 #endif /*COBJMACROS*/
 
@@ -398,9 +398,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IBDA_MUX_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IBDA_MUX_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IBDA_MUX_Release(This) (This)->pVtbl->Release(This)
+#define IBDA_MUX_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IBDA_MUX_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IBDA_MUX_Release(This) (This)->lpVtbl->Release(This)
 #define IBDA_MUX_GetPidList(This,pbPidListBuffer) (This)->lpVtbl->GetPidList(This,pbPidListBuffer)
 #define IBDA_MUX_SetPidList(This,ulPidListCount,pbPidListBuffer) (This)->lpVtbl->SetPidList(This,ulPidListCount,pbPidListBuffer)
 #endif /*COBJMACROS*/
@@ -429,9 +429,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IBDA_UserActivityService_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IBDA_UserActivityService_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IBDA_UserActivityService_Release(This) (This)->pVtbl->Release(This)
+#define IBDA_UserActivityService_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IBDA_UserActivityService_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IBDA_UserActivityService_Release(This) (This)->lpVtbl->Release(This)
 #define IBDA_UserActivityService_GetUserActivityInterval(This,pdwActivityInterval) (This)->lpVtbl->GetUserActivityInterval(This,pdwActivityInterval)
 #define IBDA_UserActivityService_SetCurrentTunerUseReason(This,dwUseReason) (This)->lpVtbl->SetCurrentTunerUseReason(This,dwUseReason)
 #define IBDA_UserActivityService_UserActivityDetected() (This)->lpVtbl->UserActivityDetected(This)
diff --git a/mingw-w64-headers/include/dvbsiparser.h b/mingw-w64-headers/include/dvbsiparser.h
index ceec71e..46a8c27 100644
--- a/mingw-w64-headers/include/dvbsiparser.h
+++ b/mingw-w64-headers/include/dvbsiparser.h
@@ -229,9 +229,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDVB_EIT_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDVB_EIT_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDVB_EIT_Release(This) (This)->pVtbl->Release(This)
+#define IDVB_EIT_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDVB_EIT_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDVB_EIT_Release(This) (This)->lpVtbl->Release(This)
 #define IDVB_EIT_ConvertNextToCurrent() (This)->lpVtbl->ConvertNextToCurrent(This)
 #define IDVB_EIT_GetCountOfRecords(This,pdwVal) (This)->lpVtbl->GetCountOfRecords(This,pdwVal)
 #define IDVB_EIT_GetLastTableId(This,pbVal) (This)->lpVtbl->GetLastTableId(This,pbVal)
@@ -301,9 +301,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDVB_EIT2_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDVB_EIT2_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDVB_EIT2_Release(This) (This)->pVtbl->Release(This)
+#define IDVB_EIT2_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDVB_EIT2_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDVB_EIT2_Release(This) (This)->lpVtbl->Release(This)
 #define IDVB_EIT2_ConvertNextToCurrent() (This)->lpVtbl->ConvertNextToCurrent(This)
 #define IDVB_EIT2_GetCountOfRecords(This,pdwVal) (This)->lpVtbl->GetCountOfRecords(This,pdwVal)
 #define IDVB_EIT2_GetLastTableId(This,pbVal) (This)->lpVtbl->GetLastTableId(This,pbVal)
@@ -357,9 +357,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDvbComponentDescriptor_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDvbComponentDescriptor_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDvbComponentDescriptor_Release(This) (This)->pVtbl->Release(This)
+#define IDvbComponentDescriptor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDvbComponentDescriptor_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDvbComponentDescriptor_Release(This) (This)->lpVtbl->Release(This)
 #define IDvbComponentDescriptor_GetComponentTag(This,pbVal) (This)->lpVtbl->GetComponentTag(This,pbVal)
 #define IDvbComponentDescriptor_GetComponentType(This,pbVal) (This)->lpVtbl->GetComponentType(This,pbVal)
 #define IDvbComponentDescriptor_GetLanguageCode(This,pszCode) (This)->lpVtbl->GetLanguageCode(This,pszCode)
@@ -395,9 +395,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDvbContentDescriptor_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDvbContentDescriptor_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDvbContentDescriptor_Release(This) (This)->pVtbl->Release(This)
+#define IDvbContentDescriptor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDvbContentDescriptor_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDvbContentDescriptor_Release(This) (This)->lpVtbl->Release(This)
 #define IDvbContentDescriptor_GetCountOfRecords(This,pbVal) (This)->lpVtbl->GetCountOfRecords(This,pbVal)
 #define IDvbContentDescriptor_GetLength(This,pbVal) (This)->lpVtbl->GetLength(This,pbVal)
 #define IDvbContentDescriptor_GetRecordContentNibbles(This,bRecordIndex,pbValLevel1,pbValLevel2) (This)->lpVtbl->GetRecordContentNibbles(This,bRecordIndex,pbValLevel1,pbValLevel2)
@@ -430,9 +430,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDvbContentIdentifierDescriptor_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDvbContentIdentifierDescriptor_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDvbContentIdentifierDescriptor_Release(This) (This)->pVtbl->Release(This)
+#define IDvbContentIdentifierDescriptor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDvbContentIdentifierDescriptor_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDvbContentIdentifierDescriptor_Release(This) (This)->lpVtbl->Release(This)
 #define IDvbContentIdentifierDescriptor_GetCountOfRecords(This,pbVal) (This)->lpVtbl->GetCountOfRecords(This,pbVal)
 #define IDvbContentIdentifierDescriptor_GetLength(This,pbVal) (This)->lpVtbl->GetLength(This,pbVal)
 #define IDvbContentIdentifierDescriptor_GetRecordCrid(This,bRecordIndex,pbType,pbLocation,pbLength,ppbBytes) (This)->lpVtbl->GetRecordCrid(This,bRecordIndex,pbType,pbLocation,pbLength,ppbBytes)
@@ -469,9 +469,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDvbDataBroadcastDescriptor_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDvbDataBroadcastDescriptor_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDvbDataBroadcastDescriptor_Release(This) (This)->pVtbl->Release(This)
+#define IDvbDataBroadcastDescriptor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDvbDataBroadcastDescriptor_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDvbDataBroadcastDescriptor_Release(This) (This)->lpVtbl->Release(This)
 #define IDvbDataBroadcastDescriptor_GetComponentTag(This,pbVal) (This)->lpVtbl->GetComponentTag(This,pbVal)
 #define IDvbDataBroadcastDescriptor_GetDataBroadcastID(This,pwVal) (This)->lpVtbl->GetDataBroadcastID(This,pwVal)
 #define IDvbDataBroadcastDescriptor_GetLangID(This,pulVal) (This)->lpVtbl->GetLangID(This,pulVal)
@@ -508,9 +508,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDvbDataBroadcastIDDescriptor_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDvbDataBroadcastIDDescriptor_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDvbDataBroadcastIDDescriptor_Release(This) (This)->pVtbl->Release(This)
+#define IDvbDataBroadcastIDDescriptor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDvbDataBroadcastIDDescriptor_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDvbDataBroadcastIDDescriptor_Release(This) (This)->lpVtbl->Release(This)
 #define IDvbDataBroadcastIDDescriptor_GetDataBroadcastID(This,pwVal) (This)->lpVtbl->GetDataBroadcastID(This,pwVal)
 #define IDvbDataBroadcastIDDescriptor_GetIDSelectorBytes(This,pbLen,pbVal) (This)->lpVtbl->GetIDSelectorBytes(This,pbLen,pbVal)
 #define IDvbDataBroadcastIDDescriptor_GetLength(This,pbVal) (This)->lpVtbl->GetLength(This,pbVal)
@@ -541,9 +541,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDvbDefaultAuthorityDescriptor_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDvbDefaultAuthorityDescriptor_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDvbDefaultAuthorityDescriptor_Release(This) (This)->pVtbl->Release(This)
+#define IDvbDefaultAuthorityDescriptor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDvbDefaultAuthorityDescriptor_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDvbDefaultAuthorityDescriptor_Release(This) (This)->lpVtbl->Release(This)
 #define IDvbDefaultAuthorityDescriptor_GetDefaultAuthority(This,pbLength,ppbBytes) (This)->lpVtbl->GetDefaultAuthority(This,pbLength,ppbBytes)
 #define IDvbDefaultAuthorityDescriptor_GetLength(This,pbVal) (This)->lpVtbl->GetLength(This,pbVal)
 #define IDvbDefaultAuthorityDescriptor_GetTag(This,pbVal) (This)->lpVtbl->GetTag(This,pbVal)
@@ -581,9 +581,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDvbExtendedEventDescriptor_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDvbExtendedEventDescriptor_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDvbExtendedEventDescriptor_Release(This) (This)->pVtbl->Release(This)
+#define IDvbExtendedEventDescriptor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDvbExtendedEventDescriptor_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDvbExtendedEventDescriptor_Release(This) (This)->lpVtbl->Release(This)
 #define IDvbExtendedEventDescriptor_GetConcatenatedItemW(This,pFollowingDescriptor,convMode,pbstrDesc,pbstrItem) (This)->lpVtbl->GetConcatenatedItemW(This,pFollowingDescriptor,convMode,pbstrDesc,pbstrItem)
 #define IDvbExtendedEventDescriptor_GetConcatenatedTextW(This,FollowingDescriptor,convMode,pbstrText) (This)->lpVtbl->GetConcatenatedTextW(This,FollowingDescriptor,convMode,pbstrText)
 #define IDvbExtendedEventDescriptor_GetCountOfRecords(This,pbVal) (This)->lpVtbl->GetCountOfRecords(This,pbVal)
@@ -623,9 +623,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDvbLogicalChannelDescriptor_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDvbLogicalChannelDescriptor_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDvbLogicalChannelDescriptor_Release(This) (This)->pVtbl->Release(This)
+#define IDvbLogicalChannelDescriptor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDvbLogicalChannelDescriptor_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDvbLogicalChannelDescriptor_Release(This) (This)->lpVtbl->Release(This)
 #define IDvbLogicalChannelDescriptor_GetCountOfRecords(This,pbVal) (This)->lpVtbl->GetCountOfRecords(This,pbVal)
 #define IDvbLogicalChannelDescriptor_GetLength(This,pbVal) (This)->lpVtbl->GetLength(This,pbVal)
 #define IDvbLogicalChannelDescriptor_GetRecordLogicalChannelNumber(This,bRecordIndex,pwVal) (This)->lpVtbl->GetRecordLogicalChannelNumber(This,bRecordIndex,pwVal)
@@ -661,9 +661,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDvbHDSimulcastLogicalChannelDescriptor_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDvbHDSimulcastLogicalChannelDescriptor_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDvbHDSimulcastLogicalChannelDescriptor_Release(This) (This)->pVtbl->Release(This)
+#define IDvbHDSimulcastLogicalChannelDescriptor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDvbHDSimulcastLogicalChannelDescriptor_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDvbHDSimulcastLogicalChannelDescriptor_Release(This) (This)->lpVtbl->Release(This)
 #define IDvbHDSimulcastLogicalChannelDescriptor_GetCountOfRecords(This,pbVal) (This)->lpVtbl->GetCountOfRecords(This,pbVal)
 #define IDvbHDSimulcastLogicalChannelDescriptor_GetLength(This,pbVal) (This)->lpVtbl->GetLength(This,pbVal)
 #define IDvbHDSimulcastLogicalChannelDescriptor_GetRecordLogicalChannelNumber(This,bRecordIndex,pwVal) (This)->lpVtbl->GetRecordLogicalChannelNumber(This,bRecordIndex,pwVal)
@@ -700,9 +700,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDvbLinkageDescriptor_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDvbLinkageDescriptor_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDvbLinkageDescriptor_Release(This) (This)->pVtbl->Release(This)
+#define IDvbLinkageDescriptor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDvbLinkageDescriptor_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDvbLinkageDescriptor_Release(This) (This)->lpVtbl->Release(This)
 #define IDvbLinkageDescriptor_GetLength(This,pbVal) (This)->lpVtbl->GetLength(This,pbVal)
 #define IDvbLinkageDescriptor_GetLinkageType(This,pbVal) (This)->lpVtbl->GetLinkageType(This,pbVal)
 #define IDvbLinkageDescriptor_GetONId(This,pwVal) (This)->lpVtbl->GetONId(This,pwVal)
@@ -742,9 +742,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDvbLogicalChannelDescriptor2_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDvbLogicalChannelDescriptor2_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDvbLogicalChannelDescriptor2_Release(This) (This)->pVtbl->Release(This)
+#define IDvbLogicalChannelDescriptor2_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDvbLogicalChannelDescriptor2_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDvbLogicalChannelDescriptor2_Release(This) (This)->lpVtbl->Release(This)
 #define IDvbLogicalChannelDescriptor2_GetCountOfRecords(This,pbVal) (This)->lpVtbl->GetCountOfRecords(This,pbVal)
 #define IDvbLogicalChannelDescriptor2_GetLength(This,pbVal) (This)->lpVtbl->GetLength(This,pbVal)
 #define IDvbLogicalChannelDescriptor2_GetRecordLogicalChannelNumber(This,bRecordIndex,pwVal) (This)->lpVtbl->GetRecordLogicalChannelNumber(This,bRecordIndex,pwVal)
@@ -791,9 +791,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDvbLogicalChannel2Descriptor_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDvbLogicalChannel2Descriptor_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDvbLogicalChannel2Descriptor_Release(This) (This)->pVtbl->Release(This)
+#define IDvbLogicalChannel2Descriptor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDvbLogicalChannel2Descriptor_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDvbLogicalChannel2Descriptor_Release(This) (This)->lpVtbl->Release(This)
 #define IDvbLogicalChannel2Descriptor_GetCountOfRecords(This,pbVal) (This)->lpVtbl->GetCountOfRecords(This,pbVal)
 #define IDvbLogicalChannel2Descriptor_GetLength(This,pbVal) (This)->lpVtbl->GetLength(This,pbVal)
 #define IDvbLogicalChannel2Descriptor_GetRecordLogicalChannelNumber(This,bRecordIndex,pwVal) (This)->lpVtbl->GetRecordLogicalChannelNumber(This,bRecordIndex,pwVal)
@@ -836,9 +836,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDvbMultilingualServiceNameDescriptor_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDvbMultilingualServiceNameDescriptor_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDvbMultilingualServiceNameDescriptor_Release(This) (This)->pVtbl->Release(This)
+#define IDvbMultilingualServiceNameDescriptor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDvbMultilingualServiceNameDescriptor_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDvbMultilingualServiceNameDescriptor_Release(This) (This)->lpVtbl->Release(This)
 #define IDvbMultilingualServiceNameDescriptor_GetCountOfRecords(This,pbVal) (This)->lpVtbl->GetCountOfRecords(This,pbVal)
 #define IDvbMultilingualServiceNameDescriptor_GetLength(This,pbVal) (This)->lpVtbl->GetLength(This,pbVal)
 #define IDvbMultilingualServiceNameDescriptor_GetRecordLangId(This,bRecordIndex,ulVal) (This)->lpVtbl->GetRecordLangId(This,bRecordIndex,ulVal)
@@ -872,9 +872,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDvbNetworkNameDescriptor_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDvbNetworkNameDescriptor_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDvbNetworkNameDescriptor_Release(This) (This)->pVtbl->Release(This)
+#define IDvbNetworkNameDescriptor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDvbNetworkNameDescriptor_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDvbNetworkNameDescriptor_Release(This) (This)->lpVtbl->Release(This)
 #define IDvbNetworkNameDescriptor_GetLength(This,pbVal) (This)->lpVtbl->GetLength(This,pbVal)
 #define IDvbNetworkNameDescriptor_GetNetworkName(This,pszName) (This)->lpVtbl->GetNetworkName(This,pszName)
 #define IDvbNetworkNameDescriptor_GetNetworkNameW(This,convMode,pbstrName) (This)->lpVtbl->GetNetworkNameW(This,convMode,pbstrName)
@@ -906,9 +906,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDvbParentalRatingDescriptor_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDvbParentalRatingDescriptor_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDvbParentalRatingDescriptor_Release(This) (This)->pVtbl->Release(This)
+#define IDvbParentalRatingDescriptor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDvbParentalRatingDescriptor_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDvbParentalRatingDescriptor_Release(This) (This)->lpVtbl->Release(This)
 #define IDvbParentalRatingDescriptor_GetCountOfRecords(This,pbVal) (This)->lpVtbl->GetCountOfRecords(This,pbVal)
 #define IDvbParentalRatingDescriptor_GetLength(This,pbVal) (This)->lpVtbl->GetLength(This,pbVal)
 #define IDvbParentalRatingDescriptor_GetRecordRating(This,bRecordIndex,pszCountryCode,pbVal) (This)->lpVtbl->GetRecordRating(This,bRecordIndex,pszCountryCode,pbVal)
@@ -939,9 +939,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDvbPrivateDataSpecifierDescriptor_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDvbPrivateDataSpecifierDescriptor_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDvbPrivateDataSpecifierDescriptor_Release(This) (This)->pVtbl->Release(This)
+#define IDvbPrivateDataSpecifierDescriptor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDvbPrivateDataSpecifierDescriptor_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDvbPrivateDataSpecifierDescriptor_Release(This) (This)->lpVtbl->Release(This)
 #define IDvbPrivateDataSpecifierDescriptor_GetLength(This,pbVal) (This)->lpVtbl->GetLength(This,pbVal)
 #define IDvbPrivateDataSpecifierDescriptor_GetPrivateDataSpecifier(This,pdwVal) (This)->lpVtbl->GetPrivateDataSpecifier(This,pdwVal)
 #define IDvbPrivateDataSpecifierDescriptor_GetTag(This,pbVal) (This)->lpVtbl->GetTag(This,pbVal)
@@ -976,9 +976,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDvbServiceDescriptor_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDvbServiceDescriptor_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDvbServiceDescriptor_Release(This) (This)->pVtbl->Release(This)
+#define IDvbServiceDescriptor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDvbServiceDescriptor_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDvbServiceDescriptor_Release(This) (This)->lpVtbl->Release(This)
 #define IDvbServiceDescriptor_GetLength(This,pbVal) (This)->lpVtbl->GetLength(This,pbVal)
 #define IDvbServiceDescriptor_GetProcessedServiceName(This,pbstrName) (This)->lpVtbl->GetProcessedServiceName(This,pbstrName)
 #define IDvbServiceDescriptor_GetServiceName(This,pszName) (This)->lpVtbl->GetServiceName(This,pszName)
@@ -1023,9 +1023,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDvbServiceDescriptor2_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDvbServiceDescriptor2_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDvbServiceDescriptor2_Release(This) (This)->pVtbl->Release(This)
+#define IDvbServiceDescriptor2_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDvbServiceDescriptor2_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDvbServiceDescriptor2_Release(This) (This)->lpVtbl->Release(This)
 #define IDvbServiceDescriptor2_GetLength(This,pbVal) (This)->lpVtbl->GetLength(This,pbVal)
 #define IDvbServiceDescriptor2_GetProcessedServiceName(This,pbstrName) (This)->lpVtbl->GetProcessedServiceName(This,pbstrName)
 #define IDvbServiceDescriptor2_GetServiceName(This,pszName) (This)->lpVtbl->GetServiceName(This,pszName)
@@ -1064,9 +1064,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDvbShortEventDescriptor_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDvbShortEventDescriptor_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDvbShortEventDescriptor_Release(This) (This)->pVtbl->Release(This)
+#define IDvbShortEventDescriptor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDvbShortEventDescriptor_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDvbShortEventDescriptor_Release(This) (This)->lpVtbl->Release(This)
 #define IDvbShortEventDescriptor_GetEventNameW(This,convMode,pbstrName) (This)->lpVtbl->GetEventNameW(This,convMode,pbstrName)
 #define IDvbShortEventDescriptor_GetLanguageCode(This,pszCode) (This)->lpVtbl->GetLanguageCode(This,pszCode)
 #define IDvbShortEventDescriptor_GetLength(This,pbVal) (This)->lpVtbl->GetLength(This,pbVal)
@@ -1117,9 +1117,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDvbSiParser_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDvbSiParser_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDvbSiParser_Release(This) (This)->pVtbl->Release(This)
+#define IDvbSiParser_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDvbSiParser_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDvbSiParser_Release(This) (This)->lpVtbl->Release(This)
 #define IDvbSiParser_GetBAT(This,pwBouquetId,ppBAT) (This)->lpVtbl->GetBAT(This,pwBouquetId,ppBAT)
 #define IDvbSiParser_GetCAT(This,dwTimeout,ppCAT) (This)->lpVtbl->GetCAT(This,dwTimeout,ppCAT)
 #define IDvbSiParser_GetDIT(This,dwTimeout,ppDIT) (This)->lpVtbl->GetDIT(This,dwTimeout,ppDIT)
@@ -1165,9 +1165,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDVB_RST_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDVB_RST_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDVB_RST_Release(This) (This)->pVtbl->Release(This)
+#define IDVB_RST_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDVB_RST_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDVB_RST_Release(This) (This)->lpVtbl->Release(This)
 #define IDVB_RST_GetCountOfRecords(This,pdwVal) (This)->lpVtbl->GetCountOfRecords(This,pdwVal)
 #define IDVB_RST_GetRecordEventId(This,dwRecordIndex,pwVal) (This)->lpVtbl->GetRecordEventId(This,dwRecordIndex,pwVal)
 #define IDVB_RST_GetRecordOriginalNetworkId(This,dwRecordIndex,pwVal) (This)->lpVtbl->GetRecordOriginalNetworkId(This,dwRecordIndex,pwVal)
@@ -1213,9 +1213,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDVB_SIT_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDVB_SIT_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDVB_SIT_Release(This) (This)->pVtbl->Release(This)
+#define IDVB_SIT_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDVB_SIT_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDVB_SIT_Release(This) (This)->lpVtbl->Release(This)
 #define IDVB_SIT_ConvertNextToCurrent() (This)->lpVtbl->ConvertNextToCurrent(This)
 #define IDVB_SIT_GetCountOfRecords(This,pdwVal) (This)->lpVtbl->GetCountOfRecords(This,pdwVal)
 #define IDVB_SIT_GetCountOfTableDescriptors(This,pdwVal) (This)->lpVtbl->GetCountOfTableDescriptors(This,pdwVal)
@@ -1257,9 +1257,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDVB_ST_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDVB_ST_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDVB_ST_Release(This) (This)->pVtbl->Release(This)
+#define IDVB_ST_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDVB_ST_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDVB_ST_Release(This) (This)->lpVtbl->Release(This)
 #define IDVB_ST_GetData(This,ppData) (This)->lpVtbl->GetData(This,ppData)
 #define IDVB_ST_GetDataLength(This,pwVal) (This)->lpVtbl->GetDataLength(This,pwVal)
 #define IDVB_ST_Initialize(This,pSectionList) (This)->lpVtbl->Initialize(This,pSectionList)
@@ -1288,9 +1288,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDVB_TDT_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDVB_TDT_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDVB_TDT_Release(This) (This)->pVtbl->Release(This)
+#define IDVB_TDT_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDVB_TDT_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDVB_TDT_Release(This) (This)->lpVtbl->Release(This)
 #define IDVB_TDT_GetUTCTime(This,pmdtVal) (This)->lpVtbl->GetUTCTime(This,pmdtVal)
 #define IDVB_TDT_Initialize(This,pSectionList) (This)->lpVtbl->Initialize(This,pSectionList)
 #endif /*COBJMACROS*/
@@ -1321,9 +1321,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDVB_TOT_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDVB_TOT_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDVB_TOT_Release(This) (This)->pVtbl->Release(This)
+#define IDVB_TOT_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDVB_TOT_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDVB_TOT_Release(This) (This)->lpVtbl->Release(This)
 #define IDVB_TOT_GetCountOfTableDescriptors(This,pdwVal) (This)->lpVtbl->GetCountOfTableDescriptors(This,pdwVal)
 #define IDVB_TOT_GetTableDescriptorByIndex(This,dwIndex,ppDescriptor) (This)->lpVtbl->GetTableDescriptorByIndex(This,dwIndex,ppDescriptor)
 #define IDVB_TOT_GetTableDescriptorByTag(This,bTag,pdwCookie,ppDescriptor) (This)->lpVtbl->GetTableDescriptorByTag(This,bTag,pdwCookie,ppDescriptor)
@@ -1371,9 +1371,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDvbSiParser2_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDvbSiParser2_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDvbSiParser2_Release(This) (This)->pVtbl->Release(This)
+#define IDvbSiParser2_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDvbSiParser2_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDvbSiParser2_Release(This) (This)->lpVtbl->Release(This)
 #define IDvbSiParser2_GetBAT(This,pwBouquetId,ppBAT) (This)->lpVtbl->GetBAT(This,pwBouquetId,ppBAT)
 #define IDvbSiParser2_GetCAT(This,dwTimeout,ppCAT) (This)->lpVtbl->GetCAT(This,dwTimeout,ppCAT)
 #define IDvbSiParser2_GetDIT(This,dwTimeout,ppDIT) (This)->lpVtbl->GetDIT(This,dwTimeout,ppDIT)
@@ -1420,9 +1420,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDvbSubtitlingDescriptor_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDvbSubtitlingDescriptor_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDvbSubtitlingDescriptor_Release(This) (This)->pVtbl->Release(This)
+#define IDvbSubtitlingDescriptor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDvbSubtitlingDescriptor_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDvbSubtitlingDescriptor_Release(This) (This)->lpVtbl->Release(This)
 #define IDvbSubtitlingDescriptor_GetCountOfRecords(This,pbVal) (This)->lpVtbl->GetCountOfRecords(This,pbVal)
 #define IDvbSubtitlingDescriptor_GetLength(This,pbVal) (This)->lpVtbl->GetLength(This,pbVal)
 #define IDvbSubtitlingDescriptor_GetRecordAncillaryPageID(This,bRecordIndex,pwVal) (This)->lpVtbl->GetRecordAncillaryPageID(This,bRecordIndex,pwVal)
@@ -1458,9 +1458,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDvbServiceListDescriptor_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDvbServiceListDescriptor_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDvbServiceListDescriptor_Release(This) (This)->pVtbl->Release(This)
+#define IDvbServiceListDescriptor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDvbServiceListDescriptor_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDvbServiceListDescriptor_Release(This) (This)->lpVtbl->Release(This)
 #define IDvbServiceListDescriptor_GetCountOfRecords(This,pbVal) (This)->lpVtbl->GetCountOfRecords(This,pbVal)
 #define IDvbServiceListDescriptor_GetLength(This,pbVal) (This)->lpVtbl->GetLength(This,pbVal)
 #define IDvbServiceListDescriptor_GetRecordServiceId(This,bRecordIndex,pwVal) (This)->lpVtbl->GetRecordServiceId(This,bRecordIndex,pwVal)
@@ -1496,9 +1496,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDvbTeletextDescriptor_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDvbTeletextDescriptor_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDvbTeletextDescriptor_Release(This) (This)->pVtbl->Release(This)
+#define IDvbTeletextDescriptor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDvbTeletextDescriptor_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDvbTeletextDescriptor_Release(This) (This)->lpVtbl->Release(This)
 #define IDvbTeletextDescriptor_GetCountOfRecords(This,pbVal) (This)->lpVtbl->GetCountOfRecords(This,pbVal)
 #define IDvbTeletextDescriptor_GetLength(This,pbVal) (This)->lpVtbl->GetLength(This,pbVal)
 #define IDvbTeletextDescriptor_GetRecordLangId(This,bRecordIndex,pulVal) (This)->lpVtbl->GetRecordLangId(This,bRecordIndex,pulVal)
@@ -1545,9 +1545,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDVB_BAT_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDVB_BAT_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDVB_BAT_Release(This) (This)->pVtbl->Release(This)
+#define IDVB_BAT_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDVB_BAT_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDVB_BAT_Release(This) (This)->lpVtbl->Release(This)
 #define IDVB_BAT_ConvertNextToCurrent() (This)->lpVtbl->ConvertNextToCurrent(This)
 #define IDVB_BAT_GetBouquetId(This,pwVal) (This)->lpVtbl->GetBouquetId(This,pwVal)
 #define IDVB_BAT_GetCountOfRecords(This,pdwVal) (This)->lpVtbl->GetCountOfRecords(This,pdwVal)
@@ -1589,9 +1589,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDVB_DIT_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDVB_DIT_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDVB_DIT_Release(This) (This)->pVtbl->Release(This)
+#define IDVB_DIT_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDVB_DIT_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDVB_DIT_Release(This) (This)->lpVtbl->Release(This)
 #define IDVB_DIT_GetTransitionFlag(This,pfVal) (This)->lpVtbl->GetTransitionFlag(This,pfVal)
 #define IDVB_DIT_Initialize(This,pSectionList) (This)->lpVtbl->Initialize(This,pSectionList)
 #endif /*COBJMACROS*/
@@ -1634,9 +1634,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDVB_NIT_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDVB_NIT_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDVB_NIT_Release(This) (This)->pVtbl->Release(This)
+#define IDVB_NIT_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDVB_NIT_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDVB_NIT_Release(This) (This)->lpVtbl->Release(This)
 #define IDVB_NIT_ConvertNextToCurrent() (This)->lpVtbl->ConvertNextToCurrent(This)
 #define IDVB_NIT_GetCountOfRecords(This,pdwVal) (This)->lpVtbl->GetCountOfRecords(This,pdwVal)
 #define IDVB_NIT_GetCountOfTableDescriptors(This,pdwVal) (This)->lpVtbl->GetCountOfTableDescriptors(This,pdwVal)
@@ -1695,9 +1695,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDVB_SDT_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDVB_SDT_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDVB_SDT_Release(This) (This)->pVtbl->Release(This)
+#define IDVB_SDT_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDVB_SDT_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDVB_SDT_Release(This) (This)->lpVtbl->Release(This)
 #define IDVB_SDT_ConvertNextToCurrent() (This)->lpVtbl->ConvertNextToCurrent(This)
 #define IDVB_SDT_GetCountOfRecords(This,pdwVal) (This)->lpVtbl->GetCountOfRecords(This,pdwVal)
 #define IDVB_SDT_GetNextTable(This,ppSDT) (This)->lpVtbl->GetNextTable(This,ppSDT)
diff --git a/mingw-w64-headers/include/dwrite.h b/mingw-w64-headers/include/dwrite.h
index 2322448..aa17e7a 100644
--- a/mingw-w64-headers/include/dwrite.h
+++ b/mingw-w64-headers/include/dwrite.h
@@ -651,9 +651,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteBitmapRenderTarget_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteBitmapRenderTarget_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWriteBitmapRenderTarget_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteBitmapRenderTarget_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteBitmapRenderTarget_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWriteBitmapRenderTarget_Release(This) (This)->lpVtbl->Release(This)
 #define IDWriteBitmapRenderTarget_DrawGlyphRun(This,baselineOriginX,baselineOriginY,measuringMode,glyphRun,renderingParams,textColor,blackBoxRect) (This)->lpVtbl->DrawGlyphRun(This,baselineOriginX,baselineOriginY,measuringMode,glyphRun,renderingParams,textColor,blackBoxRect)
 #define IDWriteBitmapRenderTarget_GetCurrentTransform(This,transform) (This)->lpVtbl->GetCurrentTransform(This,transform)
 #define IDWriteBitmapRenderTarget_GetMemoryDC() (This)->lpVtbl->GetMemoryDC(This)
@@ -793,9 +793,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteFactory_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteFactory_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWriteFactory_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteFactory_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteFactory_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWriteFactory_Release(This) (This)->lpVtbl->Release(This)
 #define IDWriteFactory_CreateCustomFontCollection(This,collectionLoader,collectionKey,collectionKeySize,fontCollection) (This)->lpVtbl->CreateCustomFontCollection(This,collectionLoader,collectionKey,collectionKeySize,fontCollection)
 #define IDWriteFactory_CreateCustomFontFileReference(This,fontFileReferenceKey,fontFileReferenceKeySize,fontFileLoader,fontFile) (This)->lpVtbl->CreateCustomFontFileReference(This,fontFileReferenceKey,fontFileReferenceKeySize,fontFileLoader,fontFile)
 #define IDWriteFactory_CreateCustomRenderingParams(This,gamma,enhancedContrast,clearTypeLevel,pixelGeometry,renderingMode,renderingParams) (This)->lpVtbl->CreateCustomRenderingParams(This,gamma,enhancedContrast,clearTypeLevel,pixelGeometry,renderingMode,renderingParams)
@@ -862,9 +862,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteFont_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteFont_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWriteFont_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteFont_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteFont_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWriteFont_Release(This) (This)->lpVtbl->Release(This)
 #define IDWriteFont_CreateFontFace(This,fontFace) (This)->lpVtbl->CreateFontFace(This,fontFace)
 #define IDWriteFont_GetFaceNames(This,names) (This)->lpVtbl->GetFaceNames(This,names)
 #define IDWriteFont_GetFontFamily(This,fontFamily) (This)->lpVtbl->GetFontFamily(This,fontFamily)
@@ -908,9 +908,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteFontCollection_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteFontCollection_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWriteFontCollection_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteFontCollection_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteFontCollection_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWriteFontCollection_Release(This) (This)->lpVtbl->Release(This)
 #define IDWriteFontCollection_FindFamilyName(This,familyName,index,exists) (This)->lpVtbl->FindFamilyName(This,familyName,index,exists)
 #define IDWriteFontCollection_GetFontFamily(This,index,fontFamily) (This)->lpVtbl->GetFontFamily(This,index,fontFamily)
 #define IDWriteFontCollection_GetFontFamilyCount() (This)->lpVtbl->GetFontFamilyCount(This)
@@ -1002,9 +1002,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteFontFace_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteFontFace_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWriteFontFace_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteFontFace_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteFontFace_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWriteFontFace_Release(This) (This)->lpVtbl->Release(This)
 #define IDWriteFontFace_GetDesignGlyphMetrics(This,glyphIndices,glyphCount,glyphMetrics,isSideways) (This)->lpVtbl->GetDesignGlyphMetrics(This,glyphIndices,glyphCount,glyphMetrics,isSideways)
 #define IDWriteFontFace_GetFiles(This,fontFiles) (This)->lpVtbl->GetFiles(This,fontFiles)
 #define IDWriteFontFace_GetGdiCompatibleMetrics(This,emSize,pixelsPerDip,transform,fontFaceMetrics) (This)->lpVtbl->GetGdiCompatibleMetrics(This,emSize,pixelsPerDip,transform,fontFaceMetrics)
@@ -1046,9 +1046,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteFontList_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteFontList_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWriteFontList_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteFontList_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteFontList_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWriteFontList_Release(This) (This)->lpVtbl->Release(This)
 #define IDWriteFontList_GetFont(This,index,font) (This)->lpVtbl->GetFont(This,index,font)
 #define IDWriteFontList_GetFontCollection(This,fontCollection) (This)->lpVtbl->GetFontCollection(This,fontCollection)
 #define IDWriteFontList_GetFontCount() (This)->lpVtbl->GetFontCount(This)
@@ -1094,9 +1094,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteFontFamily_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteFontFamily_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWriteFontFamily_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteFontFamily_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteFontFamily_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWriteFontFamily_Release(This) (This)->lpVtbl->Release(This)
 #define IDWriteFontFamily_GetFont(This,index,font) (This)->lpVtbl->GetFont(This,index,font)
 #define IDWriteFontFamily_GetFontCollection(This,fontCollection) (This)->lpVtbl->GetFontCollection(This,fontCollection)
 #define IDWriteFontFamily_GetFontCount() (This)->lpVtbl->GetFontCount(This)
@@ -1133,9 +1133,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteFontFile_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteFontFile_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWriteFontFile_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteFontFile_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteFontFile_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWriteFontFile_Release(This) (This)->lpVtbl->Release(This)
 #define IDWriteFontFile_Analyze(This,isSupportedFontType,fontFileType,fontFaceType,numberOfFaces) (This)->lpVtbl->Analyze(This,isSupportedFontType,fontFileType,fontFaceType,numberOfFaces)
 #define IDWriteFontFile_GetLoader(This,fontFileLoader) (This)->lpVtbl->GetLoader(This,fontFileLoader)
 #define IDWriteFontFile_GetReferenceKey(This,fontFileReferenceKey,fontFileReferenceKeySize) (This)->lpVtbl->GetReferenceKey(This,fontFileReferenceKey,fontFileReferenceKeySize)
@@ -1161,9 +1161,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteFontFileLoader_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteFontFileLoader_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWriteFontFileLoader_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteFontFileLoader_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteFontFileLoader_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWriteFontFileLoader_Release(This) (This)->lpVtbl->Release(This)
 #define IDWriteFontFileLoader_CreateStreamFromKey(This,fontFileReferenceKey,fontFileReferenceKeySize,fontFileStream) (This)->lpVtbl->CreateStreamFromKey(This,fontFileReferenceKey,fontFileReferenceKeySize,fontFileStream)
 #endif /*COBJMACROS*/
 
@@ -1197,9 +1197,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteFontFileStream_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteFontFileStream_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWriteFontFileStream_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteFontFileStream_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteFontFileStream_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWriteFontFileStream_Release(This) (This)->lpVtbl->Release(This)
 #define IDWriteFontFileStream_GetFileSize(This,fileSize) (This)->lpVtbl->GetFileSize(This,fileSize)
 #define IDWriteFontFileStream_GetLastWriteTime(This,lastWriteTime) (This)->lpVtbl->GetLastWriteTime(This,lastWriteTime)
 #define IDWriteFontFileStream_ReadFileFragment(This,fragmentStart,fileOffset,fragmentSize,fragmentContext) (This)->lpVtbl->ReadFileFragment(This,fragmentStart,fileOffset,fragmentSize,fragmentContext)
@@ -1223,9 +1223,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteFontCollectionLoader_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteFontCollectionLoader_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWriteFontCollectionLoader_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteFontCollectionLoader_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteFontCollectionLoader_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWriteFontCollectionLoader_Release(This) (This)->lpVtbl->Release(This)
 #define IDWriteFontCollectionLoader_CreateEnumeratorFromKey(This,factory,collectionKey,collectionKeySize,fontFileEnumerator) (This)->lpVtbl->CreateEnumeratorFromKey(This,factory,collectionKey,collectionKeySize,fontFileEnumerator)
 #endif /*COBJMACROS*/
 
@@ -1247,9 +1247,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteFontFileEnumerator_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteFontFileEnumerator_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWriteFontFileEnumerator_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteFontFileEnumerator_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteFontFileEnumerator_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWriteFontFileEnumerator_Release(This) (This)->lpVtbl->Release(This)
 #define IDWriteFontFileEnumerator_GetCurrentFontFile(This,fontFile) (This)->lpVtbl->GetCurrentFontFile(This,fontFile)
 #define IDWriteFontFileEnumerator_MoveNext(This,hasCurrentFile) (This)->lpVtbl->MoveNext(This,hasCurrentFile)
 #endif /*COBJMACROS*/
@@ -1292,9 +1292,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteGdiInterop_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteGdiInterop_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWriteGdiInterop_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteGdiInterop_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteGdiInterop_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWriteGdiInterop_Release(This) (This)->lpVtbl->Release(This)
 #define IDWriteGdiInterop_ConvertFontFaceToLOGFONT(This,font,logFont) (This)->lpVtbl->ConvertFontFaceToLOGFONT(This,font,logFont)
 #define IDWriteGdiInterop_ConvertFontToLOGFONT(This,font,logFont,isSystemFont) (This)->lpVtbl->ConvertFontToLOGFONT(This,font,logFont,isSystemFont)
 #define IDWriteGdiInterop_CreateBitmapRenderTarget(This,hdc,width,height,renderTarget) (This)->lpVtbl->CreateBitmapRenderTarget(This,hdc,width,height,renderTarget)
@@ -1333,9 +1333,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteGlyphRunAnalysis_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteGlyphRunAnalysis_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWriteGlyphRunAnalysis_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteGlyphRunAnalysis_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteGlyphRunAnalysis_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWriteGlyphRunAnalysis_Release(This) (This)->lpVtbl->Release(This)
 #define IDWriteGlyphRunAnalysis_CreateAlphaTexture(This,textureType,textureBounds,alphaValues,bufferSize) (This)->lpVtbl->CreateAlphaTexture(This,textureType,textureBounds,alphaValues,bufferSize)
 #define IDWriteGlyphRunAnalysis_GetAlphaBlendParams(This,renderingParams,blendGamma,blendEnhancedContrast,blendClearTypeLevel) (This)->lpVtbl->GetAlphaBlendParams(This,renderingParams,blendGamma,blendEnhancedContrast,blendClearTypeLevel)
 #define IDWriteGlyphRunAnalysis_GetAlphaTextureBounds(This,textureType,textureBounds) (This)->lpVtbl->GetAlphaTextureBounds(This,textureType,textureBounds)
@@ -1361,9 +1361,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteInlineObject_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteInlineObject_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWriteInlineObject_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteInlineObject_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteInlineObject_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWriteInlineObject_Release(This) (This)->lpVtbl->Release(This)
 #define IDWriteInlineObject_Draw(This,clientDrawingContext,renderer,originX,originY,isSideways,isRightToLeft,clientDrawingEffect) (This)->lpVtbl->Draw(This,clientDrawingContext,renderer,originX,originY,isSideways,isRightToLeft,clientDrawingEffect)
 #define IDWriteInlineObject_GetBreakConditions(This,breakConditionBefore,breakConditionAfter) (This)->lpVtbl->GetBreakConditions(This,breakConditionBefore,breakConditionAfter)
 #define IDWriteInlineObject_GetMetrics(This,metrics) (This)->lpVtbl->GetMetrics(This,metrics)
@@ -1389,9 +1389,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteLocalFontFileLoader_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteLocalFontFileLoader_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWriteLocalFontFileLoader_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteLocalFontFileLoader_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteLocalFontFileLoader_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWriteLocalFontFileLoader_Release(This) (This)->lpVtbl->Release(This)
 #define IDWriteLocalFontFileLoader_GetFilePathLengthFromKey(This,fontFileReferenceKey,fontFileReferenceKeySize,filePathLength) (This)->lpVtbl->GetFilePathLengthFromKey(This,fontFileReferenceKey,fontFileReferenceKeySize,filePathLength)
 #define IDWriteLocalFontFileLoader_GetFilePathFromKey(This,fontFileReferenceKey,fontFileReferenceKeySize,filePath,filePathSize) (This)->lpVtbl->GetFilePathFromKey(This,fontFileReferenceKey,fontFileReferenceKeySize,filePath,filePathSize)
 #define IDWriteLocalFontFileLoader_GetLastWriteTimeFromKey(This,fontFileReferenceKey,fontFileReferenceKeySize,lastWriteTime) (This)->lpVtbl->GetLastWriteTimeFromKey(This,fontFileReferenceKey,fontFileReferenceKeySize,lastWriteTime)
@@ -1437,9 +1437,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteLocalizedStrings_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteLocalizedStrings_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWriteLocalizedStrings_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteLocalizedStrings_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteLocalizedStrings_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWriteLocalizedStrings_Release(This) (This)->lpVtbl->Release(This)
 #define IDWriteLocalizedStrings_FindLocaleName(This,localeName,index,exists) (This)->lpVtbl->FindLocaleName(This,localeName,index,exists)
 #define IDWriteLocalizedStrings_GetCount() (This)->lpVtbl->GetCount(This)
 #define IDWriteLocalizedStrings_GetLocaleName(This,index,localeName,size) (This)->lpVtbl->GetLocaleName(This,index,localeName,size)
@@ -1464,9 +1464,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteNumberSubstitution_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteNumberSubstitution_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWriteNumberSubstitution_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteNumberSubstitution_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteNumberSubstitution_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWriteNumberSubstitution_Release(This) (This)->lpVtbl->Release(This)
 #endif /*COBJMACROS*/
 
 #undef  INTERFACE
@@ -1488,9 +1488,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWritePixelSnapping_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWritePixelSnapping_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWritePixelSnapping_Release(This) (This)->pVtbl->Release(This)
+#define IDWritePixelSnapping_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWritePixelSnapping_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWritePixelSnapping_Release(This) (This)->lpVtbl->Release(This)
 #define IDWritePixelSnapping_GetCurrentTransform(This,clientDrawingContext,transform) (This)->lpVtbl->GetCurrentTransform(This,clientDrawingContext,transform)
 #define IDWritePixelSnapping_GetPixelsPerDip(This,clientDrawingContext,pixelsPerDip) (This)->lpVtbl->GetPixelsPerDip(This,clientDrawingContext,pixelsPerDip)
 #define IDWritePixelSnapping_IsPixelSnappingEnabled(This,clientDrawingContext,isDisabled) (This)->lpVtbl->IsPixelSnappingEnabled(This,clientDrawingContext,isDisabled)
@@ -1517,9 +1517,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteRenderingParams_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteRenderingParams_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWriteRenderingParams_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteRenderingParams_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteRenderingParams_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWriteRenderingParams_Release(This) (This)->lpVtbl->Release(This)
 #define IDWriteRenderingParams_GetClearTypeLevel() (This)->lpVtbl->GetClearTypeLevel(This)
 #define IDWriteRenderingParams_GetEnhancedContrast() (This)->lpVtbl->GetEnhancedContrast(This)
 #define IDWriteRenderingParams_GetGamma() (This)->lpVtbl->GetGamma(This)
@@ -1563,9 +1563,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteTextAnalysisSink_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteTextAnalysisSink_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWriteTextAnalysisSink_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteTextAnalysisSink_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteTextAnalysisSink_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWriteTextAnalysisSink_Release(This) (This)->lpVtbl->Release(This)
 #define IDWriteTextAnalysisSink_SetBidiLevel(This,textPosition,textLength,explicitLevel,resolvedLevel) (This)->lpVtbl->SetBidiLevel(This,textPosition,textLength,explicitLevel,resolvedLevel)
 #define IDWriteTextAnalysisSink_SetLineBreakpoints(This,textPosition,textLength,lineBreakpoints) (This)->lpVtbl->SetLineBreakpoints(This,textPosition,textLength,lineBreakpoints)
 #define IDWriteTextAnalysisSink_SetNumberSubstitution(This,textPosition,textLength,numberSubstitution) (This)->lpVtbl->SetNumberSubstitution(This,textPosition,textLength,numberSubstitution)
@@ -1609,9 +1609,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteTextAnalysisSource_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteTextAnalysisSource_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWriteTextAnalysisSource_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteTextAnalysisSource_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteTextAnalysisSource_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWriteTextAnalysisSource_Release(This) (This)->lpVtbl->Release(This)
 #define IDWriteTextAnalysisSource_GetLocaleName(This,textPosition,textLength,localeName) (This)->lpVtbl->GetLocaleName(This,textPosition,textLength,localeName)
 #define IDWriteTextAnalysisSource_GetNumberSubstitution(This,textPosition,textLength,numberSubstitution) (This)->lpVtbl->GetNumberSubstitution(This,textPosition,textLength,numberSubstitution)
 #define IDWriteTextAnalysisSource_GetParagraphReadingDirection() (This)->lpVtbl->GetParagraphReadingDirection(This)
@@ -1720,9 +1720,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteTextAnalyzer_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteTextAnalyzer_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWriteTextAnalyzer_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteTextAnalyzer_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteTextAnalyzer_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWriteTextAnalyzer_Release(This) (This)->lpVtbl->Release(This)
 #define IDWriteTextAnalyzer_AnalyzeBidi(This,analysisSource,textPosition,textLength,analysisSink) (This)->lpVtbl->AnalyzeBidi(This,analysisSource,textPosition,textLength,analysisSink)
 #define IDWriteTextAnalyzer_AnalyzeLineBreakpoints(This,analysisSource,textPosition,textLength,analysisSink) (This)->lpVtbl->AnalyzeLineBreakpoints(This,analysisSource,textPosition,textLength,analysisSink)
 #define IDWriteTextAnalyzer_AnalyzeNumberSubstitution(This,analysisSource,textPosition,textLength,analysisSink) (This)->lpVtbl->AnalyzeNumberSubstitution(This,analysisSource,textPosition,textLength,analysisSink)
@@ -1773,9 +1773,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteTextFormat_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteTextFormat_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWriteTextFormat_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteTextFormat_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteTextFormat_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWriteTextFormat_Release(This) (This)->lpVtbl->Release(This)
 #define IDWriteTextFormat_GetFlowDirection() (This)->lpVtbl->GetFlowDirection(This)
 #define IDWriteTextFormat_GetFontCollection(This,fontCollection) (This)->lpVtbl->GetFontCollection(This,fontCollection)
 #define IDWriteTextFormat_GetFontFamilyName(This,fontFamilyName,nameSize) (This)->lpVtbl->GetFontFamilyName(This,fontFamilyName,nameSize)
@@ -1885,9 +1885,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteTextLayout_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteTextLayout_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWriteTextLayout_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteTextLayout_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteTextLayout_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWriteTextLayout_Release(This) (This)->lpVtbl->Release(This)
 #define IDWriteTextLayout_GetFlowDirection() (This)->lpVtbl->GetFlowDirection(This)
 #define IDWriteTextLayout_GetFontCollection(This,fontCollection) (This)->lpVtbl->GetFontCollection(This,fontCollection)
 #define IDWriteTextLayout_GetFontFamilyName(This,fontFamilyName,nameSize) (This)->lpVtbl->GetFontFamilyName(This,fontFamilyName,nameSize)
@@ -1979,12 +1979,12 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteTextRenderer_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteTextRenderer_AddRef(This) (This)->pVtbl->AddRef(This)
+#define IDWriteTextRenderer_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteTextRenderer_AddRef(This) (This)->lpVtbl->AddRef(This)
 #define IDWriteTextRenderer_GetCurrentTransform(This,clientDrawingContext,transform) (This)->lpVtbl->GetCurrentTransform(This,clientDrawingContext,transform)
 #define IDWriteTextRenderer_GetPixelsPerDip(This,clientDrawingContext,pixelsPerDip) (This)->lpVtbl->GetPixelsPerDip(This,clientDrawingContext,pixelsPerDip)
 #define IDWriteTextRenderer_IsPixelSnappingEnabled(This,clientDrawingContext,isDisabled) (This)->lpVtbl->IsPixelSnappingEnabled(This,clientDrawingContext,isDisabled)
-#define IDWriteTextRenderer_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteTextRenderer_Release(This) (This)->lpVtbl->Release(This)
 #define IDWriteTextRenderer_DrawGlyphRun(This,clientDrawingContext,baselineOriginX,baselineOriginY,measuringMode,glyphRun,glyphRunDescription,clientDrawingEffect) (This)->lpVtbl->DrawGlyphRun(This,clientDrawingContext,baselineOriginX,baselineOriginY,measuringMode,glyphRun,glyphRunDescription,clientDrawingEffect)
 #define IDWriteTextRenderer_DrawInlineObject(This,clientDrawingContext,originX,originY,inlineObject,isSideways,isRightToLeft,clientDrawingEffect) (This)->lpVtbl->DrawInlineObject(This,clientDrawingContext,originX,originY,inlineObject,isSideways,isRightToLeft,clientDrawingEffect)
 #define IDWriteTextRenderer_DrawStrikethrough(This,clientDrawingContext,baselineOriginX,baselineOriginY,strikethrough,clientDrawingEffect) (This)->lpVtbl->DrawStrikethrough(This,clientDrawingContext,baselineOriginX,baselineOriginY,strikethrough,clientDrawingEffect)
@@ -2010,9 +2010,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDWriteTypography_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDWriteTypography_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDWriteTypography_Release(This) (This)->pVtbl->Release(This)
+#define IDWriteTypography_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDWriteTypography_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDWriteTypography_Release(This) (This)->lpVtbl->Release(This)
 #define IDWriteTypography_AddFontFeature(This,fontFeature) (This)->lpVtbl->AddFontFeature(This,fontFeature)
 #define IDWriteTypography_GetFontFeature(This,fontFeatureIndex,fontFeature) (This)->lpVtbl->GetFontFeature(This,fontFeatureIndex,fontFeature)
 #define IDWriteTypography_GetFontFeatureCount() (This)->lpVtbl->GetFontFeatureCount(This)
diff --git a/mingw-w64-headers/include/dxvahd.h b/mingw-w64-headers/include/dxvahd.h
index 589ada7..edcb00b 100644
--- a/mingw-w64-headers/include/dxvahd.h
+++ b/mingw-w64-headers/include/dxvahd.h
@@ -407,9 +407,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDXVAHD_Device_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDXVAHD_Device_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDXVAHD_Device_Release(This) (This)->pVtbl->Release(This)
+#define IDXVAHD_Device_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDXVAHD_Device_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDXVAHD_Device_Release(This) (This)->lpVtbl->Release(This)
 #define IDXVAHD_Device_CreateVideoProcessor(This,pVPGuid,ppVideoProcessor) (This)->lpVtbl->CreateVideoProcessor(This,pVPGuid,ppVideoProcessor)
 #define IDXVAHD_Device_CreateVideoSurface(This,Width,Height,Format,Pool,Usage,Type,NumSurfaces,ppSurfaces,pSharedHandle) (This)->lpVtbl->CreateVideoSurface(This,Width,Height,Format,Pool,Usage,Type,NumSurfaces,ppSurfaces,pSharedHandle)
 #define IDXVAHD_Device_GetVideoProcessorCaps(This,Count,pCaps) (This)->lpVtbl->GetVideoProcessorCaps(This,Count,pCaps)
@@ -446,9 +446,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDXVAHD_VideoProcessor_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDXVAHD_VideoProcessor_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDXVAHD_VideoProcessor_Release(This) (This)->pVtbl->Release(This)
+#define IDXVAHD_VideoProcessor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDXVAHD_VideoProcessor_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDXVAHD_VideoProcessor_Release(This) (This)->lpVtbl->Release(This)
 #define IDXVAHD_VideoProcessor_GetVideoProcessBltState(This,State,DataSize,pData) (This)->lpVtbl->GetVideoProcessBltState(This,State,DataSize,pData)
 #define IDXVAHD_VideoProcessor_GetVideoProcessStreamState(This,StreamNumber,State,DataSize,pData) (This)->lpVtbl->GetVideoProcessStreamState(This,StreamNumber,State,DataSize,pData)
 #define IDXVAHD_VideoProcessor_SetVideoProcessBltState(This,State,DataSize,pData) (This)->lpVtbl->SetVideoProcessBltState(This,State,DataSize,pData)
diff --git a/mingw-w64-headers/include/endpointvolume.h b/mingw-w64-headers/include/endpointvolume.h
index 1bd0d8b..b3a28f1 100644
--- a/mingw-w64-headers/include/endpointvolume.h
+++ b/mingw-w64-headers/include/endpointvolume.h
@@ -30,11 +30,6 @@
 
 #undef  INTERFACE
 #define INTERFACE IAudioEndpointVolume
-#ifdef __GNUC__
-#warning COM interfaces layout in this header has not been verified.
-#warning COM interfaces with incorrect layout may not work at all.
-__MINGW_BROKEN_INTERFACE(INTERFACE)
-#endif
 DECLARE_INTERFACE_(IAudioEndpointVolume,IUnknown)
 {
     BEGIN_INTERFACE
@@ -45,49 +40,49 @@
     STDMETHOD_(ULONG, Release)(THIS) PURE;
 
     /* IAudioEndpointVolume methods */
-    STDMETHOD_(HRESULT,GetChannelCount)(THIS_ UINT *pnChannelCount) PURE;
-    STDMETHOD_(HRESULT,GetChannelVolumeLevel)(THIS_ UINT nChannel,float *pfLevelDB) PURE;
-    STDMETHOD_(HRESULT,GetChannelVolumeLevelScalar)(THIS_ UINT nChannel,float *pfLevel) PURE;
-    STDMETHOD_(HRESULT,GetMasterVolumeLevel)(THIS_ float *pfLevelDB) PURE;
-    STDMETHOD_(HRESULT,GetMasterVolumeLevelScalar)(THIS_ float *pfLevel) PURE;
-    STDMETHOD_(HRESULT,GetMute)(THIS_ WINBOOL *pbMute) PURE;
-    STDMETHOD_(HRESULT,GetVolumeRange)(THIS_ float *pfLevelMinDB,float *pfLevelMaxDB,float *pfVolumeIncrementDB) PURE;
-    STDMETHOD_(HRESULT,GetVolumeStepInfo)(THIS_ UINT *pnStep,UINT *pnStepCount) PURE;
-    STDMETHOD_(HRESULT,QueryHardwareSupport)(THIS_ DWORD *pdwHardwareSupportMask) PURE;
     STDMETHOD_(HRESULT,RegisterControlChangeNotify)(THIS_ IAudioEndpointVolumeCallback *pNotify) PURE;
-    STDMETHOD_(HRESULT,SetChannelVolumeLevel)(THIS_ UINT nChannel,float fLevelDB,LPCGUID pguidEventContext) PURE;
-    STDMETHOD_(HRESULT,SetChannelVolumeLevelScalar)(THIS_ UINT nChannel,float fLevel,LPCGUID pguidEventContext) PURE;
+    STDMETHOD_(HRESULT,UnregisterControlChangeNotify)(THIS_ IAudioEndpointVolumeCallback *pNotify) PURE;
+    STDMETHOD_(HRESULT,GetChannelCount)(THIS_ UINT *pnChannelCount) PURE;
     STDMETHOD_(HRESULT,SetMasterVolumeLevel)(THIS_ float fLevelDB,LPCGUID pguidEventContext) PURE;
     STDMETHOD_(HRESULT,SetMasterVolumeLevelScalar)(THIS_ float fLevel,LPCGUID pguidEventContext) PURE;
+    STDMETHOD_(HRESULT,GetMasterVolumeLevel)(THIS_ float *pfLevelDB) PURE;
+    STDMETHOD_(HRESULT,GetMasterVolumeLevelScalar)(THIS_ float *pfLevel) PURE;
+    STDMETHOD_(HRESULT,SetChannelVolumeLevel)(THIS_ UINT nChannel,float fLevelDB,LPCGUID pguidEventContext) PURE;
+    STDMETHOD_(HRESULT,SetChannelVolumeLevelScalar)(THIS_ UINT nChannel,float fLevel,LPCGUID pguidEventContext) PURE;
+    STDMETHOD_(HRESULT,GetChannelVolumeLevel)(THIS_ UINT nChannel,float *pfLevelDB) PURE;
+    STDMETHOD_(HRESULT,GetChannelVolumeLevelScalar)(THIS_ UINT nChannel,float *pfLevel) PURE;
     STDMETHOD_(HRESULT,SetMute)(THIS_ WINBOOL bMute,LPCGUID pguidEventContext) PURE;
-    STDMETHOD_(HRESULT,UnregisterControlChangeNotify)(THIS_ IAudioEndpointVolumeCallback *pNotify) PURE;
-    STDMETHOD_(HRESULT,VolumeStepDown)(THIS_ LPCGUID pguidEventContext) PURE;
+    STDMETHOD_(HRESULT,GetMute)(THIS_ WINBOOL *pbMute) PURE;
+    STDMETHOD_(HRESULT,GetVolumeStepInfo)(THIS_ UINT *pnStep,UINT *pnStepCount) PURE;
     STDMETHOD_(HRESULT,VolumeStepUp)(THIS_ LPCGUID pguidEventContext) PURE;
+    STDMETHOD_(HRESULT,VolumeStepDown)(THIS_ LPCGUID pguidEventContext) PURE;
+    STDMETHOD_(HRESULT,QueryHardwareSupport)(THIS_ DWORD *pdwHardwareSupportMask) PURE;
+    STDMETHOD_(HRESULT,GetVolumeRange)(THIS_ float *pfLevelMinDB,float *pfLevelMaxDB,float *pfVolumeIncrementDB) PURE;
 
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IAudioEndpointVolume_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IAudioEndpointVolume_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IAudioEndpointVolume_Release(This) (This)->pVtbl->Release(This)
-#define IAudioEndpointVolume_GetChannelCount(This,pnChannelCount) (This)->lpVtbl->GetChannelCount(This,pnChannelCount)
-#define IAudioEndpointVolume_GetChannelVolumeLevel(This,nChannel,pfLevelDB) (This)->lpVtbl->GetChannelVolumeLevel(This,nChannel,pfLevelDB)
-#define IAudioEndpointVolume_GetChannelVolumeLevelScalar(This,nChannel,pfLevel) (This)->lpVtbl->GetChannelVolumeLevelScalar(This,nChannel,pfLevel)
-#define IAudioEndpointVolume_GetMasterVolumeLevel(This,pfLevelDB) (This)->lpVtbl->GetMasterVolumeLevel(This,pfLevelDB)
-#define IAudioEndpointVolume_GetMasterVolumeLevelScalar(This,pfLevel) (This)->lpVtbl->GetMasterVolumeLevelScalar(This,pfLevel)
-#define IAudioEndpointVolume_GetMute(This,pbMute) (This)->lpVtbl->GetMute(This,pbMute)
-#define IAudioEndpointVolume_GetVolumeRange(This,pfLevelMinDB,pfLevelMaxDB,pfVolumeIncrementDB) (This)->lpVtbl->GetVolumeRange(This,pfLevelMinDB,pfLevelMaxDB,pfVolumeIncrementDB)
-#define IAudioEndpointVolume_GetVolumeStepInfo(This,pnStep,pnStepCount) (This)->lpVtbl->GetVolumeStepInfo(This,pnStep,pnStepCount)
-#define IAudioEndpointVolume_QueryHardwareSupport(This,pdwHardwareSupportMask) (This)->lpVtbl->QueryHardwareSupport(This,pdwHardwareSupportMask)
+#define IAudioEndpointVolume_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IAudioEndpointVolume_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IAudioEndpointVolume_Release(This) (This)->lpVtbl->Release(This)
 #define IAudioEndpointVolume_RegisterControlChangeNotify(This,pNotify) (This)->lpVtbl->RegisterControlChangeNotify(This,pNotify)
-#define IAudioEndpointVolume_SetChannelVolumeLevel(This,nChannel,fLevelDB,pguidEventContext) (This)->lpVtbl->SetChannelVolumeLevel(This,nChannel,fLevelDB,pguidEventContext)
-#define IAudioEndpointVolume_SetChannelVolumeLevelScalar(This,nChannel,fLevel,pguidEventContext) (This)->lpVtbl->SetChannelVolumeLevelScalar(This,nChannel,fLevel,pguidEventContext)
+#define IAudioEndpointVolume_UnregisterControlChangeNotify(This,pNotify) (This)->lpVtbl->UnregisterControlChangeNotify(This,pNotify)
+#define IAudioEndpointVolume_GetChannelCount(This,pnChannelCount) (This)->lpVtbl->GetChannelCount(This,pnChannelCount)
 #define IAudioEndpointVolume_SetMasterVolumeLevel(This,fLevelDB,pguidEventContext) (This)->lpVtbl->SetMasterVolumeLevel(This,fLevelDB,pguidEventContext)
 #define IAudioEndpointVolume_SetMasterVolumeLevelScalar(This,fLevel,pguidEventContext) (This)->lpVtbl->SetMasterVolumeLevelScalar(This,fLevel,pguidEventContext)
+#define IAudioEndpointVolume_GetMasterVolumeLevel(This,pfLevelDB) (This)->lpVtbl->GetMasterVolumeLevel(This,pfLevelDB)
+#define IAudioEndpointVolume_GetMasterVolumeLevelScalar(This,pfLevel) (This)->lpVtbl->GetMasterVolumeLevelScalar(This,pfLevel)
+#define IAudioEndpointVolume_SetChannelVolumeLevel(This,nChannel,fLevelDB,pguidEventContext) (This)->lpVtbl->SetChannelVolumeLevel(This,nChannel,fLevelDB,pguidEventContext)
+#define IAudioEndpointVolume_SetChannelVolumeLevelScalar(This,nChannel,fLevel,pguidEventContext) (This)->lpVtbl->SetChannelVolumeLevelScalar(This,nChannel,fLevel,pguidEventContext)
+#define IAudioEndpointVolume_GetChannelVolumeLevel(This,nChannel,pfLevelDB) (This)->lpVtbl->GetChannelVolumeLevel(This,nChannel,pfLevelDB)
+#define IAudioEndpointVolume_GetChannelVolumeLevelScalar(This,nChannel,pfLevel) (This)->lpVtbl->GetChannelVolumeLevelScalar(This,nChannel,pfLevel)
 #define IAudioEndpointVolume_SetMute(This,bMute,pguidEventContext) (This)->lpVtbl->SetMute(This,bMute,pguidEventContext)
-#define IAudioEndpointVolume_UnregisterControlChangeNotify(This,pNotify) (This)->lpVtbl->UnregisterControlChangeNotify(This,pNotify)
-#define IAudioEndpointVolume_VolumeStepDown(This,pguidEventContext) (This)->lpVtbl->VolumeStepDown(This,pguidEventContext)
+#define IAudioEndpointVolume_GetMute(This,pbMute) (This)->lpVtbl->GetMute(This,pbMute)
+#define IAudioEndpointVolume_GetVolumeStepInfo(This,pnStep,pnStepCount) (This)->lpVtbl->GetVolumeStepInfo(This,pnStep,pnStepCount)
 #define IAudioEndpointVolume_VolumeStepUp(This,pguidEventContext) (This)->lpVtbl->VolumeStepUp(This,pguidEventContext)
+#define IAudioEndpointVolume_VolumeStepDown(This,pguidEventContext) (This)->lpVtbl->VolumeStepDown(This,pguidEventContext)
+#define IAudioEndpointVolume_QueryHardwareSupport(This,pdwHardwareSupportMask) (This)->lpVtbl->QueryHardwareSupport(This,pdwHardwareSupportMask)
+#define IAudioEndpointVolume_GetVolumeRange(This,pfLevelMinDB,pfLevelMaxDB,pfVolumeIncrementDB) (This)->lpVtbl->GetVolumeRange(This,pfLevelMinDB,pfLevelMaxDB,pfVolumeIncrementDB)
 #endif /*COBJMACROS*/
 
 #undef  INTERFACE
@@ -107,9 +102,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IAudioEndpointVolumeCallback_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IAudioEndpointVolumeCallback_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IAudioEndpointVolumeCallback_Release(This) (This)->pVtbl->Release(This)
+#define IAudioEndpointVolumeCallback_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IAudioEndpointVolumeCallback_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IAudioEndpointVolumeCallback_Release(This) (This)->lpVtbl->Release(This)
 #define IAudioEndpointVolumeCallback_OnNotify(This,pNotify) (This)->lpVtbl->OnNotify(This,pNotify)
 #endif /*COBJMACROS*/
 
diff --git a/mingw-w64-headers/include/evr.h b/mingw-w64-headers/include/evr.h
index d5aa0db..c0d3ddc 100644
--- a/mingw-w64-headers/include/evr.h
+++ b/mingw-w64-headers/include/evr.h
@@ -103,9 +103,9 @@
 };
 
 #ifdef COBJMACROS
-#define IMFVideoPresenter_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFVideoPresenter_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFVideoPresenter_Release(This) (This)->pVtbl->Release(This)
+#define IMFVideoPresenter_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFVideoPresenter_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFVideoPresenter_Release(This) (This)->lpVtbl->Release(This)
 #define IMFVideoPresenter_OnClockPause(This,hnsSystemTime) (This)->lpVtbl->OnClockPause(This,hnsSystemTime)
 #define IMFVideoPresenter_OnClockRestart(This,hnsSystemTime) (This)->lpVtbl->OnClockRestart(This,hnsSystemTime)
 #define IMFVideoPresenter_OnClockSetRate(This,hnsSystemTime,flRate) (This)->lpVtbl->OnClockSetRate(This,hnsSystemTime,flRate)
@@ -139,9 +139,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFDesiredSample_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFDesiredSample_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFDesiredSample_Release(This) (This)->pVtbl->Release(This)
+#define IMFDesiredSample_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFDesiredSample_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFDesiredSample_Release(This) (This)->lpVtbl->Release(This)
 #define IMFDesiredSample_Clear() (This)->lpVtbl->Clear(This)
 #define IMFDesiredSample_GetDesiredSampleTimeAndDuration(This,phnsSampleTime,phnsSampleDuration) (This)->lpVtbl->GetDesiredSampleTimeAndDuration(This,phnsSampleTime,phnsSampleDuration)
 #define IMFDesiredSample_SetDesiredSampleTimeAndDuration(This,hnsSampleTime,hnsSampleDuration) (This)->lpVtbl->SetDesiredSampleTimeAndDuration(This,hnsSampleTime,hnsSampleDuration)
@@ -165,9 +165,9 @@
 };
 
 #ifdef COBJMACROS
-#define IMFTrackedSample_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFTrackedSample_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFTrackedSample_Release(This) (This)->pVtbl->Release(This)
+#define IMFTrackedSample_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFTrackedSample_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFTrackedSample_Release(This) (This)->lpVtbl->Release(This)
 #define IMFTrackedSample_SetAllocator(This,pSampleAllocator,pUnkState) (This)->lpVtbl->SetAllocator(This,pSampleAllocator,pUnkState)
 #endif /*COBJMACROS*/
 
@@ -188,9 +188,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFVideoDeviceID_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFVideoDeviceID_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFVideoDeviceID_Release(This) (This)->pVtbl->Release(This)
+#define IMFVideoDeviceID_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFVideoDeviceID_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFVideoDeviceID_Release(This) (This)->lpVtbl->Release(This)
 #define IMFVideoDeviceID_GetDeviceID(This,pDeviceID) (This)->lpVtbl->GetDeviceID(This,pDeviceID)
 #endif /*COBJMACROS*/
 
@@ -211,9 +211,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFVideoPositionMapper_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFVideoPositionMapper_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFVideoPositionMapper_Release(This) (This)->pVtbl->Release(This)
+#define IMFVideoPositionMapper_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFVideoPositionMapper_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFVideoPositionMapper_Release(This) (This)->lpVtbl->Release(This)
 #define IMFVideoPositionMapper_MapOutputCoordinateToInputStream(This,xOut,yOut,dwOutputStreamIndex,dwInputStreamIndex,pxIn,pyIn) (This)->lpVtbl->MapOutputCoordinateToInputStream(This,xOut,yOut,dwOutputStreamIndex,dwInputStreamIndex,pxIn,pyIn)
 #endif /*COBJMACROS*/
 
@@ -234,9 +234,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFVideoRenderer_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFVideoRenderer_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFVideoRenderer_Release(This) (This)->pVtbl->Release(This)
+#define IMFVideoRenderer_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFVideoRenderer_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFVideoRenderer_Release(This) (This)->lpVtbl->Release(This)
 #define IMFVideoRenderer_InitializeRenderer(This,pVideoMixer,pVideoPresenter) (This)->lpVtbl->InitializeRenderer(This,pVideoMixer,pVideoPresenter)
 #endif /*COBJMACROS*/
 
@@ -277,9 +277,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFVideoDisplayControl_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFVideoDisplayControl_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFVideoDisplayControl_Release(This) (This)->pVtbl->Release(This)
+#define IMFVideoDisplayControl_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFVideoDisplayControl_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFVideoDisplayControl_Release(This) (This)->lpVtbl->Release(This)
 #define IMFVideoDisplayControl_GetAspectRatioMode(This,pdwAspectRatioMode) (This)->lpVtbl->GetAspectRatioMode(This,pdwAspectRatioMode)
 #define IMFVideoDisplayControl_GetBorderColor(This,pClr) (This)->lpVtbl->GetBorderColor(This,pClr)
 #define IMFVideoDisplayControl_GetCurrentImage(This,pTimeStamp) (This)->lpVtbl->GetCurrentImage(This,pTimeStamp)
diff --git a/mingw-w64-headers/include/fsrm.h b/mingw-w64-headers/include/fsrm.h
index 1a7ce69..e96a6bd 100644
--- a/mingw-w64-headers/include/fsrm.h
+++ b/mingw-w64-headers/include/fsrm.h
@@ -324,9 +324,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmAction_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmAction_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmAction_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmAction_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmAction_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmAction_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmAction_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmAction_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmAction_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -386,9 +386,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmActionCommand_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmActionCommand_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmActionCommand_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmActionCommand_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmActionCommand_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmActionCommand_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmActionCommand_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmActionCommand_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmActionCommand_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -462,9 +462,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmActionEmail_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmActionEmail_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmActionEmail_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmActionEmail_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmActionEmail_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmActionEmail_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmActionEmail_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmActionEmail_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmActionEmail_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -542,9 +542,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmActionEmail2_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmActionEmail2_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmActionEmail2_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmActionEmail2_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmActionEmail2_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmActionEmail2_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmActionEmail2_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmActionEmail2_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmActionEmail2_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -610,9 +610,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmActionEventLog_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmActionEventLog_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmActionEventLog_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmActionEventLog_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmActionEventLog_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmActionEventLog_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmActionEventLog_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmActionEventLog_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmActionEventLog_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -666,9 +666,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmActionReport_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmActionReport_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmActionReport_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmActionReport_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmActionReport_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmActionReport_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmActionReport_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmActionReport_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmActionReport_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -718,9 +718,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmCollection_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmCollection_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmCollection_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmCollection_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmCollection_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmCollection_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmCollection_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmCollection_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmCollection_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -763,9 +763,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmDerivedObjectsResult_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmDerivedObjectsResult_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmDerivedObjectsResult_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmDerivedObjectsResult_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmDerivedObjectsResult_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmDerivedObjectsResult_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmDerivedObjectsResult_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmDerivedObjectsResult_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmDerivedObjectsResult_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -806,9 +806,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmObject_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmObject_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmObject_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmObject_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmObject_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmObject_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmObject_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmObject_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmObject_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -860,9 +860,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmMutableCollection_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmMutableCollection_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmMutableCollection_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmMutableCollection_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmMutableCollection_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmMutableCollection_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmMutableCollection_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmMutableCollection_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmMutableCollection_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -923,9 +923,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmCommittableCollection_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmCommittableCollection_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmCommittableCollection_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmCommittableCollection_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmCommittableCollection_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmCommittableCollection_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmCommittableCollection_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmCommittableCollection_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmCommittableCollection_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -977,9 +977,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmExportImport_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmExportImport_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmExportImport_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmExportImport_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmExportImport_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmExportImport_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmCommittableCollection_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmCommittableCollection_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmCommittableCollection_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -1075,9 +1075,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmFileManagementJob_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmFileManagementJob_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmFileManagementJob_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmFileManagementJob_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmFileManagementJob_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmFileManagementJob_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmFileManagementJob_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmFileManagementJob_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmFileManagementJob_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -1161,9 +1161,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmPathMapper_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmPathMapper_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmPathMapper_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmPathMapper_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmPathMapper_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmPathMapper_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmPathMapper_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmPathMapper_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmPathMapper_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -1211,9 +1211,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmSetting_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmSetting_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmSetting_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmSetting_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmSetting_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmSetting_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmSetting_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmSetting_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmSetting_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -1287,9 +1287,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmRule_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmRule_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmRule_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmRule_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmRule_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmRule_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmRule_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmRule_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmRule_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -1367,9 +1367,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmClassificationManager_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmClassificationManager_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmClassificationManager_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmClassificationManager_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmClassificationManager_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmClassificationManager_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmClassificationManager_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmClassificationManager_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmClassificationManager_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -1452,9 +1452,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmClassificationRule_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmClassificationRule_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmClassificationRule_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmClassificationRule_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmClassificationRule_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmClassificationRule_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmClassificationRule_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmClassificationRule_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmClassificationRule_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -1537,9 +1537,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmPipelineModuleDefinition_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmPipelineModuleDefinition_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmPipelineModuleDefinition_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmPipelineModuleDefinition_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmPipelineModuleDefinition_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmPipelineModuleDefinition_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmPipelineModuleDefinition_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmPipelineModuleDefinition_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmPipelineModuleDefinition_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -1631,9 +1631,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmClassifierModuleDefinition_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmClassifierModuleDefinition_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmClassifierModuleDefinition_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmClassifierModuleDefinition_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmClassifierModuleDefinition_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmClassifierModuleDefinition_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmClassifierModuleDefinition_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmClassifierModuleDefinition_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmClassifierModuleDefinition_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -1699,9 +1699,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmPipelineModuleImplementation_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmPipelineModuleImplementation_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmPipelineModuleImplementation_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmPipelineModuleImplementation_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmPipelineModuleImplementation_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmPipelineModuleImplementation_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmPipelineModuleImplementation_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmPipelineModuleImplementation_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmPipelineModuleImplementation_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -1747,9 +1747,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmClassifierModuleImplementation_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmClassifierModuleImplementation_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmClassifierModuleImplementation_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmClassifierModuleImplementation_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmClassifierModuleImplementation_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmClassifierModuleImplementation_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmClassifierModuleImplementation_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmClassifierModuleImplementation_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmClassifierModuleImplementation_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -1796,9 +1796,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmPipelineModuleConnector_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmPipelineModuleConnector_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmPipelineModuleConnector_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmPipelineModuleConnector_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmPipelineModuleConnector_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmPipelineModuleConnector_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmPipelineModuleConnector_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmPipelineModuleConnector_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmPipelineModuleConnector_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -1841,9 +1841,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmProperty_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmProperty_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmProperty_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmProperty_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmProperty_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmProperty_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmProperty_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmProperty_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmProperty_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -1902,9 +1902,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmPropertyBag_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmPropertyBag_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmPropertyBag_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmPropertyBag_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmPropertyBag_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmPropertyBag_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmPropertyBag_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmPropertyBag_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmPropertyBag_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -1993,9 +1993,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmStorageModuleDefinition_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmStorageModuleDefinition_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmStorageModuleDefinition_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmStorageModuleDefinition_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmStorageModuleDefinition_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmStorageModuleDefinition_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmStorageModuleDefinition_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmStorageModuleDefinition_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmStorageModuleDefinition_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -2066,9 +2066,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmStorageModuleImplementation_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmStorageModuleImplementation_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmStorageModuleImplementation_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmStorageModuleImplementation_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmStorageModuleImplementation_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmStorageModuleImplementation_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmStorageModuleImplementation_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmStorageModuleImplementation_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmStorageModuleImplementation_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -2114,9 +2114,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmPropertyCondition_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmPropertyCondition_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmPropertyCondition_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmPropertyCondition_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmPropertyCondition_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmPropertyCondition_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmPropertyCondition_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmPropertyCondition_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmPropertyCondition_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -2174,9 +2174,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmPropertyDefinition_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmPropertyDefinition_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmPropertyDefinition_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmPropertyDefinition_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmPropertyDefinition_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmPropertyDefinition_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmPropertyDefinition_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmPropertyDefinition_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmPropertyDefinition_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
diff --git a/mingw-w64-headers/include/fsrmquota.h b/mingw-w64-headers/include/fsrmquota.h
index cec8cf3..a459781 100644
--- a/mingw-w64-headers/include/fsrmquota.h
+++ b/mingw-w64-headers/include/fsrmquota.h
@@ -319,9 +319,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmQuotaBase_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmQuotaBase_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmQuotaBase_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmQuotaBase_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmQuotaBase_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmQuotaBase_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmQuotaBase_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmQuotaBase_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmQuotaBase_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -395,9 +395,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmQuotaObject_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmQuotaObject_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmQuotaObject_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmQuotaObject_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmQuotaObject_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmQuotaObject_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmQuotaObject_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmQuotaObject_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmQuotaObject_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -482,9 +482,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmAutoApplyQuota_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmAutoApplyQuota_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmAutoApplyQuota_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmAutoApplyQuota_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmAutoApplyQuota_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmAutoApplyQuota_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmAutoApplyQuota_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmAutoApplyQuota_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmAutoApplyQuota_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -566,9 +566,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmQuota_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmQuota_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmQuota_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmQuota_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmQuota_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmQuota_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmQuota_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmQuota_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmQuota_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -652,9 +652,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmQuotaTemplate_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmQuotaTemplate_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmQuotaTemplate_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmQuotaTemplate_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmQuotaTemplate_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmQuotaTemplate_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmQuotaTemplate_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmQuotaTemplate_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmQuotaTemplate_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -734,9 +734,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmQuotaTemplateImported_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmQuotaTemplateImported_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmQuotaTemplateImported_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmQuotaTemplateImported_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmQuotaTemplateImported_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmQuotaTemplateImported_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmQuotaTemplateImported_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmQuotaTemplateImported_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmQuotaTemplateImported_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -796,9 +796,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmQuotaTemplateManager_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmQuotaTemplateManager_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmQuotaTemplateManager_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmQuotaTemplateManager_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmQuotaTemplateManager_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmQuotaTemplateManager_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmQuotaTemplateImported_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmQuotaTemplateImported_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmQuotaTemplateImported_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -849,9 +849,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmQuotaManager_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmQuotaManager_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmQuotaManager_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmQuotaManager_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmQuotaManager_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmQuotaManager_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmQuotaManager_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmQuotaManager_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmQuotaManager_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -912,9 +912,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmQuotaManagerEx_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmQuotaManagerEx_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmQuotaManagerEx_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmQuotaManagerEx_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmQuotaManagerEx_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmQuotaManagerEx_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmQuotaManagerEx_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmQuotaManagerEx_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmQuotaManagerEx_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
diff --git a/mingw-w64-headers/include/fsrmreports.h b/mingw-w64-headers/include/fsrmreports.h
index 092cf7c..5e968bb 100644
--- a/mingw-w64-headers/include/fsrmreports.h
+++ b/mingw-w64-headers/include/fsrmreports.h
@@ -312,9 +312,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmReport_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmReport_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmReport_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmReport_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmReport_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmReport_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmReport_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmReport_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmReport_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -380,9 +380,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmReportJob_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmReportJob_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmReportJob_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmReportJob_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmReportJob_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmReportJob_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmReportJob_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmReportJob_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmReportJob_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -448,9 +448,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmReportManager_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmReportManager_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmReportManager_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmReportManager_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmReportManager_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmReportManager_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmReportManager_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmReportManager_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmReportManager_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -498,9 +498,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmReportScheduler_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmReportScheduler_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmReportScheduler_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmReportScheduler_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmReportScheduler_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmReportScheduler_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmReportScheduler_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmReportScheduler_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmReportScheduler_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -535,9 +535,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmFileManagementJobManager_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmFileManagementJobManager_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmFileManagementJobManager_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmFileManagementJobManager_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmFileManagementJobManager_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmFileManagementJobManager_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmFileManagementJobManager_get_ActionVariables(This,variables) (This)->lpVtbl->get_ActionVariables(This,variables)
 #define IFsrmFileManagementJobManager_get_ActionVariableDescriptions(This,descriptions) (This)->lpVtbl->get_ActionVariableDescriptions(This,descriptions)
 #define IFsrmFileManagementJobManager_EnumFileManagementJobs(This,options,fileManagementJobs) (This)->lpVtbl->EnumFileManagementJobs(This,options,fileManagementJobs)
@@ -545,4 +545,4 @@
 #define IFsrmFileManagementJobManager_GetFileManagementJob(This,name,fileManagementJob) (This)->lpVtbl->GetFileManagementJob(This,name,fileManagementJob)
 #endif /*COBJMACROS*/
 #endif /*(_WIN32_WINNT >= 0x0601)*/
-#endif /*_INC_FSRMREPORTS*/
\ No newline at end of file
+#endif /*_INC_FSRMREPORTS*/
diff --git a/mingw-w64-headers/include/fsrmscreen.h b/mingw-w64-headers/include/fsrmscreen.h
index f2eae3b..3f8e51f 100644
--- a/mingw-w64-headers/include/fsrmscreen.h
+++ b/mingw-w64-headers/include/fsrmscreen.h
@@ -316,9 +316,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmFileGroup_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmFileGroup_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmFileGroup_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmFileGroup_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmFileGroup_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmFileGroup_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmFileGroup_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmFileGroup_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmFileGroup_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -380,9 +380,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmFileGroupImported_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmFileGroupImported_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmFileGroupImported_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmFileGroupImported_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmFileGroupImported_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmFileGroupImported_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmFileGroupImported_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmFileGroupImported_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmFileGroupImported_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -435,9 +435,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmFileGroupManager_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmFileGroupManager_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmFileGroupManager_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmFileGroupManager_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmFileGroupManager_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmFileGroupManager_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmFileGroupManager_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmFileGroupManager_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmFileGroupManager_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -491,9 +491,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmFileScreenBase_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmFileScreenBase_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmFileScreenBase_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmFileScreenBase_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmFileScreenBase_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmFileScreenBase_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmFileScreenBase_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmFileScreenBase_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmFileScreenBase_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -550,9 +550,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmFileScreenException_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmFileScreenException_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmFileScreenException_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmFileScreenException_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmFileScreenException_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmFileScreenException_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmFileScreenException_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmFileScreenException_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmFileScreenException_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -603,9 +603,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmFileScreenManager_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmFileScreenManager_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmFileScreenManager_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmFileScreenManager_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmFileScreenManager_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmFileScreenManager_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmFileScreenManager_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmFileScreenManager_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmFileScreenManager_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -669,9 +669,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmFileScreenTemplate_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmFileScreenTemplate_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmFileScreenTemplate_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmFileScreenTemplate_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmFileScreenTemplate_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmFileScreenTemplate_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmFileScreenTemplate_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmFileScreenTemplate_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmFileScreenTemplate_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -747,9 +747,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmFileScreenTemplateImported_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmFileScreenTemplateImported_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmFileScreenTemplateImported_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmFileScreenTemplateImported_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmFileScreenTemplateImported_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmFileScreenTemplateImported_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmFileScreenTemplateImported_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmFileScreenTemplateImported_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmFileScreenTemplateImported_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -807,9 +807,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmFileScreenTemplateManager_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmFileScreenTemplateManager_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmFileScreenTemplateManager_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmFileScreenTemplateManager_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmFileScreenTemplateManager_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmFileScreenTemplateManager_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmFileScreenTemplateImported_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmFileScreenTemplateImported_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmFileScreenTemplateImported_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -869,9 +869,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFsrmFileScreen_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFsrmFileScreen_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFsrmFileScreen_Release(This) (This)->pVtbl->Release(This)
+#define IFsrmFileScreen_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFsrmFileScreen_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFsrmFileScreen_Release(This) (This)->lpVtbl->Release(This)
 #define IFsrmFileScreen_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IFsrmFileScreen_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IFsrmFileScreen_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
diff --git a/mingw-w64-headers/include/functiondiscoveryapi.h b/mingw-w64-headers/include/functiondiscoveryapi.h
index 0e8e025..cb8f986 100644
--- a/mingw-w64-headers/include/functiondiscoveryapi.h
+++ b/mingw-w64-headers/include/functiondiscoveryapi.h
@@ -64,9 +64,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFunctionInstance_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFunctionInstance_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFunctionInstance_Release(This) (This)->pVtbl->Release(This)
+#define IFunctionInstance_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFunctionInstance_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFunctionInstance_Release(This) (This)->lpVtbl->Release(This)
 #define IFunctionInstance_GetID(This,ppszCoMemIdentity) (This)->lpVtbl->GetID(This,ppszCoMemIdentity)
 #define IFunctionInstance_GetProviderInstanceID(This,ppszCoMemProviderInstanceID) (This)->lpVtbl->GetProviderInstanceID(This,ppszCoMemProviderInstanceID)
 #define IFunctionInstance_OpenPropertyStore(This,dwStgAccess,ppIPropertyStore) (This)->lpVtbl->OpenPropertyStore(This,dwStgAccess,ppIPropertyStore)
@@ -91,9 +91,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFunctionInstanceQuery_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFunctionInstanceQuery_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFunctionInstanceQuery_Release(This) (This)->pVtbl->Release(This)
+#define IFunctionInstanceQuery_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFunctionInstanceQuery_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFunctionInstanceQuery_Release(This) (This)->lpVtbl->Release(This)
 #define IFunctionInstanceQuery_Execute(This,ppIFunctionInstance) (This)->lpVtbl->Execute(This,ppIFunctionInstance)
 #endif /*COBJMACROS*/
 
@@ -125,9 +125,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFunctionInstanceCollection_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFunctionInstanceCollection_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFunctionInstanceCollection_Release(This) (This)->pVtbl->Release(This)
+#define IFunctionInstanceCollection_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFunctionInstanceCollection_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFunctionInstanceCollection_Release(This) (This)->lpVtbl->Release(This)
 #define IFunctionInstanceCollection_GetCount(This,pdwCount) (This)->lpVtbl->GetCount(This,pdwCount)
 #define IFunctionInstanceCollection_Get(This,pszInstanceIdentity,pdwIndex,ppIFunctionInstance) (This)->lpVtbl->Get(This,pszInstanceIdentity,pdwIndex,ppIFunctionInstance)
 #define IFunctionInstanceCollection_Item(This,dwIndex,ppFunctionInstance) (This)->lpVtbl->Item(This,dwIndex,ppFunctionInstance)
@@ -161,9 +161,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFunctionInstanceCollectionQuery_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFunctionInstanceCollectionQuery_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFunctionInstanceCollectionQuery_Release(This) (This)->pVtbl->Release(This)
+#define IFunctionInstanceCollectionQuery_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFunctionInstanceCollectionQuery_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFunctionInstanceCollectionQuery_Release(This) (This)->lpVtbl->Release(This)
 #define IFunctionInstanceCollectionQuery_AddQueryConstraint(This,pszConstraintName,pszConstraintValue) (This)->lpVtbl->AddQueryConstraint(This,pszConstraintName,pszConstraintValue)
 #define IFunctionInstanceCollectionQuery_AddPropertyConstraint(This,Key,pv,enumPropertyConstraint) (This)->lpVtbl->AddPropertyConstraint(This,Key,pv,enumPropertyConstraint)
 #define IFunctionInstanceCollectionQuery_Execute(This,ppIFunctionInstanceCollection) (This)->lpVtbl->Execute(This,ppIFunctionInstanceCollection)
@@ -196,9 +196,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFunctionDiscovery_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFunctionDiscovery_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFunctionDiscovery_Release(This) (This)->pVtbl->Release(This)
+#define IFunctionDiscovery_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFunctionDiscovery_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFunctionDiscovery_Release(This) (This)->lpVtbl->Release(This)
 #define IFunctionDiscovery_GetInstanceCollection(This,pszCategory,pszSubCategory,fIncludeAllSubCategories,ppIFunctionInstanceCollection) (This)->lpVtbl->GetInstanceCollection(This,pszCategory,pszSubCategory,fIncludeAllSubCategories,ppIFunctionInstanceCollection)
 #define IFunctionDiscovery_GetInstance(This,pszFunctionInstanceIdentity,ppIFunctionInstance) (This)->lpVtbl->GetInstance(This,pszFunctionInstanceIdentity,ppIFunctionInstance)
 #define IFunctionDiscovery_CreateInstanceCollectionQuery(This,pszCategory,pszSubCategory,fIncludeAllSubCategories,pIFunctionDiscoveryNotification,pfdqcQueryContext,ppIFunctionInstanceCollectionQuery) (This)->lpVtbl->CreateInstanceCollectionQuery(This,pszCategory,pszSubCategory,fIncludeAllSubCategories,pIFunctionDiscoveryNotification,pfdqcQueryContext,ppIFunctionInstanceCollectionQuery)
diff --git a/mingw-w64-headers/include/functiondiscoverynotification.h b/mingw-w64-headers/include/functiondiscoverynotification.h
index 22aaf2a..62a26f7 100644
--- a/mingw-w64-headers/include/functiondiscoverynotification.h
+++ b/mingw-w64-headers/include/functiondiscoverynotification.h
@@ -32,9 +32,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFunctionDiscoveryNotification_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFunctionDiscoveryNotification_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFunctionDiscoveryNotification_Release(This) (This)->pVtbl->Release(This)
+#define IFunctionDiscoveryNotification_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFunctionDiscoveryNotification_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFunctionDiscoveryNotification_Release(This) (This)->lpVtbl->Release(This)
 #define IFunctionDiscoveryNotification_OnUpdate(This,enumQueryUpdateAction,fdqcQueryContext,pIFunctionInstance) (This)->lpVtbl->OnUpdate(This,enumQueryUpdateAction,fdqcQueryContext,pIFunctionInstance)
 #define IFunctionDiscoveryNotification_OnError(This,hr,fdqcQueryContext,pszProvider) (This)->lpVtbl->OnError(This,hr,fdqcQueryContext,pszProvider)
 #define IFunctionDiscoveryNotification_OnEvent(This,dwEventID,fdqcQueryContext,pszProvider) (This)->lpVtbl->OnEvent(This,dwEventID,fdqcQueryContext,pszProvider)
diff --git a/mingw-w64-headers/include/guiddef.h b/mingw-w64-headers/include/guiddef.h
index f409619..efd43ed 100644
--- a/mingw-w64-headers/include/guiddef.h
+++ b/mingw-w64-headers/include/guiddef.h
@@ -15,7 +15,7 @@
 
 #if defined(__cplusplus) && (USE___UUIDOF == 0)
 extern "C++" {
-    template<typename T> const GUID &__mingw_uuidof();
+__extension__    template<typename T> const GUID &__mingw_uuidof();
 }
 #endif
 
diff --git a/mingw-w64-headers/include/identitystore.h b/mingw-w64-headers/include/identitystore.h
index e5f0ec9..89fda78 100644
--- a/mingw-w64-headers/include/identitystore.h
+++ b/mingw-w64-headers/include/identitystore.h
@@ -41,9 +41,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IAssociatedIdentityProvider_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IAssociatedIdentityProvider_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IAssociatedIdentityProvider_Release(This) (This)->pVtbl->Release(This)
+#define IAssociatedIdentityProvider_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IAssociatedIdentityProvider_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IAssociatedIdentityProvider_Release(This) (This)->lpVtbl->Release(This)
 #define IAssociatedIdentityProvider_AssociateIdentity(This,hwndParent,ppPropertyStore) (This)->lpVtbl->AssociateIdentity(This,hwndParent,ppPropertyStore)
 #define IAssociatedIdentityProvider_ChangeCredential(This,hwndParent,lpszUniqueID) (This)->lpVtbl->ChangeCredential(This,hwndParent,lpszUniqueID)
 #define IAssociatedIdentityProvider_DisassociateIdentity(This,hwndParent,lpszUniqueID) (This)->lpVtbl->DisassociateIdentity(This,hwndParent,lpszUniqueID)
diff --git a/mingw-w64-headers/include/locationapi.h b/mingw-w64-headers/include/locationapi.h
index c23fca2..90b26b8 100644
--- a/mingw-w64-headers/include/locationapi.h
+++ b/mingw-w64-headers/include/locationapi.h
@@ -49,9 +49,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define ILocationReport_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define ILocationReport_AddRef(This) (This)->pVtbl->AddRef(This)
-#define ILocationReport_Release(This) (This)->pVtbl->Release(This)
+#define ILocationReport_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ILocationReport_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ILocationReport_Release(This) (This)->lpVtbl->Release(This)
 #define ILocationReport_GetSensorID(This,pSensorID) (This)->lpVtbl->GetSensorID(This,pSensorID)
 #define ILocationReport_GetTimestamp(This,pCreationTime) (This)->lpVtbl->GetTimestamp(This,pCreationTime)
 #define ILocationReport_GetValue(This,pKey,pValue) (This)->lpVtbl->GetValue(This,pKey,pValue)
@@ -85,9 +85,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define ICivicAddressReport_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define ICivicAddressReport_AddRef(This) (This)->pVtbl->AddRef(This)
-#define ICivicAddressReport_Release(This) (This)->pVtbl->Release(This)
+#define ICivicAddressReport_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ICivicAddressReport_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ICivicAddressReport_Release(This) (This)->lpVtbl->Release(This)
 #define ICivicAddressReport_GetSensorID(This,pSensorID) (This)->lpVtbl->GetSensorID(This,pSensorID)
 #define ICivicAddressReport_GetTimestamp(This,pCreationTime) (This)->lpVtbl->GetTimestamp(This,pCreationTime)
 #define ICivicAddressReport_GetValue(This,pKey,pValue) (This)->lpVtbl->GetValue(This,pKey,pValue)
@@ -118,9 +118,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDefaultLocation_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDefaultLocation_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDefaultLocation_Release(This) (This)->pVtbl->Release(This)
+#define IDefaultLocation_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDefaultLocation_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDefaultLocation_Release(This) (This)->lpVtbl->Release(This)
 #define IDefaultLocation_GetReport(This,reportType,ppLocationReport) (This)->lpVtbl->GetReport(This,reportType,ppLocationReport)
 #define IDefaultLocation_SetReport(This,reportType,pLocationReport) (This)->lpVtbl->SetReport(This,reportType,pLocationReport)
 #endif /*COBJMACROS*/
diff --git a/mingw-w64-headers/include/mfapi.h b/mingw-w64-headers/include/mfapi.h
index 8fb4d33..7c5bf59 100644
--- a/mingw-w64-headers/include/mfapi.h
+++ b/mingw-w64-headers/include/mfapi.h
@@ -76,9 +76,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFLocalMFTRegistration_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFLocalMFTRegistration_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFLocalMFTRegistration_Release(This) (This)->pVtbl->Release(This)
+#define IMFLocalMFTRegistration_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFLocalMFTRegistration_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFLocalMFTRegistration_Release(This) (This)->lpVtbl->Release(This)
 #define IMFLocalMFTRegistration_RegisterMFTs(This,pMFTs,cMFTs) (This)->lpVtbl->RegisterMFTs(This,pMFTs,cMFTs)
 #endif /*COBJMACROS*/
 #endif /*(_WIN32_WINNT >= 0x0601)*/
diff --git a/mingw-w64-headers/include/mfidl.h b/mingw-w64-headers/include/mfidl.h
index 666e27f..8c2bbef 100644
--- a/mingw-w64-headers/include/mfidl.h
+++ b/mingw-w64-headers/include/mfidl.h
@@ -402,9 +402,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFByteStreamBuffering_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFByteStreamBuffering_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFByteStreamBuffering_Release(This) (This)->pVtbl->Release(This)
+#define IMFByteStreamBuffering_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFByteStreamBuffering_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFByteStreamBuffering_Release(This) (This)->lpVtbl->Release(This)
 #define IMFByteStreamBuffering_EnableBuffering(This,fEnable) (This)->lpVtbl->EnableBuffering(This,fEnable)
 #define IMFByteStreamBuffering_SetBufferingParams(This,pParams) (This)->lpVtbl->SetBufferingParams(This,pParams)
 #define IMFByteStreamBuffering_StopBuffering() (This)->lpVtbl->StopBuffering(This)
@@ -468,9 +468,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFPresentationDescriptor_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFPresentationDescriptor_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFPresentationDescriptor_Release(This) (This)->pVtbl->Release(This)
+#define IMFPresentationDescriptor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFPresentationDescriptor_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFPresentationDescriptor_Release(This) (This)->lpVtbl->Release(This)
 #define IMFPresentationDescriptor_Compare(This,pTheirs,MatchType,pbResult) (This)->lpVtbl->Compare(This,pTheirs,MatchType,pbResult)
 #define IMFPresentationDescriptor_CompareItem(This,guidKey,Value,pbResult) (This)->lpVtbl->CompareItem(This,guidKey,Value,pbResult)
 #define IMFPresentationDescriptor_CopyAllItems(This,pDest) (This)->lpVtbl->CopyAllItems(This,pDest)
@@ -526,9 +526,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFByteStreamCacheControl_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFByteStreamCacheControl_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFByteStreamCacheControl_Release(This) (This)->pVtbl->Release(This)
+#define IMFByteStreamCacheControl_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFByteStreamCacheControl_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFByteStreamCacheControl_Release(This) (This)->lpVtbl->Release(This)
 #define IMFByteStreamCacheControl_StopBackgroundTransfer() (This)->lpVtbl->StopBackgroundTransfer(This)
 #endif /*COBJMACROS*/
 #endif /*(_WIN32_WINNT >= 0x0601)*/
@@ -584,9 +584,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFClockStateSink_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFClockStateSink_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFClockStateSink_Release(This) (This)->pVtbl->Release(This)
+#define IMFClockStateSink_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFClockStateSink_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFClockStateSink_Release(This) (This)->lpVtbl->Release(This)
 #define IMFClockStateSink_OnClockPause(This,hnsSystemTime) (This)->lpVtbl->OnClockPause(This,hnsSystemTime)
 #define IMFClockStateSink_OnClockRestart(This,hnsSystemTime) (This)->lpVtbl->OnClockRestart(This,hnsSystemTime)
 #define IMFClockStateSink_OnClockSetRate(This,hnsSystemTime,flRate) (This)->lpVtbl->OnClockSetRate(This,hnsSystemTime,flRate)
@@ -620,9 +620,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFClock_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFClock_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFClock_Release(This) (This)->pVtbl->Release(This)
+#define IMFClock_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFClock_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFClock_Release(This) (This)->lpVtbl->Release(This)
 #define IMFClock_GetClockCharacteristics(This,pdwCharacteristics) (This)->lpVtbl->GetClockCharacteristics(This,pdwCharacteristics)
 #define IMFClock_GetContinuityKey(This,pdwContinuityKey) (This)->lpVtbl->GetContinuityKey(This,pdwContinuityKey)
 #define IMFClock_GetCorrelatedTime(This,dwReserved,pllClockTime,phnsSystemTime) (This)->lpVtbl->GetCorrelatedTime(This,dwReserved,pllClockTime,phnsSystemTime)
@@ -659,9 +659,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFPresentationTimeSource_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFPresentationTimeSource_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFPresentationTimeSource_Release(This) (This)->pVtbl->Release(This)
+#define IMFPresentationTimeSource_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFPresentationTimeSource_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFPresentationTimeSource_Release(This) (This)->lpVtbl->Release(This)
 #define IMFPresentationTimeSource_GetClockCharacteristics(This,pdwCharacteristics) (This)->lpVtbl->GetClockCharacteristics(This,pdwCharacteristics)
 #define IMFPresentationTimeSource_GetContinuityKey(This,pdwContinuityKey) (This)->lpVtbl->GetContinuityKey(This,pdwContinuityKey)
 #define IMFPresentationTimeSource_GetCorrelatedTime(This,dwReserved,pllClockTime,phnsSystemTime) (This)->lpVtbl->GetCorrelatedTime(This,dwReserved,pllClockTime,phnsSystemTime)
@@ -706,9 +706,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFPresentationClock_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFPresentationClock_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFPresentationClock_Release(This) (This)->pVtbl->Release(This)
+#define IMFPresentationClock_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFPresentationClock_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFPresentationClock_Release(This) (This)->lpVtbl->Release(This)
 #define IMFPresentationClock_GetClockCharacteristics(This,pdwCharacteristics) (This)->lpVtbl->GetClockCharacteristics(This,pdwCharacteristics)
 #define IMFPresentationClock_GetContinuityKey(This,pdwContinuityKey) (This)->lpVtbl->GetContinuityKey(This,pdwContinuityKey)
 #define IMFPresentationClock_GetCorrelatedTime(This,dwReserved,pllClockTime,phnsSystemTime) (This)->lpVtbl->GetCorrelatedTime(This,dwReserved,pllClockTime,phnsSystemTime)
@@ -759,9 +759,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFStreamSink_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFStreamSink_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFStreamSink_Release(This) (This)->pVtbl->Release(This)
+#define IMFStreamSink_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFStreamSink_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFStreamSink_Release(This) (This)->lpVtbl->Release(This)
 #define IMFStreamSink_BeginGetEvent(This,pCallback,punkState) (This)->lpVtbl->BeginGetEvent(This,pCallback,punkState)
 #define IMFStreamSink_EndGetEvent(This,pResult,ppEvent) (This)->lpVtbl->EndGetEvent(This,pResult,ppEvent)
 #define IMFStreamSink_GetEvent(This,dwFlags,ppEvent) (This)->lpVtbl->GetEvent(This,dwFlags,ppEvent)
@@ -805,9 +805,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFMediaSink_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFMediaSink_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFMediaSink_Release(This) (This)->pVtbl->Release(This)
+#define IMFMediaSink_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFMediaSink_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFMediaSink_Release(This) (This)->lpVtbl->Release(This)
 #define IMFMediaSink_AddStreamSink(This,dwStreamSinkIdentifier,pMediaType,ppStreamSink) (This)->lpVtbl->AddStreamSink(This,dwStreamSinkIdentifier,pMediaType,ppStreamSink)
 #define IMFMediaSink_GetCharacteristics(This,pdwCharacteristics) (This)->lpVtbl->GetCharacteristics(This,pdwCharacteristics)
 #define IMFMediaSink_GetPresentationClock(This,ppPresentationClock) (This)->lpVtbl->GetPresentationClock(This,ppPresentationClock)
@@ -843,9 +843,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFSchemeHandler_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFSchemeHandler_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFSchemeHandler_Release(This) (This)->pVtbl->Release(This)
+#define IMFSchemeHandler_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFSchemeHandler_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFSchemeHandler_Release(This) (This)->lpVtbl->Release(This)
 #define IMFSchemeHandler_BeginCreateObject(This,pwszURL,dwFlags,pProps,ppIUnknownCancelCookie,pCallback,punkState) (This)->lpVtbl->BeginCreateObject(This,pwszURL,dwFlags,pProps,ppIUnknownCancelCookie,pCallback,punkState)
 #define IMFSchemeHandler_CancelObjectCreation(This,pIUnknownCancelCookie) (This)->lpVtbl->CancelObjectCreation(This,pIUnknownCancelCookie)
 #define IMFSchemeHandler_EndCreateObject(This,pResult,pObjectType,ppObject) (This)->lpVtbl->EndCreateObject(This,pResult,pObjectType,ppObject)
@@ -880,9 +880,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFMediaSource_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFMediaSource_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFMediaSource_Release(This) (This)->pVtbl->Release(This)
+#define IMFMediaSource_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFMediaSource_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFMediaSource_Release(This) (This)->lpVtbl->Release(This)
 #define IMFMediaSource_CreatePresentationDescriptor(This,ppPresentationDescriptor) (This)->lpVtbl->CreatePresentationDescriptor(This,ppPresentationDescriptor)
 #define IMFMediaSource_GetCharacteristics(This,pdwCharacteristics) (This)->lpVtbl->GetCharacteristics(This,pdwCharacteristics)
 #define IMFMediaSource_Pause() (This)->lpVtbl->Pause(This)
@@ -916,9 +916,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFPMPServer_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFPMPServer_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFPMPServer_Release(This) (This)->pVtbl->Release(This)
+#define IMFPMPServer_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFPMPServer_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFPMPServer_Release(This) (This)->lpVtbl->Release(This)
 #define IMFPMPServer_CreateObjectByCLSID(This,clsid,riid,ppObject) (This)->lpVtbl->CreateObjectByCLSID(This,clsid,riid,ppObject)
 #define IMFPMPServer_LockProcess() (This)->lpVtbl->LockProcess(This)
 #define IMFPMPServer_UnlockProcess() (This)->lpVtbl->UnlockProcess(This)
@@ -997,9 +997,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFTopologyNode_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFTopologyNode_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFTopologyNode_Release(This) (This)->pVtbl->Release(This)
+#define IMFTopologyNode_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFTopologyNode_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFTopologyNode_Release(This) (This)->lpVtbl->Release(This)
 #define IMFTopologyNode_Compare(This,pTheirs,MatchType,pbResult) (This)->lpVtbl->Compare(This,pTheirs,MatchType,pbResult)
 #define IMFTopologyNode_CompareItem(This,guidKey,Value,pbResult) (This)->lpVtbl->CompareItem(This,guidKey,Value,pbResult)
 #define IMFTopologyNode_CopyAllItems(This,pDest) (This)->lpVtbl->CopyAllItems(This,pDest)
@@ -1116,9 +1116,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFTopology_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFTopology_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFTopology_Release(This) (This)->pVtbl->Release(This)
+#define IMFTopology_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFTopology_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFTopology_Release(This) (This)->lpVtbl->Release(This)
 #define IMFTopology_Compare(This,pTheirs,MatchType,pbResult) (This)->lpVtbl->Compare(This,pTheirs,MatchType,pbResult)
 #define IMFTopology_CompareItem(This,guidKey,Value,pbResult) (This)->lpVtbl->CompareItem(This,guidKey,Value,pbResult)
 #define IMFTopology_CopyAllItems(This,pDest) (This)->lpVtbl->CopyAllItems(This,pDest)
@@ -1186,9 +1186,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFTopoLoader_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFTopoLoader_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFTopoLoader_Release(This) (This)->pVtbl->Release(This)
+#define IMFTopoLoader_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFTopoLoader_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFTopoLoader_Release(This) (This)->lpVtbl->Release(This)
 #define IMFTopoLoader_Load(This,pInputTopo,ppOutputTopo,pCurrentTopo) (This)->lpVtbl->Load(This,pInputTopo,ppOutputTopo,pCurrentTopo)
 #endif /*COBJMACROS*/
 
@@ -1231,9 +1231,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFMediaSession_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFMediaSession_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFMediaSession_Release(This) (This)->pVtbl->Release(This)
+#define IMFMediaSession_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFMediaSession_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFMediaSession_Release(This) (This)->lpVtbl->Release(This)
 #define IMFMediaSession_BeginGetEvent(This,pCallback,punkState) (This)->lpVtbl->BeginGetEvent(This,pCallback,punkState)
 #define IMFMediaSession_EndGetEvent(This,pResult,ppEvent) (This)->lpVtbl->EndGetEvent(This,pResult,ppEvent)
 #define IMFMediaSession_GetEvent(This,dwFlags,ppEvent) (This)->lpVtbl->GetEvent(This,dwFlags,ppEvent)
@@ -1307,9 +1307,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFActivate_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFActivate_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFActivate_Release(This) (This)->pVtbl->Release(This)
+#define IMFActivate_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFActivate_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFActivate_Release(This) (This)->lpVtbl->Release(This)
 #define IMFActivate_Compare(This,pTheirs,MatchType,pbResult) (This)->lpVtbl->Compare(This,pTheirs,MatchType,pbResult)
 #define IMFActivate_CompareItem(This,guidKey,Value,pbResult) (This)->lpVtbl->CompareItem(This,guidKey,Value,pbResult)
 #define IMFActivate_CopyAllItems(This,pDest) (This)->lpVtbl->CopyAllItems(This,pDest)
@@ -1400,9 +1400,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFStreamDescriptor_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFStreamDescriptor_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFStreamDescriptor_Release(This) (This)->pVtbl->Release(This)
+#define IMFStreamDescriptor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFStreamDescriptor_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFStreamDescriptor_Release(This) (This)->lpVtbl->Release(This)
 #define IMFStreamDescriptor_Compare(This,pTheirs,MatchType,pbResult) (This)->lpVtbl->Compare(This,pTheirs,MatchType,pbResult)
 #define IMFStreamDescriptor_CompareItem(This,guidKey,Value,pbResult) (This)->lpVtbl->CompareItem(This,guidKey,Value,pbResult)
 #define IMFStreamDescriptor_CopyAllItems(This,pDest) (This)->lpVtbl->CopyAllItems(This,pDest)
@@ -1454,9 +1454,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFRemoteDesktopPlugin_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFRemoteDesktopPlugin_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFRemoteDesktopPlugin_Release(This) (This)->pVtbl->Release(This)
+#define IMFRemoteDesktopPlugin_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFRemoteDesktopPlugin_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFRemoteDesktopPlugin_Release(This) (This)->lpVtbl->Release(This)
 #define IMFRemoteDesktopPlugin_UpdateTopology(This,pTopology) (This)->lpVtbl->UpdateTopology(This,pTopology)
 #endif /*COBJMACROS*/
 
@@ -1486,9 +1486,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFNetProxyLocator_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFNetProxyLocator_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFNetProxyLocator_Release(This) (This)->pVtbl->Release(This)
+#define IMFNetProxyLocator_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFNetProxyLocator_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFNetProxyLocator_Release(This) (This)->lpVtbl->Release(This)
 #define IMFNetProxyLocator_Clone(This,ppProxyLocator) (This)->lpVtbl->Clone(This,ppProxyLocator)
 #define IMFNetProxyLocator_FindFirstProxy(This,pszHost,pszUrl,fReserved) (This)->lpVtbl->FindFirstProxy(This,pszHost,pszUrl,fReserved)
 #define IMFNetProxyLocator_FindNextProxy() (This)->lpVtbl->FindNextProxy(This)
@@ -1525,9 +1525,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFMediaTypeHandler_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFMediaTypeHandler_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFMediaTypeHandler_Release(This) (This)->pVtbl->Release(This)
+#define IMFMediaTypeHandler_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFMediaTypeHandler_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFMediaTypeHandler_Release(This) (This)->lpVtbl->Release(This)
 #define IMFMediaTypeHandler_GetCurrentMediaType(This,ppMediaType) (This)->lpVtbl->GetCurrentMediaType(This,ppMediaType)
 #define IMFMediaTypeHandler_GetMajorType(This,pguidMajorType) (This)->lpVtbl->GetMajorType(This,pguidMajorType)
 #define IMFMediaTypeHandler_GetMediaTypeByIndex(This,dwIndex,ppType) (This)->lpVtbl->GetMediaTypeByIndex(This,dwIndex,ppType)
@@ -1568,9 +1568,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFSampleGrabberSinkCallback_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFSampleGrabberSinkCallback_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFSampleGrabberSinkCallback_Release(This) (This)->pVtbl->Release(This)
+#define IMFSampleGrabberSinkCallback_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFSampleGrabberSinkCallback_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFSampleGrabberSinkCallback_Release(This) (This)->lpVtbl->Release(This)
 #define IMFSampleGrabberSinkCallback_OnClockPause(This,hnsSystemTime) (This)->lpVtbl->OnClockPause(This,hnsSystemTime)
 #define IMFSampleGrabberSinkCallback_OnClockRestart(This,hnsSystemTime) (This)->lpVtbl->OnClockRestart(This,hnsSystemTime)
 #define IMFSampleGrabberSinkCallback_OnClockSetRate(This,hnsSystemTime,flRate) (This)->lpVtbl->OnClockSetRate(This,hnsSystemTime,flRate)
@@ -1607,9 +1607,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFSequencerSource_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFSequencerSource_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFSequencerSource_Release(This) (This)->pVtbl->Release(This)
+#define IMFSequencerSource_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFSequencerSource_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFSequencerSource_Release(This) (This)->lpVtbl->Release(This)
 #define IMFSequencerSource_AppendTopology(This,pTopology,dwFlags,pdwId) (This)->lpVtbl->AppendTopology(This,pTopology,dwFlags,pdwId)
 #define IMFSequencerSource_DeleteTopology(This,dwId) (This)->lpVtbl->DeleteTopology(This,dwId)
 #define IMFSequencerSource_GetPresentationContext(This,pPD,pId,ppTopology) (This)->lpVtbl->GetPresentationContext(This,pPD,pId,ppTopology)
@@ -1645,9 +1645,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFSourceResolver_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFSourceResolver_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFSourceResolver_Release(This) (This)->pVtbl->Release(This)
+#define IMFSourceResolver_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFSourceResolver_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFSourceResolver_Release(This) (This)->lpVtbl->Release(This)
 #define IMFSourceResolver_BeginCreateObjectFromByteStream(This,pByteStream,pwszURL,dwFlags,pProps,ppIUnknownCancelCookie,pCallback,punkState) (This)->lpVtbl->BeginCreateObjectFromByteStream(This,pByteStream,pwszURL,dwFlags,pProps,ppIUnknownCancelCookie,pCallback,punkState)
 #define IMFSourceResolver_BeginCreateObjectFromURL(This,pwszURL,dwFlags,pProps,ppIUnknownCancelCookie,pCallback,punkState) (This)->lpVtbl->BeginCreateObjectFromURL(This,pwszURL,dwFlags,pProps,ppIUnknownCancelCookie,pCallback,punkState)
 #define IMFSourceResolver_CancelObjectCreation(This,ppIUnknownCancelCookie) (This)->lpVtbl->CancelObjectCreation(This,ppIUnknownCancelCookie)
@@ -1684,9 +1684,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFQualityManager_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFQualityManager_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFQualityManager_Release(This) (This)->pVtbl->Release(This)
+#define IMFQualityManager_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFQualityManager_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFQualityManager_Release(This) (This)->lpVtbl->Release(This)
 #define IMFQualityManager_NotifyPresentationClock(This,pClock) (This)->lpVtbl->NotifyPresentationClock(This,pClock)
 #define IMFQualityManager_NotifyProcessInput(This,pNode,lInputIndex,pSample) (This)->lpVtbl->NotifyProcessInput(This,pNode,lInputIndex,pSample)
 #define IMFQualityManager_NotifyProcessOutput(This,pNode,lOutputIndex,pSample) (This)->lpVtbl->NotifyProcessOutput(This,pNode,lOutputIndex,pSample)
@@ -1720,9 +1720,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFByteStreamHandler_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFByteStreamHandler_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFByteStreamHandler_Release(This) (This)->pVtbl->Release(This)
+#define IMFByteStreamHandler_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFByteStreamHandler_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFByteStreamHandler_Release(This) (This)->lpVtbl->Release(This)
 #define IMFByteStreamHandler_BeginCreateObject(This,pByteStream,pwszURL,dwFlags,pProps,ppIUnknownCancelCookie,pCallback,punkState) (This)->lpVtbl->BeginCreateObject(This,pByteStream,pwszURL,dwFlags,pProps,ppIUnknownCancelCookie,pCallback,punkState)
 #define IMFByteStreamHandler_CancelObjectCreation(This,pIUnknownCancelCookie) (This)->lpVtbl->CancelObjectCreation(This,pIUnknownCancelCookie)
 #define IMFByteStreamHandler_EndCreateObject(This,pResult,pObjectType,ppObject) (This)->lpVtbl->EndCreateObject(This,pResult,pObjectType,ppObject)
@@ -1757,9 +1757,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFTranscodeProfile_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFTranscodeProfile_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFTranscodeProfile_Release(This) (This)->pVtbl->Release(This)
+#define IMFTranscodeProfile_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFTranscodeProfile_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFTranscodeProfile_Release(This) (This)->lpVtbl->Release(This)
 #define IMFTranscodeProfile_GetAudioAttributes(This,ppAttrs) (This)->lpVtbl->GetAudioAttributes(This,ppAttrs)
 #define IMFTranscodeProfile_GetContainerAttributes(This,ppAttrs) (This)->lpVtbl->GetContainerAttributes(This,ppAttrs)
 #define IMFTranscodeProfile_GetVideoAttributes(This,ppAttrs) (This)->lpVtbl->GetVideoAttributes(This,ppAttrs)
@@ -1800,9 +1800,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFTranscodeSinkInfoProvider_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFTranscodeSinkInfoProvider_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFTranscodeSinkInfoProvider_Release(This) (This)->pVtbl->Release(This)
+#define IMFTranscodeSinkInfoProvider_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFTranscodeSinkInfoProvider_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFTranscodeSinkInfoProvider_Release(This) (This)->lpVtbl->Release(This)
 #define IMFTranscodeSinkInfoProvider_GetSinkInfo(This,pSinkInfo) (This)->lpVtbl->GetSinkInfo(This,pSinkInfo)
 #define IMFTranscodeSinkInfoProvider_SetOutputByteStream(This,pByteStreamActivate) (This)->lpVtbl->SetOutputByteStream(This,pByteStreamActivate)
 #define IMFTranscodeSinkInfoProvider_SetOutputFile(This,pwszFileName) (This)->lpVtbl->SetOutputFile(This,pwszFileName)
@@ -1838,9 +1838,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFVideoSampleAllocator_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFVideoSampleAllocator_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFVideoSampleAllocator_Release(This) (This)->pVtbl->Release(This)
+#define IMFVideoSampleAllocator_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFVideoSampleAllocator_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFVideoSampleAllocator_Release(This) (This)->lpVtbl->Release(This)
 #define IMFVideoSampleAllocator_GetCurrentMediaType(This,ppMediaType) (This)->lpVtbl->GetCurrentMediaType(This,ppMediaType)
 #define IMFVideoSampleAllocator_ProcessMessage(This,eMessage,ulParam) (This)->lpVtbl->ProcessMessage(This,eMessage,ulParam)
 #define IMFVideoSampleAllocator_AllocateSample(This,ppSample) (This)->lpVtbl->AllocateSample(This,ppSample)
@@ -1872,9 +1872,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFObjectReferenceStream_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFObjectReferenceStream_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFObjectReferenceStream_Release(This) (This)->pVtbl->Release(This)
+#define IMFObjectReferenceStream_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFObjectReferenceStream_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFObjectReferenceStream_Release(This) (This)->lpVtbl->Release(This)
 #define IMFObjectReferenceStream_LoadReference(This,riid,ppv) (This)->lpVtbl->LoadReference(This,riid,ppv)
 #define IMFObjectReferenceStream_SaveReference(This,riid,pUnk) (This)->lpVtbl->SaveReference(This,riid,pUnk)
 #endif /*COBJMACROS*/
@@ -1912,9 +1912,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFWorkQueueServices_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFWorkQueueServices_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFWorkQueueServices_Release(This) (This)->pVtbl->Release(This)
+#define IMFWorkQueueServices_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFWorkQueueServices_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFWorkQueueServices_Release(This) (This)->lpVtbl->Release(This)
 #define IMFWorkQueueServices_BeginRegisterPlatformWorkQueueWithMMCSS(This,dwPlatformWorkQueue,wszClass,dwTaskId,pCallback,pState) (This)->lpVtbl->BeginRegisterPlatformWorkQueueWithMMCSS(This,dwPlatformWorkQueue,wszClass,dwTaskId,pCallback,pState)
 #define IMFWorkQueueServices_BeginRegisterTopologyWorkQueuesWithMMCSS(This,pCallback,pState) (This)->lpVtbl->BeginRegisterTopologyWorkQueuesWithMMCSS(This,pCallback,pState)
 #define IMFWorkQueueServices_BeginUnregisterPlatformWorkQueueWithMMCSS(This,dwPlatformWorkQueue,pCallback,pState) (This)->lpVtbl->BeginUnregisterPlatformWorkQueueWithMMCSS(This,dwPlatformWorkQueue,pCallback,pState)
@@ -1948,9 +1948,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFVideoSampleAllocatorNotify_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFVideoSampleAllocatorNotify_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFVideoSampleAllocatorNotify_Release(This) (This)->pVtbl->Release(This)
+#define IMFVideoSampleAllocatorNotify_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFVideoSampleAllocatorNotify_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFVideoSampleAllocatorNotify_Release(This) (This)->lpVtbl->Release(This)
 #define IMFVideoSampleAllocatorNotify_NotifyRelease() (This)->lpVtbl->NotifyRelease(This)
 #endif /*COBJMACROS*/
 
@@ -1977,9 +1977,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFVideoSampleAllocatorCallback_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFVideoSampleAllocatorCallback_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFVideoSampleAllocatorCallback_Release(This) (This)->pVtbl->Release(This)
+#define IMFVideoSampleAllocatorCallback_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFVideoSampleAllocatorCallback_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFVideoSampleAllocatorCallback_Release(This) (This)->lpVtbl->Release(This)
 #define IMFVideoSampleAllocatorCallback_GetFreeSampleCount(This,plSamples) (This)->lpVtbl->GetFreeSampleCount(This,plSamples)
 #define IMFVideoSampleAllocatorCallback_SetCallback(This,pNotify) (This)->lpVtbl->SetCallback(This,pNotify)
 #endif /*COBJMACROS*/
diff --git a/mingw-w64-headers/include/mfobjects.h b/mingw-w64-headers/include/mfobjects.h
index 37d40e9..435af99 100644
--- a/mingw-w64-headers/include/mfobjects.h
+++ b/mingw-w64-headers/include/mfobjects.h
@@ -314,9 +314,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFRemoteAsyncCallback_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFRemoteAsyncCallback_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFRemoteAsyncCallback_Release(This) (This)->pVtbl->Release(This)
+#define IMFRemoteAsyncCallback_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFRemoteAsyncCallback_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFRemoteAsyncCallback_Release(This) (This)->lpVtbl->Release(This)
 #endif /*COBJMACROS*/
 
 #undef  INTERFACE
@@ -345,9 +345,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFAsyncResult_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFAsyncResult_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFAsyncResult_Release(This) (This)->pVtbl->Release(This)
+#define IMFAsyncResult_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFAsyncResult_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFAsyncResult_Release(This) (This)->lpVtbl->Release(This)
 #define IMFAsyncResult_GetObject(This,ppObject) (This)->lpVtbl->GetObject(This,ppObject)
 #define IMFAsyncResult_GetState(This,ppunkState) (This)->lpVtbl->GetState(This,ppunkState)
 #define IMFAsyncResult_GetStateNoAddRef() (This)->lpVtbl->GetStateNoAddRef(This)
@@ -382,9 +382,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFMediaEventGenerator_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFMediaEventGenerator_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFMediaEventGenerator_Release(This) (This)->pVtbl->Release(This)
+#define IMFMediaEventGenerator_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFMediaEventGenerator_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFMediaEventGenerator_Release(This) (This)->lpVtbl->Release(This)
 #define IMFMediaEventGenerator_BeginGetEvent(This,pCallback,punkState) (This)->lpVtbl->BeginGetEvent(This,pCallback,punkState)
 #define IMFMediaEventGenerator_EndGetEvent(This,pResult,ppEvent) (This)->lpVtbl->EndGetEvent(This,pResult,ppEvent)
 #define IMFMediaEventGenerator_GetEvent(This,dwFlags,ppEvent) (This)->lpVtbl->GetEvent(This,dwFlags,ppEvent)
@@ -418,9 +418,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFMediaBuffer_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFMediaBuffer_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFMediaBuffer_Release(This) (This)->pVtbl->Release(This)
+#define IMFMediaBuffer_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFMediaBuffer_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFMediaBuffer_Release(This) (This)->lpVtbl->Release(This)
 #define IMFMediaBuffer_GetCurrentLength(This,pcbCurrentLength) (This)->lpVtbl->GetCurrentLength(This,pcbCurrentLength)
 #define IMFMediaBuffer_GetMaxLength(This,pcbMaxLength) (This)->lpVtbl->GetMaxLength(This,pcbMaxLength)
 #define IMFMediaBuffer_Lock(This,ppbBuffer,pcbMaxLength,pcbCurrentLength) (This)->lpVtbl->Lock(This,ppbBuffer,pcbMaxLength,pcbCurrentLength)
@@ -479,9 +479,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFAttributes_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFAttributes_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFAttributes_Release(This) (This)->pVtbl->Release(This)
+#define IMFAttributes_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFAttributes_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFAttributes_Release(This) (This)->lpVtbl->Release(This)
 #define IMFAttributes_Compare(This,pTheirs,MatchType,pbResult) (This)->lpVtbl->Compare(This,pTheirs,MatchType,pbResult)
 #define IMFAttributes_CompareItem(This,guidKey,Value,pbResult) (This)->lpVtbl->CompareItem(This,guidKey,Value,pbResult)
 #define IMFAttributes_CopyAllItems(This,pDest) (This)->lpVtbl->CopyAllItems(This,pDest)
@@ -572,9 +572,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFMediaType_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFMediaType_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFMediaType_Release(This) (This)->pVtbl->Release(This)
+#define IMFMediaType_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFMediaType_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFMediaType_Release(This) (This)->lpVtbl->Release(This)
 #define IMFMediaType_Compare(This,pTheirs,MatchType,pbResult) (This)->lpVtbl->Compare(This,pTheirs,MatchType,pbResult)
 #define IMFMediaType_CompareItem(This,guidKey,Value,pbResult) (This)->lpVtbl->CompareItem(This,guidKey,Value,pbResult)
 #define IMFMediaType_CopyAllItems(This,pDest) (This)->lpVtbl->CopyAllItems(This,pDest)
@@ -673,9 +673,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFAudioMediaType_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFAudioMediaType_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFAudioMediaType_Release(This) (This)->pVtbl->Release(This)
+#define IMFAudioMediaType_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFAudioMediaType_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFAudioMediaType_Release(This) (This)->lpVtbl->Release(This)
 #define IMFAudioMediaType_Compare(This,pTheirs,MatchType,pbResult) (This)->lpVtbl->Compare(This,pTheirs,MatchType,pbResult)
 #define IMFAudioMediaType_CompareItem(This,guidKey,Value,pbResult) (This)->lpVtbl->CompareItem(This,guidKey,Value,pbResult)
 #define IMFAudioMediaType_CopyAllItems(This,pDest) (This)->lpVtbl->CopyAllItems(This,pDest)
@@ -711,7 +711,7 @@
 #define IMFAudioMediaType_GetRepresentation(This,guidRepresentation,ppvRepresentation) (This)->lpVtbl->GetRepresentation(This,guidRepresentation,ppvRepresentation)
 #define IMFAudioMediaType_IsCompressedFormat(This,pfCompressed) (This)->lpVtbl->IsCompressedFormat(This,pfCompressed)
 #define IMFAudioMediaType_IsEqual(This,pIMediaType,pdwFlags) (This)->lpVtbl->IsEqual(This,pIMediaType,pdwFlags)
-#define IMFAudioMediaType_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFAudioMediaType_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
 #endif /*COBJMACROS*/
 
 #undef  INTERFACE
@@ -788,9 +788,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFSample_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFSample_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFSample_Release(This) (This)->pVtbl->Release(This)
+#define IMFSample_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFSample_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFSample_Release(This) (This)->lpVtbl->Release(This)
 #define IMFSample_Compare(This,pTheirs,MatchType,pbResult) (This)->lpVtbl->Compare(This,pTheirs,MatchType,pbResult)
 #define IMFSample_CompareItem(This,guidKey,Value,pbResult) (This)->lpVtbl->CompareItem(This,guidKey,Value,pbResult)
 #define IMFSample_CopyAllItems(This,pDest) (This)->lpVtbl->CopyAllItems(This,pDest)
@@ -870,9 +870,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMF2DBuffer_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMF2DBuffer_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMF2DBuffer_Release(This) (This)->pVtbl->Release(This)
+#define IMF2DBuffer_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMF2DBuffer_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMF2DBuffer_Release(This) (This)->lpVtbl->Release(This)
 #define IMF2DBuffer_ContiguousCopyFrom(This,pbSrcBuffer,cbSrcBuffer) (This)->lpVtbl->ContiguousCopyFrom(This,pbSrcBuffer,cbSrcBuffer)
 #define IMF2DBuffer_ContiguousCopyTo(This,pbDestBuffer,cbDestBuffer) (This)->lpVtbl->ContiguousCopyTo(This,pbDestBuffer,cbDestBuffer)
 #define IMF2DBuffer_GetContiguousLength(This,pcbLength) (This)->lpVtbl->GetContiguousLength(This,pcbLength)
@@ -905,9 +905,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFAsyncCallback_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFAsyncCallback_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFAsyncCallback_Release(This) (This)->pVtbl->Release(This)
+#define IMFAsyncCallback_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFAsyncCallback_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFAsyncCallback_Release(This) (This)->lpVtbl->Release(This)
 #define IMFAsyncCallback_GetParameters(This,pdwFlags,pdwQueue) (This)->lpVtbl->GetParameters(This,pdwFlags,pdwQueue)
 #define IMFAsyncCallback_Invoke(This,pAsyncResult) (This)->lpVtbl->Invoke(This,pAsyncResult)
 #endif /*COBJMACROS*/
@@ -950,9 +950,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFByteStream_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFByteStream_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFByteStream_Release(This) (This)->pVtbl->Release(This)
+#define IMFByteStream_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFByteStream_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFByteStream_Release(This) (This)->lpVtbl->Release(This)
 #define IMFByteStream_GetParameters(This,pdwFlags,pdwQueue) (This)->lpVtbl->GetParameters(This,pdwFlags,pdwQueue)
 #define IMFByteStream_MFInvokeCallback(This,pAsyncResult) (This)->lpVtbl->MFInvokeCallback(This,pAsyncResult)
 #define IMFByteStream_BeginRead(This,pb,cb,pCallback,punkState) (This)->lpVtbl->BeginRead(This,pb,cb,pCallback,punkState)
@@ -1029,9 +1029,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFMediaEvent_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFMediaEvent_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFMediaEvent_Release(This) (This)->pVtbl->Release(This)
+#define IMFMediaEvent_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFMediaEvent_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFMediaEvent_Release(This) (This)->lpVtbl->Release(This)
 #define IMFMediaEvent_Compare(This,pTheirs,MatchType,pbResult) (This)->lpVtbl->Compare(This,pTheirs,MatchType,pbResult)
 #define IMFMediaEvent_CompareItem(This,guidKey,Value,pbResult) (This)->lpVtbl->CompareItem(This,guidKey,Value,pbResult)
 #define IMFMediaEvent_CopyAllItems(This,pDest) (This)->lpVtbl->CopyAllItems(This,pDest)
@@ -1130,9 +1130,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFVideoMediaType_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFVideoMediaType_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFVideoMediaType_Release(This) (This)->pVtbl->Release(This)
+#define IMFVideoMediaType_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFVideoMediaType_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFVideoMediaType_Release(This) (This)->lpVtbl->Release(This)
 #define IMFVideoMediaType_Compare(This,pTheirs,MatchType,pbResult) (This)->lpVtbl->Compare(This,pTheirs,MatchType,pbResult)
 #define IMFVideoMediaType_CompareItem(This,guidKey,Value,pbResult) (This)->lpVtbl->CompareItem(This,guidKey,Value,pbResult)
 #define IMFVideoMediaType_CopyAllItems(This,pDest) (This)->lpVtbl->CopyAllItems(This,pDest)
@@ -1199,9 +1199,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFCollection_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFCollection_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFCollection_Release(This) (This)->pVtbl->Release(This)
+#define IMFCollection_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFCollection_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFCollection_Release(This) (This)->lpVtbl->Release(This)
 #define IMFCollection_AddElement(This,pUnkElement) (This)->lpVtbl->AddElement(This,pUnkElement)
 #define IMFCollection_GetElement(This,dwElementIndex,ppUnkElement) (This)->lpVtbl->GetElement(This,dwElementIndex,ppUnkElement)
 #define IMFCollection_GetElementCount(This,pcElements) (This)->lpVtbl->GetElementCount(This,pcElements)
@@ -1239,9 +1239,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFPluginControl_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFPluginControl_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFPluginControl_Release(This) (This)->pVtbl->Release(This)
+#define IMFPluginControl_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFPluginControl_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFPluginControl_Release(This) (This)->lpVtbl->Release(This)
 #define IMFPluginControl_GetDisabledByIndex(This,pluginType,index,clsid) (This)->lpVtbl->GetDisabledByIndex(This,pluginType,index,clsid)
 #define IMFPluginControl_GetPreferredClsid(This,pluginType,selector,clsid) (This)->lpVtbl->GetPreferredClsid(This,pluginType,selector,clsid)
 #define IMFPluginControl_GetPreferredClsidByIndex(This,pluginType,index,selector,clsid) (This)->lpVtbl->GetPreferredClsidByIndex(This,pluginType,index,selector,clsid)
diff --git a/mingw-w64-headers/include/mfplay.h b/mingw-w64-headers/include/mfplay.h
index bb62289..968899f 100644
--- a/mingw-w64-headers/include/mfplay.h
+++ b/mingw-w64-headers/include/mfplay.h
@@ -108,9 +108,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFPMediaItem_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFPMediaItem_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFPMediaItem_Release(This) (This)->pVtbl->Release(This)
+#define IMFPMediaItem_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFPMediaItem_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFPMediaItem_Release(This) (This)->lpVtbl->Release(This)
 #define IMFPMediaItem_GetCharacteristics(This,pCharacteristics) (This)->lpVtbl->GetCharacteristics(This,pCharacteristics)
 #define IMFPMediaItem_GetDuration(This,guidPositionType,pvDurationValue) (This)->lpVtbl->GetDuration(This,guidPositionType,pvDurationValue)
 #define IMFPMediaItem_GetMediaPlayer(This,ppMediaPlayer) (This)->lpVtbl->GetMediaPlayer(This,ppMediaPlayer)
@@ -190,9 +190,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFPMediaPlayer_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFPMediaPlayer_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFPMediaPlayer_Release(This) (This)->pVtbl->Release(This)
+#define IMFPMediaPlayer_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFPMediaPlayer_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFPMediaPlayer_Release(This) (This)->lpVtbl->Release(This)
 #define IMFPMediaPlayer_ClearMediaItem() (This)->lpVtbl->ClearMediaItem(This)
 #define IMFPMediaPlayer_CreateMediaItemFromObject(This,pIUnknownObj,fSync,dwUserData,ppMediaItem) (This)->lpVtbl->CreateMediaItemFromObject(This,pIUnknownObj,fSync,dwUserData,ppMediaItem)
 #define IMFPMediaPlayer_CreateMediaItemFromURL(This,pwszURL,fSync,dwUserData,ppMediaItem) (This)->lpVtbl->CreateMediaItemFromURL(This,pwszURL,fSync,dwUserData,ppMediaItem)
@@ -254,9 +254,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFPMediaPlayerCallback_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFPMediaPlayerCallback_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFPMediaPlayerCallback_Release(This) (This)->pVtbl->Release(This)
+#define IMFPMediaPlayerCallback_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFPMediaPlayerCallback_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFPMediaPlayerCallback_Release(This) (This)->lpVtbl->Release(This)
 #define IMFPMediaPlayerCallback_OnMediaPlayerEvent(This,pEventHeader) (This)->lpVtbl->OnMediaPlayerEvent(This,pEventHeader)
 #endif /*COBJMACROS*/
 
diff --git a/mingw-w64-headers/include/mfreadwrite.h b/mingw-w64-headers/include/mfreadwrite.h
index 20dba57..3a777e0 100644
--- a/mingw-w64-headers/include/mfreadwrite.h
+++ b/mingw-w64-headers/include/mfreadwrite.h
@@ -68,9 +68,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFSinkWriter_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFSinkWriter_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFSinkWriter_Release(This) (This)->pVtbl->Release(This)
+#define IMFSinkWriter_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFSinkWriter_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFSinkWriter_Release(This) (This)->lpVtbl->Release(This)
 #define IMFSinkWriter_AddStream(This,pTargetMediaType,pdwStreamIndex) (This)->lpVtbl->AddStream(This,pTargetMediaType,pdwStreamIndex)
 #define IMFSinkWriter_BeginWriting() (This)->lpVtbl->BeginWriting(This)
 #define IMFSinkWriter_Finalize() (This)->lpVtbl->Finalize(This)
@@ -115,9 +115,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFSourceReader_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFSourceReader_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFSourceReader_Release(This) (This)->pVtbl->Release(This)
+#define IMFSourceReader_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFSourceReader_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFSourceReader_Release(This) (This)->lpVtbl->Release(This)
 #define IMFSourceReader_Flush(This,dwStreamIndex) (This)->lpVtbl->Flush(This,dwStreamIndex)
 #define IMFSourceReader_GetCurrentMediaType(This,dwStreamIndex,ppMediaType) (This)->lpVtbl->GetCurrentMediaType(This,dwStreamIndex,ppMediaType)
 #define IMFSourceReader_GetNativeMediaType(This,dwStreamIndex,dwMediaTypeIndex,ppMediaType) (This)->lpVtbl->GetNativeMediaType(This,dwStreamIndex,dwMediaTypeIndex,ppMediaType)
diff --git a/mingw-w64-headers/include/mftransform.h b/mingw-w64-headers/include/mftransform.h
index 1d50185..77404a2 100644
--- a/mingw-w64-headers/include/mftransform.h
+++ b/mingw-w64-headers/include/mftransform.h
@@ -170,9 +170,9 @@
 };
 
 #ifdef COBJMACROS
-#define IMFTransform_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFTransform_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFTransform_Release(This) (This)->pVtbl->Release(This)
+#define IMFTransform_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFTransform_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFTransform_Release(This) (This)->lpVtbl->Release(This)
 #define IMFTransform_AddInputStreams(This,cStreams,adwStreamIDs) (This)->lpVtbl->AddInputStreams(This,cStreams,adwStreamIDs)
 #define IMFTransform_DeleteInputStream(This,dwStreamID) (This)->lpVtbl->DeleteInputStream(This,dwStreamID)
 #define IMFTransform_GetAttributes(This,pAttributes) (This)->lpVtbl->GetAttributes(This,pAttributes)
diff --git a/mingw-w64-headers/include/mpeg2data.h b/mingw-w64-headers/include/mpeg2data.h
index 93f5cf3..03d86a3 100644
--- a/mingw-w64-headers/include/mpeg2data.h
+++ b/mingw-w64-headers/include/mpeg2data.h
@@ -61,9 +61,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define ISectionList_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define ISectionList_AddRef(This) (This)->pVtbl->AddRef(This)
-#define ISectionList_Release(This) (This)->pVtbl->Release(This)
+#define ISectionList_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ISectionList_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ISectionList_Release(This) (This)->lpVtbl->Release(This)
 #define ISectionList_CancelPendingRequest() (This)->lpVtbl->CancelPendingRequest(This)
 #define ISectionList_GetNumberOfSections(This,pCount) (This)->lpVtbl->GetNumberOfSections(This,pCount)
 #define ISectionList_GetProgramIdentifier(This,pPid) (This)->lpVtbl->GetProgramIdentifier(This,pPid)
@@ -97,9 +97,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMpeg2Data_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMpeg2Data_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMpeg2Data_Release(This) (This)->pVtbl->Release(This)
+#define IMpeg2Data_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMpeg2Data_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMpeg2Data_Release(This) (This)->lpVtbl->Release(This)
 #define IMpeg2Data_GetSection(This,pid,tid,pFilter,dwTimeout,ppSectionList) (This)->lpVtbl->GetSection(This,pid,tid,pFilter,dwTimeout,ppSectionList)
 #define IMpeg2Data_GetStreamOfSections(This,pid,tid,pFilter,hDataReadyEvent,ppMpegStream) (This)->lpVtbl->GetStreamOfSections(This,pid,tid,pFilter,hDataReadyEvent,ppMpegStream)
 #define IMpeg2Data_GetTable(This,pid,tid,pFilter,dwTimeout,ppSectionList) (This)->lpVtbl->GetTable(This,pid,tid,pFilter,dwTimeout,ppSectionList)
@@ -128,9 +128,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMpeg2Stream_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMpeg2Stream_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMpeg2Stream_Release(This) (This)->pVtbl->Release(This)
+#define IMpeg2Stream_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMpeg2Stream_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMpeg2Stream_Release(This) (This)->lpVtbl->Release(This)
 #define IMpeg2Stream_Initialize(This,requestType,pMpeg2Data,pContext,pid,tid,pFilter,hDataReadyEvent) (This)->lpVtbl->Initialize(This,requestType,pMpeg2Data,pContext,pid,tid,pFilter,hDataReadyEvent)
 #define IMpeg2Stream_SupplyDataBuffer(This,pStreamBuffer) (This)->lpVtbl->SupplyDataBuffer(This,pStreamBuffer)
 #endif /*COBJMACROS*/
diff --git a/mingw-w64-headers/include/mpeg2psiparser.h b/mingw-w64-headers/include/mpeg2psiparser.h
index 65808e8..28ee258 100644
--- a/mingw-w64-headers/include/mpeg2psiparser.h
+++ b/mingw-w64-headers/include/mpeg2psiparser.h
@@ -71,9 +71,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IPAT_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IPAT_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IPAT_Release(This) (This)->pVtbl->Release(This)
+#define IPAT_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IPAT_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IPAT_Release(This) (This)->lpVtbl->Release(This)
 #define IPAT_ConvertNextToCurrent() (This)->lpVtbl->ConvertNextToCurrent(This)
 #define IPAT_FindRecordProgramMapPid(This,wProgramNumber,pwVal) (This)->lpVtbl->FindRecordProgramMapPid(This,wProgramNumber,pwVal)
 #define IPAT_GetCountOfRecords(This,pdwVal) (This)->lpVtbl->GetCountOfRecords(This,pdwVal)
@@ -104,9 +104,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IPSITables_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IPSITables_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IPSITables_Release(This) (This)->pVtbl->Release(This)
+#define IPSITables_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IPSITables_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IPSITables_Release(This) (This)->lpVtbl->Release(This)
 #define IPSITables_GetTable(This,dwTSID,dwTID_PID,dwHashedVer,dwPara4,ppIUnknown) (This)->lpVtbl->GetTable(This,dwTSID,dwTID_PID,dwHashedVer,dwPara4,ppIUnknown)
 #endif /*COBJMACROS*/
 
@@ -150,9 +150,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IPMT_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IPMT_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IPMT_Release(This) (This)->pVtbl->Release(This)
+#define IPMT_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IPMT_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IPMT_Release(This) (This)->lpVtbl->Release(This)
 #define IPMT_ConvertNextToCurrent() (This)->lpVtbl->ConvertNextToCurrent(This)
 #define IPMT_GetCountOfRecords(This,pwVal) (This)->lpVtbl->GetCountOfRecords(This,pwVal)
 #define IPMT_GetCountOfTableDescriptors(This,pdwVal) (This)->lpVtbl->GetCountOfTableDescriptors(This,pdwVal)
@@ -199,9 +199,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IGenericDescriptor_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IGenericDescriptor_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IGenericDescriptor_Release(This) (This)->pVtbl->Release(This)
+#define IGenericDescriptor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IGenericDescriptor_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IGenericDescriptor_Release(This) (This)->lpVtbl->Release(This)
 #define IGenericDescriptor_GetBody(This,ppbVal) (This)->lpVtbl->GetBody(This,ppbVal)
 #define IGenericDescriptor_GetLength(This,pbVal) (This)->lpVtbl->GetLength(This,pbVal)
 #define IGenericDescriptor_GetTag(This,pbVal) (This)->lpVtbl->GetTag(This,pbVal)
@@ -238,9 +238,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define ITSDT_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define ITSDT_AddRef(This) (This)->pVtbl->AddRef(This)
-#define ITSDT_Release(This) (This)->pVtbl->Release(This)
+#define ITSDT_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITSDT_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITSDT_Release(This) (This)->lpVtbl->Release(This)
 #define ITSDT_ConvertNextToCurrent() (This)->lpVtbl->ConvertNextToCurrent(This)
 #define ITSDT_GetCountOfTableDescriptors(This,pdwVal) (This)->lpVtbl->GetCountOfTableDescriptors(This,pdwVal)
 #define ITSDT_GetNextTable(This,ppTSDT) (This)->lpVtbl->GetNextTable(This,ppTSDT)
@@ -277,9 +277,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define ICAT_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define ICAT_AddRef(This) (This)->pVtbl->AddRef(This)
-#define ICAT_Release(This) (This)->pVtbl->Release(This)
+#define ICAT_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ICAT_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ICAT_Release(This) (This)->lpVtbl->Release(This)
 #define ICAT_ConvertNextToCurrent() (This)->lpVtbl->ConvertNextToCurrent(This)
 #define ICAT_GetCountOfTableDescriptors(This,pdwVal) (This)->lpVtbl->GetCountOfTableDescriptors(This,pdwVal)
 #define ICAT_GetNextTable(This,dwTimeout,ppCAT) (This)->lpVtbl->GetNextTable(This,dwTimeout,ppCAT)
diff --git a/mingw-w64-headers/include/msrdc.h b/mingw-w64-headers/include/msrdc.h
index 0cc4f11..01f8e9b 100644
--- a/mingw-w64-headers/include/msrdc.h
+++ b/mingw-w64-headers/include/msrdc.h
@@ -124,9 +124,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IRdcFileWriter_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IRdcFileWriter_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IRdcFileWriter_Release(This) (This)->pVtbl->Release(This)
+#define IRdcFileWriter_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IRdcFileWriter_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IRdcFileWriter_Release(This) (This)->lpVtbl->Release(This)
 #define IRdcFileWriter_Write(This,offsetFileStart,bytesToWrite,buffer) (This)->lpVtbl->Write(This,offsetFileStart,bytesToWrite,buffer)
 #define IRdcFileWriter_Truncate() (This)->lpVtbl->Truncate(This)
 #define IRdcFileWriter_DeleteOnClose() (This)->lpVtbl->DeleteOnClose(This)
@@ -160,9 +160,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define ISimilarityFileIdTable_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define ISimilarityFileIdTable_AddRef(This) (This)->pVtbl->AddRef(This)
-#define ISimilarityFileIdTable_Release(This) (This)->pVtbl->Release(This)
+#define ISimilarityFileIdTable_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ISimilarityFileIdTable_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ISimilarityFileIdTable_Release(This) (This)->lpVtbl->Release(This)
 #define ISimilarityFileIdTable_CreateTable(This,path,truncate,securityDescriptor,recordSize,isNew) (This)->lpVtbl->CreateTable(This,path,truncate,securityDescriptor,recordSize,isNew)
 #define ISimilarityFileIdTable_CreateTableIndirect(This,fileIdFile,truncate,recordSize,isNew) (This)->lpVtbl->CreateTableIndirect(This,fileIdFile,truncate,recordSize,isNew)
 #define ISimilarityFileIdTable_CloseTable(This,isValid) (This)->lpVtbl->CloseTable(This,isValid)
@@ -197,9 +197,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define ISimilarityTraitsMappedView_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define ISimilarityTraitsMappedView_AddRef(This) (This)->pVtbl->AddRef(This)
-#define ISimilarityTraitsMappedView_Release(This) (This)->pVtbl->Release(This)
+#define ISimilarityTraitsMappedView_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ISimilarityTraitsMappedView_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ISimilarityTraitsMappedView_Release(This) (This)->lpVtbl->Release(This)
 #define ISimilarityTraitsMappedView_Flush() (This)->lpVtbl->Flush(This)
 #define ISimilarityTraitsMappedView_Unmap() (This)->lpVtbl->Unmap(This)
 #define ISimilarityTraitsMappedView_Get(This,fileOffset,dirty,numElements,viewInfo) (This)->lpVtbl->Get(This,fileOffset,dirty,numElements,viewInfo)
@@ -229,9 +229,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IFindSimilarResults_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IFindSimilarResults_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IFindSimilarResults_Release(This) (This)->pVtbl->Release(This)
+#define IFindSimilarResults_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IFindSimilarResults_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IFindSimilarResults_Release(This) (This)->lpVtbl->Release(This)
 #define IFindSimilarResults_GetSize(This,size) (This)->lpVtbl->GetSize(This,size)
 #define IFindSimilarResults_GetNextFileId(This,numTraitsMatched,similarityFileId) (This)->lpVtbl->GetNextFileId(This,numTraitsMatched,similarityFileId)
 #endif /*COBJMACROS*/
@@ -264,9 +264,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define ISimilarityTraitsMapping_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define ISimilarityTraitsMapping_AddRef(This) (This)->pVtbl->AddRef(This)
-#define ISimilarityTraitsMapping_Release(This) (This)->pVtbl->Release(This)
+#define ISimilarityTraitsMapping_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ISimilarityTraitsMapping_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ISimilarityTraitsMapping_Release(This) (This)->lpVtbl->Release(This)
 #define ISimilarityTraitsMapping_CloseMapping() (This)->lpVtbl->CloseMapping(This)
 #define ISimilarityTraitsMapping_SetFileSize(This,fileSize) (This)->lpVtbl->SetFileSize(This,fileSize)
 #define ISimilarityTraitsMapping_GetFileSize(This,fileSize) (This)->lpVtbl->GetFileSize(This,fileSize)
@@ -298,9 +298,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define ISimilarityReportProgress_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define ISimilarityReportProgress_AddRef(This) (This)->pVtbl->AddRef(This)
-#define ISimilarityReportProgress_Release(This) (This)->pVtbl->Release(This)
+#define ISimilarityReportProgress_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ISimilarityReportProgress_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ISimilarityReportProgress_Release(This) (This)->lpVtbl->Release(This)
 #define ISimilarityReportProgress_ReportProgress(This,percentCompleted) (This)->lpVtbl->ReportProgress(This,percentCompleted)
 #endif /*COBJMACROS*/
 
@@ -332,9 +332,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define ISimilarity_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define ISimilarity_AddRef(This) (This)->pVtbl->AddRef(This)
-#define ISimilarity_Release(This) (This)->pVtbl->Release(This)
+#define ISimilarity_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ISimilarity_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ISimilarity_Release(This) (This)->lpVtbl->Release(This)
 #define ISimilarity_CreateTable(This,path,truncate,securityDescriptor,recordSize,isNew) (This)->lpVtbl->CreateTable(This,path,truncate,securityDescriptor,recordSize,isNew)
 #define ISimilarity_CreateTableIndirect(This,mapping,fileIdFile,truncate,recordSize,isNew) (This)->lpVtbl->CreateTableIndirect(This,mapping,fileIdFile,truncate,recordSize,isNew)
 #define ISimilarity_CloseTable(This,isValid) (This)->lpVtbl->CloseTable(This,isValid)
diff --git a/mingw-w64-headers/include/ndhelper.h b/mingw-w64-headers/include/ndhelper.h
index 9171cae..b79f083 100644
--- a/mingw-w64-headers/include/ndhelper.h
+++ b/mingw-w64-headers/include/ndhelper.h
@@ -56,9 +56,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define INetDiagHelperInfo_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define INetDiagHelperInfo_AddRef(This) (This)->pVtbl->AddRef(This)
-#define INetDiagHelperInfo_Release(This) (This)->pVtbl->Release(This)
+#define INetDiagHelperInfo_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define INetDiagHelperInfo_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define INetDiagHelperInfo_Release(This) (This)->lpVtbl->Release(This)
 #define INetDiagHelperInfo_GetAttributeInfo(This,pcelt,pprgAttributeInfos) (This)->lpVtbl->GetAttributeInfo(This,pcelt,pprgAttributeInfos)
 #endif /*COBJMACROS*/
 
@@ -96,9 +96,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define INetDiagHelper_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define INetDiagHelper_AddRef(This) (This)->pVtbl->AddRef(This)
-#define INetDiagHelper_Release(This) (This)->pVtbl->Release(This)
+#define INetDiagHelper_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define INetDiagHelper_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define INetDiagHelper_Release(This) (This)->lpVtbl->Release(This)
 #define INetDiagHelper_Cancel() (This)->lpVtbl->Cancel(This)
 #define INetDiagHelper_Cleanup() (This)->lpVtbl->Cleanup(This)
 #define INetDiagHelper_GetAttributes(This,pcelt,pprgAttributes) (This)->lpVtbl->GetAttributes(This,pcelt,pprgAttributes)
@@ -147,9 +147,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define INetDiagHelperUtilFactory_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define INetDiagHelperUtilFactory_AddRef(This) (This)->pVtbl->AddRef(This)
-#define INetDiagHelperUtilFactory_Release(This) (This)->pVtbl->Release(This)
+#define INetDiagHelperUtilFactory_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define INetDiagHelperUtilFactory_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define INetDiagHelperUtilFactory_Release(This) (This)->lpVtbl->Release(This)
 #define INetDiagHelperUtilFactory_CreateUtilityInstance(This,riid,ppvObject) (This)->lpVtbl->CreateUtilityInstance(This,riid,ppvObject)
 #endif /*COBJMACROS*/
 
@@ -177,9 +177,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define INetDiagHelperEx_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define INetDiagHelperEx_AddRef(This) (This)->pVtbl->AddRef(This)
-#define INetDiagHelperEx_Release(This) (This)->pVtbl->Release(This)
+#define INetDiagHelperEx_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define INetDiagHelperEx_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define INetDiagHelperEx_Release(This) (This)->lpVtbl->Release(This)
 #define INetDiagHelperEx_ReconfirmLowHealth(This,celt,pResults,ppwszUpdatedDescription,pUpdatedStatus) (This)->lpVtbl->ReconfirmLowHealth(This,celt,pResults,ppwszUpdatedDescription,pUpdatedStatus)
 #define INetDiagHelperEx_ReproduceFailure() (This)->lpVtbl->ReproduceFailure(This)
 #define INetDiagHelperEx_SetUtilities(This,pUtilities) (This)->lpVtbl->SetUtilities(This,pUtilities)
diff --git a/mingw-w64-headers/include/opmapi.h b/mingw-w64-headers/include/opmapi.h
index d6f5a4a..2081357 100644
--- a/mingw-w64-headers/include/opmapi.h
+++ b/mingw-w64-headers/include/opmapi.h
@@ -234,9 +234,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IOPMVideoOutput_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IOPMVideoOutput_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IOPMVideoOutput_Release(This) (This)->pVtbl->Release(This)
+#define IOPMVideoOutput_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IOPMVideoOutput_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IOPMVideoOutput_Release(This) (This)->lpVtbl->Release(This)
 #define IOPMVideoOutput_Configure(This,pParameters,ulAdditionalParametersSize,pbAdditionalParameters) (This)->lpVtbl->Configure(This,pParameters,ulAdditionalParametersSize,pbAdditionalParameters)
 #define IOPMVideoOutput_COPPCompatibleGetInformation(This,pParameters,pRequestedInformation) (This)->lpVtbl->COPPCompatibleGetInformation(This,pParameters,pRequestedInformation)
 #define IOPMVideoOutput_FinishInitialization(This,pParameters) (This)->lpVtbl->FinishInitialization(This,pParameters)
diff --git a/mingw-w64-headers/include/portabledeviceconnectapi.h b/mingw-w64-headers/include/portabledeviceconnectapi.h
index 7128b47..8118853 100644
--- a/mingw-w64-headers/include/portabledeviceconnectapi.h
+++ b/mingw-w64-headers/include/portabledeviceconnectapi.h
@@ -32,9 +32,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IConnectionRequestCallback_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IConnectionRequestCallback_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IConnectionRequestCallback_Release(This) (This)->pVtbl->Release(This)
+#define IConnectionRequestCallback_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IConnectionRequestCallback_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IConnectionRequestCallback_Release(This) (This)->lpVtbl->Release(This)
 #define IConnectionRequestCallback_OnComplete(This,hrStatus) (This)->lpVtbl->OnComplete(This,hrStatus)
 #endif /*COBJMACROS*/
 
diff --git a/mingw-w64-headers/include/rdpencomapi.h b/mingw-w64-headers/include/rdpencomapi.h
index f01de89..922880d 100644
--- a/mingw-w64-headers/include/rdpencomapi.h
+++ b/mingw-w64-headers/include/rdpencomapi.h
@@ -102,9 +102,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IRDPSRAPITcpConnectionInfo_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IRDPSRAPITcpConnectionInfo_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IRDPSRAPITcpConnectionInfo_Release(This) (This)->pVtbl->Release(This)
+#define IRDPSRAPITcpConnectionInfo_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IRDPSRAPITcpConnectionInfo_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IRDPSRAPITcpConnectionInfo_Release(This) (This)->lpVtbl->Release(This)
 #define IRDPSRAPITcpConnectionInfo_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IRDPSRAPITcpConnectionInfo_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IRDPSRAPITcpConnectionInfo_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -151,9 +151,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IRDPSRAPIAttendee_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IRDPSRAPIAttendee_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IRDPSRAPIAttendee_Release(This) (This)->pVtbl->Release(This)
+#define IRDPSRAPIAttendee_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IRDPSRAPIAttendee_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IRDPSRAPIAttendee_Release(This) (This)->lpVtbl->Release(This)
 #define IRDPSRAPIAttendee_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IRDPSRAPIAttendee_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IRDPSRAPIAttendee_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
diff --git a/mingw-w64-headers/include/strmif.h b/mingw-w64-headers/include/strmif.h
index 0f5a645..7eefde6 100644
--- a/mingw-w64-headers/include/strmif.h
+++ b/mingw-w64-headers/include/strmif.h
@@ -9416,9 +9416,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IAMAsyncReaderTimestampScaling_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IAMAsyncReaderTimestampScaling_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IAMAsyncReaderTimestampScaling_Release(This) (This)->pVtbl->Release(This)
+#define IAMAsyncReaderTimestampScaling_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IAMAsyncReaderTimestampScaling_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IAMAsyncReaderTimestampScaling_Release(This) (This)->lpVtbl->Release(This)
 #define IAMAsyncReaderTimestampScaling_GetTimestampMode(This,pfRaw) (This)->lpVtbl->GetTimestampMode(This,pfRaw)
 #define IAMAsyncReaderTimestampScaling_SetTimestampMode(This,fRaw) (This)->lpVtbl->SetTimestampMode(This,fRaw)
 #endif /*COBJMACROS*/
@@ -9451,9 +9451,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IAMPluginControl_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IAMPluginControl_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IAMPluginControl_Release(This) (This)->pVtbl->Release(This)
+#define IAMPluginControl_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IAMPluginControl_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IAMPluginControl_Release(This) (This)->lpVtbl->Release(This)
 #define IAMPluginControl_GetDisabledByIndex(This,index,clsid) (This)->lpVtbl->GetDisabledByIndex(This,index,clsid)
 #define IAMPluginControl_GetPreferredClsid(This,subType,clsid) (This)->lpVtbl->GetPreferredClsid(This,subType,clsid)
 #define IAMPluginControl_GetPreferredClsidByIndex(This,index,subType,clsid) (This)->lpVtbl->GetPreferredClsidByIndex(This,index,subType,clsid)
diff --git a/mingw-w64-headers/include/tuner.h b/mingw-w64-headers/include/tuner.h
index 93cda7c..03dece0 100644
--- a/mingw-w64-headers/include/tuner.h
+++ b/mingw-w64-headers/include/tuner.h
@@ -113,9 +113,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IBDACreateTuneRequestEx_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IBDACreateTuneRequestEx_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IBDACreateTuneRequestEx_Release(This) (This)->pVtbl->Release(This)
+#define IBDACreateTuneRequestEx_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IBDACreateTuneRequestEx_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IBDACreateTuneRequestEx_Release(This) (This)->lpVtbl->Release(This)
 #define IBDACreateTuneRequestEx_CreateTuneRequestEx(This,TuneRequestIID,ppTuneRequest) (This)->lpVtbl->CreateTuneRequestEx(This,TuneRequestIID,ppTuneRequest)
 #endif /*COBJMACROS*/
 
@@ -151,9 +151,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define ITuneRequest_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define ITuneRequest_AddRef(This) (This)->pVtbl->AddRef(This)
-#define ITuneRequest_Release(This) (This)->pVtbl->Release(This)
+#define ITuneRequest_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITuneRequest_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITuneRequest_Release(This) (This)->lpVtbl->Release(This)
 #define ITuneRequest_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define ITuneRequest_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define ITuneRequest_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -188,9 +188,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IChannelIDTuneRequest_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IChannelIDTuneRequest_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IChannelIDTuneRequest_Release(This) (This)->pVtbl->Release(This)
+#define IChannelIDTuneRequest_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IChannelIDTuneRequest_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IChannelIDTuneRequest_Release(This) (This)->lpVtbl->Release(This)
 #define IChannelIDTuneRequest_put_ChannelID(This,ChannelID) (This)->lpVtbl->put_ChannelID(This,ChannelID)
 #define IChannelIDTuneRequest_get_ChannelID(This,ChannelID) (This)->lpVtbl->get_ChannelID(This,ChannelID)
 #endif /*COBJMACROS*/
@@ -237,9 +237,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define ILocator_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define ILocator_AddRef(This) (This)->pVtbl->AddRef(This)
-#define ILocator_Release(This) (This)->pVtbl->Release(This)
+#define ILocator_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ILocator_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ILocator_Release(This) (This)->lpVtbl->Release(This)
 #define ILocator_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define ILocator_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define ILocator_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -305,9 +305,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDigitalLocator_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDigitalLocator_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDigitalLocator_Release(This) (This)->pVtbl->Release(This)
+#define IDigitalLocator_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDigitalLocator_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDigitalLocator_Release(This) (This)->lpVtbl->Release(This)
 #define IDigitalLocator_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IDigitalLocator_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IDigitalLocator_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -385,9 +385,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDVBSLocator_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDVBSLocator_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDVBSLocator_Release(This) (This)->pVtbl->Release(This)
+#define IDVBSLocator_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDVBSLocator_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDVBSLocator_Release(This) (This)->lpVtbl->Release(This)
 #define IDVBSLocator_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IDVBSLocator_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IDVBSLocator_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -493,9 +493,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDVBSLocator2_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDVBSLocator2_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDVBSLocator2_Release(This) (This)->pVtbl->Release(This)
+#define IDVBSLocator2_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDVBSLocator2_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDVBSLocator2_Release(This) (This)->lpVtbl->Release(This)
 #define IDVBSLocator2_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IDVBSLocator2_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IDVBSLocator2_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -603,9 +603,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDVBTLocator_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDVBTLocator_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDVBTLocator_Release(This) (This)->pVtbl->Release(This)
+#define IDVBTLocator_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDVBTLocator_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDVBTLocator_Release(This) (This)->lpVtbl->Release(This)
 #define IDVBTLocator_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IDVBTLocator_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IDVBTLocator_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -705,9 +705,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDVBTLocator2_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDVBTLocator2_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDVBTLocator2_Release(This) (This)->pVtbl->Release(This)
+#define IDVBTLocator2_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDVBTLocator2_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDVBTLocator2_Release(This) (This)->lpVtbl->Release(This)
 #define IDVBTLocator2_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IDVBTLocator2_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IDVBTLocator2_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -780,9 +780,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IComponents_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IComponents_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IComponents_Release(This) (This)->pVtbl->Release(This)
+#define IComponents_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IComponents_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IComponents_Release(This) (This)->lpVtbl->Release(This)
 #define IComponents_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IComponents_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IComponents_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -821,9 +821,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IEnumComponents_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IEnumComponents_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IEnumComponents_Release(This) (This)->pVtbl->Release(This)
+#define IEnumComponents_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IEnumComponents_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IEnumComponents_Release(This) (This)->lpVtbl->Release(This)
 #define IEnumComponents_Clone(This,ppEnum) (This)->lpVtbl->Clone(This,ppEnum)
 #define IEnumComponents_Next(This,celt,pprgelt,pceltFetched) (This)->lpVtbl->Next(This,celt,pprgelt,pceltFetched)
 #define IEnumComponents_Reset() (This)->lpVtbl->Reset(This)
@@ -866,9 +866,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IComponent_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IComponent_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IComponent_Release(This) (This)->pVtbl->Release(This)
+#define IComponent_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IComponent_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IComponent_Release(This) (This)->lpVtbl->Release(This)
 #define IComponent_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IComponent_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IComponent_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -928,9 +928,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMPEG2Component_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMPEG2Component_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMPEG2Component_Release(This) (This)->pVtbl->Release(This)
+#define IMPEG2Component_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMPEG2Component_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMPEG2Component_Release(This) (This)->lpVtbl->Release(This)
 #define IMPEG2Component_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IMPEG2Component_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IMPEG2Component_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -998,9 +998,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define ITuningSpace_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define ITuningSpace_AddRef(This) (This)->pVtbl->AddRef(This)
-#define ITuningSpace_Release(This) (This)->pVtbl->Release(This)
+#define ITuningSpace_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITuningSpace_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITuningSpace_Release(This) (This)->lpVtbl->Release(This)
 #define ITuningSpace_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define ITuningSpace_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define ITuningSpace_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -1060,9 +1060,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IComponentTypes_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IComponentTypes_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IComponentTypes_Release(This) (This)->pVtbl->Release(This)
+#define IComponentTypes_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IComponentTypes_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IComponentTypes_Release(This) (This)->lpVtbl->Release(This)
 #define IComponentTypes_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IComponentTypes_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IComponentTypes_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -1121,9 +1121,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IComponentType_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IComponentType_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IComponentType_Release(This) (This)->pVtbl->Release(This)
+#define IComponentType_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IComponentType_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IComponentType_Release(This) (This)->lpVtbl->Release(This)
 #define IComponentType_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo)
 #define IComponentType_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo)
 #define IComponentType_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
@@ -1172,13 +1172,13 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IEnumComponentTypes_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IEnumComponentTypes_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IEnumComponentTypes_Release(This) (This)->pVtbl->Release(This)
+#define IEnumComponentTypes_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IEnumComponentTypes_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IEnumComponentTypes_Release(This) (This)->lpVtbl->Release(This)
 #define IEnumComponentTypes_Clone(This,ppEnum) (This)->lpVtbl->Clone(This,ppEnum)
 #define IEnumComponentTypes_Next(This,celt,pprgelt,pceltFetched) (This)->lpVtbl->Next(This,celt,pprgelt,pceltFetched)
 #define IEnumComponentTypes_Reset() (This)->lpVtbl->Reset(This)
 #define IEnumComponentTypes_Skip(This,celt) (This)->lpVtbl->Skip(This,celt)
 #endif /*COBJMACROS*/
 
-#endif /*__INC_TUNER__*/
\ No newline at end of file
+#endif /*__INC_TUNER__*/
diff --git a/mingw-w64-headers/include/vsadmin.h b/mingw-w64-headers/include/vsadmin.h
index 24b19f1..d7e51d4 100644
--- a/mingw-w64-headers/include/vsadmin.h
+++ b/mingw-w64-headers/include/vsadmin.h
@@ -33,9 +33,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IVssAdmin_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IVssAdmin_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IVssAdmin_Release(This) (This)->pVtbl->Release(This)
+#define IVssAdmin_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IVssAdmin_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IVssAdmin_Release(This) (This)->lpVtbl->Release(This)
 #define IVssAdmin_RegisterProvider(This,pProviderId,ClassId,pwszProviderName,eProviderType,pwszProviderVersion,ProviderVersionId) (This)->lpVtbl->RegisterProvider(This,pProviderId,ClassId,pwszProviderName,eProviderType,pwszProviderVersion,ProviderVersionId)
 #define IVssAdmin_UnregisterProvider(This,ProviderId) (This)->lpVtbl->UnregisterProvider(This,ProviderId)
 #define IVssAdmin_QueryProviders(This,ppEnum) (This)->lpVtbl->QueryProviders(This,ppEnum)
diff --git a/mingw-w64-headers/include/vsbackup.h b/mingw-w64-headers/include/vsbackup.h
index da86ee2..6806c37 100644
--- a/mingw-w64-headers/include/vsbackup.h
+++ b/mingw-w64-headers/include/vsbackup.h
@@ -169,9 +169,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IVssBackupComponents_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IVssBackupComponents_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IVssBackupComponents_Release(This) (This)->pVtbl->Release(This)
+#define IVssBackupComponents_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IVssBackupComponents_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IVssBackupComponents_Release(This) (This)->lpVtbl->Release(This)
 #define IVssBackupComponents_GetWriterComponentsCount(This,pcComponents) (This)->lpVtbl->GetWriterComponentsCount(This,pcComponents)
 #define IVssBackupComponents_GetWriterComponents(This,iWriter,pWriterComponents) (This)->lpVtbl->GetWriterComponents(This,iWriter,pWriterComponents)
 #define IVssBackupComponents_InitializeForBackup(This,bstrXML) (This)->lpVtbl->InitializeForBackup(This,bstrXML)
@@ -294,9 +294,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IVssBackupComponentsEx_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IVssBackupComponentsEx_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IVssBackupComponentsEx_Release(This) (This)->pVtbl->Release(This)
+#define IVssBackupComponentsEx_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IVssBackupComponentsEx_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IVssBackupComponentsEx_Release(This) (This)->lpVtbl->Release(This)
 #define IVssBackupComponentsEx_GetWriterComponentsCount(This,pcComponents) (This)->lpVtbl->GetWriterComponentsCount(This,pcComponents)
 #define IVssBackupComponentsEx_GetWriterComponents(This,iWriter,pWriterComponents) (This)->lpVtbl->GetWriterComponents(This,iWriter,pWriterComponents)
 #define IVssBackupComponentsEx_InitializeForBackup(This,bstrXML) (This)->lpVtbl->InitializeForBackup(This,bstrXML)
@@ -429,9 +429,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IVssBackupComponentsEx2_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IVssBackupComponentsEx2_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IVssBackupComponentsEx2_Release(This) (This)->pVtbl->Release(This)
+#define IVssBackupComponentsEx2_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IVssBackupComponentsEx2_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IVssBackupComponentsEx2_Release(This) (This)->lpVtbl->Release(This)
 #define IVssBackupComponentsEx2_GetWriterComponentsCount(This,pcComponents) (This)->lpVtbl->GetWriterComponentsCount(This,pcComponents)
 #define IVssBackupComponentsEx2_GetWriterComponents(This,iWriter,pWriterComponents) (This)->lpVtbl->GetWriterComponents(This,iWriter,pWriterComponents)
 #define IVssBackupComponentsEx2_InitializeForBackup(This,bstrXML) (This)->lpVtbl->InitializeForBackup(This,bstrXML)
@@ -579,9 +579,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IVssBackupComponentsEx3_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IVssBackupComponentsEx3_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IVssBackupComponentsEx3_Release(This) (This)->pVtbl->Release(This)
+#define IVssBackupComponentsEx3_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IVssBackupComponentsEx3_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IVssBackupComponentsEx3_Release(This) (This)->lpVtbl->Release(This)
 #define IVssBackupComponentsEx3_AddSnapshotToRecoverySet(This,snapshotId,dwFlags,pwszDestinationVolume) (This)->lpVtbl->AddSnapshotToRecoverySet(This,snapshotId,dwFlags,pwszDestinationVolume)
 #define IVssBackupComponentsEx3_GetSessionId(This,idSession) (This)->lpVtbl->GetSessionId(This,idSession)
 #define IVssBackupComponentsEx3_GetWriterStatusEx(This,iWriter,pidInstance,pidWriter,pbstrWriter,pnStatus,phrFailureWriter,pbstrApplicationMessage) (This)->lpVtbl->GetWriterStatusEx(This,iWriter,pidInstance,pidWriter,pbstrWriter,pnStatus,phrFailureWriter,pbstrApplicationMessage)
diff --git a/mingw-w64-headers/include/vsmgmt.h b/mingw-w64-headers/include/vsmgmt.h
index c08f67a..446c7f8 100644
--- a/mingw-w64-headers/include/vsmgmt.h
+++ b/mingw-w64-headers/include/vsmgmt.h
@@ -120,9 +120,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IVssDifferentialSoftwareSnapshotMgmt_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IVssDifferentialSoftwareSnapshotMgmt_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IVssDifferentialSoftwareSnapshotMgmt_Release(This) (This)->pVtbl->Release(This)
+#define IVssDifferentialSoftwareSnapshotMgmt_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IVssDifferentialSoftwareSnapshotMgmt_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IVssDifferentialSoftwareSnapshotMgmt_Release(This) (This)->lpVtbl->Release(This)
 #define IVssDifferentialSoftwareSnapshotMgmt_AddDiffArea(This,pwszVolumeName,pwszDiffAreaVolumeName,llMaximumDiffSpace) (This)->lpVtbl->AddDiffArea(This,pwszVolumeName,pwszDiffAreaVolumeName,llMaximumDiffSpace)
 #define IVssDifferentialSoftwareSnapshotMgmt_ChangeDiffAreaMaximumSize(This,pwszVolumeName,pwszDiffAreaVolumeName,llMaximumDiffSpace) (This)->lpVtbl->ChangeDiffAreaMaximumSize(This,pwszVolumeName,pwszDiffAreaVolumeName,llMaximumDiffSpace)
 #define IVssDifferentialSoftwareSnapshotMgmt_QueryVolumesSupportedForDiffAreas(This,pwszOriginalVolumeName,ppEnum) (This)->lpVtbl->QueryVolumesSupportedForDiffAreas(This,pwszOriginalVolumeName,ppEnum)
@@ -166,9 +166,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IVssDifferentialSoftwareSnapshotMgmt2_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IVssDifferentialSoftwareSnapshotMgmt2_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IVssDifferentialSoftwareSnapshotMgmt2_Release(This) (This)->pVtbl->Release(This)
+#define IVssDifferentialSoftwareSnapshotMgmt2_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IVssDifferentialSoftwareSnapshotMgmt2_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IVssDifferentialSoftwareSnapshotMgmt2_Release(This) (This)->lpVtbl->Release(This)
 #define IVssDifferentialSoftwareSnapshotMgmt2_AddDiffArea(This,pwszVolumeName,pwszDiffAreaVolumeName,llMaximumDiffSpace) (This)->lpVtbl->AddDiffArea(This,pwszVolumeName,pwszDiffAreaVolumeName,llMaximumDiffSpace)
 #define IVssDifferentialSoftwareSnapshotMgmt2_ChangeDiffAreaMaximumSize(This,pwszVolumeName,pwszDiffAreaVolumeName,llMaximumDiffSpace) (This)->lpVtbl->ChangeDiffAreaMaximumSize(This,pwszVolumeName,pwszDiffAreaVolumeName,llMaximumDiffSpace)
 #define IVssDifferentialSoftwareSnapshotMgmt2_QueryVolumesSupportedForDiffAreas(This,pwszOriginalVolumeName,ppEnum) (This)->lpVtbl->QueryVolumesSupportedForDiffAreas(This,pwszOriginalVolumeName,ppEnum)
@@ -221,9 +221,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IVssDifferentialSoftwareSnapshotMgmt3_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IVssDifferentialSoftwareSnapshotMgmt3_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IVssDifferentialSoftwareSnapshotMgmt3_Release(This) (This)->pVtbl->Release(This)
+#define IVssDifferentialSoftwareSnapshotMgmt3_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IVssDifferentialSoftwareSnapshotMgmt3_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IVssDifferentialSoftwareSnapshotMgmt3_Release(This) (This)->lpVtbl->Release(This)
 #define IVssDifferentialSoftwareSnapshotMgmt3_AddDiffArea(This,pwszVolumeName,pwszDiffAreaVolumeName,llMaximumDiffSpace) (This)->lpVtbl->AddDiffArea(This,pwszVolumeName,pwszDiffAreaVolumeName,llMaximumDiffSpace)
 #define IVssDifferentialSoftwareSnapshotMgmt3_ChangeDiffAreaMaximumSize(This,pwszVolumeName,pwszDiffAreaVolumeName,llMaximumDiffSpace) (This)->lpVtbl->ChangeDiffAreaMaximumSize(This,pwszVolumeName,pwszDiffAreaVolumeName,llMaximumDiffSpace)
 #define IVssDifferentialSoftwareSnapshotMgmt3_QueryVolumesSupportedForDiffAreas(This,pwszOriginalVolumeName,ppEnum) (This)->lpVtbl->QueryVolumesSupportedForDiffAreas(This,pwszOriginalVolumeName,ppEnum)
@@ -267,9 +267,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IVssEnumMgmtObject_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IVssEnumMgmtObject_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IVssEnumMgmtObject_Release(This) (This)->pVtbl->Release(This)
+#define IVssEnumMgmtObject_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IVssEnumMgmtObject_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IVssEnumMgmtObject_Release(This) (This)->lpVtbl->Release(This)
 #define IVssEnumMgmtObject_Next(This,celt,rgelt,pceltFetched) (This)->lpVtbl->Next(This,celt,rgelt,pceltFetched)
 #define IVssEnumMgmtObject_Skip(This,celt) (This)->lpVtbl->Skip(This,celt)
 #define IVssEnumMgmtObject_Reset() (This)->lpVtbl->Reset(This)
@@ -303,9 +303,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IVssSnapshotMgmt_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IVssSnapshotMgmt_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IVssSnapshotMgmt_Release(This) (This)->pVtbl->Release(This)
+#define IVssSnapshotMgmt_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IVssSnapshotMgmt_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IVssSnapshotMgmt_Release(This) (This)->lpVtbl->Release(This)
 #define IVssSnapshotMgmt_GetProviderMgmtInterface(This,ProviderId,InterfaceId,ppItf) (This)->lpVtbl->GetProviderMgmtInterface(This,ProviderId,InterfaceId,ppItf)
 #define IVssSnapshotMgmt_QueryVolumesSupportedForSnapshots() (This)->lpVtbl->QueryVolumesSupportedForSnapshots(This)
 #define IVssSnapshotMgmt_QuerySnapshotsByVolume() (This)->lpVtbl->QuerySnapshotsByVolume(This)
@@ -328,9 +328,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IVssSnapshotMgmt2_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IVssSnapshotMgmt2_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IVssSnapshotMgmt2_Release(This) (This)->pVtbl->Release(This)
+#define IVssSnapshotMgmt2_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IVssSnapshotMgmt2_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IVssSnapshotMgmt2_Release(This) (This)->lpVtbl->Release(This)
 #define IVssSnapshotMgmt2_GetMinDiffAreaSize(This,pllMinDiffAreaSize) (This)->lpVtbl->GetMinDiffAreaSize(This,pllMinDiffAreaSize)
 #endif /*COBJMACROS*/
 
diff --git a/mingw-w64-headers/include/vsprov.h b/mingw-w64-headers/include/vsprov.h
index 1acd5aa..b58848a 100644
--- a/mingw-w64-headers/include/vsprov.h
+++ b/mingw-w64-headers/include/vsprov.h
@@ -35,9 +35,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IVssHardwareSnapshotProvider_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IVssHardwareSnapshotProvider_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IVssHardwareSnapshotProvider_Release(This) (This)->pVtbl->Release(This)
+#define IVssHardwareSnapshotProvider_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IVssHardwareSnapshotProvider_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IVssHardwareSnapshotProvider_Release(This) (This)->lpVtbl->Release(This)
 #define IVssHardwareSnapshotProvider_AreLunsSupported(This,lLunCount,lContext,rgwszDevices,pLunInformation,pbIsSupported) (This)->lpVtbl->AreLunsSupported(This,lLunCount,lContext,rgwszDevices,pLunInformation,pbIsSupported)
 #define IVssHardwareSnapshotProvider_FillInLunInfo(This,wszDeviceName,pLunInfo,pbIsSupported) (This)->lpVtbl->FillInLunInfo(This,wszDeviceName,pLunInfo,pbIsSupported)
 #define IVssHardwareSnapshotProvider_BeginPrepareSnapshot(This,SnapshotSetId,SnapshotId,lContext,lLunCount,rgDeviceNames,rgLunInformation) (This)->lpVtbl->BeginPrepareSnapshot(This,SnapshotSetId,SnapshotId,lContext,lLunCount,rgDeviceNames,rgLunInformation)
@@ -79,9 +79,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IVssHardwareSnapshotProviderEx_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IVssHardwareSnapshotProviderEx_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IVssHardwareSnapshotProviderEx_Release(This) (This)->pVtbl->Release(This)
+#define IVssHardwareSnapshotProviderEx_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IVssHardwareSnapshotProviderEx_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IVssHardwareSnapshotProviderEx_Release(This) (This)->lpVtbl->Release(This)
 #define IVssHardwareSnapshotProviderEx_AreLunsSupported(This,lLunCount,lContext,rgwszDevices,pLunInformation,pbIsSupported) (This)->lpVtbl->AreLunsSupported(This,lLunCount,lContext,rgwszDevices,pLunInformation,pbIsSupported)
 #define IVssHardwareSnapshotProviderEx_FillInLunInfo(This,wszDeviceName,pLunInfo,pbIsSupported) (This)->lpVtbl->FillInLunInfo(This,wszDeviceName,pLunInfo,pbIsSupported)
 #define IVssHardwareSnapshotProviderEx_BeginPrepareSnapshot(This,SnapshotSetId,SnapshotId,lContext,lLunCount,rgDeviceNames,rgLunInformation) (This)->lpVtbl->BeginPrepareSnapshot(This,SnapshotSetId,SnapshotId,lContext,lLunCount,rgDeviceNames,rgLunInformation)
@@ -122,9 +122,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IVssProviderCreateSnapshotSet_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IVssProviderCreateSnapshotSet_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IVssProviderCreateSnapshotSet_Release(This) (This)->pVtbl->Release(This)
+#define IVssProviderCreateSnapshotSet_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IVssProviderCreateSnapshotSet_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IVssProviderCreateSnapshotSet_Release(This) (This)->lpVtbl->Release(This)
 #define IVssProviderCreateSnapshotSet_EndPrepareSnapshots(This,SnapshotSetId) (This)->lpVtbl->EndPrepareSnapshots(This,SnapshotSetId)
 #define IVssProviderCreateSnapshotSet_PreCommitSnapshots(This,SnapshotSetId) (This)->lpVtbl->PreCommitSnapshots(This,SnapshotSetId)
 #define IVssProviderCreateSnapshotSet_CommitSnapshots(This,SnapshotSetId) (This)->lpVtbl->CommitSnapshots(This,SnapshotSetId)
@@ -152,9 +152,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IVssProviderNotifications_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IVssProviderNotifications_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IVssProviderNotifications_Release(This) (This)->pVtbl->Release(This)
+#define IVssProviderNotifications_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IVssProviderNotifications_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IVssProviderNotifications_Release(This) (This)->lpVtbl->Release(This)
 #define IVssProviderNotifications_OnLoad(This,pCallback) (This)->lpVtbl->OnLoad(This,pCallback)
 #define IVssProviderNotifications_OnUnload(This,bForceUnload) (This)->lpVtbl->OnUnload(This,bForceUnload)
 #endif /*COBJMACROS*/
@@ -190,9 +190,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IVssSoftwareSnapshotProvider_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IVssSoftwareSnapshotProvider_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IVssSoftwareSnapshotProvider_Release(This) (This)->pVtbl->Release(This)
+#define IVssSoftwareSnapshotProvider_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IVssSoftwareSnapshotProvider_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IVssSoftwareSnapshotProvider_Release(This) (This)->lpVtbl->Release(This)
 #define IVssSoftwareSnapshotProvider_SetContext(This,lContext) (This)->lpVtbl->SetContext(This,lContext)
 #define IVssSoftwareSnapshotProvider_GetSnapshotProperties(This,SnapshotId,pProp) (This)->lpVtbl->GetSnapshotProperties(This,SnapshotId,pProp)
 #define IVssSoftwareSnapshotProvider_Query(This,QueriedObjectId,eQueriedObjectType,eReturnedObjectsType,ppEnum) (This)->lpVtbl->Query(This,QueriedObjectId,eQueriedObjectType,eReturnedObjectsType,ppEnum)
diff --git a/mingw-w64-headers/include/vss.h b/mingw-w64-headers/include/vss.h
index a39dce4..44ebaed 100644
--- a/mingw-w64-headers/include/vss.h
+++ b/mingw-w64-headers/include/vss.h
@@ -440,9 +440,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IVssAsync_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IVssAsync_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IVssAsync_Release(This) (This)->pVtbl->Release(This)
+#define IVssAsync_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IVssAsync_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IVssAsync_Release(This) (This)->lpVtbl->Release(This)
 #define IVssAsync_Cancel() (This)->lpVtbl->Cancel(This)
 #define IVssAsync_Wait(This,dwMilliseconds) (This)->lpVtbl->Wait(This,dwMilliseconds)
 #define IVssAsync_QueryStatus(This,pHrResult,pReserved) (This)->lpVtbl->QueryStatus(This,pHrResult,pReserved)
@@ -474,9 +474,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IVssEnumObject_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IVssEnumObject_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IVssEnumObject_Release(This) (This)->pVtbl->Release(This)
+#define IVssEnumObject_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IVssEnumObject_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IVssEnumObject_Release(This) (This)->lpVtbl->Release(This)
 #define IVssEnumObject_Next(This,celt,rgelt,pceltFetched) (This)->lpVtbl->Next(This,celt,rgelt,pceltFetched)
 #define IVssEnumObject_Skip(This,celt) (This)->lpVtbl->Skip(This,celt)
 #define IVssEnumObject_Reset() (This)->lpVtbl->Reset(This)
diff --git a/mingw-w64-headers/include/vswriter.h b/mingw-w64-headers/include/vswriter.h
index ddd7fa0..18158cf 100644
--- a/mingw-w64-headers/include/vswriter.h
+++ b/mingw-w64-headers/include/vswriter.h
@@ -122,9 +122,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IVssCreateExpressWriterMetadata_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IVssCreateExpressWriterMetadata_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IVssCreateExpressWriterMetadata_Release(This) (This)->pVtbl->Release(This)
+#define IVssCreateExpressWriterMetadata_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IVssCreateExpressWriterMetadata_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IVssCreateExpressWriterMetadata_Release(This) (This)->lpVtbl->Release(This)
 #define IVssCreateExpressWriterMetadata_AddComponent(This,componentType,wszLogicalPath,wszComponentName,wszCaption,pbIcon,cbIcon,bRestoreMetadata,bNotifyOnBackupComplete,bSelectable,bSelectableForRestore,dwComponentFlags) (This)->lpVtbl->AddComponent(This,componentType,wszLogicalPath,wszComponentName,wszCaption,pbIcon,cbIcon,bRestoreMetadata,bNotifyOnBackupComplete,bSelectable,bSelectableForRestore,dwComponentFlags)
 #define IVssCreateExpressWriterMetadata_AddFilesToFileGroup(This,wszLogicalPath,wszGroupName,wszPath,wszFilespec,bRecursive,wszAlternateLocation,dwBackupTypeMask) (This)->lpVtbl->AddFilesToFileGroup(This,wszLogicalPath,wszGroupName,wszPath,wszFilespec,bRecursive,wszAlternateLocation,dwBackupTypeMask)
 #define IVssCreateExpressWriterMetadata_SaveAsXML(This,pbstrXML) (This)->lpVtbl->SaveAsXML(This,pbstrXML)
@@ -229,9 +229,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IVssExpressWriter_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IVssExpressWriter_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IVssExpressWriter_Release(This) (This)->pVtbl->Release(This)
+#define IVssExpressWriter_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IVssExpressWriter_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IVssExpressWriter_Release(This) (This)->lpVtbl->Release(This)
 #define IVssExpressWriter_CreateMetadata(This,writerId,writerName,usageType,versionMajor,versionMinor,reserved,ppMetadata) (This)->lpVtbl->CreateMetadata(This,writerId,writerName,usageType,versionMajor,versionMinor,reserved,ppMetadata)
 #define IVssExpressWriter_Load(This,metadata,reserved) (This)->lpVtbl->Load(This,metadata,reserved)
 #define IVssExpressWriter_Register() (This)->lpVtbl->Register(This)
@@ -325,9 +325,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IVssComponent_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IVssComponent_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IVssComponent_Release(This) (This)->pVtbl->Release(This)
+#define IVssComponent_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IVssComponent_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IVssComponent_Release(This) (This)->lpVtbl->Release(This)
 #define IVssComponent_GetLogicalPath(This,pbstrPath) (This)->lpVtbl->GetLogicalPath(This,pbstrPath)
 #define IVssComponent_GetComponentType(This,pType) (This)->lpVtbl->GetComponentType(This,pType)
 #define IVssComponent_GetComponentName(This,pwszName) (This)->lpVtbl->GetComponentName(This,pwszName)
@@ -437,9 +437,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IVssComponentEx_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IVssComponentEx_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IVssComponentEx_Release(This) (This)->pVtbl->Release(This)
+#define IVssComponentEx_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IVssComponentEx_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IVssComponentEx_Release(This) (This)->lpVtbl->Release(This)
 #define IVssComponentEx_GetLogicalPath(This,pbstrPath) (This)->lpVtbl->GetLogicalPath(This,pbstrPath)
 #define IVssComponentEx_GetComponentType(This,pType) (This)->lpVtbl->GetComponentType(This,pType)
 #define IVssComponentEx_GetComponentName(This,pwszName) (This)->lpVtbl->GetComponentName(This,pwszName)
@@ -561,9 +561,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IVssComponentEx2_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IVssComponentEx2_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IVssComponentEx2_Release(This) (This)->pVtbl->Release(This)
+#define IVssComponentEx2_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IVssComponentEx2_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IVssComponentEx2_Release(This) (This)->lpVtbl->Release(This)
 #define IVssComponentEx2_GetLogicalPath(This,pbstrPath) (This)->lpVtbl->GetLogicalPath(This,pbstrPath)
 #define IVssComponentEx2_GetComponentType(This,pType) (This)->lpVtbl->GetComponentType(This,pType)
 #define IVssComponentEx2_GetComponentName(This,pwszName) (This)->lpVtbl->GetComponentName(This,pwszName)
diff --git a/mingw-w64-headers/include/winsync.h b/mingw-w64-headers/include/winsync.h
index 5386ba1..c15ed16 100644
--- a/mingw-w64-headers/include/winsync.h
+++ b/mingw-w64-headers/include/winsync.h
@@ -200,9 +200,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IAsynchronousDataRetriever_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IAsynchronousDataRetriever_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IAsynchronousDataRetriever_Release(This) (This)->pVtbl->Release(This)
+#define IAsynchronousDataRetriever_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IAsynchronousDataRetriever_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IAsynchronousDataRetriever_Release(This) (This)->lpVtbl->Release(This)
 #define IAsynchronousDataRetriever_GetIdParameters(This,pIdParameters) (This)->lpVtbl->GetIdParameters(This,pIdParameters)
 #define IAsynchronousDataRetriever_LoadChangeData(This,pLoadChangeContext) (This)->lpVtbl->LoadChangeData(This,pLoadChangeContext)
 #define IAsynchronousDataRetriever_RegisterCallback(This,pDataRetrieverCallback) (This)->lpVtbl->RegisterCallback(This,pDataRetrieverCallback)
@@ -232,9 +232,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IDataRetrieverCallback_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IDataRetrieverCallback_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IDataRetrieverCallback_Release(This) (This)->pVtbl->Release(This)
+#define IDataRetrieverCallback_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDataRetrieverCallback_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDataRetrieverCallback_Release(This) (This)->lpVtbl->Release(This)
 #define IDataRetrieverCallback_LoadChangeDataComplete(This,pUnkData) (This)->lpVtbl->LoadChangeDataComplete(This,pUnkData)
 #define IDataRetrieverCallback_LoadChangeDataError(This,hrError) (This)->lpVtbl->LoadChangeDataError(This,hrError)
 #endif /*COBJMACROS*/
@@ -268,9 +268,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IChangeConflict_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IChangeConflict_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IChangeConflict_Release(This) (This)->pVtbl->Release(This)
+#define IChangeConflict_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IChangeConflict_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IChangeConflict_Release(This) (This)->lpVtbl->Release(This)
 #define IChangeConflict_GetDestinationProviderConflictingChange(This,ppConflictingChange) (This)->lpVtbl->GetDestinationProviderConflictingChange(This,ppConflictingChange)
 #define IChangeConflict_GetDestinationProviderConflictingData(This,ppConflictingData) (This)->lpVtbl->GetDestinationProviderConflictingData(This,ppConflictingData)
 #define IChangeConflict_GetResolveActionForChange(This,pResolveAction) (This)->lpVtbl->GetResolveActionForChange(This,pResolveAction)
@@ -305,9 +305,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IChangeUnitException_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IChangeUnitException_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IChangeUnitException_Release(This) (This)->pVtbl->Release(This)
+#define IChangeUnitException_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IChangeUnitException_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IChangeUnitException_Release(This) (This)->lpVtbl->Release(This)
 #define IChangeUnitException_GetChangeUnitId(This,pcbIdSize) (This)->lpVtbl->GetChangeUnitId(This,pcbIdSize)
 #define IChangeUnitException_GetClockVector(This,riid,ppUnk) (This)->lpVtbl->GetClockVector(This,riid,ppUnk)
 #define IChangeUnitException_GetItemId(This,pcbIdSize) (This)->lpVtbl->GetItemId(This,pcbIdSize)
@@ -330,9 +330,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define ISyncFilterInfo_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define ISyncFilterInfo_AddRef(This) (This)->pVtbl->AddRef(This)
-#define ISyncFilterInfo_Release(This) (This)->pVtbl->Release(This)
+#define ISyncFilterInfo_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ISyncFilterInfo_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ISyncFilterInfo_Release(This) (This)->lpVtbl->Release(This)
 #define ISyncFilterInfo_Serialize(This,pcbBuffer) (This)->lpVtbl->Serialize(This,pcbBuffer)
 #endif /*COBJMACROS*/
 
@@ -363,9 +363,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IChangeUnitListFilterInfo_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IChangeUnitListFilterInfo_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IChangeUnitListFilterInfo_Release(This) (This)->pVtbl->Release(This)
+#define IChangeUnitListFilterInfo_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IChangeUnitListFilterInfo_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IChangeUnitListFilterInfo_Release(This) (This)->lpVtbl->Release(This)
 #define IChangeUnitListFilterInfo_Serialize(This,pcbBuffer) (This)->lpVtbl->Serialize(This,pcbBuffer)
 #define IChangeUnitListFilterInfo_GetChangeUnitId(This,dwChangeUnitIdIndex,pcbIdSize) (This)->lpVtbl->GetChangeUnitId(This,dwChangeUnitIdIndex,pcbIdSize)
 #define IChangeUnitListFilterInfo_GetChangeUnitIdCount(This,pdwChangeUnitIdCount) (This)->lpVtbl->GetChangeUnitIdCount(This,pdwChangeUnitIdCount)
@@ -395,9 +395,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IClockVector_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IClockVector_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IClockVector_Release(This) (This)->pVtbl->Release(This)
+#define IClockVector_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IClockVector_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IClockVector_Release(This) (This)->lpVtbl->Release(This)
 #define IClockVector_GetClockVectorElementCount(This,pdwCount) (This)->lpVtbl->GetClockVectorElementCount(This,pdwCount)
 #define IClockVector_GetClockVectorElements(This,riid,ppiEnumClockVector) (This)->lpVtbl->GetClockVectorElements(This,riid,ppiEnumClockVector)
 #endif /*COBJMACROS*/
@@ -425,9 +425,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IClockVectorElement_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IClockVectorElement_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IClockVectorElement_Release(This) (This)->pVtbl->Release(This)
+#define IClockVectorElement_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IClockVectorElement_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IClockVectorElement_Release(This) (This)->lpVtbl->Release(This)
 #define IClockVectorElement_GetReplicaKey(This,pdwReplicaKey) (This)->lpVtbl->GetReplicaKey(This,pdwReplicaKey)
 #define IClockVectorElement_GetTickCount(This,pullTickCount) (This)->lpVtbl->GetTickCount(This,pullTickCount)
 #endif /*COBJMACROS*/
@@ -449,9 +449,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IConstructReplicaKeyMap_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IConstructReplicaKeyMap_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IConstructReplicaKeyMap_Release(This) (This)->pVtbl->Release(This)
+#define IConstructReplicaKeyMap_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IConstructReplicaKeyMap_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IConstructReplicaKeyMap_Release(This) (This)->lpVtbl->Release(This)
 #define IConstructReplicaKeyMap_FindOrAddReplica(This,pbReplicaId,pdwReplicaKey) (This)->lpVtbl->FindOrAddReplica(This,pbReplicaId,pdwReplicaKey)
 #endif /*COBJMACROS*/
 
@@ -481,9 +481,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define ICoreFragment_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define ICoreFragment_AddRef(This) (This)->pVtbl->AddRef(This)
-#define ICoreFragment_Release(This) (This)->pVtbl->Release(This)
+#define ICoreFragment_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ICoreFragment_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ICoreFragment_Release(This) (This)->lpVtbl->Release(This)
 #define ICoreFragment_GetColumnCount(This,pColumnCount) (This)->lpVtbl->GetColumnCount(This,pColumnCount)
 #define ICoreFragment_GetRangeCount(This,pRangeCount) (This)->lpVtbl->GetRangeCount(This,pRangeCount)
 #define ICoreFragment_NextColumn(This,pChangeUnitIdSize) (This)->lpVtbl->NextColumn(This,pChangeUnitIdSize)
@@ -515,9 +515,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define ILoadChangeContext_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define ILoadChangeContext_AddRef(This) (This)->pVtbl->AddRef(This)
-#define ILoadChangeContext_Release(This) (This)->pVtbl->Release(This)
+#define ILoadChangeContext_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ILoadChangeContext_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ILoadChangeContext_Release(This) (This)->lpVtbl->Release(This)
 #define ILoadChangeContext_GetSyncChange(This,ppSyncChange) (This)->lpVtbl->GetSyncChange(This,ppSyncChange)
 #define ILoadChangeContext_SetRecoverableErrorOnChange(This,hrError,pErrorData) (This)->lpVtbl->SetRecoverableErrorOnChange(This,hrError,pErrorData)
 #define ILoadChangeContext_SetRecoverableErrorOnChangeUnit(This,hrError,pChangeUnit,pErrorData) (This)->lpVtbl->SetRecoverableErrorOnChangeUnit(This,hrError,pChangeUnit,pErrorData)
@@ -554,9 +554,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define ISyncChange_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define ISyncChange_AddRef(This) (This)->pVtbl->AddRef(This)
-#define ISyncChange_Release(This) (This)->pVtbl->Release(This)
+#define ISyncChange_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ISyncChange_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ISyncChange_Release(This) (This)->lpVtbl->Release(This)
 #define ISyncChange_GetChangeUnits(This,ppEnum) (This)->lpVtbl->GetChangeUnits(This,ppEnum)
 #define ISyncChange_GetChangeVersion(This,pbCurrentReplicaId,pVersion) (This)->lpVtbl->GetChangeVersion(This,pbCurrentReplicaId,pVersion)
 #define ISyncChange_GetCreationVersion(This,pbCurrentReplicaId,pVersion) (This)->lpVtbl->GetCreationVersion(This,pbCurrentReplicaId,pVersion)
@@ -593,9 +593,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define ISyncChangeUnit_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define ISyncChangeUnit_AddRef(This) (This)->pVtbl->AddRef(This)
-#define ISyncChangeUnit_Release(This) (This)->pVtbl->Release(This)
+#define ISyncChangeUnit_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ISyncChangeUnit_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ISyncChangeUnit_Release(This) (This)->lpVtbl->Release(This)
 #define ISyncChangeUnit_GetChangeUnitId(This,pcbIdSize) (This)->lpVtbl->GetChangeUnitId(This,pcbIdSize)
 #define ISyncChangeUnit_GetChangeUnitVersion(This,pbCurrentReplicaId,pVersion) (This)->lpVtbl->GetChangeUnitVersion(This,pbCurrentReplicaId,pVersion)
 #define ISyncChangeUnit_GetItemChange(This,ppSyncChange) (This)->lpVtbl->GetItemChange(This,ppSyncChange)
@@ -625,9 +625,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IRecoverableErrorData_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IRecoverableErrorData_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IRecoverableErrorData_Release(This) (This)->pVtbl->Release(This)
+#define IRecoverableErrorData_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IRecoverableErrorData_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IRecoverableErrorData_Release(This) (This)->lpVtbl->Release(This)
 #define IRecoverableErrorData_GetErrorDescription(This,pcchErrorDescription) (This)->lpVtbl->GetErrorDescription(This,pcchErrorDescription)
 #define IRecoverableErrorData_GetItemDisplayName(This,pcchItemDisplayName) (This)->lpVtbl->GetItemDisplayName(This,pcchItemDisplayName)
 #define IRecoverableErrorData_Initialize(This,pcszItemDisplayName,pcszErrorDescription) (This)->lpVtbl->Initialize(This,pcszItemDisplayName,pcszErrorDescription)
@@ -658,9 +658,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IEnumSyncChangeUnits_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IEnumSyncChangeUnits_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IEnumSyncChangeUnits_Release(This) (This)->pVtbl->Release(This)
+#define IEnumSyncChangeUnits_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IEnumSyncChangeUnits_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IEnumSyncChangeUnits_Release(This) (This)->lpVtbl->Release(This)
 #define IEnumSyncChangeUnits_Clone(This,ppEnum) (This)->lpVtbl->Clone(This,ppEnum)
 #define IEnumSyncChangeUnits_Next(This,cChanges,ppChangeUnit,pcFetched) (This)->lpVtbl->Next(This,cChanges,ppChangeUnit,pcFetched)
 #define IEnumSyncChangeUnits_Reset() (This)->lpVtbl->Reset(This)
diff --git a/mingw-w64-headers/include/wmcontainer.h b/mingw-w64-headers/include/wmcontainer.h
index cd6f887..e5f930b 100644
--- a/mingw-w64-headers/include/wmcontainer.h
+++ b/mingw-w64-headers/include/wmcontainer.h
@@ -96,9 +96,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFASFMutualExclusion_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFASFMutualExclusion_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFASFMutualExclusion_Release(This) (This)->pVtbl->Release(This)
+#define IMFASFMutualExclusion_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFASFMutualExclusion_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFASFMutualExclusion_Release(This) (This)->lpVtbl->Release(This)
 #define IMFASFMutualExclusion_AddRecord(This,pdwRecordNumber) (This)->lpVtbl->AddRecord(This,pdwRecordNumber)
 #define IMFASFMutualExclusion_AddStreamForRecord(This,dwRecordNumber,wStreamNumber) (This)->lpVtbl->AddStreamForRecord(This,dwRecordNumber,wStreamNumber)
 #define IMFASFMutualExclusion_Clone(This,ppIMutex) (This)->lpVtbl->Clone(This,ppIMutex)
@@ -136,9 +136,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFASFStreamPrioritization_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFASFStreamPrioritization_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFASFStreamPrioritization_Release(This) (This)->pVtbl->Release(This)
+#define IMFASFStreamPrioritization_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFASFStreamPrioritization_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFASFStreamPrioritization_Release(This) (This)->lpVtbl->Release(This)
 #define IMFASFStreamPrioritization_AddStream(This,wStreamNumber,wStreamFlags) (This)->lpVtbl->AddStream(This,wStreamNumber,wStreamFlags)
 #define IMFASFStreamPrioritization_Clone(This,ppIStreamPrioritization) (This)->lpVtbl->Clone(This,ppIStreamPrioritization)
 #define IMFASFStreamPrioritization_GetStream(This,dwStreamIndex,pwStreamNumber,pwStreamFlags) (This)->lpVtbl->GetStream(This,dwStreamIndex,pwStreamNumber,pwStreamFlags)
@@ -177,9 +177,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFASFSplitter_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFASFSplitter_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFASFSplitter_Release(This) (This)->pVtbl->Release(This)
+#define IMFASFSplitter_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFASFSplitter_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFASFSplitter_Release(This) (This)->lpVtbl->Release(This)
 #define IMFASFSplitter_Flush() (This)->lpVtbl->Flush(This)
 #define IMFASFSplitter_GetFlags(This,pdwFlags) (This)->lpVtbl->GetFlags(This,pdwFlags)
 #define IMFASFSplitter_GetLastSendTime(This,pdwLastSendTime) (This)->lpVtbl->GetLastSendTime(This,pdwLastSendTime)
@@ -251,9 +251,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFASFContentInfo_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFASFContentInfo_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFASFContentInfo_Release(This) (This)->pVtbl->Release(This)
+#define IMFASFContentInfo_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFASFContentInfo_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFASFContentInfo_Release(This) (This)->lpVtbl->Release(This)
 #define IMFASFContentInfo_Compare(This,pTheirs,MatchType,pbResult) (This)->lpVtbl->Compare(This,pTheirs,MatchType,pbResult)
 #define IMFASFContentInfo_CompareItem(This,guidKey,Value,pbResult) (This)->lpVtbl->CompareItem(This,guidKey,Value,pbResult)
 #define IMFASFContentInfo_CopyAllItems(This,pDest) (This)->lpVtbl->CopyAllItems(This,pDest)
@@ -356,9 +356,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFASFStreamConfig_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFASFStreamConfig_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFASFStreamConfig_Release(This) (This)->pVtbl->Release(This)
+#define IMFASFStreamConfig_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFASFStreamConfig_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFASFStreamConfig_Release(This) (This)->lpVtbl->Release(This)
 #define IMFASFStreamConfig_Compare(This,pTheirs,MatchType,pbResult) (This)->lpVtbl->Compare(This,pTheirs,MatchType,pbResult)
 #define IMFASFStreamConfig_CompareItem(This,guidKey,Value,pbResult) (This)->lpVtbl->CompareItem(This,guidKey,Value,pbResult)
 #define IMFASFStreamConfig_CopyAllItems(This,pDest) (This)->lpVtbl->CopyAllItems(This,pDest)
@@ -470,9 +470,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFASFProfile_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFASFProfile_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFASFProfile_Release(This) (This)->pVtbl->Release(This)
+#define IMFASFProfile_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFASFProfile_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFASFProfile_Release(This) (This)->lpVtbl->Release(This)
 #define IMFASFProfile_Compare(This,pTheirs,MatchType,pbResult) (This)->lpVtbl->Compare(This,pTheirs,MatchType,pbResult)
 #define IMFASFProfile_CompareItem(This,guidKey,Value,pbResult) (This)->lpVtbl->CompareItem(This,guidKey,Value,pbResult)
 #define IMFASFProfile_CopyAllItems(This,pDest) (This)->lpVtbl->CopyAllItems(This,pDest)
@@ -555,9 +555,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFASFIndexer_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFASFIndexer_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFASFIndexer_Release(This) (This)->pVtbl->Release(This)
+#define IMFASFIndexer_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFASFIndexer_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFASFIndexer_Release(This) (This)->lpVtbl->Release(This)
 #define IMFASFIndexer_CommitIndex(This,pIContentInfo) (This)->lpVtbl->CommitIndex(This,pIContentInfo)
 #define IMFASFIndexer_GenerateIndexEntries(This,pIASFPacketSample) (This)->lpVtbl->GenerateIndexEntries(This,pIASFPacketSample)
 #define IMFASFIndexer_GetCompletedIndex(This,pIIndexBuffer,cbOffsetWithinIndex) (This)->lpVtbl->GetCompletedIndex(This,pIIndexBuffer,cbOffsetWithinIndex)
@@ -603,9 +603,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IMFASFMultiplexer_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IMFASFMultiplexer_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IMFASFMultiplexer_Release(This) (This)->pVtbl->Release(This)
+#define IMFASFMultiplexer_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IMFASFMultiplexer_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IMFASFMultiplexer_Release(This) (This)->lpVtbl->Release(This)
 #define IMFASFMultiplexer_End(This,pIContentInfo) (This)->lpVtbl->End(This,pIContentInfo)
 #define IMFASFMultiplexer_Flush() (This)->lpVtbl->Flush(This)
 #define IMFASFMultiplexer_GetFlags(This,pdwFlags) (This)->lpVtbl->GetFlags(This,pdwFlags)
diff --git a/mingw-w64-headers/include/wsdattachment.h b/mingw-w64-headers/include/wsdattachment.h
index 5d7ea48..dd0a58b 100644
--- a/mingw-w64-headers/include/wsdattachment.h
+++ b/mingw-w64-headers/include/wsdattachment.h
@@ -33,9 +33,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDAttachment_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDAttachment_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDAttachment_Release(This) (This)->pVtbl->Release(This)
+#define IWSDAttachment_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDAttachment_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDAttachment_Release(This) (This)->lpVtbl->Release(This)
 #endif /*COBJMACROS*/
 
 #undef  INTERFACE
@@ -63,9 +63,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDInboundAttachment_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDInboundAttachment_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDInboundAttachment_Release(This) (This)->pVtbl->Release(This)
+#define IWSDInboundAttachment_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDInboundAttachment_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDInboundAttachment_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDInboundAttachment_Read(This,pBuffer,dwBytesToRead,pdwNumberofBytesRead) (This)->lpVtbl->Read(This,pBuffer,dwBytesToRead,pdwNumberofBytesRead)
 #define IWSDInboundAttachment_Close() (This)->lpVtbl->Close(This)
 #endif /*COBJMACROS*/
@@ -96,9 +96,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDOutboundAttachment_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDOutboundAttachment_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDOutboundAttachment_Release(This) (This)->pVtbl->Release(This)
+#define IWSDOutboundAttachment_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDOutboundAttachment_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDOutboundAttachment_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDOutboundAttachment_Write(This,pBuffer,dwBytesToWrite,pdwNumberofBytesWritten) (This)->lpVtbl->Write(This,pBuffer,dwBytesToWrite,pdwNumberofBytesWritten)
 #define IWSDOutboundAttachment_Close() (This)->lpVtbl->Close(This)
 #define IWSDOutboundAttachment_Abort() (This)->lpVtbl->Abort(This)
diff --git a/mingw-w64-headers/include/wsdbase.h b/mingw-w64-headers/include/wsdbase.h
index 05a36c0..76cddf7 100644
--- a/mingw-w64-headers/include/wsdbase.h
+++ b/mingw-w64-headers/include/wsdbase.h
@@ -54,9 +54,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDTransportAddress_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDTransportAddress_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDTransportAddress_Release(This) (This)->pVtbl->Release(This)
+#define IWSDTransportAddress_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDTransportAddress_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDTransportAddress_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDTransportAddress_GetPort(This,pwPort) (This)->lpVtbl->GetPort(This,pwPort)
 #define IWSDTransportAddress_SetPort(This,wPort) (This)->lpVtbl->SetPort(This,wPort)
 #define IWSDTransportAddress_GetTransportAddress(This,ppszAddress) (This)->lpVtbl->GetTransportAddress(This,ppszAddress)
@@ -96,9 +96,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDHttpAddress_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDHttpAddress_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDHttpAddress_Release(This) (This)->pVtbl->Release(This)
+#define IWSDHttpAddress_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDHttpAddress_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDHttpAddress_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDHttpAddress_GetPort(This,pwPort) (This)->lpVtbl->GetPort(This,pwPort)
 #define IWSDHttpAddress_SetPort(This,wPort) (This)->lpVtbl->SetPort(This,wPort)
 #define IWSDHttpAddress_GetTransportAddress(This,ppszAddress) (This)->lpVtbl->GetTransportAddress(This,ppszAddress)
@@ -148,9 +148,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDUdpAddress_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDUdpAddress_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDUdpAddress_Release(This) (This)->pVtbl->Release(This)
+#define IWSDUdpAddress_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDUdpAddress_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDUdpAddress_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDUdpAddress_GetPort(This,pwPort) (This)->lpVtbl->GetPort(This,pwPort)
 #define IWSDUdpAddress_SetPort(This,wPort) (This)->lpVtbl->SetPort(This,wPort)
 #define IWSDUdpAddress_GetTransportAddress(This,ppszAddress) (This)->lpVtbl->GetTransportAddress(This,ppszAddress)
@@ -191,9 +191,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDAddress_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDAddress_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDAddress_Release(This) (This)->pVtbl->Release(This)
+#define IWSDAddress_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDAddress_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDAddress_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDAddress_Serialize(This,pszBuffer,cchLength,fSafe) (This)->lpVtbl->Serialize(This,pszBuffer,cchLength,fSafe)
 #define IWSDAddress_Deserialize(This,pszBuffer) (This)->lpVtbl->Deserialize(This,pszBuffer)
 #endif /*COBJMACROS*/
@@ -224,9 +224,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDMessageParameters_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDMessageParameters_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDMessageParameters_Release(This) (This)->pVtbl->Release(This)
+#define IWSDMessageParameters_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDMessageParameters_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDMessageParameters_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDMessageParameters_GetLocalAddress(This,ppAddress) (This)->lpVtbl->GetLocalAddress(This,ppAddress)
 #define IWSDMessageParameters_SetLocalAddress(This,pAddress) (This)->lpVtbl->SetLocalAddress(This,pAddress)
 #define IWSDMessageParameters_GetRemoteAddress(This,ppAddress) (This)->lpVtbl->GetRemoteAddress(This,ppAddress)
@@ -271,9 +271,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDHttpMessageParameters_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDHttpMessageParameters_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDHttpMessageParameters_Release(This) (This)->pVtbl->Release(This)
+#define IWSDHttpMessageParameters_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDHttpMessageParameters_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDHttpMessageParameters_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDHttpMessageParameters_GetLocalAddress(This,ppAddress) (This)->lpVtbl->GetLocalAddress(This,ppAddress)
 #define IWSDHttpMessageParameters_SetLocalAddress(This,pAddress) (This)->lpVtbl->SetLocalAddress(This,pAddress)
 #define IWSDHttpMessageParameters_GetRemoteAddress(This,ppAddress) (This)->lpVtbl->GetRemoteAddress(This,ppAddress)
@@ -320,9 +320,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDUdpMessageParameters_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDUdpMessageParameters_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDUdpMessageParameters_Release(This) (This)->pVtbl->Release(This)
+#define IWSDUdpMessageParameters_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDUdpMessageParameters_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDUdpMessageParameters_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDUdpMessageParameters_GetLocalAddress(This,ppAddress) (This)->lpVtbl->GetLocalAddress(This,ppAddress)
 #define IWSDUdpMessageParameters_SetLocalAddress(This,pAddress) (This)->lpVtbl->SetLocalAddress(This,pAddress)
 #define IWSDUdpMessageParameters_GetRemoteAddress(This,ppAddress) (This)->lpVtbl->GetRemoteAddress(This,ppAddress)
diff --git a/mingw-w64-headers/include/wsdclient.h b/mingw-w64-headers/include/wsdclient.h
index 5b3307d..906762a 100644
--- a/mingw-w64-headers/include/wsdclient.h
+++ b/mingw-w64-headers/include/wsdclient.h
@@ -36,9 +36,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDEventingStatus_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDEventingStatus_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDEventingStatus_Release(This) (This)->pVtbl->Release(This)
+#define IWSDEventingStatus_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDEventingStatus_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDEventingStatus_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDEventingStatus_SubscriptionRenewed(This,pszSubscriptionAction) (This)->lpVtbl->SubscriptionRenewed(This,pszSubscriptionAction)
 #define IWSDEventingStatus_SubscriptionRenewalFailed(This,pszSubscriptionAction,hr) (This)->lpVtbl->SubscriptionRenewalFailed(This,pszSubscriptionAction,hr)
 #define IWSDEventingStatus_SubscriptionEnded(This,pszSubscriptionAction) (This)->lpVtbl->SubscriptionEnded(This,pszSubscriptionAction)
@@ -66,9 +66,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDAsyncCallback_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDAsyncCallback_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDAsyncCallback_Release(This) (This)->pVtbl->Release(This)
+#define IWSDAsyncCallback_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDAsyncCallback_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDAsyncCallback_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDAsyncCallback_AsyncOperationComplete(This,pAsyncResult,pAsyncState) (This)->lpVtbl->AsyncOperationComplete(This,pAsyncResult,pAsyncState)
 #endif /*COBJMACROS*/
 
@@ -100,9 +100,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDAsyncResult_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDAsyncResult_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDAsyncResult_Release(This) (This)->pVtbl->Release(This)
+#define IWSDAsyncResult_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDAsyncResult_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDAsyncResult_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDAsyncResult_SetCallback(This,pCallback,pAsyncState) (This)->lpVtbl->SetCallback(This,pCallback,pAsyncState)
 #define IWSDAsyncResult_SetWaitHandle(This,hWaitHandle) (This)->lpVtbl->SetWaitHandle(This,hWaitHandle)
 #define IWSDAsyncResult_HasCompleted() (This)->lpVtbl->HasCompleted(This)
@@ -143,9 +143,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDDeviceProxy_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDDeviceProxy_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDDeviceProxy_Release(This) (This)->pVtbl->Release(This)
+#define IWSDDeviceProxy_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDDeviceProxy_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDDeviceProxy_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDDeviceProxy_Init(This,pszDeviceId,pDeviceAddress,pszLocalId,pSponsor) (This)->lpVtbl->Init(This,pszDeviceId,pDeviceAddress,pszLocalId,pSponsor)
 #define IWSDDeviceProxy_BeginGetMetadata(This,ppResult) (This)->lpVtbl->BeginGetMetadata(This,ppResult)
 #define IWSDDeviceProxy_EndGetMetadata(This,pResult) (This)->lpVtbl->EndGetMetadata(This,pResult)
@@ -180,9 +180,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDMetadataExchange_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDMetadataExchange_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDMetadataExchange_Release(This) (This)->pVtbl->Release(This)
+#define IWSDMetadataExchange_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDMetadataExchange_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDMetadataExchange_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDMetadataExchange_GetMetadata(This,MetadataOut) (This)->lpVtbl->GetMetadata(This,MetadataOut)
 #endif /*COBJMACROS*/
 
@@ -217,9 +217,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDServiceProxy_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDServiceProxy_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDServiceProxy_Release(This) (This)->pVtbl->Release(This)
+#define IWSDServiceProxy_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDServiceProxy_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDServiceProxy_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDServiceProxy_BeginGetMetadata(This,ppResult) (This)->lpVtbl->BeginGetMetadata(This,ppResult)
 #define IWSDServiceProxy_EndGetMetadata(This,pResult,ppMetadata) (This)->lpVtbl->EndGetMetadata(This,pResult,ppMetadata)
 #define IWSDServiceProxy_GetServiceMetadata(This,ppServiceMetadata) (This)->lpVtbl->GetServiceMetadata(This,ppServiceMetadata)
@@ -257,9 +257,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDEndpointProxy_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDEndpointProxy_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDEndpointProxy_Release(This) (This)->pVtbl->Release(This)
+#define IWSDEndpointProxy_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDEndpointProxy_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDEndpointProxy_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDEndpointProxy_SendOneWayRequest(This,pBody,pOperation) (This)->lpVtbl->SendOneWayRequest(This,pBody,pOperation)
 #define IWSDEndpointProxy_SendTwoWayRequest(This,pBody,pOperation,pResponseContext) (This)->lpVtbl->SendTwoWayRequest(This,pBody,pOperation,pResponseContext)
 #define IWSDEndpointProxy_SendTwoWayRequestAsync(This,pBody,pOperation,pAsyncState,pCallback,pResult) (This)->lpVtbl->SendTwoWayRequestAsync(This,pBody,pOperation,pAsyncState,pCallback,pResult)
diff --git a/mingw-w64-headers/include/wsddisco.h b/mingw-w64-headers/include/wsddisco.h
index 7db11fa..b46b54c 100644
--- a/mingw-w64-headers/include/wsddisco.h
+++ b/mingw-w64-headers/include/wsddisco.h
@@ -35,9 +35,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDScopeMatchingRule_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDScopeMatchingRule_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDScopeMatchingRule_Release(This) (This)->pVtbl->Release(This)
+#define IWSDScopeMatchingRule_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDScopeMatchingRule_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDScopeMatchingRule_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDScopeMatchingRule_GetScopeRule(This,ppszScopeMatchingRule) (This)->lpVtbl->GetScopeRule(This,ppszScopeMatchingRule)
 #define IWSDScopeMatchingRule_MatchScopes(This,pszScope1,pszScope2,pfMatch) (This)->lpVtbl->MatchScopes(This,pszScope1,pszScope2,pfMatch)
 #endif /*COBJMACROS*/
@@ -65,9 +65,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDiscoveryPublisherNotify_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDiscoveryPublisherNotify_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDiscoveryPublisherNotify_Release(This) (This)->pVtbl->Release(This)
+#define IWSDiscoveryPublisherNotify_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDiscoveryPublisherNotify_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDiscoveryPublisherNotify_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDiscoveryPublisherNotify_ProbeHandler(This,pSoap,pMessageParameters) (This)->lpVtbl->ProbeHandler(This,pSoap,pMessageParameters)
 #define IWSDiscoveryPublisherNotify_ResolveHandler(This,pSoap,pMessageParameters) (This)->lpVtbl->ResolveHandler(This,pSoap,pMessageParameters)
 #endif /*COBJMACROS*/
@@ -104,9 +104,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDiscoveredService_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDiscoveredService_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDiscoveredService_Release(This) (This)->pVtbl->Release(This)
+#define IWSDiscoveredService_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDiscoveredService_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDiscoveredService_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDiscoveredService_GetEndpointReference(This,ppEndPointReference) (This)->lpVtbl->GetEndpointReference(This,ppEndPointReference)
 #define IWSDiscoveredService_GetTypes(This,ppTypesList) (This)->lpVtbl->GetTypes(This,ppTypesList)
 #define IWSDiscoveredService_GetScopes(This,ppScopesList) (This)->lpVtbl->GetScopes(This,ppScopesList)
@@ -145,9 +145,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDiscoveryProviderNotify_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDiscoveryProviderNotify_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDiscoveryProviderNotify_Release(This) (This)->pVtbl->Release(This)
+#define IWSDiscoveryProviderNotify_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDiscoveryProviderNotify_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDiscoveryProviderNotify_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDiscoveryProviderNotify_Add(This,pService) (This)->lpVtbl->Add(This,pService)
 #define IWSDiscoveryProviderNotify_Remove(This,pService) (This)->lpVtbl->Remove(This,pService)
 #define IWSDiscoveryProviderNotify_SearchFailed(This,hr,pszTag) (This)->lpVtbl->SearchFailed(This,hr,pszTag)
@@ -182,9 +182,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDiscoveryProvider_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDiscoveryProvider_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDiscoveryProvider_Release(This) (This)->pVtbl->Release(This)
+#define IWSDiscoveryProvider_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDiscoveryProvider_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDiscoveryProvider_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDiscoveryProvider_SetAddressFamily(This,dwAddressFamily) (This)->lpVtbl->SetAddressFamily(This,dwAddressFamily)
 #define IWSDiscoveryProvider_Attach(This,pSink) (This)->lpVtbl->Attach(This,pSink)
 #define IWSDiscoveryProvider_Detach() (This)->lpVtbl->Detach(This)
@@ -228,9 +228,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDiscoveryPublisher_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDiscoveryPublisher_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDiscoveryPublisher_Release(This) (This)->pVtbl->Release(This)
+#define IWSDiscoveryPublisher_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDiscoveryPublisher_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDiscoveryPublisher_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDiscoveryPublisher_SetAddressFamily(This,dwAddressFamily) (This)->lpVtbl->SetAddressFamily(This,dwAddressFamily)
 #define IWSDiscoveryPublisher_RegisterNotificationSink(This,pSink) (This)->lpVtbl->RegisterNotificationSink(This,pSink)
 #define IWSDiscoveryPublisher_UnRegisterNotificationSink(This,pSink) (This)->lpVtbl->UnRegisterNotificationSink(This,pSink)
diff --git a/mingw-w64-headers/include/wsdhost.h b/mingw-w64-headers/include/wsdhost.h
index a8ec8eb..04926de 100644
--- a/mingw-w64-headers/include/wsdhost.h
+++ b/mingw-w64-headers/include/wsdhost.h
@@ -35,9 +35,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDServiceMessaging_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDServiceMessaging_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDServiceMessaging_Release(This) (This)->pVtbl->Release(This)
+#define IWSDServiceMessaging_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDServiceMessaging_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDServiceMessaging_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDServiceMessaging_FaultRequest(This,pRequestHeader,pMessageParameters,pFault) (This)->lpVtbl->FaultRequest(This,pRequestHeader,pMessageParameters,pFault)
 #define IWSDServiceMessaging_SendResponse(This,pBody,pOperation,pMessageParameters) (This)->lpVtbl->SendResponse(This,pBody,pOperation,pMessageParameters)
 #endif /*COBJMACROS*/
@@ -64,9 +64,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDDeviceHostNotify_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDDeviceHostNotify_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDDeviceHostNotify_Release(This) (This)->pVtbl->Release(This)
+#define IWSDDeviceHostNotify_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDDeviceHostNotify_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDDeviceHostNotify_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDDeviceHostNotify_GetService(This,pszServiceId,ppService) (This)->lpVtbl->GetService(This,pszServiceId,ppService)
 #endif /*COBJMACROS*/
 
@@ -109,9 +109,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDDeviceHost_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDDeviceHost_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDDeviceHost_Release(This) (This)->pVtbl->Release(This)
+#define IWSDDeviceHost_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDDeviceHost_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDDeviceHost_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDDeviceHost_Init(This,pszLocalId,dwHostAddressCount) (This)->lpVtbl->Init(This,pszLocalId,dwHostAddressCount)
 #define IWSDDeviceHost_Start(This,ullInstanceId,pScopeList,pNotificationSink) (This)->lpVtbl->Start(This,ullInstanceId,pScopeList,pNotificationSink)
 #define IWSDDeviceHost_Stop() (This)->lpVtbl->Stop(This)
diff --git a/mingw-w64-headers/include/wsdxml.h b/mingw-w64-headers/include/wsdxml.h
index 34ad686..9073ede 100644
--- a/mingw-w64-headers/include/wsdxml.h
+++ b/mingw-w64-headers/include/wsdxml.h
@@ -36,9 +36,9 @@
     END_INTERFACE
 };
 #ifdef COBJMACROS
-#define IWSDXMLContext_QueryInterface(This,riid,ppvObject) (This)->pVtbl->QueryInterface(This,riid,ppvObject)
-#define IWSDXMLContext_AddRef(This) (This)->pVtbl->AddRef(This)
-#define IWSDXMLContext_Release(This) (This)->pVtbl->Release(This)
+#define IWSDXMLContext_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IWSDXMLContext_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IWSDXMLContext_Release(This) (This)->lpVtbl->Release(This)
 #define IWSDXMLContext_SetNamespaces(This,pNamespaces,wNamespacesCount,bLayerNumber) (This)->lpVtbl->SetNamespaces(This,pNamespaces,wNamespacesCount,bLayerNumber)
 #define IWSDXMLContext_SetTypes(This,pTypes,dwTypesCount,bLayerNumber) (This)->lpVtbl->SetTypes(This,pTypes,dwTypesCount,bLayerNumber)
 #define IWSDXMLContext_AddNamespace(This,pszUri,pszSuggestedPrefix,ppNamespace) (This)->lpVtbl->AddNamespace(This,pszUri,pszSuggestedPrefix,ppNamespace)
