• 三、视频设备的枚举以及插拔检测

    一、前言

            本章主要讲述，如何获取设备名称以及guid，采集设备的采集格式识别，设备的插拔

            设备列表以及属性的获取使用的directshow(后续的MediaFoundation无法获取OBS摄像头)

            设备的插拔使用的是QT 捕获系统消息，捕获到设备插拔后，重新获取下设备列表(这里并没有动态的添加或者删除，考虑的主要是维护UI显示时 设备顺序的一致性)

    二、设备列表的获取

            ICreateDevEnum 接口，创建特定的类（如视频捕获设备，音频捕获设备，视频压缩等）的一个枚举器 ，可以使用CLSID_SystemDeviceEnum来得到该指针。

    1. CreateDevEnum::CreateClassEnumerator(
    2. REFCLSID clsidDeviceClass, //设备类别
    3. IEnumMoniker **ppEnumMoniker, //输出参数，IEnumMoniker ××
    4. DWORD dwFlags 
    5. );

            IEnumMoniker 接口,  表示特定的设备枚举类

            IMoniker::Enum 方法获取指向 IEnumMoniker 实现的指针，该实现可以通过名字对象的组件向前或向后枚举。

            IRunningObjectTable::EnumRunning 方法返回一个指向 IEnumMoniker 实现的指针，该实现可以枚举在运行对象表中注册的名字对象。

            IEnumMoniker::Next  此方法检索枚举序列中下一个设备是否存在

    1. struct CameraDevice
    2. {
    3.     int                  nIndex;                    // index
    4.     std::string          uid;                       // 硬件层uniqueId mac中为BuiltInMicrophoneDevice  
    5.     std::string          name;                      // 设备名称
    6. };
    7.  
    8.  
    9. std::map VideoCoreDevice::getVideoDeviceList()
    10. {
    11.     if(!m_pDevEnum)
    12.     {
    13.          ::CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC, IID_ICreateDevEnum, (void**)&m_pDevEnum);
    14.     }
    15.     std::map devices;
    16.     if (!m_bCoUninitializeIsRequired)
    17.     {
    18.         goto END;
    19.     }
    20.  
    21.     HRESULT hr = m_pDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory, &m_pMonikerDevEnum, 0);
    22.     if (hr != NOERROR)
    23.     {
    24. 		std::cout << "CreateClassEnumerator failed" << std::endl;
    25.         goto END;
    26.     }
    27.     m_pMonikerDevEnum->Reset();
    28.     ULONG cFetched;
    29.     IMoniker* pM;
    30.     int index = 0;
    31.     while (S_OK == m_pMonikerDevEnum->Next(1, &pM, &cFetched)) 
    32.     {
    33.         IPropertyBag* pBag;
    34.         hr = pM->BindToStorage(0, 0, IID_IPropertyBag, (void**)&pBag);
    35.         if (S_OK == hr) 
    36.         {
    37.             // Find the description or friendly name.
    38.             VARIANT varName;
    39.             VariantInit(&varName);
    40.             hr = pBag->Read(L"Description", &varName, 0);
    41.             if (FAILED(hr)) 
    42.             {
    43.                 hr = pBag->Read(L"FriendlyName", &varName, 0);
    44.             }
    45.             if (SUCCEEDED(hr)) 
    46.             {
    47.                 // ignore all VFW drivers
    48.                 if ((wcsstr(varName.bstrVal, (L"(VFW)")) == NULL) &&
    49.                     (_wcsnicmp(varName.bstrVal, (L"Google Camera Adapter"), 21) != 0)) 
    50.                 {
    51.                     // Found a valid device.
    52.                     {
    53.                         char device_name[256] = { 0 };
    54.                         char unique_name[256] = { 0 };
    55.                         char product_name[256] = { 0 };
    56.  
    57.                         int convResult = WideCharToMultiByte(CP_UTF8, 0, varName.bstrVal, -1, (char*)device_name, sizeof(device_name), NULL, NULL);
    58.                         if (convResult == 0)
    59.                         {
    60. 							std::cout << "WideCharToMultiByte failed" << std::endl;
    61. 							goto END;
    62.                         }
    63.                         hr = pBag->Read(L"DevicePath", &varName, 0);
    64.                         if (FAILED(hr))
    65.                         {
    66.                             strncpy_s((char*)unique_name, sizeof(unique_name),
    67.                                 (char*)device_name, convResult);
    68.                         }
    69.                         else
    70.                         {
    71.                             convResult = WideCharToMultiByte(CP_UTF8, 0, varName.bstrVal, -1, (char*)unique_name, sizeof(unique_name), NULL, NULL);
    72.                             if (convResult == 0)
    73.                             {
    74. 								std::cout << "WideCharToMultiByte failed" << std::endl;
    75.                                 goto END;
    76.                             }
    77.                         }
    78.                         GetProductId(unique_name, product_name, sizeof(product_name));
    79.  
    80.                         CameraDevice camera;
    81.                         camera.nIndex = index;
    82.                         camera.name = device_name;
    83.                         camera.uid = unique_name;
    84.  
    85.                         devices.insert(std::make_pair(camera.uid, camera));
    86.                     }
    87.                     ++index;  // increase the number of valid devices
    88.                 }
    89.             }
    90.             VariantClear(&varName);
    91.             pBag->Release();
    92.             pM->Release();
    93.         }
    94.     }
    95.  
    96. END:
    97.     return devices;
    98. }
    99.  
    100. // 不同获取方式得到的ID不一致，通过处理得到相同的ID
    101. void GetProductId(const char* devicePath, char* productUniqueIdUTF8, uint32_t productUniqueIdUTF8Length)
    102. {
    103.     *productUniqueIdUTF8 = '\0';
    104.     char* startPos = strstr((char*)devicePath, "\\\\?\\");
    105.     if (!startPos) 
    106.     {
    107.         strncpy_s((char*)productUniqueIdUTF8, productUniqueIdUTF8Length, "", 1);
    108.         std::cout << "Failed to get the product Id" << std::endl;
    109.         return;
    110.     }
    111.     startPos += 4;
    112.  
    113.     char* pos = strchr(startPos, '&');
    114.     if (!pos || pos >= (char*)devicePath + strlen((char*)devicePath)) 
    115.     {
    116.         strncpy_s((char*)productUniqueIdUTF8, productUniqueIdUTF8Length, "", 1);
    117.         std::cout << "Failed to get the product Id" << std::endl;
    118.         return;
    119.     }
    120.     // Find the second occurrence.
    121.     pos = strchr(pos + 1, '&');
    122.     uint32_t bytesToCopy = (uint32_t)(pos - startPos);
    123.     if (pos && (bytesToCopy < productUniqueIdUTF8Length) &&
    124.         bytesToCopy <= kVideoCaptureProductIdLength) 
    125.     {
    126.         strncpy_s((char*)productUniqueIdUTF8, productUniqueIdUTF8Length,
    127.             (char*)startPos, bytesToCopy);
    128.     }
    129.     else
    130.     {
    131.         strncpy_s((char*)productUniqueIdUTF8, productUniqueIdUTF8Length, "", 1);
    132.         std::cout << "Failed to get the product Id" << std::endl;
    133.     }
    134. }

    三、设备的插拔检测

            目前使用的是Qt::nativeEventFilter 过滤设备插拔信息,然后去响应设备列表

    1. // 头文件
    2. #pragma once
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. class VideoNotificationClient : public QAbstractNativeEventFilter, public QWidget
    10. {
    11. public:
    12.     class Listener
    13.     {
    14.     public:
    15.         virtual void onDeviceAdded(const std::string& uid) = 0;
    16.         virtual void onDeviceRemoved(const std::string& uid) = 0;
    17.     };
    18.  
    19. public:
    20.     void initialized();
    21.     void uninstallFilter();
    22.     bool nativeEventFilter(const QByteArray& eventType, void* message, long* result) override;
    23.  
    24. public:
    25.     VideoNotificationClient(VideoNotificationClient::Listener* listener);
    26.     ~VideoNotificationClient();
    27.  
    28.  
    29. private:
    30.     bool                                                     m_bInitialized;
    31.     QHash                                 m_hSevNotifys;
    32.     VideoNotificationClient::Listener*                       m_pListener;
    33. };
    1. //源文件
    2. #include "VideoNotificationClient.h"
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. //具体的设备guid如usbiodef需要initguid
    9. #include 
    10. //USB设备
    11. //GUID_DEVINTERFACE_USB_DEVICE
    12. #include 
    13. //HID人机交互设备-鼠标键盘等
    14. #include 
    15. //GUID_DEVINTERFACE_KEYBOARD
    16. #include 
    17. //GUID_DEVINTERFACE_MOUSE
    18. #include 
    19. #include 
    20. #pragma comment(lib, "user32.lib")
    21. #pragma comment(lib, "setupapi.lib")
    22.  
    23. static const GUID GUID_DEVINTERFACE_LIST[] =
    24. {
    25.     // GUID_DEVINTERFACE_CAMERA_DEVICE 
    26.     { 0x65E8773D, 0x8F56, 0x11D0, { 0xA3, 0xB9, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96 } },
    27.  
    28.     // GUID_DEVINTERFACE_USB_DEVICE  
    29.     { 0xA5DCBF10, 0x6530, 0x11D2, { 0x90, 0x1F, 0x00, 0xC0, 0x4F, 0xB9, 0x51, 0xED } },
    30.  
    31.     // GUID_DEVINTERFACE_DISK  
    32.     { 0x53f56307, 0xb6bf, 0x11d0, { 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b } },
    33.  
    34.     // GUID_DEVINTERFACE_HID,   
    35.     { 0x4D1E55B2, 0xF16F, 0x11CF, { 0x88, 0xCB, 0x00, 0x11, 0x11, 0x00, 0x00, 0x30 } },
    36.  
    37.     // GUID_NDIS_LAN_CLASS  
    38.     { 0xad498944, 0x762f, 0x11d0, { 0x8d, 0xcb, 0x00, 0xc0, 0x4f, 0xc3, 0x35, 0x8c } },
    39.  
    40.     // GUID_DEVINTERFACE_COMPORT
    41.     { 0x86e0d1e0, 0x8089, 0x11d0, { 0x9c, 0xe4, 0x08, 0x00, 0x3e, 0x30, 0x1f, 0x73 } },
    42.  
    43.     // GUID_DEVINTERFACE_SERENUM_BUS_ENUMERATOR
    44.     { 0x4D36E978, 0xE325, 0x11CE, { 0xBF, 0xC1, 0x08, 0x00, 0x2B, 0xE1, 0x03, 0x18 } },
    45.  
    46.     // GUID_DEVINTERFACE_PARALLEL
    47.     { 0x97F76EF0, 0xF883, 0x11D0, { 0xAF, 0x1F, 0x00, 0x00, 0xF8, 0x00, 0x84, 0x5C } },
    48.  
    49.     // GUID_DEVINTERFACE_PARCLASS
    50.     { 0x811FC6A5, 0xF728, 0x11D0, { 0xA5, 0x37, 0x00, 0x00, 0xF8, 0x75, 0x3E, 0xD1 } }
    51. };
    52.  
    53. VideoNotificationClient::VideoNotificationClient(VideoNotificationClient::Listener *listener)
    54.     : QWidget(nullptr)
    55.     , m_bInitialized(false)
    56.     , m_pListener(listener)
    57. {
    58.     this->hide();
    59.     qApp->installNativeEventFilter(this);
    60. }
    61.  
    62. VideoNotificationClient::~VideoNotificationClient()
    63. {
    64.     uninstallFilter();
    65.     qApp->removeNativeEventFilter(this);
    66. } 
    67.  
    68. void VideoNotificationClient::initialized()
    69. {
    70.     HANDLE winid = (HANDLE)this->winId();
    71.     if (!winid)
    72.     {
    73.         return;
    74.     }
    75.  
    76.     //注册插拔事件
    77.     HDEVNOTIFY hDevNotify;
    78.     DEV_BROADCAST_DEVICEINTERFACE NotifacationFiler;
    79.     ZeroMemory(&NotifacationFiler, sizeof(DEV_BROADCAST_DEVICEINTERFACE));
    80.     NotifacationFiler.dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE);
    81.     NotifacationFiler.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
    82.  
    83.     for (int i = 0; i < sizeof(GUID_DEVINTERFACE_LIST) / sizeof(GUID); i++)
    84.     {
    85.         NotifacationFiler.dbcc_classguid = GUID_DEVINTERFACE_LIST[i];
    86.  
    87.         hDevNotify = RegisterDeviceNotification(winid, &NotifacationFiler, DEVICE_NOTIFY_WINDOW_HANDLE);
    88.         if (!hDevNotify)
    89.         {
    90.             qDebug() << "注册失败" << endl;
    91.             m_bInitialized = false;
    92.             return;
    93.         }
    94.         m_hSevNotifys.insert(QUuid(NotifacationFiler.dbcc_classguid), hDevNotify);
    95.     }
    96.     m_bInitialized = true;
    97.  
    98. }
    99.  
    100. void VideoNotificationClient::uninstallFilter()
    101. {
    102.     for (HDEVNOTIFY handle : qAsConst(m_hSevNotifys))
    103.     {
    104.         ::UnregisterDeviceNotification(handle);
    105.     }
    106.     m_hSevNotifys.clear();
    107. }
    108.  
    109. bool VideoNotificationClient::nativeEventFilter(const QByteArray& eventType, void* message, long* result)
    110. {
    111.     Q_UNUSED(result);
    112.  
    113.     MSG* msg = reinterpret_cast(message);
    114.     int msgType = msg->message;
    115.     if (msgType == WM_DEVICECHANGE)
    116.     {
    117.         PDEV_BROADCAST_HDR lpdb = (PDEV_BROADCAST_HDR)msg->lParam;
    118.         switch (msg->wParam) {
    119.         case DBT_DEVICEARRIVAL:
    120.             if (lpdb->dbch_devicetype = DBT_DEVTYP_DEVICEINTERFACE)
    121.             {
    122.                 PDEV_BROADCAST_DEVICEINTERFACE pDevInf = (PDEV_BROADCAST_DEVICEINTERFACE)lpdb;
    123.                 GUID cameraGuid = { 0x65E8773D, 0x8F56, 0x11D0, { 0xA3, 0xB9, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96 } };
    124.                 if (cameraGuid == pDevInf->dbcc_classguid)
    125.                 {
    126.                     QString devicePath = QString::fromWCharArray(pDevInf->dbcc_name);
    127.                     QStringList parts = devicePath.split('#');
    128.                     if (parts.length() != 4)
    129.                     {
    130.                         qDebug() << "camera logic error";
    131.                         return false;
    132.                     }
    133.                     QString usbPortStr = parts[2];
    134.                     QStringList usbPortParts = usbPortStr.split('&');
    135.                     if (usbPortParts.length() != 4)
    136.                     {
    137.                         qDebug() << "camera logic error";
    138.                         return false;
    139.                     }   
    140.                     if ("0000" != usbPortParts[3])
    141.                     {
    142.                         return false;
    143.                     }
    144.                     devicePath = devicePath.toLower();
    145.  
    146.                     m_pListener->onDeviceAdded(devicePath.toStdString());
    147.                     //emit cameraPlugged(true, devicePath);
    148.                 }
    149.             }
    150.             break;
    151.         case DBT_DEVICEREMOVECOMPLETE:
    152.             if (lpdb->dbch_devicetype = DBT_DEVTYP_DEVICEINTERFACE)
    153.             {
    154.                 PDEV_BROADCAST_DEVICEINTERFACE pDevInf = (PDEV_BROADCAST_DEVICEINTERFACE)lpdb;
    155.                 GUID cameraGuid = { 0x65E8773D, 0x8F56, 0x11D0, { 0xA3, 0xB9, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96 } };
    156.                 if (cameraGuid == pDevInf->dbcc_classguid)
    157.                 {
    158.                     // USB拔出马上触发
    159.                     QString devicePath = QString::fromWCharArray(pDevInf->dbcc_name);
    160.                     QStringList parts = devicePath.split('#');
    161.                     if (parts.length() != 4)
    162.                     {
    163.                         qDebug() << "camera logic error";
    164.                         return false;
    165.                     }
    166.                     QString usbPortStr = parts[2];
    167.                     QStringList usbPortParts = usbPortStr.split('&');
    168.                     if (usbPortParts.length() != 4)
    169.                     {
    170.                         qDebug() << "camera logic error";
    171.                         return false;
    172.                     }
    173.                     if ("0000" != usbPortParts[3])
    174.                     {
    175.                         return false;
    176.                     }
    177.                     devicePath = devicePath.toLower();
    178.                     m_pListener->onDeviceRemoved(devicePath.toStdString());
    179.                 }
    180.             }
    181.             break;
    182.         }
    183.     }
    184.     return false;
    185. }

    四、设备插拔库设计

    项目完整代码，在后续的文章中给出

    1. // camra
    2. struct CameraDevice
    3. {
    4. 	int                  nIndex = 0;                     // index
    5. 	std::string          uid = "";                       // 硬件层uniqueId mac中为BuiltInMicrophoneDevice  
    6. 	std::string          name = "";                      // 设备名称
    7. };
    8.  
    9. // IVideoCore
    10. class VIDEODEVICE_SHARED_EXPORT IVideoCore
    11. {
    12. public:
    13. 	static IVideoCore* getInstance();
    14. 	virtual void addListener(IVideoDeviceListner* listner) = 0;
    15. 	virtual void removeListener(IVideoDeviceListner* listner) = 0;
    16. 	virtual std::map getVideoDevicesList() = 0;
    17. };
    18.  
    19. // IVideoDevice
    20. class VIDEODEVICE_SHARED_EXPORT IVideoDevice
    21. {
    22. public:
    23.     virtual bool initlized() = 0;
    24.     virtual std::map getVideoDevicesList() = 0;
    25.     virtual void addListener(IVideoDeviceListner* listener) = 0;
    26.     virtual void removeListener(IVideoDeviceListner* listener) = 0;
    27.  
    28. };
    29.  
    30. // IVideoDeviceListner
    31. class VIDEODEVICE_SHARED_EXPORT IVideoDeviceListner
    32. {
    33. public:
    34.     virtual void onDeviceAdded(CameraDevice device) = 0;
    35.     virtual void onDeviceRemoved(CameraDevice device) = 0;
    36.     virtual void onDeviceListUpdate(std::map cameraList) = 0;
    37. };
    38.  
    39.  
    40. class VideoNotificationClient 
    41. {
    42. public:
    43.     class Listener
    44.     {
    45.     public:
    46.         virtual void onDeviceAdded(const std::string& uid) = 0;
    47.         virtual void onDeviceRemoved(const std::string& uid) = 0;
    48.     };
    49. }

  • 相关阅读:
    MATLAB中polyval函数用法
    【PAT甲级】1073 Scientific Notation
    JVM概述和内存管理（未完待续）
    2.mysql--备份恢复
    Ubuntu MongoDB账户密码设置
    Linux命令系列之top——里面藏着很多鲜为人知的宝藏知识
    MySQL8小时连接超时断开问题
    基于R语言结构方程模型
    测试开发-celery框架详解
    【Django】网上蛋糕项目商城-商品分类
  • 原文地址：https://blog.csdn.net/qq_15821883/article/details/132671310