Detect USB camera disconnection using IMFSourceReaderCallback - c++

I am using IMFSourceReaderCallback asynchroneous c++ implementation to read and process an USB Camera video stream
It is working fine, except that if the camera gets unplugged (which can happen often, since we are using many USB Repeaters), I am not being notified. Here is an extract of the code :
HRESULT CMFSourceReaderCallback::OnEvent(DWORD dwStreamIndex, IMFMediaEvent *pEvent)
{
// I was hoping to get an Event here if I lost the camera, but no...
// The break point nether hits, and from EvilCorp documentation, there is no such event type
return S_OK;
}
HRESULT CMFSourceReaderCallback::OnReadSample(
HRESULT hrStatus,
DWORD dwStreamIndex,
DWORD dwStreamFlags,
LONGLONG llTimestamp,
IMFSample *pSample)
{
bool isGrabbing = false;
try
{
if (SUCCEEDED(hrStatus))
{
if (pSample)
{
// Do something with the sample.
IMFMediaBuffer * pMediaBuffer;
HRESULT hr;
hr = pSample->ConvertToContiguousBuffer(&pMediaBuffer);
if (FAILED(hr))
{
// Inform other thread of the disconnection
//...
return S_OK;
}
byte *imgBuff;
DWORD buffCurrLen = 0;
DWORD buffMaxLen = 0;
pMediaBuffer->Lock(&imgBuff, &buffMaxLen, &buffCurrLen);
// Process image byte buffer
pMediaBuffer->Unlock();
pMediaBuffer->Release();
}
}
else
{
// Inform other thread of the disconnection
//...
return S_OK;
}
if ((MF_SOURCE_READERF_ENDOFSTREAM & dwStreamFlags) ||
(MF_SOURCE_READERF_ERROR & dwStreamFlags))
{
// Inform other thread of the disconnection
//...
return S_OK;
}
} catch (std::exception &ex )
{
// Inform other thread of the disconnection
//...
return S_OK;
}
// check if other thread has not requested a stop
isGrabbing = ...;
if (isGrabbing)
{
//Re-arm callback
HRESULT hr = _dataStruct->Reader->ReadSample(MF_SOURCE_READER_FIRST_VIDEO_STREAM,
0, NULL, NULL, NULL, NULL);
if (FAILED(hr))
{
// Inform other thread of the disconnection
//...
return S_OK;
}
}
return S_OK;
}
Is there a way to get such notification through IMFSourceReader without the headache of polling available devices with MFEnumDeviceSources from time to time, which can be time consuming... ?
Thanks In advance !

The recommended way to handle capture device loss is explained here : Handling Video Device Loss
You need to register for device notification : RegisterDeviceNotification. You need a window handle (HWND).
In the message loop, you will receive WM_DEVICECHANGE. You have to check the symbolic link (is it the USB camera ?).
When you are done, call UnregisterDeviceNotification.

Related

Retrieving info from multiple sensors using Windows Sensor API

