Convert a zero-terminated c-string to a java string. See documentation for string->c for encodings.

Define a strongly typed instance that can be used with foreign-interface-instance->c. This instance takes a single constructor argument which is the IFn that it is wrapping. It has a single typesafe ‘invoke’ method taking types defined by the underlying binding and transforming them into types that Clojure expects - for instance pointers are transformed to/from tech.v3.datatype.ffi.Pointer upon entry/exit from the wrapped IFn.

• rettype - The return type of the function.
• argtypes - A possibly empty sequence of argument types.

Options:

• :classname - Similar to :classname in ‘define-library’. A class will be generated to compile-path and after this statement (import classname) will be a valid call.

See foreign-interface-instance->c for example.

Define a library returning the class. The class can be instantiated with a string naming the library path or nil for the current process. After instantiation the library instance will have strongly typed methods named the same as the keyword keys in fn-defs efficiently bound to symbols of the same exact name in library.

• fn-defs - map of fn-name -> {:rettype :argtypes}.
  • argtypes -
  • :void - return type only.
  • :int8 :int16 :int32 :int64
  • :float32 :float64
  • :size-t - int32 or int64 depending on cpu architecture.
  • :pointer :pointer? - Something convertible to a Pointer type. Potentially exception when nil.
  • rettype - any argtype plus :void

Options:

• :classname - If classname (a symbol) is provided a .class file is saved to compile-path after which (import classname) will be a validcall meaning that after AOT no further reflection or class generation is required to access the class explicitly. That being said ‘import’ does not reload classes that are already on the classpath so this option is best used after library has stopped changing.

Example:

