Detect when webcam is unplugged

J.Hilk

I haven't tested it my self, but QCamera inherits from QMediaObject and therefore should have access to the the Signal void QMediaObject::availabilityChanged(QMultimedia::AvailabilityStatus availability)

this should emit a Signal when the camera becomes unavailable!?

Chris Hennes

@J.Hilk Unfortunately, although it certainly seems like it should emit that signal, it does not (at least in Windows). Absolutely nothing that I could find emits a signal when I unplug the webcam from my Win10 PC. The good news is that the polling solution I posted above works very well, and by running it in its own thread doesn't impact the performance of my program. The call to QCameraInfo::availableCameras() takes over a half second on my machine!

kshegunov

@Chris-Hennes said in Detect when webcam is unplugged:

I know, I know... but I simply could not figure out any other way.

I would suggest a more responsive polling method, however. Consider this:

void CameraMonitor::interrupt()
{
    requestInterruption();
    threadWait.release();
}

void CameraMonitor::run()
{
    qDebug() << "Starting a new check thread";
    while (!isInterruptionRequested()) {
        auto cameras = QCameraInfo::availableCameras();
        bool found = false;
        for (auto camera : cameras)  {
            if (camera == _camera) //< Beware!! This may be a race condition (QCameraInfo *might* not be reentrant)!! You should be careful about it.
                found = true;
        }
        if (!found) {
            emit cameraLost();
            return;
        }

        threadWait.tryAcquire(1, 1000); // Wait 1 second or until we are flagged that we should exit (i.e. interrupt() was called).
    }
}

Where threadWait is a default initialized QSemaphore instance. Also take note on my comment about the way you compare the camera info objects, it may be dangerous ...

Chris Hennes

Thanks, using the QSemaphore is a good idea. I'm not sure how to address your concern about QCameraInfo. In my implementation _camera is set before the thread is started, and then only changes in response to the cameraLost() signal (which is emitted and then ends the thread). My thinking was that this was enough to ensure I was avoiding a race condition. Is there a corner case I am missing, or is a changing _camera not what you were concerned about?

kshegunov

@Chris-Hennes said in Detect when webcam is unplugged:

In my implementation _camera is set before the thread is started, and then only changes in response to the cameraLost() signal (which is emitted and then ends the thread). My thinking was that this was enough to ensure I was avoiding a race condition.

If CameraInfo is reentrant it is. However, it's not stated in the QtMultimedia docs, so any calls into that module (i.e. calling some function like QCameraInfo::availableCameras() from a different thread) while your polling thread is running may be a race condition. To make matter worse the last is not even a requirement as the module might queue some async operation behind the scenes, which might also induce a race condition (e.g. modifying an internal static member from the main thread, while you hold a camera info instance which depends on that resource). And finally using a non-reentrant class/function makes the user code non-reentrant too, which is the worst.

@Chris-Hennes said in Detect when webcam is unplugged:

Is there a corner case I am missing, or is a changing _camera not what you were concerned about?

I'm concerned about the module pulling the rug from under your feet, so to speak. What you should do to be sure is to take a look at the module's source and make certain there are no common statics between the classes that break reentrancy or bring the question of whether the classes are reentrant to the mailing list. I strongly suspect the QMediaObject implementations are not reentrant however, so don't hold your breath ...

Chris Hennes

The QCameraInfo class itself is basically trivial, it's just a bit of storage and and accessor, with no static variables. It's that static member function that introduces the complication: in particular I have no idea what QMediaServiceProvider might be doing in the call to provider->devices(service); (qcamerainfo.cpp:248). I don't see a clear path forward from here. That call is slow -- for usability it's got to be in its own thread. It seems like overkill to write an entire wrapper class for the QCameraInfo functionality, but I don't see how short of doing that I can guarantee thread safety.

kshegunov

@Chris-Hennes said in Detect when webcam is unplugged:

The QCameraInfo class itself is basically trivial, it's just a bit of storage and and accessor, with no static variables.

Then it is probably okay.

It's that static member function that introduces the complication: in particular I have no idea what QMediaServiceProvider might be doing in the call to provider->devices(service); (qcamerainfo.cpp:248). I don't see a clear path forward from here.

I advise to bring it to the mailing list. There you could get thoughts from the developers of the module and perhaps a better/improved solution. I currently don't have the time to dig into the module, but I suspect that provider->devices(service); is listing the devices through a common system resource, which implies it isn't thread-safe.

mayamail

You can use the statusChanged signal of QCamera to detect when the camera is disconnected. When the status changes to QCamera::UnavailableStatus, you can switch to displaying the error message indicating the camera can't be connected. Here's a brief example of how you can implement it:

camera = QCamera()
camera.setViewfinder(viewfinder)  # Assuming viewfinder is your QCameraViewfinder

def handle_camera_status(status):
    if status == QCamera.UnavailableStatus:
        # Switch to displaying error message
        display_error_message()

camera.statusChanged.connect(handle_camera_status)

I have test and take help from Chat GPT 4 and it's was working for me and hope it will also work for you.

Best..
Maya (author of webcammictest.io)

JoeCFD

@mayamail Works? Nice! What is your Qt version? And the class QCameraViewfinder does not exist any more in Qt6.

michaelmyk

Hey Chris, this is a common issue with QCameraViewfinder. The viewfinder freezing on the last frame when the camera disconnects is pretty standard behavior. Here are a few approaches you can try:

You can connect to the QCamera's stateChanged signal and watch for when it goes to QCamera::UnloadedState or QCamera::UnavailableState. That's usually the most reliable way to detect disconnection.

Another option is to monitor the QCamera's statusChanged signal for QCamera::UnavailableStatus. This specifically tells you when the camera becomes unavailable.

If those don't work perfectly for your case, you could implement a simple watchdog timer that checks if the frame has been updated recently. If no new frames arrive for a certain period (like 2-3 seconds), you can assume the camera disconnected like Michigan county map.

Here's a basic example of watching the state:

cpp
connect(camera, &QCamera::stateChanged, this, [this](QCamera::State state) {
    if (state == QCamera::UnloadedState || state == QCamera::UnavailableState) {
        // Show your error display here
        showCameraError();
    }
});

The watchdog approach might be more reliable though, since sometimes the state changes can be a bit delayed depending on the camera driver.

Hope this helps you get the detection working!