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;
}