user> (dtype-ffi/define-library {:memset {:rettype :pointer
                                          :argtypes [:pointer :int32 :size-t]}}
                                {:classname 'tech.libmemset})
{:library tech.libmemset}
user> (import 'tech.libmemset)
tech.libmemset
user> (def inst (tech.libmemset. nil)) ;;nil for current process
#'user/inst
user> (def test-buf (dtype/make-container :native-heap :float32 (range 10)))
#'user/test-buf
user> test-buf
#native-buffer@0x00007F4E28CE56D0<float32>[10]
[0.000, 1.000, 2.000, 3.000, 4.000, 5.000, 6.000, 7.000, 8.000, 9.000, ]
user> (.memset ^tech.libmemset inst test-buf 0 40)
#object[tech.v3.datatype.ffi.Pointer 0x33013c57 "{:address 0x00007F4E28CE56D0 }"]
user> test-buf
#native-buffer@0x00007F4E28CE56D0<float32>[10]
[0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, ]
user>

Define public callable vars that will call library functions marshaling strings back and forth. These vars will call find-fn with the fn-name in a late-bound way and check-error may be provided and called on a return value assuming :check-error? is set in the library definition.

• library-def-symbol - The fully namespaced symbol that points to the function definitions.
• find-fn - A function taking one argument - the fn name, and returning the function.
• check-error - A function or macro that receives two arguments - the fn definition from above and the actual un-evaluated function call allowing you to insert pre/post checks.

Example:

(dt-ffi/define-library-functions avclj.ffi/avcodec-fns find-avcodec-fn check-error)

Define public callable vars that will call library functions marshaling strings back and forth. Returns a library singleton.

• fn-defs - map of fn-name -> {:rettype :argtypes}
• argtypes -
  • :void - return type only.
  • :int8 :int16 :int32 :int64
  • :float32 :float64
  • :size-t - int32 or int64 depending on cpu architecture.
  • :pointer :pointer? - Something convertible to a Pointer type. Potentially exception when nil.
• rettype - any argtype plus :void
• doc - docstring for the function
• check-error? apply pre/post checks with check-error. default: false

Options:

• :classname - If classname (a symbol) is provided a .class file is saved to compile-path after which (import classname) will be a validcall meaning that after AOT no further reflection or class generation is required to access the class explicitly. That being said ‘import’ does not reload classes that are already on the classpath so this option is best used after library has stopped changing.

• :check-error - A function or macro that receives two arguments - the fn definition from above and the actual un-evaluated function call allowing you to insert pre/post checks.

• :symbols - A sequence of symbols in the shared library that should be available for use with find-symbol

• :libraries - (graalvm only) A sequence of dependent shared libraries that should be loaded.

• :header-files - (graalvm only) A sequence of header files.

Example:

user> (dt-ffi/define-library-interface
        {:memset {:rettype :pointer
                  :argtypes [['p :pointer]
                             ['x :int32]
                             ['len :size-t]]}})
user> (def test-buf (dtype/make-container :native-heap :float32 (range 10)))
#'user/test-buf
user> test-buf
#native-buffer@0x00007F4E28CE56D0<float32>[10]
[0.000, 1.000, 2.000, 3.000, 4.000, 5.000, 6.000, 7.000, 8.000, 9.000, ]
user> (memset test-buf 0 40)
#object[tech.v3.datatype.ffi.Pointer 0x33013c57 "{:address 0x00007F4E28CE56D0 }"]
user> test-buf
#native-buffer@0x00007F4E28CE56D0<float32>[10]
[0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, ]

Enable tracking how often string->c is getting called.

This method is useful to check if loading a library will work. If successful, returns the library name that did finally succeed. This may be different from libname in the case where java.library.path has been used to actively find the library.

Find a symbol in a library. A library symbol is guaranteed to have a conversion to a pointer.

Convert an instance of the above foreign interface definition into a Pointer suitable to be called from C. Callers must ensure that foreign-inst is visible to the gc the entire time the foreign system has a reference to the pointer.

• foreign-inst - an instance of the class defined by ‘define-foreign-interface’.

Utility function to instantiate a class via its first constructor in its list of declared constructors. Works with classes returned from ‘define-library’ and ‘define-foreign-interface’. Uses reflection.

Instantiate a foreign interface defintion. This returns an instance object which can then be converted into a c-pointer via foreign-interface-instance->c.

Uses reflection to instantiate a library

Is the JDK foreign function interface available?

Is the JDK native memory model available?

Is JNA’s ffi interface available?

Create a singleton object, ideally assigned to a variable with defonce, that you can reset to auto-reload the bindings i.e. with new function definitions at the repl.

• library-def-var must be something that deref’s to the latest library definition.

(defonce ^:private lib (dt-ffi/library-singleton #'avcodec-fns))

;;Safe to call on uninitialized library.  If the library is initialized, however,
;;a new library instance is created from the latest avcodec-fns
(dt-ffi/library-singelton-reset! lib)

(defn set-library!
  [libpath]
  (dt-ffi/library-singelton-set! lib libpath))
(defn- find-avcodec-fn
  [fn-kwd]
  (dt-ffi/library-singelton-find-fn lib fn-kwd))

Make an object convertible to a pointer that points to single value of type dtype.

Protocol to allow easy definition of a library singleton that manages re-creating the library definition when the library data changes and also recreating the library instance if necessary.

Given a struct type and a pointer return a struct whose data starts at the address of the pointer.

  (let [codec (dt-ffi/ptr->struct (:datatype-name @av-context/codec-def*) codec-ptr)]
       ...)

Set the global ffi implementation. Options are * :jdk - namespace 'tech.v3.datatype.ffi.mmodel/ffi-fns - only available with jdk’s foreign function module enabled. * :jna - namespace ''tech.v3.datatype.ffi.jna/ffi-fns - available if JNA version 5+ is in the classpath.

Convert a java String to a zero-padded c-string. Available encodings are

• :ascii, :utf-8 (default), :utf-16, :utf-16LE, utf-16-BE and :utf-32

String data will be zero padded.

Get a pointer to a struct data member.

   (swscale/sws_scale sws-ctx
                      (struct-member-ptr input-frame :data)
                      (struct-member-ptr input-frame :linesize)
                      0 (:height input-frame)
                      (struct-member-ptr encoder-frame :data)
                      (struct-member-ptr encoder-frame :linesize))

Get the utf-16 encoding that matches the current platform so you can encode a utf-16 string without a bom.

Get the utf-16 encoding that matches the current platform so you can encode a utf-16 string without a bom.