static HRESULT DeviceNameGet( IMMDeviceCollection *dc, UINT id, wchar_t *name, size_t nameBytes) { HRESULT hr = 0; IMMDevice *device = nullptr; LPWSTR deviceId = nullptr; IPropertyStore *ps = nullptr; PROPVARIANT pv; assert(dc); assert(name); name[0] = 0; assert(0 < nameBytes); PropVariantInit(&pv); HRR(dc->Item(id, &device)); HRR(device->GetId(&deviceId)); HRR(device->OpenPropertyStore(STGM_READ, &ps)); HRG(ps->GetValue(PKEY_Device_FriendlyName, &pv)); SafeRelease(&ps); wcsncpy_s(name, nameBytes / sizeof name[0], pv.pwszVal, _TRUNCATE); end: PropVariantClear(&pv); CoTaskMemFree(deviceId); SafeRelease(&ps); return hr; }
HRESULT CPlayer::GetBufferProgress( DWORD *pProgress ) { IPropertyStore *pProp = NULL; PROPVARIANT var; // Get the property store from the media session. HRESULT hr = MFGetService( m_pSession, MFNETSOURCE_STATISTICS_SERVICE, IID_PPV_ARGS( &pProp ) ); if ( SUCCEEDED( hr ) ) { PROPERTYKEY key; key.fmtid = MFNETSOURCE_STATISTICS; key.pid = MFNETSOURCE_BUFFERPROGRESS_ID; hr = pProp->GetValue( key, &var ); } if ( SUCCEEDED( hr ) ) { *pProgress = var.lVal; // cout << "buff prog " << *pProgress << endl; } PropVariantClear( &var ); SafeRelease( &pProp ); return hr; }
// (static) Creates a ShellLink that encapsulate a separator. nsresult JumpListSeparator::GetSeparator(nsRefPtr<IShellLinkW>& aShellLink) { HRESULT hr; IShellLinkW* psl; // Create a IShellLink. hr = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLinkW, (LPVOID*)&psl); if (FAILED(hr)) return NS_ERROR_UNEXPECTED; IPropertyStore* pPropStore = nullptr; hr = psl->QueryInterface(IID_IPropertyStore, (LPVOID*)&pPropStore); if (FAILED(hr)) return NS_ERROR_UNEXPECTED; PROPVARIANT pv; InitPropVariantFromBoolean(TRUE, &pv); pPropStore->SetValue(PKEY_AppUserModel_IsDestListSeparator, pv); pPropStore->Commit(); pPropStore->Release(); PropVariantClear(&pv); aShellLink = dont_AddRef(psl); return NS_OK; }
void JumpListsManager::addTask(ActionInfo *info) { if (!m_destList) return; WinApi::IShellLinkW *task; HRESULT res = CoCreateInstance(WinApi::CLSID_ShellLink, 0, CLSCTX_INPROC_SERVER, WinApi::IID_IShellLinkW, (void**)&task); if (FAILED(res)) return; task->SetDescription(info->description); task->SetPath(L"rundll32.exe"); task->SetArguments(makeArgs(info).c_str()); if (info->iconPath) task->SetIconLocation(info->iconPath, 0); IPropertyStore *title; PROPVARIANT titlepv; res = task->QueryInterface(IID_IPropertyStore, (void**)&title); if (FAILED(res)) { task->Release(); return; } InitPropVariantFromString(info->name, &titlepv); title->SetValue(PKEY_Title, titlepv); title->Commit(); WinApi::PropVariantClear(&titlepv); res = m_destListContent->AddObject(task); title->Release(); task->Release(); m_actionInfoMap.insert(std::make_pair(info->id, info)); }
HRESULT _CreateSeparatorLink(IShellLink **ppsl) { IPropertyStore *pps; HRESULT hr = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pps)); if (SUCCEEDED(hr)) { PROPVARIANT propvar; hr = InitPropVariantFromBoolean(TRUE, &propvar); if (SUCCEEDED(hr)) { hr = pps->SetValue(PKEY_AppUserModel_IsDestListSeparator, propvar); if (SUCCEEDED(hr)) { hr = pps->Commit(); if (SUCCEEDED(hr)) { hr = pps->QueryInterface(IID_PPV_ARGS(ppsl)); } } PropVariantClear(&propvar); } pps->Release(); } return hr; }
HRESULT GetPropertyValue(PCWSTR pszFilename, PCWSTR pszCanonicalName) { // Convert the Canonical name of the property to PROPERTYKEY PROPERTYKEY key; HRESULT hr = PSGetPropertyKeyFromName(pszCanonicalName, &key); if (SUCCEEDED(hr)) { IPropertyStore* pps = NULL; // Call the helper to get the property store for the initialized item hr = GetPropertyStore(pszFilename, GPS_DEFAULT, &pps); if (SUCCEEDED(hr)) { hr = PrintProperty(pps, key, pszCanonicalName); pps->Release(); } else { wprintf(L"Error %x: getting the propertystore for the item.\n", hr); } } else { wprintf(L"Invalid property specified: %s\n", pszCanonicalName); } return hr; }
// // Retrieves the device friendly name for a particular device in a device collection. // // The returned string was allocated using malloc() so it should be freed using free(); // String GetDeviceName(IMMDeviceCollection *DeviceCollection, UINT DeviceIndex) { IMMDevice *device; LPWSTR deviceId; HRESULT hr; hr = DeviceCollection->Item(DeviceIndex, &device); PersistentAssert(SUCCEEDED(hr), "DeviceCollection->Item failed"); hr = device->GetId(&deviceId); PersistentAssert(SUCCEEDED(hr), "device->GetId failed"); IPropertyStore *propertyStore; hr = device->OpenPropertyStore(STGM_READ, &propertyStore); SafeRelease(&device); PersistentAssert(SUCCEEDED(hr), "device->OpenPropertyStore failed"); PROPVARIANT friendlyName; PropVariantInit(&friendlyName); hr = propertyStore->GetValue(PKEY_Device_FriendlyName, &friendlyName); SafeRelease(&propertyStore); PersistentAssert(SUCCEEDED(hr), "propertyStore->GetValue failed"); String Result = String(UnicodeString(friendlyName.pwszVal)); // + String(" (") + String( UnicodeString(deviceId) ) + String(")") PropVariantClear(&friendlyName); CoTaskMemFree(deviceId); return Result; }
// // 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; } }
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; }
HRESULT CTaskbar7::CreateShellLink(Destination destination, IShellLink **ppShellLink) { USES_CONVERSION; IShellLink *pShellLink = NULL; IPropertyStore *pPropertyStore = NULL; PROPVARIANT propVariant; HRESULT hr = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pShellLink)); EXIT_ON_ERROR(hr); // Path hr = pShellLink->SetPath(CW2A(destination.path.c_str())); EXIT_ON_ERROR(hr); // Arguments hr = pShellLink->SetArguments(CW2A(destination.arguments.c_str())); EXIT_ON_ERROR(hr); // Working Directory if (!destination.workingFolder.empty()) { hr = pShellLink->SetWorkingDirectory(CW2A(destination.workingFolder.c_str())); EXIT_ON_ERROR(hr); } // Icon Location if (!destination.icon.empty()) { hr = pShellLink->SetIconLocation(CW2A(destination.icon.c_str()), destination.iconIndex); EXIT_ON_ERROR(hr); } hr = pShellLink->QueryInterface(IID_PPV_ARGS(&pPropertyStore)); EXIT_ON_ERROR(hr); // Name hr = InitPropVariantFromString(destination.name.c_str(), &propVariant); EXIT_ON_ERROR(hr); hr = pPropertyStore->SetValue(PKEY_Title, propVariant); EXIT_ON_ERROR(hr); hr = pPropertyStore->Commit(); EXIT_ON_ERROR(hr); hr = pShellLink->QueryInterface(IID_PPV_ARGS(ppShellLink)); Exit: PropVariantClear(&propVariant); SAFE_RELEASE(pPropertyStore); SAFE_RELEASE(pShellLink); return hr; }
HRESULT SetPropertyValue(PCWSTR pszFilename, PCWSTR pszCanonicalName, PCWSTR pszValue) { // Convert the Canonical name of the property to PROPERTYKEY PROPERTYKEY key; HRESULT hr = PSGetPropertyKeyFromName(pszCanonicalName, &key); if (SUCCEEDED(hr)) { IPropertyStore* pps = NULL; // Call the helper to get the property store for the // initialized item hr = GetPropertyStore(pszFilename, GPS_READWRITE, &pps); if (SUCCEEDED(hr)) { PROPVARIANT propvarValue = {0}; hr = InitPropVariantFromString(pszValue, &propvarValue); if (SUCCEEDED(hr)) { hr = PSCoerceToCanonicalValue(key, &propvarValue); if (SUCCEEDED(hr)) { // Set the value to the property store of the item. hr = pps->SetValue(key, propvarValue); if (SUCCEEDED(hr)) { // Commit does the actual writing back to the file stream. hr = pps->Commit(); if (SUCCEEDED(hr)) { wprintf(L"Property %s value %s written successfully \n", pszCanonicalName, pszValue); } else { wprintf(L"Error %x: Commit to the propertystore failed.\n", hr); } } else { wprintf(L"Error %x: Set value to the propertystore failed.\n", hr); } } PropVariantClear(&propvarValue); } pps->Release(); } else { wprintf(L"Error %x: getting the propertystore for the item.\n", hr); } } else { wprintf(L"Invalid property specified: %s\n", pszCanonicalName); } return hr; }
void Win32TaskbarManager::addRecent(const Common::String &name, const Common::String &description) { //warning("[Win32TaskbarManager::addRecent] Adding recent list entry: %s (%s)", name.c_str(), description.c_str()); if (_taskbar == NULL) return; // ANSI version doesn't seem to work correctly with Win7 jump lists, so explicitly use Unicode interface. IShellLinkW *link; // Get the ScummVM executable path. WCHAR path[MAX_PATH]; GetModuleFileNameW(NULL, path, MAX_PATH); // Create a shell link. if (SUCCEEDED(CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC, IID_IShellLinkW, reinterpret_cast<void **> (&link)))) { // Convert game name and description to Unicode. LPWSTR game = ansiToUnicode(name.c_str()); LPWSTR desc = ansiToUnicode(description.c_str()); // Set link properties. link->SetPath(path); link->SetArguments(game); Common::String iconPath = getIconPath(name); if (iconPath.empty()) { link->SetIconLocation(path, 0); // No game-specific icon available } else { LPWSTR icon = ansiToUnicode(iconPath.c_str()); link->SetIconLocation(icon, 0); delete[] icon; } // The link's display name must be set via property store. IPropertyStore* propStore; HRESULT hr = link->QueryInterface(IID_IPropertyStore, reinterpret_cast<void **> (&(propStore))); if (SUCCEEDED(hr)) { PROPVARIANT pv; pv.vt = VT_LPWSTR; pv.pwszVal = desc; hr = propStore->SetValue(PKEY_Title, pv); propStore->Commit(); propStore->Release(); } // SHAddToRecentDocs will cause the games to be added to the Recent list, allowing the user to pin them. SHAddToRecentDocs(SHARD_LINK, link); link->Release(); delete[] game; delete[] desc; } }
HRESULT _CreateShellLink(PCSTR pszArguments, PCWSTR pszTitle, LPCSTR szDescription, IShellLink **ppsl) { IShellLink *psl; HRESULT hr = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&psl)); if (SUCCEEDED(hr)) { // Determine our executable's file path so the task will execute this application CHAR szAppPath[MAX_PATH]; if (GetModuleFileName(NULL, szAppPath, ARRAYSIZE(szAppPath))) { hr = psl->SetPath(szAppPath); if (SUCCEEDED(hr)) { hr = psl->SetArguments(pszArguments); if (SUCCEEDED(hr)) { hr = psl->SetDescription( szDescription ); if (SUCCEEDED(hr)) { // The title property is required on Jump List items provided as an IShellLink // instance. This value is used as the display name in the Jump List. IPropertyStore *pps; hr = psl->QueryInterface(IID_PPV_ARGS(&pps)); if (SUCCEEDED(hr)) { PROPVARIANT propvar; hr = InitPropVariantFromString(pszTitle, &propvar); if (SUCCEEDED(hr)) { hr = pps->SetValue(PKEY_Title, propvar); if (SUCCEEDED(hr)) { hr = pps->Commit(); if (SUCCEEDED(hr)) { hr = psl->QueryInterface(IID_PPV_ARGS(ppsl)); } } PropVariantClear(&propvar); } pps->Release(); } } } } } else { hr = HRESULT_FROM_WIN32(GetLastError()); } psl->Release(); } return hr; }
// (static) ShellItems are used to encapsulate links to things. We currently only support URI links, // but more support could be added, such as local file and directory links. nsresult JumpListLink::GetShellItem(nsCOMPtr<nsIJumpListItem>& item, nsRefPtr<IShellItem2>& aShellItem) { IShellItem2 *psi = nullptr; nsresult rv; int16_t type; if (NS_FAILED(item->GetType(&type))) return NS_ERROR_INVALID_ARG; if (type != nsIJumpListItem::JUMPLIST_ITEM_LINK) return NS_ERROR_INVALID_ARG; nsCOMPtr<nsIJumpListLink> link = do_QueryInterface(item, &rv); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIURI> uri; rv = link->GetUri(getter_AddRefs(uri)); NS_ENSURE_SUCCESS(rv, rv); nsAutoCString spec; rv = uri->GetSpec(spec); NS_ENSURE_SUCCESS(rv, rv); // Create the IShellItem if (FAILED(WinUtils::SHCreateItemFromParsingName( NS_ConvertASCIItoUTF16(spec).get(), NULL, IID_PPV_ARGS(&psi)))) { return NS_ERROR_INVALID_ARG; } // Set the title nsAutoString linkTitle; link->GetUriTitle(linkTitle); IPropertyStore* pPropStore = nullptr; HRESULT hres = psi->GetPropertyStore(GPS_DEFAULT, IID_IPropertyStore, (void**)&pPropStore); if (FAILED(hres)) return NS_ERROR_UNEXPECTED; PROPVARIANT pv; InitPropVariantFromString(linkTitle.get(), &pv); // May fail due to shell item access permissions. pPropStore->SetValue(PKEY_ItemName, pv); pPropStore->Commit(); pPropStore->Release(); PropVariantClear(&pv); aShellItem = dont_AddRef(psi); return NS_OK; }
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; }
BOOL install_util::CreateLnkPath(std::wstring wsSourceFilePath, std::wstring wsDestLnkPath, std::wstring wsArgument, std::wstring wsAppId) { IShellLink *pisl = NULL; HRESULT hr = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (void**)&pisl); if (FAILED(hr)) { return FALSE; } pisl->SetPath(wsSourceFilePath.c_str()); pisl->SetArguments(wsArgument.c_str()); int nStart = wsSourceFilePath.find_last_of(_T("/\\")); pisl->SetWorkingDirectory(wsSourceFilePath.substr(0,nStart).c_str()); IPersistFile *plPF = NULL; hr = pisl->QueryInterface(IID_IPersistFile, (void**)&plPF); bool shortcut_existed = false; if (SUCCEEDED(hr)) { if (PathExists(wsDestLnkPath)) { shortcut_existed = true; install_util::DeleteFile(wsDestLnkPath.c_str()); } if (Win7OrLater() && !wsAppId.empty() && wsAppId.length() < 64) { IPropertyStore *piPS = NULL; if (SUCCEEDED(pisl->QueryInterface(IID_IPropertyStore, (void**)&piPS))) { PROPVARIANT property_value; if (SUCCEEDED(InitPropVariantFromString(wsAppId.c_str(), &property_value))) { if (piPS->SetValue(PKEY_AppUserModel_ID, property_value) == S_OK) piPS->Commit(); PropVariantClear(&property_value); } piPS->Release(); } } hr = plPF->Save(wsDestLnkPath.c_str(), TRUE); plPF->Release(); } pisl->Release(); SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, NULL, NULL); return SUCCEEDED(hr); }
AsfContentInfoBuilder::AsfContentInfoBuilder() { IPropertyStore* fileLevelEncodingConfiguration = nullptr; HRESULT hr; _mfAsfContentInfo = nullptr; _mfAsfProfile = nullptr; _mfMetadataProvider = nullptr; _mfMetadata = nullptr; do { if (!SUCCEEDED(hr = MFCreateASFContentInfo(&_mfAsfContentInfo))) break; if (!SUCCEEDED(hr = MFCreateASFProfile(&_mfAsfProfile))) break; if (!SUCCEEDED(hr = _mfAsfContentInfo->QueryInterface(IID_IMFMetadataProvider, (void**)&_mfMetadataProvider))) break; if (!SUCCEEDED(hr = _mfMetadataProvider->GetMFMetadata(NULL, 0, 0, &_mfMetadata))) break; // Set MFPKEY_ASFMEDIASINK_AUTOADJUST_BITRATE to true on the file-level encoding configuration // property store. Does this actually do anything? Is it needed? if (!SUCCEEDED(hr = _mfAsfContentInfo->GetEncodingConfigurationPropertyStore(0, &fileLevelEncodingConfiguration))) break; PROPVARIANT pv; InitPropVariantFromBoolean(TRUE, &pv); if (!SUCCEEDED(hr = fileLevelEncodingConfiguration->SetValue(MFPKEY_ASFMEDIASINK_AUTOADJUST_BITRATE, pv))) break; PropVariantClear(&pv); } while (0); if (fileLevelEncodingConfiguration) fileLevelEncodingConfiguration->Release(); if (FAILED(hr)) { if (_mfMetadata) _mfMetadata->Release(); if (_mfMetadataProvider) _mfMetadataProvider->Release(); if (_mfAsfProfile) _mfAsfProfile->Release(); if (_mfAsfContentInfo) _mfAsfContentInfo->Release(); throw std::exception("Unable to create MediaSinkContentInfo object"); } }
void SetAppID(HWND hWnd, wstring appId) { IPropertyStore *pps; HRESULT hr = SHGetPropertyStoreForWindow(hWnd, IID_PPV_ARGS(&pps)); if (SUCCEEDED(hr)) { PROPVARIANT pv; hr = InitPropVariantFromString(appId.c_str(), &pv); if (SUCCEEDED(hr)) { hr = pps->SetValue(PKEY_AppUserModel_ID, pv); PropVariantClear(&pv); } pps->Release(); } }
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; }
// 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; }
HRESULT SetTouchDisableProperty(HWND hwnd, BOOL fDisableTouch) { IPropertyStore* pPropStore; HRESULT hrReturnValue = SHGetPropertyStoreForWindow(hwnd, IID_PPV_ARGS(&pPropStore)); if (SUCCEEDED(hrReturnValue)) { PROPVARIANT var; var.vt = VT_BOOL; var.boolVal = fDisableTouch ? VARIANT_TRUE : VARIANT_FALSE; hrReturnValue = pPropStore->SetValue(PKEY_EdgeGesture_DisableTouchWhenFullscreen, var); pPropStore->Release(); } return hrReturnValue; }
HRESULT CTaskbar7::AddRecent(BSTR name, BSTR path, BSTR arguments, BSTR icon) { USES_CONVERSION; // ANSI version doesn't seem to work correctly with Win7 jump lists, so explicitly use Unicode interface. IShellLinkW *pShellLink = NULL; IPropertyStore *pPropertyStore = NULL; PROPVARIANT propVariant; HRESULT hr = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pShellLink)); EXIT_ON_ERROR(hr); // Path hr = pShellLink->SetPath(path); EXIT_ON_ERROR(hr); // Arguments hr = pShellLink->SetArguments(arguments); EXIT_ON_ERROR(hr); // Icon Location hr = pShellLink->SetIconLocation(wstring(icon).empty() ? path : icon, 0); EXIT_ON_ERROR(hr); hr = pShellLink->QueryInterface(IID_PPV_ARGS(&pPropertyStore)); EXIT_ON_ERROR(hr); // Name hr = InitPropVariantFromString(name, &propVariant); EXIT_ON_ERROR(hr); hr = pPropertyStore->SetValue(PKEY_Title, propVariant); EXIT_ON_ERROR(hr); hr = pPropertyStore->Commit(); EXIT_ON_ERROR(hr); // SHAddToRecentDocs will cause the link to be added to the Recent list, allowing the user to pin them. SHAddToRecentDocs(SHARD_LINK, pShellLink); Exit: PropVariantClear(&propVariant); SAFE_RELEASE(pPropertyStore); SAFE_RELEASE(pShellLink); return hr; }
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 nullptr; } hr = device->GetId(&deviceId); if (FAILED(hr)) { printf("Unable to get device %d id: %x\n", DeviceIndex, hr); return nullptr; } IPropertyStore *propertyStore; hr = device->OpenPropertyStore(STGM_READ, &propertyStore); if (FAILED(hr)) { printf("Unable to open device %d property store: %x\n", DeviceIndex, hr); return nullptr; } PROPVARIANT friendlyName; PropVariantInit(&friendlyName); hr = propertyStore->GetValue(PKEY_Device_FriendlyName, &friendlyName); if (FAILED(hr)) { printf("Unable to retrieve friendly name for device %d : %x\n", DeviceIndex, hr); return nullptr; } DVAR(friendlyName.vt); if (friendlyName.vt != VT_LPWSTR) DVAR("Unknown"); else DVAR((const wchar_t *)friendlyName.pwszVal); PropVariantClear(&friendlyName); CoTaskMemFree(deviceId); return nullptr; }
// returns an instance of a memory property store (IPropertyStore) or related interface in the output HRESULT ClonePropertyStoreToMemory(IPropertyStore *ppsSource, REFIID riid, void **ppv) { *ppv = NULL; IPropertyStore *ppsMemory; HRESULT hr = PSCreateMemoryPropertyStore(IID_PPV_ARGS(&ppsMemory)); if (SUCCEEDED(hr)) { hr = CopyPropertyStores(ppsMemory, ppsSource); if (SUCCEEDED(hr)) { hr = ppsMemory->QueryInterface(riid, ppv); } ppsMemory->Release(); } return hr; }
Array AudioDriverWASAPI::audio_device_get_list(bool p_capture) { Array list; IMMDeviceCollection *devices = NULL; IMMDeviceEnumerator *enumerator = NULL; list.push_back(String("Default")); CoInitialize(NULL); HRESULT hr = CoCreateInstance(CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, IID_IMMDeviceEnumerator, (void **)&enumerator); ERR_FAIL_COND_V(hr != S_OK, Array()); hr = enumerator->EnumAudioEndpoints(p_capture ? eCapture : eRender, DEVICE_STATE_ACTIVE, &devices); ERR_FAIL_COND_V(hr != S_OK, Array()); UINT count = 0; hr = devices->GetCount(&count); ERR_FAIL_COND_V(hr != S_OK, Array()); for (ULONG i = 0; i < count; i++) { IMMDevice *device = NULL; hr = devices->Item(i, &device); ERR_BREAK(hr != S_OK); IPropertyStore *props = NULL; hr = device->OpenPropertyStore(STGM_READ, &props); ERR_BREAK(hr != S_OK); PROPVARIANT propvar; PropVariantInit(&propvar); hr = props->GetValue(PKEY_Device_FriendlyName, &propvar); ERR_BREAK(hr != S_OK); list.push_back(String(propvar.pwszVal)); PropVariantClear(&propvar); props->Release(); device->Release(); } devices->Release(); enumerator->Release(); return list; }
HRESULT GetPropertyValueForArray(PCWSTR pszFilename, PCWSTR pszCanonicalName,char*value) { // Convert the Canonical name of the property to PROPERTYKEY PROPERTYKEY key; HRESULT hr = PSGetPropertyKeyFromName(pszCanonicalName, &key); if (SUCCEEDED(hr)) { IPropertyStore* pps = NULL; // Call the helper to get the property store for the initialized item hr = GetPropertyStore(pszFilename, GPS_DEFAULT, &pps); if (SUCCEEDED(hr)) { PROPVARIANT propvarValue = { 0 }; HRESULT hr = pps->GetValue(key, &propvarValue); if (SUCCEEDED(hr)) { PWSTR pszDisplayValue = NULL; hr = PSFormatForDisplayAlloc(key, propvarValue, PDFF_DEFAULT, &pszDisplayValue); if (SUCCEEDED(hr)) { wprintf(L"%s = %s\n", pszCanonicalName, pszDisplayValue); if (value!= NULL) { WideCharToMultiByte(CP_OEMCP, 0, pszDisplayValue, -1, value, 1000, NULL, FALSE); } CoTaskMemFree(pszDisplayValue); } PropVariantClear(&propvarValue); } //return hr; //hr = PrintProperty(pps, key, pszCanonicalName); pps->Release(); } else { wprintf(L"Error %x: getting the propertystore for the item.\n", hr); } } else { wprintf(L"Invalid property specified: %s\n", pszCanonicalName); } return hr; }
static void addDeviceSelectorItem(QComboBox *const deviceSelector, IMMDevice *const pEndpoint) { LPWSTR pwszID = 0; IPropertyStore *pProps = 0; pEndpoint->GetId(&pwszID); pEndpoint->OpenPropertyStore(STGM_READ, &pProps); if (pwszID && pProps) { PROPVARIANT varName; std::memset(&varName, 0, sizeof varName); if (SUCCEEDED(pProps->GetValue(PKEY_Device_FriendlyName, &varName))) { deviceSelector->addItem(QString::fromWCharArray(varName.pwszVal), QVariant::fromValue(std::wstring(pwszID))); CoTaskMemFree(varName.pwszVal); //PropVariantClear(&varName); } CoTaskMemFree(pwszID); pProps->Release(); } }
int _tmain(int argc, _TCHAR* argv[]) { CLSID wid; CoInitialize(NULL); CLSIDFromString(const_cast<wchar_t*>(default_guid), &wid); IInitializeWithFile *oo; HRESULT hr; if ((hr = CoCreateInstance(wid, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&oo))) != S_OK) fail(); #if 0 IStorage *isto; if ((hr = StgCreateDocfile(L"t.mp3", STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_DIRECT, 0, &isto)) != S_OK) fail(); IStream *is; if ((hr = isto->CreateStream(L"lol", STGM_DIRECT | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &is)) != S_OK) fail(); #endif IPropertyStore *ips; IPropertyStoreCapabilities *ipcs; if ((hr = oo->QueryInterface(IID_PPV_ARGS(&ips))) != S_OK) fail(); if ((hr = oo->QueryInterface(IID_PPV_ARGS(&ipcs))) != S_OK) fail(); //iws->Initialize(is, STGM_READWRITE); if ((hr = oo->Initialize(L"t.mp3", STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_DIRECT)) != S_OK) fail(); DWORD props; if ((hr = ips->GetCount(&props)) != S_OK) fail(); for (DWORD i = 0; i < props; ++i) { PROPERTYKEY pkey; ips->GetAt(i, &pkey); WCHAR *sz; PSGetNameFromPropertyKey(pkey, &sz); std::wcout << (ipcs->IsPropertyWritable(pkey) == S_OK) << "\t" << sz << std::endl; } return 0; }
HRESULT EnumerateProperties(PCWSTR pszFilename) { IPropertyStore* pps = NULL; // Call the helper to get the property store for the initialized item // Note that as long as you have the property store, you are keeping the file open // So always release it once you are done. HRESULT hr = GetPropertyStore(pszFilename, GPS_DEFAULT, &pps); if (SUCCEEDED(hr)) { // Retrieve the number of properties stored in the item. DWORD cProperties = 0; hr = pps->GetCount(&cProperties); if (SUCCEEDED(hr)) { for (DWORD i = 0; i < cProperties; i++) { // Get the property key at a given index. PROPERTYKEY key; hr = pps->GetAt(i, &key); if (SUCCEEDED(hr)) { // Get the canonical name of the property PWSTR pszCanonicalName = NULL; hr = PSGetNameFromPropertyKey(key, &pszCanonicalName); if (SUCCEEDED(hr)) { hr = PrintProperty(pps, key, pszCanonicalName); CoTaskMemFree(pszCanonicalName); } } } } pps->Release(); } else { wprintf(L"Error %x: getting the propertystore for the item.\n", hr); } return hr; }