java.lang.UnsatisfiedLinkError: unresolved symbol: IID_IDXGIFactory1

[Thomas-Vos]

I would like to call the function CreateDXGIFactory1. This is the code I currently have:

import jdk.incubator.foreign.ResourceScope.newConfinedScope
import win32.mapped.com.IDXGIFactory1_J
import win32.mapped.constants.Constants.S_OK
import win32.pure.IDXGIFactory1
import win32.pure.Win32.CreateDXGIFactory1

fun main() {
    System.loadLibrary("Dxgi")

    val scope = newConfinedScope()

    val riid = IDXGIFactory1_J.REFIID() // crashes
    val ppFactory = IDXGIFactory1.allocate(scope)
    val hr = CreateDXGIFactory1(riid, ppFactory)
    if (S_OK != hr) {
        throw IllegalStateException("Result: $hr")
    }
}

I think this is the correct way, but if this is wrong please let me know. I could not find any examples of jwin32, which would be helpful to get started.

When running the code I get the following output:

WARNING: Using incubator modules: jdk.incubator.foreign
Exception in thread "main" java.lang.UnsatisfiedLinkError: unresolved symbol: IID_IDXGIFactory1
	at win32.pure.RuntimeHelper.requireNonNull(RuntimeHelper.java:39)
	at win32.pure.Win32_22.IID_IDXGIFactory1$SEGMENT(Win32_22.java:2734)
	at win32.mapped.com.IDXGIFactory1_J.REFIID(IDXGIFactory1_J.java:64)
	at MainKt.main(Main.kt:12)
	at MainKt.main(Main.kt)

Any idea what is going wrong here? Looks like the library is not loaded correctly, but I do not know why,

I am using openjdk-17-panama+3-167_windows-x64_bin.

I cloned the jwin32 project, and added the line #include <dxgi.h> to config.h. Then I ran the generate and build commands and included the generated jar in my project.

Help would be appreciated. Your project looks amazing.

[Thomas-Vos]

By the way, calling the same function using JNA works fine. But the difference there is that I specify the riid manually like the following JNA code:

REFIID(IID("770aae78-f26f-4dba-a829-253c83d1b387"))

[Thomas-Vos]

Hey @FalsePattern, it would be very great if you could help me figure this out.

[FalsePattern]

Unfortunately i was unable to fix the unresolved symbol problem.

However, as a solution for arbitrary GUID constants, i extended GUID_J with additional constructors that makes creating GUIDs from strings trivial. This feature is available in the 0.5.0 tagged release (the feature itself was added in commit 64e4363)

Example usage with the new GUID code:

val riid = GUID_J(SegmentAllocator.ofScope(scope), "770aae78-f26f-4dba-a829-253c83d1b387")
val ppFactory = IDXGIFactory1.allocate(scope)
val hr = CreateDXGIFactory1(riid.segment, ppFactory)

I don't think there's a proper fix for the underlying issue of the nonexistent symbols, seeing as how most of the GUID stuff in the C/C++ API are done during preprocessing/compilation, so this solution will have to do for now.

[Thomas-Vos]

Thanks for the workaround. I noticed a typo in native.h which I fixed here: #3

It seems to be working now, as it no longer throws an exception, thanks!

However, when calling a function on the returned factory, I get a native crash:

#
# A fatal error has been detected by the Java Runtime Environment:
#
#  EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x00000000020007d0, pid=1272, tid=2536
#
# JRE version: OpenJDK Runtime Environment (17.0+3) (build 17-panama+3-167)
# Java VM: OpenJDK 64-Bit Server VM (17-panama+3-167, mixed mode, sharing, tiered, compressed oops, compressed class ptrs, g1 gc, windows-amd64)
# Problematic frame:
# C  0x00000000020007d0
#
# No core dump will be written. Minidumps are not enabled by default on client versions of Windows
#
# An error report file with more information is saved as:
# C:\Users\Thomas\IdeaProjects\WindowsScreenRecording\hs_err_pid1272.log
#
# If you would like to submit a bug report, please visit:
#   https://bugreport.java.com/bugreport/crash.jsp
# The crash happened outside the Java Virtual Machine in native code.
# See problematic frame for where to report the bug.
#

Here is the complete example:

import jdk.incubator.foreign.ResourceScope.newConfinedScope
import jdk.incubator.foreign.SegmentAllocator
import win32.mapped.com.IDXGIFactory1_J
import win32.mapped.constants.Constants.S_OK
import win32.mapped.struct.GUID_J
import win32.pure.IDXGIAdapter1
import win32.pure.IDXGIFactory1
import win32.pure.Win32.CreateDXGIFactory1

fun main() {
    System.loadLibrary("Dxgi")

    val scope = newConfinedScope()

    val riid = GUID_J(SegmentAllocator.ofScope(scope), "770aae78-f26f-4dba-a829-253c83d1b387")
    val factory = IDXGIFactory1.allocate(scope)
    val hr = CreateDXGIFactory1(riid.segment, factory)
    if (S_OK != hr) {
        throw IllegalStateException("Result: $hr")
    }

    val factory2 = IDXGIFactory1_J(factory.address())
    val adapter = IDXGIAdapter1.allocate(scope)
    factory2.EnumAdapters1(0, adapter.address()) // seems to crash here
}

