mirror of https://github.com/AxioDL/boo.git
885 lines
32 KiB
C++
885 lines
32 KiB
C++
#include "boo/inputdev/HIDParser.hpp"
|
|
#include <map>
|
|
#include <algorithm>
|
|
|
|
#undef min
|
|
#undef max
|
|
|
|
namespace boo {
|
|
|
|
/* Based on "Device Class Definition for Human Interface Devices (HID)"
|
|
* http://www.usb.org/developers/hidpage/HID1_11.pdf
|
|
*/
|
|
|
|
static const char* UsagePageNames[] = {"Undefined", "Generic Desktop", "Simulation", "VR", "Sport",
|
|
"Game Controls", "Generic Device", "Keyboard", "LEDs", "Button",
|
|
"Ordinal", "Telephony", "Consumer", "Digitizer"};
|
|
|
|
static const char* GenericDesktopUsages[] = {"Undefined",
|
|
"Pointer",
|
|
"Mouse",
|
|
"Reserved",
|
|
"Joystick",
|
|
"Game Pad",
|
|
"Keyboard",
|
|
"Keypad",
|
|
"Multi-axis Controller",
|
|
"Tablet PC System Controls",
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
"X",
|
|
"Y",
|
|
"Z",
|
|
"Rx",
|
|
"Ry",
|
|
"Rz",
|
|
"Slider",
|
|
"Dial",
|
|
"Wheel",
|
|
"Hat Switch",
|
|
"Counted Buffer",
|
|
"Byte Count",
|
|
"Motion Wakeup",
|
|
"Start",
|
|
"Select",
|
|
"Reserved",
|
|
"Vx",
|
|
"Vy",
|
|
"Vz",
|
|
"Vbrx",
|
|
"Vbry",
|
|
"Vbrz",
|
|
"Vno",
|
|
"Feature Notification",
|
|
"Resolution Multiplier",
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
"System Control",
|
|
"System Power Down",
|
|
"System Sleep",
|
|
"System Wake Up",
|
|
"System Context Menu",
|
|
"System Main Menu",
|
|
"System App Menu",
|
|
"System Menu Help",
|
|
"System Menu Exit",
|
|
"System Menu Select",
|
|
"System Menu Right",
|
|
"System Menu Left",
|
|
"System Menu Up",
|
|
"System Menu Down",
|
|
"System Cold Restart",
|
|
"System Warm Restart",
|
|
"D-pad Up",
|
|
"D-pad Down",
|
|
"D-pad Right",
|
|
"D-pad Left",
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
"System Dock",
|
|
"System Undock",
|
|
"System Setup",
|
|
"System Break",
|
|
"System Debugger Break",
|
|
"Application Break",
|
|
"Application Debugger Break",
|
|
"System Speaker Mute",
|
|
"System Hibernate",
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
"System Display Invert",
|
|
"System Display Internal",
|
|
"System Display External",
|
|
"System Display Both",
|
|
"System Display Dual",
|
|
"System Display Toggle Int/Ext"};
|
|
|
|
static const char* GameUsages[] = {"Undefined",
|
|
"3D Game Controller",
|
|
"Pinball Device",
|
|
"Gun Device",
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
"Point of View",
|
|
"Turn Right/Left",
|
|
"Pitch Forward/Backward",
|
|
"Roll Right/Left",
|
|
"Move Right/Left",
|
|
"Move Forward/Backward",
|
|
"Move Up/Down",
|
|
"Lean Right/Left",
|
|
"Lean Forward/Backward",
|
|
"Height of POV",
|
|
"Flipper",
|
|
"Secondary Flipper",
|
|
"Bump",
|
|
"New Game",
|
|
"Shoot Ball",
|
|
"Player",
|
|
"Gun Bolt",
|
|
"Gun Clip",
|
|
"Gun Selector",
|
|
"Gun Single Shot",
|
|
"Gun Burst",
|
|
"Gun Automatic",
|
|
"Gun Safety",
|
|
"Gemepad Fire/Jump",
|
|
nullptr,
|
|
"Gamepad Trigger"};
|
|
|
|
enum class HIDCollectionType : uint8_t {
|
|
Physical,
|
|
Application,
|
|
Logical,
|
|
Report,
|
|
NamedArray,
|
|
UsageSwitch,
|
|
UsageModifier
|
|
};
|
|
|
|
enum class HIDItemType : uint8_t { Main, Global, Local, Reserved };
|
|
|
|
enum class HIDItemTag : uint8_t {
|
|
/* [6.2.2.4] Main Items */
|
|
Input = 0b1000,
|
|
Output = 0b1001,
|
|
Feature = 0b1011,
|
|
Collection = 0b1010,
|
|
EndCollection = 0b1100,
|
|
|
|
/* [6.2.2.7] Global Items */
|
|
UsagePage = 0b0000,
|
|
LogicalMinimum = 0b0001,
|
|
LogicalMaximum = 0b0010,
|
|
PhysicalMinimum = 0b0011,
|
|
PhysicalMaximum = 0b0100,
|
|
UnitExponent = 0b0101,
|
|
Unit = 0b0110,
|
|
ReportSize = 0b0111,
|
|
ReportID = 0b1000,
|
|
ReportCount = 0b1001,
|
|
Push = 0b1010,
|
|
Pop = 0b1011,
|
|
|
|
/* [6.2.2.8] Local Items */
|
|
Usage = 0b0000,
|
|
UsageMinimum = 0b0001,
|
|
UsageMaximum = 0b0010,
|
|
DesignatorIndex = 0b0011,
|
|
DesignatorMinimum = 0b0100,
|
|
DesignatorMaximum = 0b0101,
|
|
StringIndex = 0b0111,
|
|
StringMinimum = 0b1000,
|
|
StringMaximum = 0b1001,
|
|
Delimiter = 0b1010,
|
|
};
|
|
|
|
struct HIDItemState {
|
|
/* [6.2.2.7] Global items */
|
|
HIDUsagePage m_usagePage = HIDUsagePage::Undefined;
|
|
HIDRange m_logicalRange = {};
|
|
HIDRange m_physicalRange = {};
|
|
int32_t m_unitExponent = 0;
|
|
uint32_t m_unit = 0;
|
|
uint32_t m_reportSize = 0; // In bits
|
|
uint32_t m_reportID = 0;
|
|
uint32_t m_reportCount = 0;
|
|
|
|
/* [6.2.2.8] Local Items */
|
|
std::vector<HIDUsage> m_usage;
|
|
HIDRange m_usageRange = {};
|
|
#if 0
|
|
std::vector<int32_t> m_designatorIndex;
|
|
std::vector<HIDRange> m_designatorRange;
|
|
std::vector<int32_t> m_stringIndex;
|
|
std::vector<HIDRange> m_stringRange;
|
|
std::vector<int32_t> m_delimiter;
|
|
#endif
|
|
|
|
void ResetLocalItems() {
|
|
m_usage.clear();
|
|
m_usageRange = HIDRange();
|
|
#if 0
|
|
m_designatorIndex.clear();
|
|
m_designatorRange.clear();
|
|
m_stringIndex.clear();
|
|
m_stringRange.clear();
|
|
m_delimiter.clear();
|
|
#endif
|
|
}
|
|
|
|
template <typename T>
|
|
static T _GetLocal(const std::vector<T>& v, uint32_t idx) {
|
|
if (v.empty())
|
|
return {};
|
|
if (idx >= v.size())
|
|
return v[0];
|
|
return v[idx];
|
|
}
|
|
|
|
HIDUsage GetUsage(uint32_t idx) const {
|
|
if (m_usageRange.second - m_usageRange.first != 0)
|
|
return HIDUsage(m_usageRange.first + idx);
|
|
return _GetLocal(m_usage, idx);
|
|
}
|
|
};
|
|
|
|
struct HIDCollectionItem {
|
|
/* [6.2.2.6] Collection, End Collection Items */
|
|
HIDCollectionType m_type;
|
|
HIDUsagePage m_usagePage;
|
|
HIDUsage m_usage;
|
|
|
|
HIDCollectionItem(HIDCollectionType type, const HIDItemState& state)
|
|
: m_type(type), m_usagePage(state.m_usagePage), m_usage(state.GetUsage(0)) {}
|
|
};
|
|
|
|
HIDMainItem::HIDMainItem(uint32_t flags, const HIDItemState& state, uint32_t reportIdx) : m_flags(uint16_t(flags)) {
|
|
m_usagePage = state.m_usagePage;
|
|
m_usage = state.GetUsage(reportIdx);
|
|
m_logicalRange = state.m_logicalRange;
|
|
m_reportSize = state.m_reportSize;
|
|
}
|
|
|
|
HIDMainItem::HIDMainItem(uint32_t flags, HIDUsagePage usagePage, HIDUsage usage, HIDRange logicalRange,
|
|
int32_t reportSize)
|
|
: m_flags(uint16_t(flags))
|
|
, m_usagePage(usagePage)
|
|
, m_usage(usage)
|
|
, m_logicalRange(logicalRange)
|
|
, m_reportSize(reportSize) {}
|
|
|
|
const char* HIDMainItem::GetUsagePageName() const {
|
|
if (int(m_usagePage) >= std::extent<decltype(UsagePageNames)>::value)
|
|
return nullptr;
|
|
return UsagePageNames[int(m_usagePage)];
|
|
}
|
|
|
|
const char* HIDMainItem::GetUsageName() const {
|
|
switch (m_usagePage) {
|
|
case HIDUsagePage::GenericDesktop:
|
|
if (int(m_usage) >= std::extent<decltype(GenericDesktopUsages)>::value)
|
|
return nullptr;
|
|
return GenericDesktopUsages[int(m_usage)];
|
|
case HIDUsagePage::Game:
|
|
if (int(m_usage) >= std::extent<decltype(GameUsages)>::value)
|
|
return nullptr;
|
|
return GameUsages[int(m_usage)];
|
|
default:
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
struct HIDReports {
|
|
std::map<int32_t, std::vector<HIDMainItem>> m_inputReports;
|
|
std::map<int32_t, std::vector<HIDMainItem>> m_outputReports;
|
|
std::map<int32_t, std::vector<HIDMainItem>> m_featureReports;
|
|
|
|
static void _AddItem(std::map<int32_t, std::vector<HIDMainItem>>& m, uint32_t flags, const HIDItemState& state) {
|
|
std::vector<HIDMainItem>& report = m[state.m_reportID];
|
|
report.reserve(report.size() + state.m_reportCount);
|
|
for (int i = 0; i < state.m_reportCount; ++i)
|
|
report.emplace_back(flags, state, i);
|
|
}
|
|
|
|
void AddInputItem(uint32_t flags, const HIDItemState& state) { _AddItem(m_inputReports, flags, state); }
|
|
void AddOutputItem(uint32_t flags, const HIDItemState& state) { _AddItem(m_outputReports, flags, state); }
|
|
void AddFeatureItem(uint32_t flags, const HIDItemState& state) { _AddItem(m_featureReports, flags, state); }
|
|
};
|
|
|
|
#if _WIN32
|
|
#if !WINDOWS_STORE
|
|
HIDParser::ParserStatus HIDParser::Parse(const PHIDP_PREPARSED_DATA descriptorData) {
|
|
/* User mode HID report descriptor isn't available on Win32.
|
|
* Opaque preparsed data must be enumerated and sorted into
|
|
* iterable items.
|
|
*
|
|
* Wine's implementation has a good illustration of what's
|
|
* going on here:
|
|
* https://github.com/wine-mirror/wine/blob/master/dlls/hidclass.sys/descriptor.c
|
|
*
|
|
* (Thanks for this pointless pain-in-the-ass Microsoft)
|
|
*/
|
|
|
|
m_descriptorData = descriptorData;
|
|
HIDP_CAPS caps;
|
|
HidP_GetCaps(descriptorData, &caps);
|
|
m_dataList.resize(HidP_MaxDataListLength(HidP_Input, descriptorData));
|
|
|
|
std::map<uint32_t, HIDMainItem> inputItems;
|
|
|
|
{
|
|
/* First enumerate buttons */
|
|
USHORT length = caps.NumberInputButtonCaps;
|
|
std::vector<HIDP_BUTTON_CAPS> bCaps(caps.NumberInputButtonCaps, HIDP_BUTTON_CAPS());
|
|
HidP_GetButtonCaps(HidP_Input, bCaps.data(), &length, descriptorData);
|
|
for (const HIDP_BUTTON_CAPS& caps : bCaps) {
|
|
if (caps.IsRange) {
|
|
int usage = caps.Range.UsageMin;
|
|
for (int i = caps.Range.DataIndexMin; i <= caps.Range.DataIndexMax; ++i, ++usage) {
|
|
inputItems.insert(std::make_pair(
|
|
i, HIDMainItem(caps.BitField, HIDUsagePage(caps.UsagePage), HIDUsage(usage), std::make_pair(0, 1), 1)));
|
|
}
|
|
} else {
|
|
inputItems.insert(std::make_pair(caps.NotRange.DataIndex,
|
|
HIDMainItem(caps.BitField, HIDUsagePage(caps.UsagePage),
|
|
HIDUsage(caps.NotRange.Usage), std::make_pair(0, 1), 1)));
|
|
}
|
|
}
|
|
}
|
|
|
|
{
|
|
/* Now enumerate values */
|
|
USHORT length = caps.NumberInputValueCaps;
|
|
std::vector<HIDP_VALUE_CAPS> vCaps(caps.NumberInputValueCaps, HIDP_VALUE_CAPS());
|
|
HidP_GetValueCaps(HidP_Input, vCaps.data(), &length, descriptorData);
|
|
for (const HIDP_VALUE_CAPS& caps : vCaps) {
|
|
if (caps.IsRange) {
|
|
int usage = caps.Range.UsageMin;
|
|
for (int i = caps.Range.DataIndexMin; i <= caps.Range.DataIndexMax; ++i, ++usage) {
|
|
inputItems.insert(
|
|
std::make_pair(i, HIDMainItem(caps.BitField, HIDUsagePage(caps.UsagePage), HIDUsage(usage),
|
|
std::make_pair(caps.LogicalMin, caps.LogicalMax), caps.BitSize)));
|
|
}
|
|
} else {
|
|
inputItems.insert(
|
|
std::make_pair(caps.NotRange.DataIndex,
|
|
HIDMainItem(caps.BitField, HIDUsagePage(caps.UsagePage), HIDUsage(caps.NotRange.Usage),
|
|
HIDRange(caps.LogicalMin, caps.LogicalMax), caps.BitSize)));
|
|
}
|
|
}
|
|
}
|
|
|
|
m_itemPool.reserve(inputItems.size());
|
|
for (const auto& item : inputItems)
|
|
m_itemPool.push_back(item.second);
|
|
|
|
m_status = ParserStatus::Done;
|
|
return ParserStatus::Done;
|
|
}
|
|
#endif
|
|
#else
|
|
|
|
static HIDParser::ParserStatus AdvanceIt(const uint8_t*& it, const uint8_t* end, size_t adv) {
|
|
it += adv;
|
|
if (it > end) {
|
|
it = end;
|
|
return HIDParser::ParserStatus::Error;
|
|
} else if (it == end) {
|
|
return HIDParser::ParserStatus::Done;
|
|
}
|
|
return HIDParser::ParserStatus::OK;
|
|
}
|
|
|
|
static uint8_t GetByteValue(const uint8_t*& it, const uint8_t* end, HIDParser::ParserStatus& status) {
|
|
const uint8_t* oldIt = it;
|
|
status = AdvanceIt(it, end, 1);
|
|
if (status == HIDParser::ParserStatus::Error)
|
|
return 0;
|
|
return *oldIt;
|
|
}
|
|
|
|
static uint32_t GetShortValue(const uint8_t*& it, const uint8_t* end, int adv, HIDParser::ParserStatus& status) {
|
|
const uint8_t* oldIt = it;
|
|
switch (adv) {
|
|
case 1:
|
|
status = AdvanceIt(it, end, 1);
|
|
if (status == HIDParser::ParserStatus::Error)
|
|
return 0;
|
|
return *oldIt;
|
|
case 2:
|
|
status = AdvanceIt(it, end, 2);
|
|
if (status == HIDParser::ParserStatus::Error)
|
|
return 0;
|
|
return *reinterpret_cast<const uint16_t*>(&*oldIt);
|
|
case 3:
|
|
status = AdvanceIt(it, end, 4);
|
|
if (status == HIDParser::ParserStatus::Error)
|
|
return 0;
|
|
return *reinterpret_cast<const uint32_t*>(&*oldIt);
|
|
default:
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
HIDParser::ParserStatus HIDParser::ParseItem(HIDReports& reportsOut, std::stack<HIDItemState>& stateStack,
|
|
std::stack<HIDCollectionItem>& collectionStack, const uint8_t*& it,
|
|
const uint8_t* end, bool& multipleReports) {
|
|
ParserStatus status = ParserStatus::OK;
|
|
uint8_t head = *it++;
|
|
if (head == 0b11111110) {
|
|
/* Long item */
|
|
uint8_t bDataSize = GetByteValue(it, end, status);
|
|
if (status == ParserStatus::Error)
|
|
return ParserStatus::Error;
|
|
/*uint8_t bLongItemTag =*/GetByteValue(it, end, status);
|
|
if (status == ParserStatus::Error)
|
|
return ParserStatus::Error;
|
|
status = AdvanceIt(it, end, bDataSize);
|
|
if (status == ParserStatus::Error)
|
|
return ParserStatus::Error;
|
|
} else {
|
|
/* Short Item */
|
|
uint32_t data = GetShortValue(it, end, head & 0x3, status);
|
|
if (status == ParserStatus::Error)
|
|
return ParserStatus::Error;
|
|
|
|
switch (HIDItemType((head >> 2) & 0x3)) {
|
|
case HIDItemType::Main:
|
|
switch (HIDItemTag(head >> 4)) {
|
|
case HIDItemTag::Input:
|
|
reportsOut.AddInputItem(data, stateStack.top());
|
|
break;
|
|
case HIDItemTag::Output:
|
|
reportsOut.AddOutputItem(data, stateStack.top());
|
|
break;
|
|
case HIDItemTag::Feature:
|
|
reportsOut.AddFeatureItem(data, stateStack.top());
|
|
break;
|
|
case HIDItemTag::Collection:
|
|
collectionStack.emplace(HIDCollectionType(data), stateStack.top());
|
|
break;
|
|
case HIDItemTag::EndCollection:
|
|
if (collectionStack.empty())
|
|
return ParserStatus::Error;
|
|
collectionStack.pop();
|
|
break;
|
|
default:
|
|
return ParserStatus::Error;
|
|
}
|
|
stateStack.top().ResetLocalItems();
|
|
break;
|
|
case HIDItemType::Global:
|
|
switch (HIDItemTag(head >> 4)) {
|
|
case HIDItemTag::UsagePage:
|
|
stateStack.top().m_usagePage = HIDUsagePage(data);
|
|
break;
|
|
case HIDItemTag::LogicalMinimum:
|
|
stateStack.top().m_logicalRange.first = data;
|
|
break;
|
|
case HIDItemTag::LogicalMaximum:
|
|
stateStack.top().m_logicalRange.second = data;
|
|
break;
|
|
case HIDItemTag::PhysicalMinimum:
|
|
stateStack.top().m_physicalRange.first = data;
|
|
break;
|
|
case HIDItemTag::PhysicalMaximum:
|
|
stateStack.top().m_physicalRange.second = data;
|
|
break;
|
|
case HIDItemTag::UnitExponent:
|
|
stateStack.top().m_unitExponent = data;
|
|
break;
|
|
case HIDItemTag::Unit:
|
|
stateStack.top().m_unit = data;
|
|
break;
|
|
case HIDItemTag::ReportSize:
|
|
stateStack.top().m_reportSize = data;
|
|
break;
|
|
case HIDItemTag::ReportID:
|
|
multipleReports = true;
|
|
stateStack.top().m_reportID = data;
|
|
break;
|
|
case HIDItemTag::ReportCount:
|
|
stateStack.top().m_reportCount = data;
|
|
break;
|
|
case HIDItemTag::Push:
|
|
stateStack.push(stateStack.top());
|
|
break;
|
|
case HIDItemTag::Pop:
|
|
if (stateStack.empty())
|
|
return ParserStatus::Error;
|
|
stateStack.pop();
|
|
break;
|
|
default:
|
|
return ParserStatus::Error;
|
|
}
|
|
break;
|
|
case HIDItemType::Local:
|
|
switch (HIDItemTag(head >> 4)) {
|
|
case HIDItemTag::Usage:
|
|
stateStack.top().m_usage.push_back(HIDUsage(data));
|
|
break;
|
|
case HIDItemTag::UsageMinimum:
|
|
stateStack.top().m_usageRange.first = data;
|
|
break;
|
|
case HIDItemTag::UsageMaximum:
|
|
stateStack.top().m_usageRange.second = data;
|
|
break;
|
|
case HIDItemTag::DesignatorIndex:
|
|
case HIDItemTag::DesignatorMinimum:
|
|
case HIDItemTag::DesignatorMaximum:
|
|
case HIDItemTag::StringIndex:
|
|
case HIDItemTag::StringMinimum:
|
|
case HIDItemTag::StringMaximum:
|
|
case HIDItemTag::Delimiter:
|
|
break;
|
|
default:
|
|
return ParserStatus::Error;
|
|
}
|
|
break;
|
|
default:
|
|
return ParserStatus::Error;
|
|
}
|
|
}
|
|
|
|
return it == end ? ParserStatus::Done : ParserStatus::OK;
|
|
}
|
|
|
|
HIDParser::ParserStatus HIDParser::Parse(const uint8_t* descriptorData, size_t len) {
|
|
std::stack<HIDItemState> stateStack;
|
|
stateStack.emplace();
|
|
std::stack<HIDCollectionItem> collectionStack;
|
|
HIDReports reports;
|
|
|
|
const uint8_t* end = descriptorData + len;
|
|
for (const uint8_t* it = descriptorData; it != end;)
|
|
if ((m_status = ParseItem(reports, stateStack, collectionStack, it, end, m_multipleReports)) != ParserStatus::OK)
|
|
break;
|
|
|
|
if (m_status != ParserStatus::Done)
|
|
return m_status;
|
|
|
|
uint32_t itemCount = 0;
|
|
uint32_t reportCount =
|
|
uint32_t(reports.m_inputReports.size() + reports.m_outputReports.size() + reports.m_featureReports.size());
|
|
|
|
for (const auto& rep : reports.m_inputReports)
|
|
itemCount += rep.second.size();
|
|
for (const auto& rep : reports.m_outputReports)
|
|
itemCount += rep.second.size();
|
|
for (const auto& rep : reports.m_featureReports)
|
|
itemCount += rep.second.size();
|
|
|
|
m_itemPool.reset(new HIDMainItem[itemCount]);
|
|
m_reportPool.reset(new Report[reportCount]);
|
|
|
|
uint32_t itemIndex = 0;
|
|
uint32_t reportIndex = 0;
|
|
|
|
auto func = [&](std::pair<uint32_t, uint32_t>& out, const std::map<int32_t, std::vector<HIDMainItem>>& in) {
|
|
out = std::make_pair(reportIndex, reportIndex + in.size());
|
|
for (const auto& rep : in) {
|
|
m_reportPool[reportIndex++] = std::make_pair(rep.first, std::make_pair(itemIndex, itemIndex + rep.second.size()));
|
|
for (const auto& item : rep.second)
|
|
m_itemPool[itemIndex++] = item;
|
|
}
|
|
};
|
|
func(m_inputReports, reports.m_inputReports);
|
|
func(m_outputReports, reports.m_outputReports);
|
|
func(m_featureReports, reports.m_featureReports);
|
|
|
|
return m_status;
|
|
}
|
|
|
|
size_t HIDParser::CalculateMaxInputReportSize(const uint8_t* descriptorData, size_t len) {
|
|
std::stack<HIDItemState> stateStack;
|
|
stateStack.emplace();
|
|
std::stack<HIDCollectionItem> collectionStack;
|
|
HIDReports reports;
|
|
ParserStatus status = ParserStatus::Done;
|
|
|
|
bool multipleReports = false;
|
|
const uint8_t* end = descriptorData + len;
|
|
for (const uint8_t* it = descriptorData; it != end;)
|
|
if ((status = ParseItem(reports, stateStack, collectionStack, it, end, multipleReports)) != ParserStatus::OK)
|
|
break;
|
|
|
|
if (status != ParserStatus::Done)
|
|
return 0;
|
|
|
|
size_t maxSize = 0;
|
|
for (const auto& rep : reports.m_inputReports) {
|
|
size_t repSize = 0;
|
|
for (const auto& item : rep.second)
|
|
repSize += item.m_reportSize;
|
|
if (repSize > maxSize)
|
|
maxSize = repSize;
|
|
}
|
|
|
|
return (maxSize + 7) / 8 + multipleReports;
|
|
}
|
|
|
|
std::pair<HIDUsagePage, HIDUsage> HIDParser::GetApplicationUsage(const uint8_t* descriptorData, size_t len) {
|
|
std::stack<HIDItemState> stateStack;
|
|
stateStack.emplace();
|
|
std::stack<HIDCollectionItem> collectionStack;
|
|
HIDReports reports;
|
|
ParserStatus status = ParserStatus::Done;
|
|
|
|
bool multipleReports = false;
|
|
const uint8_t* end = descriptorData + len;
|
|
for (const uint8_t* it = descriptorData; it != end;) {
|
|
status = ParseItem(reports, stateStack, collectionStack, it, end, multipleReports);
|
|
if (collectionStack.empty())
|
|
continue;
|
|
if (collectionStack.top().m_type == HIDCollectionType::Application)
|
|
return {collectionStack.top().m_usagePage, collectionStack.top().m_usage};
|
|
if (status != ParserStatus::OK)
|
|
break;
|
|
}
|
|
|
|
return {};
|
|
}
|
|
#endif
|
|
|
|
#if _WIN32
|
|
void HIDParser::EnumerateValues(const std::function<bool(const HIDMainItem& item)>& valueCB) const {
|
|
#if !WINDOWS_STORE
|
|
if (m_status != ParserStatus::Done)
|
|
return;
|
|
|
|
for (const HIDMainItem& item : m_itemPool) {
|
|
if (item.IsConstant())
|
|
continue;
|
|
if (!valueCB(item))
|
|
return;
|
|
}
|
|
#endif
|
|
}
|
|
#else
|
|
void HIDParser::EnumerateValues(const std::function<bool(const HIDMainItem& item)>& valueCB) const {
|
|
if (m_status != ParserStatus::Done)
|
|
return;
|
|
|
|
for (uint32_t i = m_inputReports.first; i < m_inputReports.second; ++i) {
|
|
const Report& rep = m_reportPool[i];
|
|
for (uint32_t j = rep.second.first; j < rep.second.second; ++j) {
|
|
const HIDMainItem& item = m_itemPool[j];
|
|
if (item.IsConstant())
|
|
continue;
|
|
if (!valueCB(item))
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if _WIN32
|
|
void HIDParser::ScanValues(const std::function<bool(const HIDMainItem& item, int32_t value)>& valueCB,
|
|
const uint8_t* data, size_t len) const {
|
|
#if !WINDOWS_STORE
|
|
if (m_status != ParserStatus::Done)
|
|
return;
|
|
|
|
ULONG dataLen = m_dataList.size();
|
|
if (HidP_GetData(HidP_Input, m_dataList.data(), &dataLen, m_descriptorData, PCHAR(data), len) != HIDP_STATUS_SUCCESS)
|
|
return;
|
|
|
|
int idx = 0;
|
|
auto it = m_dataList.begin();
|
|
auto end = m_dataList.begin() + dataLen;
|
|
for (const HIDMainItem& item : m_itemPool) {
|
|
if (item.IsConstant())
|
|
continue;
|
|
int32_t value = 0;
|
|
if (it != end) {
|
|
const HIDP_DATA& data = *it;
|
|
if (data.DataIndex == idx) {
|
|
value = data.RawValue;
|
|
++it;
|
|
}
|
|
}
|
|
if (!valueCB(item, value))
|
|
return;
|
|
++idx;
|
|
}
|
|
#endif
|
|
}
|
|
#else
|
|
|
|
class BitwiseIterator {
|
|
const uint8_t*& m_it;
|
|
const uint8_t* m_end;
|
|
int m_bit = 0;
|
|
|
|
public:
|
|
BitwiseIterator(const uint8_t*& it, const uint8_t* end) : m_it(it), m_end(end) {}
|
|
|
|
uint32_t GetUnsignedValue(int numBits, HIDParser::ParserStatus& status) {
|
|
uint32_t val = 0;
|
|
for (int i = 0; i < numBits;) {
|
|
if (m_it >= m_end) {
|
|
status = HIDParser::ParserStatus::Error;
|
|
return 0;
|
|
}
|
|
int remBits = std::min(8 - m_bit, numBits - i);
|
|
val |= uint32_t((*m_it >> m_bit) & ((1 << remBits) - 1)) << i;
|
|
i += remBits;
|
|
m_bit += remBits;
|
|
if (m_bit == 8) {
|
|
m_bit = 0;
|
|
AdvanceIt(m_it, m_end, 1);
|
|
}
|
|
}
|
|
return val;
|
|
}
|
|
};
|
|
|
|
void HIDParser::ScanValues(const std::function<bool(const HIDMainItem& item, int32_t value)>& valueCB,
|
|
const uint8_t* data, size_t len) const {
|
|
if (m_status != ParserStatus::Done)
|
|
return;
|
|
|
|
auto it = data;
|
|
auto end = data + len;
|
|
ParserStatus status = ParserStatus::OK;
|
|
uint8_t reportId = 0;
|
|
if (m_multipleReports)
|
|
reportId = GetByteValue(it, end, status);
|
|
if (status == ParserStatus::Error)
|
|
return;
|
|
|
|
BitwiseIterator bitIt(it, end);
|
|
|
|
for (uint32_t i = m_inputReports.first; i < m_inputReports.second; ++i) {
|
|
const Report& rep = m_reportPool[i];
|
|
if (rep.first != reportId)
|
|
continue;
|
|
for (uint32_t j = rep.second.first; j < rep.second.second; ++j) {
|
|
const HIDMainItem& item = m_itemPool[j];
|
|
int32_t val = bitIt.GetUnsignedValue(item.m_reportSize, status);
|
|
if (status == ParserStatus::Error)
|
|
return;
|
|
if (item.IsConstant())
|
|
continue;
|
|
if (!valueCB(item, val))
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
} // namespace boo
|