I am using the Windows Sensor API to get info from various sensors including accelerometer and gyroscope. (https://learn.microsoft.com/en-us/windows/desktop/sensorsapi/sensor-api-programming-guide)
My initial implementation of sensor driver for accelerometer worked - I asynchronously can get the values for that sensor.
The working initialization code for a single sensor (accelerometer) looks like the following:
void initialize1(AccelerometerCallBack callBack) {
HRESULT hr = S_OK;
CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
ISensorManager* pSensorManager = NULL;
ISensorCollection* pSensorColl = NULL;
ISensor* accelerometer = NULL;
hr = CoCreateInstance(CLSID_SensorManager,
NULL, CLSCTX_INPROC_SERVER,
IID_PPV_ARGS(&pSensorManager));
if (SUCCEEDED(hr))
{
printf("Succeeded getting Sensor...\n");
ULONG ulCount = 0;
// Verify that the collection contains
// at least one sensor.
hr = pSensorColl->GetCount(&ulCount);
if (SUCCEEDED(hr))
{
if (ulCount < 1)
{
wprintf_s(L"\nNo sensors of the requested category.\n");
hr = E_UNEXPECTED;
}
}
}
else {
printf("Failed to get Sensor...\n");
}
if (SUCCEEDED(hr))
{
// Get the first available sensor.
hr = pSensorColl->GetAt(0, &accelerometer);
BSTR name = 0;
hr = accelerometer->GetFriendlyName(&name);
wprintf(L"%s\n", name);
}
AccelerometerEvent* pEventClass = NULL;
ISensorEvents* pMyEvents = NULL;
if (SUCCEEDED(hr))
{
// Create an instance of the event class.
pEventClass = new(std::nothrow) AccelerometerEvent();
pEventClass->globalCallBack = callBack;
}
if (SUCCEEDED(hr))
{
// Retrieve the pointer to the callback interface.
hr = pEventClass->QueryInterface(IID_PPV_ARGS(&pMyEvents));
}
if (SUCCEEDED(hr))
{
// Start receiving events.
hr = accelerometer->SetEventSink(pMyEvents);
}
MSG msg;
BOOL bRet;
while ((bRet = GetMessage(&msg, NULL, 0, 0)) != 0)
{
if (bRet == -1)
{
// handle the error and possibly exit
}
else
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
}
Now I wanted to simultaneously get the gyroscope, so I add a similar initialization code:
void initialize2(GyroscopeCallBack callBack);, which does similar thing as above.
Now my C# layer triggers those code like this:
internal void Start()
{
AccelerometerCallBack myCallBack1 = new AccelerometerCallBack(onAccelerometerDataChanged);
initialize1(myCallBack1);
GyroscopeCallBack myCallBack2 = new GyroscopeCallBack(onGyroscopeDataChanged);
initialize2(myCallBack2);
}
However, only the accelerometer info is received through the callback, not the gyroscope's.
I have confirmed that my device has both sensors of the correct type
I have confirmed that my callback functions and C# to C++ interface all works properly
What is the correct way to "fetch" multiple sensors (instead of one) using the Windows Sensor API?
There are no examples on the official website about doing this, and the only related SO post (Exposing multiple sensors on a single device to Windows Sensor API) does not help. Thanks!
It worked! Solution was to remove the message pump and use COINIT_MULTITHREADED option for Coinitializine(). Thanks for all the help.

How do I implement `BeginRead` in the IMFByteStream interface

I have created ReadByteContainer to store current data and ReadByteAsyncCallback for the callback. Are there alternatives that would work better?
HRESULT MediaByteStream::BeginRead(
BYTE *pb,
ULONG cb,
IMFAsyncCallback *pCallback,
IUnknown *punkState)
{
HRESULT hr = S_OK;
// Create a new read byte container.
ReadByteContainer* readBytes = new ReadByteContainer(pb, cb);
ReadByteAsyncCallback* readCallback = new ReadByteAsyncCallback(this);
// If not created.
if (readBytes == NULL)
{
return E_OUTOFMEMORY;
}
// If not created.
if (readCallback == NULL)
{
return E_OUTOFMEMORY;
}
IMFAsyncResult *pResult = NULL;
readBytes->_readCallback = readCallback;
// Creates an asynchronous result object. Use this function if you are implementing an asynchronous method.
hr = MFCreateAsyncResult(readBytes, pCallback, punkState, &pResult);
if (SUCCEEDED(hr))
{
// Start a new work item thread.
hr = MFPutWorkItem(MFASYNC_CALLBACK_QUEUE_STANDARD, readCallback, pResult);
pResult->Release();
}
// Return the result.
return hr;
}
If pb remains valid until EndRead occurs, you can avoid the copy (new ReadByteContainer), and just keep pb as is.
Normally your MediaByteStream implements IMFAsyncCallback so you should call MFPutWorkItem like this (avoid new ReadByteAsyncCallback) :
hr = MFPutWorkItem(MFASYNC_CALLBACK_QUEUE_STANDARD, this, pResult);
Also, i don't see some lock mechanism inside BeginRead. If you use it in a multithreading environment you should handle this. Close can be call when BeginRead has been called and did not finish, so you will face problems.

WIA 2.0, C++: IWiaDevMgr2::EnumDeviceInfo doesn't detect connected camera

I'm trying to write a program that transfers images and videos from a camera (for my personal use, on Win 8.1). I'm using Microsoft's example code as a starting point (WIA Tutorial), and I've hit a wall trying to detect connected camera devices. The problem is that there are no errors and the code seems to work, but it just doesn't detect any connected camera (I've tried with two different cameras), while the camera is clearly detected by the OS (shows up in Windows Explorer).
Am I missing something? Is IWiaDevMgr2::EnumDeviceInfo not the way to detect connected devices? Here's the code I'm using:
HRESULT WiaCreateDeviceManager(IWiaDevMgr2 **ppWiaDevMgr)
{
if(NULL == ppWiaDevMgr) return E_INVALIDARG;
*ppWiaDevMgr = NULL;
// Create an instance of the device manager
HRESULT hr = CoCreateInstance(CLSID_WiaDevMgr2, NULL, CLSCTX_LOCAL_SERVER, IID_IWiaDevMgr2, (void**)ppWiaDevMgr);
return hr;
}
HRESULT WiaEnumerateDevices(IWiaDevMgr2 *pWiaDevMgr)
{
if(NULL == pWiaDevMgr)
{
return E_INVALIDARG;
}
// Get a device enumerator interface
IEnumWIA_DEV_INFO *pWiaEnumDevInfo = NULL;
HRESULT hr = pWiaDevMgr->EnumDeviceInfo(WIA_DEVINFO_ENUM_LOCAL, &pWiaEnumDevInfo);
assert(hr == S_OK);
if(SUCCEEDED(hr))
{
ULONG count(911);
HRESULT res = pWiaEnumDevInfo->GetCount(&count);
if(res == S_OK) printf("EnumDeviceInfo: count = %lu\n", count); // count is always zero
else printf("IEnumWIA_DEV_INFO::GetCount() failed!\n");
// Loop until you get an error or pWiaEnumDevInfo->Next returns
// S_FALSE to signal the end of the list.
while(S_OK == hr)
{
// Get the next device's property storage interface pointer
IWiaPropertyStorage *pWiaPropertyStorage = NULL;
hr = pWiaEnumDevInfo->Next(1, &pWiaPropertyStorage, NULL);
// pWiaEnumDevInfo->Next will return S_FALSE when the list is
// exhausted, so check for S_OK before using the returned
// value.
if(hr == S_OK)
{
// Do something with the device's IWiaPropertyStorage*
WiaReadProperties(pWiaPropertyStorage); // this line is never reached
// Release the device's IWiaPropertyStorage*
pWiaPropertyStorage->Release();
pWiaPropertyStorage = NULL;
}
}
// If the result of the enumeration is S_FALSE (which
// is normal), change it to S_OK.
if(S_FALSE == hr) hr = S_OK;
// Release the enumerator
pWiaEnumDevInfo->Release();
pWiaEnumDevInfo = NULL;
}
return hr;
}
int main()
{
...
IWiaDevMgr2 *wiamgr;
WiaCreateDeviceManager(&wiamgr);
HRESULT res = WiaEnumerateDevices(wiamgr); // res is always S_OK, but no device is detected
...
}
Apparently, WIA does not support camera devices on Windows Vista and later. I've only seen this implied or mentioned in passing twice in the WIA documentation, the last time being on this page. I can't believe this is happening, after I've spent so much time researching WIA. Apparently, I'm supposed to be using WPD for cameras, not WIA.
Edit: That being said, I'm still not sure what's going on. If I can't use WIA programmatically on Win 8.1, then why do these PowerShell commands work?
$WIAdialog = New-Object -ComObject "WIA.CommonDialog"
$Device = $WIAdialog.ShowSelectDevice()
$i=$WIAdialog.ShowAcquireImage()
$i.SaveFile("$pwd\test.$($i.fileExtension)")
Is it that only the API doesn't work for cameras, while the Scripting Model does?

Why can I not acquire the keyboard with DirectInput?

I just started getting into DirectInput today, using DirectInput8 with MinGW on Windows 7 Ultimate N. I started off with a simple program to report which keys are currently down every second (just codes, not readable keys). However, I can't even get as far as acquiring the keyboard before it errors out:
#define _WIN32_WINNT 0x0601
#include <dinput.h>
//link to dinput8.lib and dxguid.lib
int main() {
IDirectInput8 *dinput;
DirectInput8Create(GetModuleHandle(nullptr), DIRECTINPUT_VERSION, IID_IDirectInput8, (void **)&dinput, nullptr);
IDirectInputDevice8 *kb;
dinput->CreateDevice(GUID_SysKeyboard, &kb, nullptr);
kb->SetDataFormat(&c_dfDIKeyboard);
kb->SetCooperativeLevel(GetConsoleWindow(), DISCL_FOREGROUND | DISCL_NONEXCLUSIVE);
kb->Acquire(); //fails with DIERR_INVALIDPARAM
}
I omitted error checking, but what happens is that every call succeeds (by judgement of the FAILED macro) up to Acquire(). That call fails with the error DIERR_INVALIDPARAM. I looked on the MSDN pages and across the web, but I can't find any reason it would fail with that based on everything before it present and working.
For good measure, I also tried looping the Acquire() call until it succeeded and then played around with windows and the keyboard while it was running, but the program never successfully acquired the keyboard in all the time it was running. How can I successfully acquire the keyboard?
Experimenting with direct input in a console program for the keyboard and joystick
It is not necessary to have a handle to a window to use direct input. You can just use null in the parameter for a handle to a window.
Instead of:
kb->SetCooperativeLevel(GetConsoleWindow(), DISCL_FOREGROUND | DISCL_NONEXCLUSIVE);
Use:
kb->SetCooperativeLevel(NULL, DISCL_FOREGROUND | DISCL_NONEXCLUSIVE);
Here is an example program that uses direct input to display the keys 'a' and 'd' when those keys are pressed. It will repeat those keys when they are held for 300 milliseconds. The example program is also a good example of a high resolution counter. There is no need to add in properties in Visual Studio to add the libraries dinput8.lib and dxguid.lib. The #pragma comment code lines at the top of the program do that for you.
#include <dinput.h>
#include <iostream>
#include <Windows.h>
#pragma comment(lib,"dinput8.lib")
#pragma comment(lib,"dxguid.lib")
using std::cout;
using std::endl;
LPDIRECTINPUT8 di;
LPDIRECTINPUTDEVICE8 keyboard;
class CTimer
{
public:
CTimer() {
QueryPerformanceFrequency(&mqFreq);
}
~CTimer() {}
void Start() {
QueryPerformanceCounter(&mqStart);
}
void End() {
QueryPerformanceCounter(&mqEnd);
}
double GetTimeInSeconds() {
return (mqEnd.QuadPart - mqStart.QuadPart)/(double)mqFreq.QuadPart;
}
double GetTimeInMilliseconds() {
return (1.0e3*(mqEnd.QuadPart - mqStart.QuadPart))/mqFreq.QuadPart;
}
double GetTimeInMicroseconds() {
return (1.0e6*(mqEnd.QuadPart - mqStart.QuadPart))/mqFreq.QuadPart;
}
double GetTimeInNanoseconds() {
return (1.0e9*(mqEnd.QuadPart - mqStart.QuadPart))/mqFreq.QuadPart;
}
private:
LARGE_INTEGER mqStart;
LARGE_INTEGER mqEnd;
LARGE_INTEGER mqFreq;
};
HRESULT initializedirectinput8() {
HRESULT hr;
// Create a DirectInput device
if (FAILED(hr = DirectInput8Create(GetModuleHandle(NULL), DIRECTINPUT_VERSION,
IID_IDirectInput8, (VOID**)&di, NULL))) {
return hr;
}
}
void createdikeyboard() {
di->CreateDevice(GUID_SysKeyboard, &keyboard, NULL);
keyboard->SetDataFormat(&c_dfDIKeyboard);
keyboard->SetCooperativeLevel(NULL,DISCL_FOREGROUND | DISCL_EXCLUSIVE);
keyboard->Acquire();
}
void destroydikeyboard() {
keyboard->Unacquire();
keyboard->Release();
}
#define keydown(name,key) (name[key] & 0x80)
void main() {
HRESULT hr;
BYTE dikeys[256];
CTimer timeint;
CTimer timekeywaspressedclass;
double gettime;
double lastkeywasa=false;
double timekeywaspressed=0;
bool lasttimetherewasakeypress=false;
bool akeywaspressed=false;
initializedirectinput8();
createdikeyboard();
hr=keyboard->GetDeviceState(256,dikeys);
timeint.Start();
while (!keydown(dikeys,DIK_ESCAPE)) {
timeint.End();
gettime=timeint.GetTimeInMilliseconds();
if (gettime >=5) {
hr=keyboard->GetDeviceState(256,dikeys);
akeywaspressed=false;
if (keydown(dikeys,DIK_A)) {
akeywaspressed=true;
if (timekeywaspressed >=300) {
cout << "a";
lasttimetherewasakeypress=false;
}
}
if (keydown(dikeys,DIK_D)) {
akeywaspressed=true;
if (timekeywaspressed >=300) {
cout << "d";
lasttimetherewasakeypress=false;
}
}
if (lasttimetherewasakeypress==false && akeywaspressed==true) {
timekeywaspressedclass.Start();
timekeywaspressed=0;
lasttimetherewasakeypress=true;
}
if (lasttimetherewasakeypress==true && akeywaspressed==true) {
timekeywaspressedclass.End();
gettime=timekeywaspressedclass.GetTimeInMilliseconds();
timekeywaspressed+=gettime;
timekeywaspressedclass.Start();
}
if (akeywaspressed==false) {
lasttimetherewasakeypress=false;
timekeywaspressed=0;
}
} // end if (gettime >=5)
} // end while
destroydikeyboard();
} // end main
Here is an example console program for the joystick.
#include <dinput.h>
#include <iostream>
#include <Windows.h>
#pragma comment(lib,"dinput8.lib")
#pragma comment(lib,"dxguid.lib")
using std::cout;
using std::endl;
LPDIRECTINPUT8 di;
LPDIRECTINPUTDEVICE8 joystick;
LPDIRECTINPUTDEVICE8 keyboard;
DIJOYSTATE2 js;
BOOL CALLBACK enumCallback(const DIDEVICEINSTANCE* instance, VOID* context);
BOOL CALLBACK enumAxesCallback(const DIDEVICEOBJECTINSTANCE* instance, VOID* context);
HRESULT selectjoystick() {
HRESULT hr;
// Look for the first simple joystick we can find.
if (FAILED(hr = di->EnumDevices(DI8DEVCLASS_GAMECTRL, enumCallback,
NULL, DIEDFL_ATTACHEDONLY))) {
return hr;
}
// Make sure we got a joystick
if (joystick == NULL) {
// printf("Joystick not found.\n");
return E_FAIL;
}
}
DIDEVCAPS capabilities;
HRESULT setjoystickproperties() {
HRESULT hr;
// Set the data format to "simple joystick" - a predefined data format
//
// A data format specifies which controls on a device we are interested in,
// and how they should be reported. This tells DInput that we will be
// passing a DIJOYSTATE2 structure to IDirectInputDevice::GetDeviceState().
if (FAILED(hr = joystick->SetDataFormat(&c_dfDIJoystick2))) {
return hr;
}
// Set the cooperative level to let DInput know how this device should
// interact with the system and with other DInput applications.
if (FAILED(hr = joystick->SetCooperativeLevel(NULL, DISCL_EXCLUSIVE |
DISCL_FOREGROUND))) {
return hr;
}
// Determine how many axis the joystick has (so we don't error out setting
// properties for unavailable axis)
capabilities.dwSize = sizeof(DIDEVCAPS);
if (FAILED(hr = joystick->GetCapabilities(&capabilities))) {
return hr;
}
}
BOOL CALLBACK enumCallback(const DIDEVICEINSTANCE* instance, VOID* context)
{
HRESULT hr;
// Obtain an interface to the enumerated joystick.
hr = di->CreateDevice(instance->guidInstance, &joystick, NULL);
// If it failed, then we can't use this joystick. (Maybe the user unplugged
// it while we were in the middle of enumerating it.)
if (FAILED(hr)) {
return DIENUM_CONTINUE;
}
// Stop enumeration. Note: we're just taking the first joystick we get. You
// could store all the enumerated joysticks and let the user pick.
return DIENUM_STOP;
}
HRESULT enumaxes() {
HRESULT hr;
// Enumerate the axes of the joyctick and set the range of each axis. Note:
// we could just use the defaults, but we're just trying to show an example
// of enumerating device objects (axes, buttons, etc.).
if (FAILED(hr = joystick->EnumObjects(enumAxesCallback, NULL, DIDFT_AXIS))) {
return hr;
}
}
BOOL CALLBACK enumAxesCallback(const DIDEVICEOBJECTINSTANCE* instance, VOID* context)
{
HWND hDlg = (HWND)context;
DIPROPRANGE propRange;
propRange.diph.dwSize = sizeof(DIPROPRANGE);
propRange.diph.dwHeaderSize = sizeof(DIPROPHEADER);
propRange.diph.dwHow = DIPH_BYID;
propRange.diph.dwObj = instance->dwType;
propRange.lMin = -1000;
propRange.lMax = +1000;
// Set the range for the axis
if (FAILED(joystick->SetProperty(DIPROP_RANGE, &propRange.diph))) {
return DIENUM_STOP;
}
return DIENUM_CONTINUE;
}
HRESULT polljoy() {
HRESULT hr;
if (joystick == NULL) {
return S_OK;
}
// Poll the device to read the current state
hr = joystick->Poll();
if (FAILED(hr)) {
// DInput is telling us that the input stream has been
// interrupted. We aren't tracking any state between polls, so
// we don't have any special reset that needs to be done. We
// just re-acquire and try again.
hr = joystick->Acquire();
while (hr == DIERR_INPUTLOST) {
hr = joystick->Acquire();
}
// If we encounter a fatal error, return failure.
if ((hr == DIERR_INVALIDPARAM) || (hr == DIERR_NOTINITIALIZED)) {
return E_FAIL;
}
// If another application has control of this device, return successfully.
// We'll just have to wait our turn to use the joystick.
if (hr == DIERR_OTHERAPPHASPRIO) {
return S_OK;
}
}
// Get the input's device state
if (FAILED(hr = joystick->GetDeviceState(sizeof(DIJOYSTATE2), &js))) {
return hr; // The device should have been acquired during the Poll()
}
return S_OK;
}
class CTimer
{
public:
CTimer() {
QueryPerformanceFrequency(&mqFreq);
}
~CTimer() {}
void Start() {
QueryPerformanceCounter(&mqStart);
}
void End() {
QueryPerformanceCounter(&mqEnd);
}
double GetTimeInSeconds() {
return (mqEnd.QuadPart - mqStart.QuadPart)/(double)mqFreq.QuadPart;
}
double GetTimeInMilliseconds() {
return (1.0e3*(mqEnd.QuadPart - mqStart.QuadPart))/mqFreq.QuadPart;
}
double GetTimeInMicroseconds() {
return (1.0e6*(mqEnd.QuadPart - mqStart.QuadPart))/mqFreq.QuadPart;
}
double GetTimeInNanoseconds() {
return (1.0e9*(mqEnd.QuadPart - mqStart.QuadPart))/mqFreq.QuadPart;
}
private:
LARGE_INTEGER mqStart;
LARGE_INTEGER mqEnd;
LARGE_INTEGER mqFreq;
};
HRESULT initializedirectinput8() {
HRESULT hr;
// Create a DirectInput device
if (FAILED(hr = DirectInput8Create(GetModuleHandle(NULL), DIRECTINPUT_VERSION,
IID_IDirectInput8, (VOID**)&di, NULL))) {
return hr;
}
}
void createdikeyboard() {
di->CreateDevice(GUID_SysKeyboard, &keyboard, NULL);
keyboard->SetDataFormat(&c_dfDIKeyboard);
keyboard->SetCooperativeLevel(NULL,DISCL_FOREGROUND | DISCL_EXCLUSIVE);
keyboard->Acquire();
}
void destroydikeyboard() {
keyboard->Unacquire();
keyboard->Release();
}
void closejoystick() {
if (joystick) {
joystick->Unacquire();
}
if (joystick) {
joystick->Release();
}
}
#define keydown(name,key) (name[key] & 0x80)
void main() {
HRESULT hr;
CTimer pollintclass;
hr=initializedirectinput8();
createdikeyboard();
hr=selectjoystick();
hr=setjoystickproperties();
hr=enumaxes();
bool endloop=false;
double gettime;
BYTE dikeys[256];
pollintclass.Start();
while (endloop==false) {
pollintclass.End();
gettime=pollintclass.GetTimeInMilliseconds();
if (gettime >=5) {
hr=keyboard->GetDeviceState(256,dikeys);
if (FAILED(hr))
keyboard->Acquire();
if (keydown(dikeys,DIK_ESCAPE))
endloop=true;
polljoy();
cout << "joy x-axis=" << js.lX << " " << "joy y-axis=" << js.lY << endl;
pollintclass.Start();
}
}
destroydikeyboard();
closejoystick();
}
Have you tried DISCL_BACKGROUND instead of DISCL_FOREGROUND ?
It actually happens that the error magically disappears when I change it from associating with the console window (which is visibly existent) to one I create in the SetCooperativeLevel() call. Why a console window can't be used I don't know, so I'll leave this unaccepted for a while in lieu of an answerer who does, but this does solve the problem.

How to globally mute and unmute sound in Vista and 7, and to get a mute state?

I'm using the old good Mixer API right now, but it does not work as expected on Windows Vista & 7 in the normal, not in XP compatibility mode. It mutes the sound for the current app only, but I need a global (hardware) mute. How to rearch the goal? Is there any way to code this w/o COM interfaces and strange calls, in pure C/C++?
The audio stack was significantly rewritten for Vista. Per-application volume and mute control was indeed one of the new features. Strange calls will be required to use the IAudioEndpointVolume interface.
I recently dealt with this same issue. We have a Windows application that uses the sound system for alarms. We cannot abide the user muting the sound system inadvertently. Here is how I was able to use the interface suggested above to address this issue:
During initialization I added a function to initialize a member of type IAudioEndpointVolume. It was a bit tricky and the help wasn't as helpful as it could be. Here's how to do it:
/****************************************************************************
** Initialize the Audio Endpoint (Only for post XP systems)
****************************************************************************/
void CMuteWatchdog::InitAudioEndPoint(void)
{
HRESULT hr;
IMMDeviceEnumerator * pDevEnum;
IMMDevice * pDev;
const CLSID CLSID_MMDeviceEnumerator = __uuidof(MMDeviceEnumerator);
const IID IID_IMMDeviceEnumerator = __uuidof(IMMDeviceEnumerator);
hr = CoCreateInstance(CLSID_MMDeviceEnumerator, NULL,
CLSCTX_ALL, IID_IMMDeviceEnumerator,
(void**)&pDevEnum);
m_pIaudEndPt = NULL;
if(hr == S_OK)
{
hr = pDevEnum->GetDefaultAudioEndpoint(eRender, eConsole, &pDev);
if(hr == S_OK)
{
DWORD dwClsCtx;
const IID iidAEV = __uuidof(IAudioEndpointVolume);
dwClsCtx = 0;
hr = pDev->Activate(iidAEV, dwClsCtx, NULL, (void**) &m_pIaudEndPt);
if(hr == S_OK)
{
// Everything is groovy.
}
else
{
m_pIaudEndPt = NULL; // Might mean it's running on XP or something. Don't use.
}
pDev->Release();
}
pDevEnum->Release();
}
}
...
About once per second I added a simple call to the following:
////////////////////////////////////////////////////////////////////////
// Watchdog function for mute.
void CMuteWatchdog::GuardMute(void)
{
if(m_pIaudEndPt)
{
BOOL bMute;
HRESULT hr;
bMute = FALSE;
hr = m_pIaudEndPt->GetMute(&bMute);
if(hr == S_OK)
{
if(bMute)
{
m_pIaudEndPt->SetMute(FALSE, NULL);
}
}
}
}
Finally, when the program exits just remember to release the allocated resource.
////////////////////////////////////////////////////////////////////////
// De-initialize the watchdog
void CMuteWatchdog::OnClose(void)
{
if(m_pIaudEndPt)
{
m_pIaudEndPt->Release();
m_pIaudEndPt = NULL;
}
}