I am not sure what is going wrong here.

[Thomas-Vos]

Here is the error report, forgot to attach it: hs_err_pid1272.log

[FalsePattern]

The jextract win32 api mappings are kinda weird:
Win32.CreateDXGIFactory1 populates the second parameter with a pointer to a pointer to the interface, instead of directly a memory segment. This is an artifact of how it's done inside C.

The correct way to do it would be allocating a memory segment for a pointer, passing in said memory segment, then retrieving the stored pointer from the segment, and passing that to the IDXGIFactory1_J constructor.

As a protip, you should never call .allocate() for COM objects, and for methods that output COM objects (can be identified as [out] typename ** on MSDN), you need to pass in a reference to a pointer, then extract the result from said reference into the wrapper class.

The following example uses MemoryStack, as it simplifies memory management for short-lived native variables:

  val factory: IDXGIFactory1_J
  val adapter: IDXGIAdapter1_J
  MemoryStack.stackPush().use{ stack ->
    val riid = GUID_J(stack, "770aae78-f26f-4dba-a829-253c83d1b387")
    val pp = stack.mallocPointer();
    val hr = CreateDXGIFactory1(riid.segment, pp)
    if (S_OK != hr) {
        throw IllegalStateException("Result: $hr")
    }
    //MemoryUtil.GetPointer extracts a void* from a void**
    factory = IDXGIFactory1_J(MemoryUtil.GetPointer(pp)) 

    //Reuse the void** for the EnumAdapters1 call
    factory.EnumAdapters1(0, pp) //don't forget to check HResult
    
    adapter = IDXGIAdapter1_J(MemoryUtil.GetPointer(pp))
  } //riid and pp are freed here
  //Make sure to .Release() the COM objects once no longer needed, as they were allocated by COM and aren't tied to any ResourceScope

[Thomas-Vos]

Thanks, that seems to work. I think I understand now thanks to your clarification.

One question about your example, should the line factory.EnumAdapters1(0, pp) be changed to factory.EnumAdapters1(0, pp.address())? You mentioned "you need to pass in a reference to a pointer", does that mean an address in this situation? The EnumAdapters1 function expects a MemoryAddress.

[Thomas-Vos]

Seems to just be a difference in the generated code between jextract and jwin32 COM objects. The jextract generated functions which expect Addressable (and calls address() internally), while jwin32 generated code which expect a MemoryAddress.

Small demo which prints the adapter descriptions:

import com.falsepattern.jwin32.memory.MemoryStack
import com.falsepattern.jwin32.memory.MemoryUtil
import jdk.incubator.foreign.MemorySegment
import win32.mapped.com.IDXGIAdapter1_J
import win32.mapped.com.IDXGIFactory1_J
import win32.mapped.constants.Constants.DXGI_ERROR_NOT_FOUND
import win32.mapped.constants.Constants.S_OK
import win32.mapped.struct.DXGI_ADAPTER_DESC1_J
import win32.mapped.struct.GUID_J
import win32.pure.DXGI_ADAPTER_DESC1
import win32.pure.Win32.CreateDXGIFactory1

fun main() {
    System.loadLibrary("Dxgi")

    MemoryStack.stackPush().use { stack ->
        val riid = GUID_J(stack, "770aae78-f26f-4dba-a829-253c83d1b387")
        val pp = stack.mallocPointer()
        CreateDXGIFactory1(riid.segment, pp).checkHResult()
        //MemoryUtil.GetPointer extracts a void* from a void**
        val factory = IDXGIFactory1_J(MemoryUtil.GetPointer(pp))

        val adapters = buildList {
            var i = 0
            //Reuse the void** for the EnumAdapters1 call
            while (DXGI_ERROR_NOT_FOUND != factory.EnumAdapters1(i, pp.address())) {
                this += IDXGIAdapter1_J(MemoryUtil.GetPointer(pp))
                i++
            }
        }

        factory.Release()

        adapters.forEach { adapter ->
            val pDesc = DXGI_ADAPTER_DESC1_J(stack)
            adapter.GetDesc1(pDesc.segment.address()).checkHResult()

            adapter.Release()

            val description = DXGI_ADAPTER_DESC1.`Description$slice`(pDesc.segment).toStringFromWChars()

            println("Adapter: $description")
        }
    }
}

private fun Int.checkHResult() {
    if (S_OK != this) {
        throw IllegalStateException("Invalid result: $this")
    }
}

private fun MemorySegment.toStringFromWChars(): String {
    return String(this.toCharArray()).trimEnd('\u0000')
}

On my PC it prints:

Adapter: NVIDIA GeForce GTX 1080 Ti
Adapter: Microsoft Basic Render Driver

Looks like generating wrapper code for arrays inside structs is already on your goal list. That should make the code above a bit simpler.

Thank you so much for your help, I really appreciate it.

[FalsePattern]

I'll keep the issue open for the time being. I have some internal plans on how to fix the original problem of the missing symbols, but it will take some time to implement properly.