下面是
最后，我当前
我正尝试使用JNA来桥接Leap Motion的C API(LeapC)和Java，因为Leap Motion已经否决了它们的官方Java绑定。然而，我对C并不熟悉，而且我以前也没有使用过JNA。到目前为止，我已经设法完成了一些工作(比如连接到我的Leap Motion控制器并轮询它的状态事件)，但在接收实际跟踪数据时，我陷入了困境。
LeapC的相关结构在LeapC.h:中定义如下
/** ingroup Structs
* A snapshot, or frame of data, containing the tracking data for a single moment in time.
* The LEAP_FRAME struct is the container for all the tracking data.
* @since 3.0.0
*/
typedef struct _LEAP_TRACKING_EVENT {
LEAP_FRAME_HEADER info;
int64_t tracking_frame_id;
/** The number of hands tracked in this frame, i.e. the number of elements in
* the pHands array.
*/
uint32_t nHands;
/**
* A pointer to the array of hands tracked in this frame.
*/
LEAP_HAND* pHands;
/**
* Current tracking frame rate in hertz.
*/
float framerate;
} LEAP_TRACKING_EVENT;
我在JNA中实现它的尝试只取得了部分成功：info、tracking_frame_id和nHands字段读取正确，并包含期望的信息。pHands拒绝工作。
尝试1
首先，我尝试将pHands作为指向LEAP_HAND数组开头的指针：
@FieldOrder({ "info", "tracking_frame_id", "nHands", "pHands", "framerate" })
public static class LEAP_TRACKING_EVENT extends Structure
{
public LEAP_FRAME_HEADER info;
public long tracking_frame_id;
public int nHands;
public Pointer pHands;
public float framerate;
}
试图从指针指向的地址读取任何内容，无论是完整结构(new LEAP_HAND(pHands))还是仅单个字节(pHands.getByte())，都会从JNA发出Invalid Memory Access错误。
根据阅读其他各种StackOverflow问题和答案，我似乎应该做这样的事情。
尝试2
其次，我尝试将pHands处理为一个直上阵列：
@FieldOrder({ "info", "tracking_frame_id", "nHands", "pHands", "framerate" })
public static class LEAP_TRACKING_EVENT extends Structure
{
public LEAP_FRAME_HEADER info;
public long tracking_frame_id;
public int nHands;
public LEAP_HAND[] pHands = new LEAP_HAND[1]; //Size-limited to 1 here while testing.
public float framerate;
}
给定恰好存在1只手的情况(如上面的JNA代码中所定义的)，数组由LEAP_hand的实例填充，但它包含垃圾数据(大部分为零)。奇怪的是，当我沿着x轴移动手时，pHands[0].palm.position.z的值确实发生了变化，所以它似乎与这里正确的记忆部分部分重叠，但没有正确对齐。
我读这个数组的方式一定有问题。有人知道我遗漏了什么吗？
编辑：使用SDK示例中的C代码
他们这样称呼LeapPollConnection：result = LeapPollConnection(connectionHandle, timeout, &msg);。如果msg包含跟踪事件，则它们调用handleTrackingEvent(msg.tracking_event);。该功能定义如下：
//File: ExampleConnection.c
static void handleTrackingEvent(const LEAP_TRACKING_EVENT *tracking_event){
if(ConnectionCallbacks.on_frame){
ConnectionCallbacks.on_frame(tracking_event);
}
}
ConnectionCallbacks.on_frame绑定到以下OnFrame函数：
//File: CallbackSample.c
/** Callback for when a frame of tracking data is available. */
static void OnFrame(const LEAP_TRACKING_EVENT *frame){
printf("Frame %lli with %i hands.n", (long long int)frame->info.frame_id, frame->nHands);
for(uint32_t h = 0; h < frame->nHands; h++){
LEAP_HAND* hand = &frame->pHands[h];
printf(" Hand id %i is a %s hand with position (%f, %f, %f).n",
hand->id,
(hand->type == eLeapHandType_Left ? "left" : "right"),
hand->palm.position.x,
hand->palm.position.y,
hand->palm.position.z);
}
}
编辑2：到目前为止的所有(相关)代码：
首先，轮询和获取事件的代码
// Define an object to receive an event message into.
LEAP_CONNECTION_MESSAGE.ByReference messageRef = new LEAP_CONNECTION_MESSAGE.ByReference();
while (true)
{
// Poll LeapC for an event. A status code for success is returned,
// and messageRef is populated with the event message.
LeapC.INSTANCE.LeapPollConnection(leapConnection.getValue(), 500, messageRef);
// If the event is a tracking event, get the event data.
if (messageRef.type == eLeapEventType.Tracking.getShortValue())
{
LEAP_TRACKING_EVENT event = messageRef.union.tracking_event;
}
// Sleep a moment before polling again.
try
{
Thread.sleep(100);
}
catch (InterruptedException e)
{
}
}
下面是PollLeapConnection和LEAP_CONNECTION_MESSAGE的实现
LeapPollConnection(LeapC API参考)
// Original C signature:
// LeapPollConnection(LEAP_CONNECTION hConnection, uint32_t timeout, LEAP_CONNECTION_MESSAGE* evt);
public eLeapRS LeapPollConnection(Pointer hConnection, int timeout,
LEAP_CONNECTION_MESSAGE.ByReference message);
LEAP_CONNECTION_MESSAGE(LeapC API参考)
// Original C signature:
// typedef struct _LEAP_CONNECTION_MESSAGE {
// /**
// * The size of this message struct. @since 3.0.0
// */
// uint32_t size;
//
// /**
// * The message type. @since 3.0.0
// */
// eLeapEventType type;
//
// /**
// * A pointer to the event data for the current type of message. @since 3.0.0
// */
// union {
// /** An untyped pointer. @since 3.0.0 */
// const void* pointer;
// /** A connection message. @since 3.0.0 */
// const LEAP_CONNECTION_EVENT* connection_event;
// /** A connection lost. @since 3.0.0 */
// const LEAP_CONNECTION_LOST_EVENT* connection_lost_event;
// /** A device detected message. @since 3.0.0 */
// const LEAP_DEVICE_EVENT* device_event;
// /** A device's status has changed. @since 3.1.3 */
// const LEAP_DEVICE_STATUS_CHANGE_EVENT* device_status_change_event;
// /** A policy message. @since 3.0.0 */
// const LEAP_POLICY_EVENT* policy_event;
// /** A device failure message. @since 3.0.0 */
// const LEAP_DEVICE_FAILURE_EVENT* device_failure_event;
// /** A tracking message. @since 3.0.0 */
// const LEAP_TRACKING_EVENT* tracking_event;
// /** A log message. @since 3.0.0 */
// const LEAP_LOG_EVENT* log_event;
// /** A log messages. @since 4.0.0 */
// const LEAP_LOG_EVENTS* log_events;
// /** A get config value message. @since 3.0.0 */
// const LEAP_CONFIG_RESPONSE_EVENT* config_response_event;
// /** A set config value message. @since 3.0.0 */
// const LEAP_CONFIG_CHANGE_EVENT* config_change_event;
// const LEAP_DROPPED_FRAME_EVENT* dropped_frame_event;
// /** A streaming image message. @since 4.0.0 */
// const LEAP_IMAGE_EVENT* image_event;
// /** A point mapping message. @since 4.0.0 */
// const LEAP_POINT_MAPPING_CHANGE_EVENT* point_mapping_change_event;
// const LEAP_HEAD_POSE_EVENT* head_pose_event;
// };
// } LEAP_CONNECTION_MESSAGE;
@FieldOrder({ "size", "type", "union" })
public static class LEAP_CONNECTION_MESSAGE extends Structure
{
public static class EventUnion extends Union
{
public Pointer pointer;
// Pointer is used for all event types I haven't mapped yet.
public Pointer connection_event;
public Pointer connection_lost_event;
public Pointer device_event;
public Pointer device_status_change_event;
public Pointer policy_event;
public Pointer device_failure_event;
public LEAP_TRACKING_EVENT.ByReference tracking_event;
public Pointer log_event;
public Pointer log_events;
public Pointer config_response_event;
public Pointer config_change_event;
public Pointer dropped_frame_event;
public Pointer image_event;
public Pointer point_mapping_change_event;
public Pointer head_pose_event;
}
public int size;
public short type;
public EventUnion union;
private eLeapEventType typeE;
@Override
public void read()
{
super.read();
// Convert the short in type to an enum constant.
typeE = eLeapEventType.None.getForValue(type);
if (typeE == null)
{
typeE = eLeapEventType.None;
}
switch (typeE)
{
case ConfigChange :
union.setType("config_change_event");
break;
case ConfigResponse :
union.setType("config_response_event");
break;
case Connection :
union.setType("connection_event");
break;
case ConnectionLost :
union.setType("connection_lost_event");
break;
case Device :
union.setType("device_event");
break;
case DeviceFailure :
union.setType("device_failure_event");
break;
case DeviceLost :
union.setType("device_event");
break;
case DeviceStatusChange :
union.setType("device_status_change_event");
break;
case DroppedFrame :
union.setType("dropped_frame_event");
break;
case HeadPose :
union.setType("head_pose_event");
break;
case Image :
union.setType("image_event");
break;
case ImageComplete :
break;
case ImageRequestError :
break;
case LogEvent :
union.setType("log_event");
break;
case LogEvents :
union.setType("log_events");
break;
case None :
union.setType("pointer");
break;
case PointMappingChange :
union.setType("point_mapping_change_event");
break;
case Policy :
union.setType("policy_event");
break;
case Tracking :
union.setType("tracking_event");
break;
default :
System.out.println("Unknown message type: " + typeE);
break;
}
union.read();
}
public static class ByReference extends LEAP_CONNECTION_MESSAGE
implements Structure.ByReference
{
}
}
最后，我当前LEAP_TRACKING_EVENT的完整代码
(LeapC API参考)
// Original C signature: See the top of this post.
@FieldOrder({ "info", "tracking_frame_id", "nHands", "pHands", "framerate" })
public static class LEAP_TRACKING_EVENT extends Structure
{
public LEAP_FRAME_HEADER info;
public long tracking_frame_id;
public int nHands;
public Pointer pHands;
public float framerate;
// Field to store all LEAP_HAND objects pointed to by pHands.
private LEAP_HAND[] hands;
@Override
public void read()
{
super.read();
// Print frame ID and hand count
System.out.println("======================");
System.out.println("ID: " + tracking_frame_id);
System.out.println("Hands: " + nHands);
if (nHands > 0)
{
// Attempt to read LEAP_HAND data and print info about hand #0.
System.out.println("===");
LEAP_HAND hand = new LEAP_HAND(pHands);
hands = (LEAP_HAND[]) hand.toArray(nHands);
String log = String.format(
"Hand 0| id: %d, type: %d, pos: [%.02f, %.02f, %.02f]%n",
hands[0].id, hands[0].type,
hands[0].palm.position.union.struct.x,
hands[0].palm.position.union.struct.y,
hands[0].palm.position.union.struct.z);
System.out.println(log);
}
System.out.println("======================");
}
public static class ByReference extends LEAP_TRACKING_EVENT
implements Structure.ByReference
{
}
}
new LEAP_HAND(pHands)只需将指针传递给超级构造函数，然后在其自身上调用read()(当然，下面链接的要点中仍然提供了这方面的代码)。
编辑3：无效内存访问堆栈跟踪
Exception in thread "main" java.lang.Error: Invalid memory access
at com.sun.jna.Native.getInt(Native Method)
at com.sun.jna.Pointer.getInt(Pointer.java:580)
at com.sun.jna.Pointer.getValue(Pointer.java:382)
at com.sun.jna.Structure.readField(Structure.java:732)
at com.sun.jna.Structure.read(Structure.java:591)
at komposten.leapmouse.LeapC$LEAP_HAND.read(LeapC.java:322)
at komposten.leapmouse.LeapC$LEAP_HAND.<init>(LeapC.java:316)
at komposten.leapmouse.LeapC$LEAP_TRACKING_EVENT.read(LeapC.java:236)
at com.sun.jna.Structure.autoRead(Structure.java:2203)
at com.sun.jna.Structure.conditionalAutoRead(Structure.java:561)
at com.sun.jna.Structure.updateStructureByReference(Structure.java:690)
at com.sun.jna.Pointer.getValue(Pointer.java:367)
at com.sun.jna.Structure.readField(Structure.java:732)
at com.sun.jna.Union.readField(Union.java:223)
at com.sun.jna.Structure.read(Structure.java:591)
at komposten.leapmouse.LeapC$LEAP_CONNECTION_MESSAGE.read(LeapC.java:196)
at com.sun.jna.Structure.autoRead(Structure.java:2203)
at com.sun.jna.Function.invoke(Function.java:381)
at com.sun.jna.Library$Handler.invoke(Library.java:265)
at com.sun.jna.Native$3.invoke(Native.java:1202)
at com.sun.proxy.$Proxy0.LeapPollConnection(Unknown Source)
at komposten.leapmouse.LeapTest.<init>(LeapTest.java:35)
at komposten.leapmouse.LeapTest.main(LeapTest.java:88)
我已经创建了一个要点，其中包含LeapTest和LeapC的完整代码，根据SO:LeapJna gist上的答案和评论进行了一些更改。如果需要的话，我可以在这里内联这个代码，但要点有行号，更容易获得(IMO)的概述。
如果需要，这里是LEAP_HAND的实现(以及完整的LEAP_TRACKING_EVENT代码和这两个代码使用的其他结构映射)。
经过与@DanielWiddis的多次讨论(谢谢！)，我们终于找到了问题。根据Daniel的建议，使用Pointer.dump()，我手动将内存映射到JNA加载到LEAP_TRACKING_EVENT类中的数据：
memory | mapped to
-----------|--------------
[bceba2ed] | info.reserved
[f5010000] | info.reserved
[d7990600] | info.frame_id
[00000000] | info.frame_id
[adbaca0b] | info.timestamp
[04000000] | info.timestamp
[9d990600] | tracking_frame_id
[00000000] | tracking_frame_id
[01000000] | nHands
[80e7a2ed] |
[f5010000] | pHands
[6c4edd42] | pHands
[00000000] | framerate
由于JNA对结构4字节的默认对齐设置在nHands和pHands之间跳过，导致pHands指向0x42dd4e6c000001f5而不是0x000001f5eda2e780(在本例中)。因此CCD_ 30指向完全错误的位置。
为了解决这个问题，我简单地将LEAP_TRACKING_DATA更改为使用ALIGN_NONE而不是ALIGN_DEFAULT。
首先，欢迎使用StackOverflow！第二，感谢您提供更多细节。对于您选择的映射结构的方式，您缺少一些实现细节，但简化实现比添加更多代码更容易。
LEAP_CONNECTION_MESSAGE的ByReference实现的指针构造函数中缺少一个super(p)，因此它可能无法以这种方式正确读取所有值。但是，没有必要使用ByReference实现。在函数参数中使用时，JNA会自动使用Structure的指针。删除ByReference，只使用LEAP_CONNECTION_MESSAGE message = new LEAP_CONNECTION_MESSAGE();进行实例化。
另一个问题是试图将本机内存读取到结构数组中。LEAP_HAND hand = new LEAP_HAND(pHands);的初始分配可能会为您提供数组的第一个元素，但随后使用hands = (LEAP_HAND[]) hand.toArray(nHands);会在本机端分配新内存。您应该创建自己的LEAP_HAND[]数组，迭代从0开始并递增Native.getNativeSize(LEAP_HAND.class)的偏移量，并用new LEAP_HAND(pHands.share(offset))实例化每个元素。(一旦你开始工作，还有其他方法可以稍微优雅一点。)
另一个可能存在问题的地方是您将消息类型定义为public short type。API将此类型指定为enum，其通常为int。看看你的要点，你有几个其他的枚举映射，它们是用int以外的东西映射的(例如，LEAP_HAND的type元素是byte)，这也可能会使这些结构错位。(但是，根据您的解释和测试，您可能是正确的。)
正如我们最终确定的那样，还有一些其他问题需要解决，包括结构对齐和端序。Pointer.dump()作为一个调试工具赢得了胜利！