//------------------------------------------------------------------------- // Description: // // GetCurrentEffectsSetting // Gets the current aggregate effects-enable setting // // Parameters: // // properties - Property store holding configurable effects settings // // pkeyEnable - VT_UI4 property holding an enable/disable setting // // processingMode - Audio processing mode // // Return values: // LONG - true if the effect is enabled // // Remarks: // The routine considers the value of the specified property, the well known // master PKEY_AudioEndpoint_Disable_SysFx property, and the specified // processing mode.If the processing mode is RAW then the effect is off. If // PKEY_AudioEndpoint_Disable_SysFx is non-zero then the effect is off. // LONG GetCurrentEffectsSetting(IPropertyStore* properties, PROPERTYKEY pkeyEnable, GUID processingMode) { HRESULT hr; BOOL enabled; PROPVARIANT var; PropVariantInit(&var); // Get the state of whether channel swap MFX is enabled or not. // Check the master disable property defined by Windows hr = properties->GetValue(PKEY_AudioEndpoint_Disable_SysFx, &var); enabled = (SUCCEEDED(hr)) && !((var.vt == VT_UI4) && (var.ulVal != 0)); PropVariantClear(&var); // Check the APO's enable property, defined by this APO. hr = properties->GetValue(pkeyEnable, &var); enabled = enabled && ((SUCCEEDED(hr)) && ((var.vt == VT_UI4) && (var.ulVal != 0))); PropVariantClear(&var); enabled = enabled && !IsEqualGUID(processingMode, AUDIO_SIGNALPROCESSINGMODE_RAW); return (LONG)enabled; }
HRESULT FakeDevice::GetObjectIDsFromPersistentUniqueIDs( ACCESS_SCOPE Scope, _In_ IPortableDevicePropVariantCollection* pPersistentIDs, _In_ IPortableDevicePropVariantCollection* pObjectIDs) { HRESULT hr = S_OK; DWORD dwCount = 0; if ((pPersistentIDs == NULL) || (pObjectIDs == NULL)) { hr = E_POINTER; CHECK_HR(hr, ("Cannot have NULL parameter")); return hr; } // Iterate through the persistent ID list and add the equivalent object ID for each element. hr = pPersistentIDs->GetCount(&dwCount); CHECK_HR(hr, "Failed to get count from persistent ID collection"); if (hr == S_OK) { PROPVARIANT pvPersistentID = {0}; for(DWORD dwIndex = 0; dwIndex < dwCount; dwIndex++) { PropVariantInit(&pvPersistentID); hr = pPersistentIDs->GetAt(dwIndex, &pvPersistentID); CHECK_HR(hr, "Failed to get persistent ID at index %d", dwIndex); if (hr == S_OK) { hr = m_DeviceContent.GetObjectIDByPersistentID(Scope, pvPersistentID.pwszVal, pObjectIDs); CHECK_HR(hr, "Failed to get object ID from persistent unique ID '%ws'", pvPersistentID.pwszVal); } if (hr == HRESULT_FROM_WIN32(ERROR_NOT_FOUND)) { PROPVARIANT pvEmptyObjectID = {0}; pvEmptyObjectID.vt = VT_LPWSTR; pvEmptyObjectID.pwszVal = L""; // Insert empty string when object cannot be found hr = pObjectIDs->Add(&pvEmptyObjectID); CHECK_HR(hr, "Failed to set empty string for persistent unique ID '%ws' when object cannot be found", pvPersistentID.pwszVal); } PropVariantClear(&pvPersistentID); if(FAILED(hr)) { break; } } } return hr; }
static HRESULT LoadUnknownMetadata(IStream *input, const GUID *preferred_vendor, DWORD persist_options, MetadataItem **items, DWORD *item_count) { HRESULT hr; MetadataItem *result; STATSTG stat; BYTE *data; ULONG bytesread; TRACE("\n"); hr = IStream_Stat(input, &stat, STATFLAG_NONAME); if (FAILED(hr)) return hr; data = HeapAlloc(GetProcessHeap(), 0, stat.cbSize.QuadPart); if (!data) return E_OUTOFMEMORY; hr = IStream_Read(input, data, stat.cbSize.QuadPart, &bytesread); if (bytesread != stat.cbSize.QuadPart) hr = E_FAIL; if (hr != S_OK) { HeapFree(GetProcessHeap(), 0, data); return hr; } result = HeapAlloc(GetProcessHeap(), 0, sizeof(MetadataItem)); if (!result) { HeapFree(GetProcessHeap(), 0, data); return E_OUTOFMEMORY; } PropVariantInit(&result[0].schema); PropVariantInit(&result[0].id); PropVariantInit(&result[0].value); result[0].value.vt = VT_BLOB; result[0].value.u.blob.cbSize = bytesread; result[0].value.u.blob.pBlobData = data; *items = result; *item_count = 1; return S_OK; }
// // Retrieves the device friendly name for a particular device in a device collection. // LPWSTR GetDeviceName(IMMDeviceCollection *DeviceCollection, UINT DeviceIndex) { IMMDevice *device; LPWSTR deviceId; HRESULT hr; hr = DeviceCollection->Item(DeviceIndex, &device); if (FAILED(hr)) { printf("Unable to get device %d: %x\n", DeviceIndex, hr); return NULL; } hr = device->GetId(&deviceId); if (FAILED(hr)) { printf("Unable to get device %d id: %x\n", DeviceIndex, hr); return NULL; } IPropertyStore *propertyStore; hr = device->OpenPropertyStore(STGM_READ, &propertyStore); SafeRelease(&device); if (FAILED(hr)) { printf("Unable to open device %d property store: %x\n", DeviceIndex, hr); return NULL; } PROPVARIANT friendlyName; PropVariantInit(&friendlyName); hr = propertyStore->GetValue(PKEY_Device_FriendlyName, &friendlyName); SafeRelease(&propertyStore); if (FAILED(hr)) { printf("Unable to retrieve friendly name for device %d : %x\n", DeviceIndex, hr); return NULL; } wchar_t deviceName[128]; hr = StringCbPrintf(deviceName, sizeof(deviceName), L"%s (%s)", friendlyName.vt != VT_LPWSTR ? L"Unknown" : friendlyName.pwszVal, deviceId); if (FAILED(hr)) { printf("Unable to format friendly name for device %d : %x\n", DeviceIndex, hr); return NULL; } PropVariantClear(&friendlyName); CoTaskMemFree(deviceId); wchar_t *returnValue = _wcsdup(deviceName); if (returnValue == NULL) { printf("Unable to allocate buffer for return\n"); return NULL; } return returnValue; }
// ---------------------------------------------------------------------------- // AudioVolumeController* AudioVolumeController::createVolumeController( ) { HRESULT hr; IMMDeviceEnumerator *pEnumerator = NULL; IMMDevice *pDefaultDevice = NULL; IAudioEndpointVolume *endpointVolume = NULL; LPWSTR pstrDefaultId = NULL; IPropertyStore *pProperties = NULL; try { hr = CoCreateInstance( CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, IID_IMMDeviceEnumerator, (void**)&pEnumerator); AUDIO_VOLUME_ASSERT( hr, "Cannot create COM device enumerator instance" ); // Get the default audio endpoint (if we don't get one its not an error) hr = pEnumerator->GetDefaultAudioEndpoint( eRender, eConsole, &pDefaultDevice ); AUDIO_VOLUME_ASSERT( hr, "Cannot get default audio render device" ); hr = pDefaultDevice->OpenPropertyStore( STGM_READ, &pProperties ); AUDIO_VOLUME_ASSERT( hr, "Cannot open IMMDevice property store" ); PROPVARIANT varName; // Initialize container for property value. PropVariantInit(&varName); // Get the endpoint's friendly-name property. hr = pProperties->GetValue( PKEY_Device_DeviceDesc , &varName); AUDIO_VOLUME_ASSERT( hr, "Cannot open IMMDevice name property" ); CString render_name = CW2A( varName.pwszVal ); DMXStudio::log_status( "Default audio render device '%s'", render_name ); PropVariantClear(&varName); hr = pDefaultDevice->Activate( IID_IAudioEndpointVolume, CLSCTX_INPROC_SERVER, NULL, (LPVOID *)&endpointVolume ); AUDIO_VOLUME_ASSERT( hr, "Cannot activate default render device" ); SAFE_RELEASE( pDefaultDevice ); SAFE_RELEASE( pProperties ); SAFE_RELEASE( pEnumerator ); CoTaskMemFree( pstrDefaultId ); return new AudioVolumeController( endpointVolume, render_name ); } catch ( ... ) { CoTaskMemFree( pstrDefaultId ); SAFE_RELEASE( pDefaultDevice ); SAFE_RELEASE( pProperties ); SAFE_RELEASE( pEnumerator ); throw; } }
HRESULT CSwapAPOLFX::Initialize(UINT32 cbDataSize, BYTE* pbyData) { HRESULT hr = S_OK; PROPVARIANT var; IF_TRUE_ACTION_JUMP( ((NULL == pbyData) && (0 != cbDataSize)), hr = E_INVALIDARG, Exit); IF_TRUE_ACTION_JUMP( ((NULL != pbyData) && (0 == cbDataSize)), hr = E_POINTER, Exit); IF_TRUE_ACTION_JUMP( (cbDataSize != sizeof(APOInitSystemEffects) ), hr = E_INVALIDARG, Exit); APOInitSystemEffects* papoSysFxInit = (APOInitSystemEffects*)pbyData; // // Store locally for later reference // m_spAPOSystemEffectsProperties = papoSysFxInit->pAPOSystemEffectsProperties; // // Get the current value // PropVariantInit(&var); if (m_spAPOSystemEffectsProperties != NULL) { // Get the state of whether channel swap LFX is enabled or not hr = m_spAPOSystemEffectsProperties->GetValue(PKEY_Endpoint_Enable_Channel_Swap_LFX, &var); if (SUCCEEDED(hr) && (var.vt == VT_UI4)) { if (var.ulVal == 0L) { m_fEnableSwapLFX = FALSE; } else { m_fEnableSwapLFX = TRUE; } } else { PropVariantClear(&var); } } // // Register for notification of registry updates // hr = m_spEnumerator.CoCreateInstance(__uuidof(MMDeviceEnumerator)); IF_FAILED_JUMP(hr, Exit); hr = m_spEnumerator->RegisterEndpointNotificationCallback(this); IF_FAILED_JUMP(hr, Exit); m_bIsInitialized = true; Exit: return hr; }
/////////////////////////////////////////////////////////////////////////// // // Function: // EnumDevice // // Description: // Enumerate audio device and return the device information. // // Parameters: // eDataFlow: eRender for render device, eCapture for capture device // uNumElements: Size of audio device info structure array. // pDevicInfo: device info structure array. Caller is responsible to allocate and free // memory. The array size is specified by uNumElements. // // Return: // S_OK if successful // /////////////////////////////////////////////////////////////////////////////// HRESULT EnumDevice(EDataFlow eDataFlow, UINT uNumElements, AUDIO_DEVICE_INFO *pDevicInfo) { HRESULT hResult = S_OK; WCHAR* pszDeviceId = NULL; PROPVARIANT value; UINT index, dwCount; bool IsMicArrayDevice; CComPtr<IMMDeviceEnumerator> spEnumerator; CComPtr<IMMDeviceCollection> spEndpoints; hResult = spEnumerator.CoCreateInstance(__uuidof(MMDeviceEnumerator)); IF_FAILED_JUMP(hResult, Exit); hResult = spEnumerator->EnumAudioEndpoints(eDataFlow, DEVICE_STATE_ACTIVE, &spEndpoints); IF_FAILED_JUMP(hResult, Exit); hResult = spEndpoints->GetCount(&dwCount); IF_FAILED_JUMP(hResult, Exit); if (dwCount != uNumElements) return E_INVALIDARG; ZeroMemory(pDevicInfo, sizeof(AUDIO_DEVICE_INFO)*uNumElements); for (index = 0; index < dwCount; index++) { CComPtr<IMMDevice> spDevice; CComPtr<IPropertyStore> spProperties; PropVariantInit(&value); hResult = spEndpoints->Item(index, &spDevice); IF_FAILED_JUMP(hResult, Exit); hResult = spDevice->GetId(&pszDeviceId); IF_FAILED_JUMP(hResult, Exit); hResult = spDevice->OpenPropertyStore(STGM_READ, &spProperties); IF_FAILED_JUMP(hResult, Exit); hResult = spProperties->GetValue(PKEY_Device_FriendlyName, &value); IF_FAILED_JUMP(hResult, Exit); EndpointIsMicArray(spDevice, IsMicArrayDevice); StringCchCopy(pDevicInfo[index].szDeviceID, MAX_STR_LEN-1, pszDeviceId); StringCchCopy(pDevicInfo[index].szDeviceName, MAX_STR_LEN-1, value.pwszVal); pDevicInfo[index].bIsMicArrayDevice = IsMicArrayDevice; PropVariantClear(&value); CoTaskMemFree(pszDeviceId); pszDeviceId = NULL; } Exit: return hResult; }
std::string CAESinkDirectSound::GetDefaultDevice() { IMMDeviceEnumerator* pEnumerator = NULL; IMMDevice* pDevice = NULL; IPropertyStore* pProperty = NULL; HRESULT hr; PROPVARIANT varName; std::string strDevName = "default"; hr = CoCreateInstance(CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, IID_IMMDeviceEnumerator, (void**)&pEnumerator); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Could not allocate WASAPI device enumerator. CoCreateInstance error code: %s", WASAPIErrToStr(hr)); goto failed; } hr = pEnumerator->GetDefaultAudioEndpoint(eRender, eMultimedia, &pDevice); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of audio endpoint enumeration failed."); goto failed; } hr = pDevice->OpenPropertyStore(STGM_READ, &pProperty); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of DirectSound endpoint properties failed."); goto failed; } PropVariantInit(&varName); hr = pProperty->GetValue(PKEY_AudioEndpoint_FormFactor, &varName); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of DirectSound endpoint form factor failed."); goto failed; } AEDeviceType aeDeviceType = winEndpoints[(EndpointFormFactor)varName.uiVal].aeDeviceType; PropVariantClear(&varName); hr = pProperty->GetValue(PKEY_AudioEndpoint_GUID, &varName); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of DirectSound endpoint GUID failed."); goto failed; } strDevName = localWideToUtf(varName.pwszVal); PropVariantClear(&varName); failed: SAFE_RELEASE(pProperty); SAFE_RELEASE(pDevice); SAFE_RELEASE(pEnumerator); return strDevName; }
STDMETHODIMP tTVPPlayerCallback::Invoke( IMFAsyncResult *pAsyncResult ) { HRESULT hr; MediaEventType met = MESessionClosed; CComPtr<IMFMediaEvent> pMediaEvent; if( SUCCEEDED(hr = owner_->GetMediaSession()->EndGetEvent( pAsyncResult, &pMediaEvent )) ) { if( SUCCEEDED(hr = pMediaEvent->GetType(&met)) ) { PROPVARIANT pvValue; PropVariantInit(&pvValue); switch( met ) { case MESessionClosed: owner_->OnMediaItemCleared(); break; case MESessionPaused: owner_->OnPause(); break; case MESessionEnded: owner_->OnPlayBackEnded(); break; case MESessionNotifyPresentationTime: break; case MESessionRateChanged: if( SUCCEEDED(pMediaEvent->GetValue( &pvValue )) ) { double value; if( FAILED(PropVariantToDouble(pvValue,&value)) ) { value = 1.0; } owner_->OnRateSet(value); } else { owner_->OnRateSet(1.0); } break; case MESessionScrubSampleComplete: break; case MESessionStarted: owner_->OnPlay(); break; case MESessionStopped: owner_->OnStop(); break; case MESessionStreamSinkFormatChanged: break; case MESessionTopologiesCleared: break; case MESessionTopologySet: break; case MESessionTopologyStatus: { UINT32 status = MF_TOPOSTATUS_INVALID; pMediaEvent->GetUINT32( MF_EVENT_TOPOLOGY_STATUS, &status ); owner_->OnTopologyStatus(status); break; } } PropVariantClear(&pvValue); } owner_->GetMediaSession()->BeginGetEvent( this, NULL ); } return S_OK; }
void CWordBinaryMetadataDiscoveryWorker::DiscoverSummaryInformation(REFFMTID iidPropsertySet) { bool bNotFound; OpenPropertySet(iidPropsertySet, bNotFound); if(bNotFound) { ClosePropertySet(); return; } if(NULL == m_pPropertyStg) throw Workshare::Exception(_T("NULL pointer encountered (m_pPropertyStg)")); IEnumSTATPROPSTG *pEnumProp; HRESULT hRes = m_pPropertyStg->Enum(&pEnumProp); if(FAILED(hRes)) { ClosePropertySet(); HandlePropertyError(_T(__FUNCTION__), _T("Enumerate user-defined properties failed"), hRes); return; } STATPROPSTG PropertyInformation; ZeroMemory(&PropertyInformation, sizeof(STATPROPSTG)); PROPSPEC propSpec; PROPVARIANT propVar; SetCodePageProperty(); while(S_OK == pEnumProp->Next(1, &PropertyInformation, NULL)) { PropVariantInit(&propVar); // Build a PROPSPEC for this property. ZeroMemory(&propSpec, sizeof(PROPSPEC)); propSpec.ulKind = PRSPEC_PROPID; propSpec.propid = PropertyInformation.propid; // Read this property. hRes = m_pPropertyStg->ReadMultiple(1, &propSpec, &propVar); if(SUCCEEDED(hRes)) { if (FMTID_SummaryInformation == iidPropsertySet) AddBuiltInPropertyForSummary(propVar, PropertyInformation.propid); else if (FMTID_DocSummaryInformation == iidPropsertySet) AddBuiltInPropertyForDocSummary(propVar, PropertyInformation.propid); } else { CStdString sErr; sErr.Format(_T("Failed to read property id: %d, error code: %d"), propSpec.propid, hRes); LOG_WS_ERROR(sErr); } } pEnumProp->Release(); ClosePropertySet(); }
/** * This method is called when we receive a WPD_COMMAND_CAPABILITIES_GET_SUPPORTED_FORMATS * command. This message is sent when the client needs to know the possible formats supported * by the specified content type (e.g. for image objects, the driver may choose to support JPEG and BMP files). * * The parameters sent to us are: * - WPD_PROPERTY_CAPABILITIES_CONTENT_TYPE - a GUID value containing the content type * whose formats the caller is interested in. If the value is WPD_CONTENT_TYPE_ALL, then the driver * must return a list of all formats supported by the device. * * The driver should: * - Return an IPortableDevicePropVariantCollection (of type VT_CLSID) in * WPD_PROPERTY_CAPABILITIES_FORMATS, indicating the formats supported by the * specified content type. * If there are no formats supported by the specified content type, the driver should return an * empty collection. */ HRESULT WpdCapabilities::OnGetSupportedFormats( _In_ IPortableDeviceValues* pParams, _In_ IPortableDeviceValues* pResults) { HRESULT hr = S_OK; GUID guidContentType = GUID_NULL; CComPtr<IPortableDevicePropVariantCollection> pFormats; // First get ALL parameters for this command. If we cannot get ALL parameters // then E_INVALIDARG should be returned and no further processing should occur. // Get the content type whose supported formats have been requested if (hr == S_OK) { hr = pParams->GetGuidValue(WPD_PROPERTY_CAPABILITIES_CONTENT_TYPE, &guidContentType); CHECK_HR(hr, "Missing value for WPD_PROPERTY_CAPABILITIES_CONTENT_TYPE"); } // CoCreate a collection to store the supported formats. if (hr == S_OK) { hr = CoCreateInstance(CLSID_PortableDevicePropVariantCollection, NULL, CLSCTX_INPROC_SERVER, IID_IPortableDevicePropVariantCollection, (VOID**) &pFormats); CHECK_HR(hr, "Failed to CoCreate CLSID_PortableDevicePropVariantCollection"); } // Add the supported formats for the specified content type to the collection. if (hr == S_OK) { PROPVARIANT pv = {0}; PropVariantInit(&pv); // Don't call PropVariantClear, since we did not allocate the memory for these GUIDs if ((guidContentType == WPD_CONTENT_TYPE_DOCUMENT) || ((guidContentType == WPD_CONTENT_TYPE_ALL))) { // Add WPD_OBJECT_FORMAT_TEXT to the supported formats collection pv.vt = VT_CLSID; pv.puuid = (CLSID*)&WPD_OBJECT_FORMAT_TEXT; hr = pFormats->Add(&pv); CHECK_HR(hr, "Failed to add WPD_OBJECT_FORMAT_TEXT"); } } // Set the WPD_PROPERTY_CAPABILITIES_FORMATS value in the results. if (hr == S_OK) { hr = pResults->SetIUnknownValue(WPD_PROPERTY_CAPABILITIES_FORMATS, pFormats); CHECK_HR(hr, "Failed to set WPD_PROPERTY_CAPABILITIES_FORMATS"); } return hr; }
//! Retrieves the value associated with pkey, if it exists. QVariant ShellNodeInfo::propertyValue(const PROPERTYKEY &pkey) { QVariant ret; PROPVARIANT var; PropVariantInit(&var); if (d->item->GetProperty(pkey, &var) == S_OK) ret = util::fromPROPVARIANT(var); PropVariantClear(&var); return ret; }
void MFDecoderSourceReader::reset() { if (!m_sourceReader) return; PROPVARIANT vPos; PropVariantInit(&vPos); vPos.vt = VT_I8; vPos.uhVal.QuadPart = 0; m_sourceReader->SetCurrentPosition(GUID_NULL, vPos); }
//nog werk nodig! met de union!! PROPVARIANT ConvertJavaToPropVariant(JNIEnv* env, jobject jobjPropVariant) { //variabelen jclass cls; jmethodID mid; PROPVARIANT pv; jstring jsValue; LPWSTR wszBuffer; LPWSTR wszValue; jobject jobjObjectValue; //methode implementatie PropVariantInit(&pv); cls = env->FindClass("jmtp/PropVariant"); //printf("convert 1\n"); mid = env->GetMethodID(cls, "getVt", "()I"); pv.vt = static_cast<VARTYPE>(env->CallIntMethod(jobjPropVariant, mid)); //printf("convert 2\n"); int strLength; switch(pv.vt) { case VT_LPWSTR: //printf("convert 3\n"); mid = env->GetMethodID(cls, "getValue", "()Ljava/lang/Object;"); jsValue = (jstring)env->CallObjectMethod(jobjPropVariant, mid); strLength = env->GetStringLength(jsValue); //printf("convert3.4:%d\n", strLength); wszBuffer = ConvertJavaStringToWCHAR(env, jsValue); //(WCHAR*)env->GetStringChars(jsValue, NULL); wszValue = new WCHAR[strLength+1]; if (wszValue == NULL) { //printf("conver tproblem null\n"); } for (int i = 0; i < strLength; i++) { wszValue[i] = wszBuffer[i]; } wszValue[strLength] = 0; //wcscpy_s(wszValue, strLength, wszBuffer); //wprintf(L"convert3.5:%s\n", wszBuffer); //wprintf(L"convert3.6:%s\n", wszValue); delete wszBuffer; pv.pwszVal = wszValue; //wprintf(L"convert4:%s\n", pv.pwszVal); break; case VT_BOOL: mid = env->GetMethodID(cls, "getValue", "()Ljava/lang/Object;"); jobjObjectValue = env->CallObjectMethod(jobjPropVariant, mid); mid = env->GetMethodID(env->FindClass("java/lang/Boolean"), "booleanValue", "()Z"); pv.boolVal = env->CallBooleanMethod(jobjObjectValue, mid); break; } //andere types worden momenteel niet ondersteunt return pv; }
void CMFCamCapture::runSession() { PROPVARIANT var; PropVariantInit(&var); HRESULT hr = S_OK; CHECK_HR(hr = m_spSession->Start(&GUID_NULL, &var)); done: PropVariantClear(&var); }
// SINGLE_CHANNEL_AEC = 0 // OPTIBEAM_ARRAY_ONLY = 2 // OPTIBEAM_ARRAY_AND_AEC = 4 // SINGLE_CHANNEL_NSAGC = 5 void KinectAudioSource::SetSystemMode( LONG mode ) { // Set AEC-MicArray DMO system mode. // This must be set for the DMO to work properly PROPVARIANT pvSysMode; PropVariantInit(&pvSysMode); pvSysMode.vt = VT_I4; pvSysMode.lVal = mode; CHECKHR(propertyStore_->SetValue(MFPKEY_WMAAECMA_SYSTEM_MODE, pvSysMode)); PropVariantClear(&pvSysMode); }
HRESULT FakeDevice::GetFunctionalObjects( _In_ REFGUID guidFunctionalCategory, _In_ IPortableDevicePropVariantCollection* pFunctionalObjects) { HRESULT hr = S_OK; PROPVARIANT pv = {0}; if(pFunctionalObjects == NULL) { hr = E_POINTER; CHECK_HR(hr, "Cannot have NULL parameter"); return hr; } PropVariantInit(&pv); // Don't call PropVariantClear, since we did not allocate the memory for these object identifiers // Add WPD_DEVICE_OBJECT_ID to the functional object identifiers collection if ((guidFunctionalCategory == WPD_FUNCTIONAL_CATEGORY_DEVICE) || (guidFunctionalCategory == WPD_FUNCTIONAL_CATEGORY_ALL)) { pv.vt = VT_LPWSTR; pv.pwszVal = WPD_DEVICE_OBJECT_ID; hr = pFunctionalObjects->Add(&pv); CHECK_HR(hr, "Failed to add device object ID"); } // Add CONTACTS_SERVICE_OBJECT_ID to the functional object identifiers collection if (hr == S_OK) { if ((guidFunctionalCategory == SERVICE_Contacts) || (guidFunctionalCategory == WPD_FUNCTIONAL_CATEGORY_ALL)) { pv.vt = VT_LPWSTR; pv.pwszVal = CONTACTS_SERVICE_OBJECT_ID; hr = pFunctionalObjects->Add(&pv); CHECK_HR(hr, "Failed to add contacts service object ID"); } } // Add STORAGE_OBJECT_ID to the functional object identifiers collection // if request is not scoped by the contacts service if ((guidFunctionalCategory == WPD_FUNCTIONAL_CATEGORY_STORAGE) || (guidFunctionalCategory == WPD_FUNCTIONAL_CATEGORY_ALL)) { pv.vt = VT_LPWSTR; pv.pwszVal = STORAGE_OBJECT_ID; hr = pFunctionalObjects->Add(&pv); CHECK_HR(hr, "Failed to add storage object ID"); } return hr; }
/** Starts playback */ void FImfVideoPlayer::StartPlayback( ) { check( MediaSession != NULL ); PROPVARIANT VariantStart; PropVariantInit( &VariantStart ); HRESULT HResult = MediaSession->Start( &GUID_NULL, &VariantStart ); check( SUCCEEDED( HResult ) ); PropVariantClear( &VariantStart ); }
HRESULT CopyAttribute(IMFAttributes *pSrc, IMFAttributes *pDest, const GUID& key) { PROPVARIANT var; PropVariantInit( &var ); HRESULT hr = pSrc->GetItem(key, &var); if (SUCCEEDED(hr)) { hr = pDest->SetItem(key, var); PropVariantClear(&var); } return hr; }
void OleProperties::SetCodePageProperty(IPropertyStoragePtr& spPropertyStorage) { PROPSPEC propSpecification = {0}; propSpecification.ulKind = PRSPEC_PROPID; propSpecification.propid = PID_CODEPAGE; PROPVARIANT propVariant; PropVariantInit(&propVariant); HRESULT hResult = spPropertyStorage->ReadMultiple(1, &propSpecification, &propVariant); if (S_OK == hResult) m_wCodePage = propVariant.iVal; }
void MediaPlayerPrivateMediaFoundation::seekDouble(double time) { const double tenMegahertz = 10000000; PROPVARIANT propVariant; PropVariantInit(&propVariant); propVariant.vt = VT_I8; propVariant.hVal.QuadPart = static_cast<__int64>(time * tenMegahertz); HRESULT hr = m_mediaSession->Start(&GUID_NULL, &propVariant); ASSERT(SUCCEEDED(hr)); PropVariantClear(&propVariant); }
PLUGIN_EXPORT LPCWSTR GetString(void* data) { static WCHAR result[256]; wsprintf(result, L"ERROR"); if (!InitCom() || !pEnumerator) { UnInitCom(); wsprintf(result, L"ERROR - Initializing COM"); return result; } IMMDevice * pEndpoint = 0; if (pEnumerator->GetDefaultAudioEndpoint(eRender, eConsole, &pEndpoint) == S_OK) { IPropertyStore * pProps = 0; if (pEndpoint->OpenPropertyStore(STGM_READ, &pProps) == S_OK) { PROPVARIANT varName; PropVariantInit(&varName); if (pProps->GetValue(PKEY_Device_DeviceDesc, &varName) == S_OK) { wcsncpy(result, varName.pwszVal, 255); PropVariantClear(&varName); SAFE_RELEASE(pProps) SAFE_RELEASE(pEndpoint) UnInitCom(); return result; } else { PropVariantClear(&varName); SAFE_RELEASE(pProps) SAFE_RELEASE(pEndpoint) wsprintf(result, L"ERROR - Getting Device Description"); } } else { SAFE_RELEASE(pProps) SAFE_RELEASE(pEndpoint) wsprintf(result, L"ERROR - Getting Property"); } } else { SAFE_RELEASE(pEndpoint) wsprintf(result, L"ERROR - Getting Default Device"); } UnInitCom(); return result; }
void CWordBinaryMetadataDiscoveryWorker::SetCodePageProperty() { PROPSPEC propSpec; PROPVARIANT propVar; PropVariantInit(&propVar); ZeroMemory(&propSpec, sizeof(PROPSPEC)); propSpec.ulKind = PRSPEC_PROPID; propSpec.propid = PID_CODEPAGE; HRESULT hRes = m_pPropertyStg->ReadMultiple(1, &propSpec, &propVar); if (hRes == S_OK) m_wCodePage = propVar.iVal; }
BOOL PyObject_AsPROPVARIANT(PyObject *ob, PROPVARIANT *pVar) { if (ob==Py_None) { PropVariantInit(pVar); } else if (ob==Py_True) { pVar->boolVal = -1; pVar->vt = VT_BOOL; } else if (ob==Py_False) { pVar->boolVal = 0; pVar->vt = VT_BOOL; } else if (PyLong_Check(ob)) { pVar->hVal.QuadPart = PyLong_AsLongLong(ob); if (pVar->hVal.QuadPart == -1 && PyErr_Occurred()){ // Could still fit in an unsigned long long PyErr_Clear(); pVar->uhVal.QuadPart = PyLong_AsUnsignedLongLong(ob); if (pVar->uhVal.QuadPart == -1 && PyErr_Occurred()) return FALSE; pVar->vt = VT_UI8; } else{ pVar->vt=VT_I8; // Could still fit in a regular long if (pVar->hVal.QuadPart >= LONG_MIN && pVar->hVal.QuadPart <= LONG_MAX){ pVar->lVal = (long)pVar->hVal.QuadPart; pVar->vt = VT_I4; } // ... or an unsigned long else if (pVar->hVal.QuadPart >=0 && pVar->hVal.QuadPart <= ULONG_MAX){ pVar->ulVal = (unsigned long)pVar->hVal.QuadPart; pVar->vt = VT_UI4; } } #if (PY_VERSION_HEX < 0x03000000) // Not needed in Py3k, as PyInt_Check is defined to PyLong_Check } else if (PyInt_Check(ob)) { pVar->lVal = PyInt_AsLong(ob); pVar->vt = VT_I4; #endif } else if (PyFloat_Check(ob)) { pVar->dblVal = PyFloat_AsDouble(ob); pVar->vt = VT_R8; } else if (PyUnicode_Check(ob) || PyString_Check(ob)) { PyWinObject_AsBstr(ob, &pVar->bstrVal); pVar->vt = VT_BSTR; } else { PyErr_SetString(PyExc_TypeError, "Unsupported object for PROPVARIANT"); return FALSE; } return TRUE; }
static void test_BodyDeleteProp(void) { static const char topic[] = "wine topic"; HRESULT hr; IMimeMessage *msg; IMimeBody *body; PROPVARIANT prop; hr = MimeOleCreateMessage(NULL, &msg); ok(hr == S_OK, "ret %08x\n", hr); PropVariantInit(&prop); hr = IMimeMessage_BindToObject(msg, HBODY_ROOT, &IID_IMimeBody, (void**)&body); ok(hr == S_OK, "ret %08x\n", hr); hr = IMimeBody_DeleteProp(body, "Subject"); ok(hr == MIME_E_NOT_FOUND, "ret %08x\n", hr); hr = IMimeBody_DeleteProp(body, PIDTOSTR(PID_HDR_SUBJECT)); ok(hr == MIME_E_NOT_FOUND, "ret %08x\n", hr); prop.vt = VT_LPSTR; prop.u.pszVal = CoTaskMemAlloc(strlen(topic)+1); strcpy(prop.u.pszVal, topic); hr = IMimeBody_SetProp(body, "Subject", 0, &prop); ok(hr == S_OK, "ret %08x\n", hr); PropVariantClear(&prop); hr = IMimeBody_DeleteProp(body, "Subject"); ok(hr == S_OK, "ret %08x\n", hr); hr = IMimeBody_GetProp(body, "Subject", 0, &prop); ok(hr == MIME_E_NOT_FOUND, "ret %08x\n", hr); prop.vt = VT_LPSTR; prop.u.pszVal = CoTaskMemAlloc(strlen(topic)+1); strcpy(prop.u.pszVal, topic); hr = IMimeBody_SetProp(body, PIDTOSTR(PID_HDR_SUBJECT), 0, &prop); ok(hr == S_OK, "ret %08x\n", hr); PropVariantClear(&prop); hr = IMimeBody_DeleteProp(body, PIDTOSTR(PID_HDR_SUBJECT)); ok(hr == S_OK, "ret %08x\n", hr); hr = IMimeBody_GetProp(body, PIDTOSTR(PID_HDR_SUBJECT), 0, &prop); ok(hr == MIME_E_NOT_FOUND, "ret %08x\n", hr); IMimeBody_Release(body); IMimeMessage_Release(msg); }
const QHash<QString, QString> WASAPISystem::getDevices(EDataFlow dataflow) { QHash<QString, QString> devices; HRESULT hr; IMMDeviceEnumerator *pEnumerator = NULL; IMMDeviceCollection *pCollection = NULL; hr = CoCreateInstance(__uuidof(MMDeviceEnumerator), NULL, CLSCTX_ALL, __uuidof(IMMDeviceEnumerator), reinterpret_cast<void **>(&pEnumerator)); if (! pEnumerator || FAILED(hr)) { qWarning("WASAPI: Failed to instatiate enumerator"); } else { hr = pEnumerator->EnumAudioEndpoints(dataflow, DEVICE_STATE_ACTIVE, &pCollection); if (! pCollection || FAILED(hr)) { qWarning("WASAPI: Failed to enumerate"); } else { devices.insert(QString(), tr("Default Device")); UINT ndev = 0; pCollection->GetCount(&ndev); for (unsigned int idx=0;idx<ndev;++idx) { IMMDevice *pDevice = NULL; IPropertyStore *pStore = NULL; pCollection->Item(idx, &pDevice); pDevice->OpenPropertyStore(STGM_READ, &pStore); LPWSTR strid = NULL; pDevice->GetId(&strid); PROPVARIANT varName; PropVariantInit(&varName); pStore->GetValue(PKEY_Device_FriendlyName, &varName); devices.insert(QString::fromWCharArray(strid), QString::fromWCharArray(varName.pwszVal)); PropVariantClear(&varName); CoTaskMemFree(strid); pStore->Release(); pDevice->Release(); } pCollection->Release(); } pEnumerator->Release(); } return devices; }
STDMETHODIMP CLocationReport::GetValue(REFPROPERTYKEY pKey, PROPVARIANT *pValue) { HRESULT hr = S_OK; // properties for civic address reports if (pKey.pid == SENSOR_DATA_TYPE_ADDRESS1.pid) { hr = InitPropVariantFromString(m_address1, pValue); } else if (pKey.pid == SENSOR_DATA_TYPE_ADDRESS2.pid) { hr = InitPropVariantFromString(m_address2, pValue); } else if (pKey.pid == SENSOR_DATA_TYPE_CITY.pid) { hr = InitPropVariantFromString(m_city, pValue); } else if (pKey.pid == SENSOR_DATA_TYPE_STATE_PROVINCE.pid) { hr = InitPropVariantFromString(m_stateprovince, pValue); } else if (pKey.pid == SENSOR_DATA_TYPE_POSTALCODE.pid) { hr = InitPropVariantFromString(m_postalcode, pValue); } else if (pKey.pid == SENSOR_DATA_TYPE_COUNTRY_REGION.pid) { hr = InitPropVariantFromString(m_countryregion, pValue); } // properties for latitude/longitude reports else if (pKey.pid == SENSOR_DATA_TYPE_LATITUDE_DEGREES.pid) { hr = InitPropVariantFromDouble(m_latitude, pValue); } else if (pKey.pid == SENSOR_DATA_TYPE_LONGITUDE_DEGREES.pid) { hr = InitPropVariantFromDouble(m_longitude, pValue); } else if (pKey.pid == SENSOR_DATA_TYPE_ERROR_RADIUS_METERS.pid) { hr = InitPropVariantFromDouble(m_errorradius, pValue); } else { hr = HRESULT_FROM_WIN32(ERROR_NO_DATA); PropVariantInit(pValue); } return hr; }
// Private method // dwKeyName means: // 0 DeviceDesc (main name) // 1 DeviceInterface_FriendlyName (interface name) // 2 Device_FriendlyName (main name + interface name) void _GetDeviceName(IMMDevice *pDevice, LPWSTR pszBuffer, int bufferLen, DWORD dwKeyName) { static const WCHAR szDefault[] = L"<Device not available>"; HRESULT hr = E_FAIL; IPropertyStore *pProps = NULL; PROPVARIANT varName; // Initialize container for property value. PropVariantInit(&varName); // assert(pszBuffer != NULL); // assert(bufferLen > 0); // assert(dwKeyName == 0 || dwKeyName == 1 || dwKeyName == 2); if (pDevice != NULL) { hr = pDevice->OpenPropertyStore(STGM_READ, &pProps); if (hr == S_OK) { switch (dwKeyName) { case 0: hr = pProps->GetValue(PKEY_Device_DeviceDesc, &varName); break; case 1: hr = pProps->GetValue(PKEY_DeviceInterface_FriendlyName, &varName); break; case 2: hr = pProps->GetValue(PKEY_Device_FriendlyName, &varName); break; } } } if (hr == S_OK) { // Found the device name. wcsncpy_s(pszBuffer, bufferLen, varName.pwszVal, _TRUNCATE); } else { // Failed to find the device name. wcsncpy_s(pszBuffer, bufferLen, szDefault, _TRUNCATE); } PropVariantClear(&varName); SAFE_RELEASE(pProps); return; }
///////////////////////////////////////////////////////////////////////// // // GetStoredApplicationOrder() // // Retrieves the gadget order from the property store. The memory must // be CoTaskMemFree'd by the caller. // // Parameters: // ppAppIds [out] // A pointer to an array of APPLICATION_IDs that upon return will // contain the application IDs in the order that they should be // presented on the device // pcAppIds [out] // A pointer to a DWORD that upon return will contain the count of // APPLICATION_ID contained in the array pointed to by ppAppIds. // // Return Values: // S_OK: Success // ///////////////////////////////////////////////////////////////////////// HRESULT CWssBasicDDI::GetStoredApplicationOrder(APPLICATION_ID** ppAppIds, DWORD* pcAppIds) { if ((NULL == m_pUserSID) || (0 == IsValidSid(m_pUserSID)) || (NULL == m_pPropertyStore)) { return E_UNEXPECTED; } HRESULT hr = S_OK; LPTSTR wszKey = NULL; // Initialize out parameters *ppAppIds = NULL; *pcAppIds = 0; // // Get the key to use for the property store // hr = GetApplicationOrderString(&wszKey); // // Put the data into a PROPVARIANT, and store it in the property store // if ((SUCCEEDED(hr)) && (NULL != wszKey)) { PROPVARIANT pvBlob = {0}; PropVariantInit(&pvBlob); hr = m_pPropertyStore->GetNamedValue(wszKey, &pvBlob); if (SUCCEEDED(hr) && (VT_BLOB == pvBlob.vt) && (0 == (pvBlob.blob.cbSize % sizeof(APPLICATION_ID)))) { *pcAppIds = pvBlob.blob.cbSize / sizeof(APPLICATION_ID); *ppAppIds = (APPLICATION_ID*)pvBlob.blob.pBlobData; } // Don't clear the PROPVARIANT because we don't want to erase the memory that we pass out of this method } if (NULL != wszKey) { ::CoTaskMemFree(wszKey); } return hr; }
/** * This method is called when we receive a WPD_COMMAND_CAPABILITIES_GET_SUPPORTED_FUNCTIONAL_CATEGORIES * command. * * The parameters sent to us are: * - none. * * The driver should: * - Return an IPortableDevicePropVariantCollection (of type VT_CLSID) in * WPD_PROPERTY_CAPABILITIES_FUNCTIONAL_CATEGORIES, containing * the supported functional categories for this device. */ HRESULT WpdCapabilities::OnGetFunctionalCategories( _In_ IPortableDeviceValues* pParams, _In_ IPortableDeviceValues* pResults) { HRESULT hr = S_OK; CComPtr<IPortableDevicePropVariantCollection> pFunctionalCategories; UNREFERENCED_PARAMETER(pParams); // CoCreate a collection to store the supported functional categories. if (hr == S_OK) { hr = CoCreateInstance(CLSID_PortableDevicePropVariantCollection, NULL, CLSCTX_INPROC_SERVER, IID_IPortableDevicePropVariantCollection, (VOID**) &pFunctionalCategories); CHECK_HR(hr, "Failed to CoCreate CLSID_PortableDevicePropVariantCollection"); } // Add the supported functional categories to the collection. if (hr == S_OK) { for (DWORD dwIndex = 0; dwIndex < ARRAYSIZE(g_SupportedFunctionalCategories); dwIndex++) { PROPVARIANT pv = {0}; PropVariantInit(&pv); // Don't call PropVariantClear, since we did not allocate the memory for these GUIDs pv.vt = VT_CLSID; pv.puuid = (GUID*) &g_SupportedFunctionalCategories[dwIndex]; hr = pFunctionalCategories->Add(&pv); CHECK_HR(hr, "Failed to add supported functional category at index %d", dwIndex); if (FAILED(hr)) { break; } } } // Set the WPD_PROPERTY_CAPABILITIES_FUNCTIONAL_CATEGORIES value in the results. if (hr == S_OK) { hr = pResults->SetIUnknownValue(WPD_PROPERTY_CAPABILITIES_FUNCTIONAL_CATEGORIES, pFunctionalCategories); CHECK_HR(hr, "Failed to set WPD_PROPERTY_CAPABILITIES_FUNCTIONAL_CATEGORIES"); } return hr; }