diff a/modules/javafx.media/src/main/native/gstreamer/3rd_party/libffi/src/prep_cif.c b/modules/javafx.media/src/main/native/gstreamer/3rd_party/libffi/src/prep_cif.c
--- a/modules/javafx.media/src/main/native/gstreamer/3rd_party/libffi/src/prep_cif.c
+++ b/modules/javafx.media/src/main/native/gstreamer/3rd_party/libffi/src/prep_cif.c
@@ -27,16 +27,16 @@
 #include <ffi_common.h>
 #include <stdlib.h>
 
 /* Round up to FFI_SIZEOF_ARG. */
 
-#define STACK_ARG_SIZE(x) ALIGN(x, FFI_SIZEOF_ARG)
+#define STACK_ARG_SIZE(x) FFI_ALIGN(x, FFI_SIZEOF_ARG)
 
 /* Perform machine independent initialization of aggregate type
    specifications. */
 
-static ffi_status initialize_aggregate(ffi_type *arg)
+static ffi_status initialize_aggregate(ffi_type *arg, size_t *offsets)
 {
   ffi_type **ptr;
 
   if (UNLIKELY(arg == NULL || arg->elements == NULL))
     return FFI_BAD_TYPEDEF;
@@ -50,17 +50,19 @@
     return FFI_BAD_TYPEDEF;
 
   while ((*ptr) != NULL)
     {
       if (UNLIKELY(((*ptr)->size == 0)
-            && (initialize_aggregate((*ptr)) != FFI_OK)))
+            && (initialize_aggregate((*ptr), NULL) != FFI_OK)))
     return FFI_BAD_TYPEDEF;
 
       /* Perform a sanity check on the argument type */
       FFI_ASSERT_VALID_TYPE(*ptr);
 
-      arg->size = ALIGN(arg->size, (*ptr)->alignment);
+      arg->size = FFI_ALIGN(arg->size, (*ptr)->alignment);
+      if (offsets)
+    *offsets++ = arg->size;
       arg->size += (*ptr)->size;
 
       arg->alignment = (arg->alignment > (*ptr)->alignment) ?
     arg->alignment : (*ptr)->alignment;
 
@@ -72,11 +74,11 @@
      Linux ABI that right justify small structs in a register.
      It's also needed for nested structure layout, for example
      struct A { long a; char b; }; struct B { struct A x; char y; };
      should find y at an offset of 2*sizeof(long) and result in a
      total size of 3*sizeof(long).  */
-  arg->size = ALIGN (arg->size, arg->alignment);
+  arg->size = FFI_ALIGN (arg->size, arg->alignment);
 
   /* On some targets, the ABI defines that structures have an additional
      alignment beyond the "natural" one based on their elements.  */
 #ifdef FFI_AGGREGATE_ALIGNMENT
   if (FFI_AGGREGATE_ALIGNMENT > arg->alignment)
@@ -125,17 +127,20 @@
   cif->arg_types = atypes;
   cif->nargs = ntotalargs;
   cif->rtype = rtype;
 
   cif->flags = 0;
-
+#ifdef _M_ARM64
+  cif->is_variadic = isvariadic;
+#endif
 #if HAVE_LONG_DOUBLE_VARIANT
   ffi_prep_types (abi);
 #endif
 
   /* Initialize the return type if necessary */
-  if ((cif->rtype->size == 0) && (initialize_aggregate(cif->rtype) != FFI_OK))
+  if ((cif->rtype->size == 0)
+      && (initialize_aggregate(cif->rtype, NULL) != FFI_OK))
     return FFI_BAD_TYPEDEF;
 
 #ifndef FFI_TARGET_HAS_COMPLEX_TYPE
   if (rtype->type == FFI_TYPE_COMPLEX)
     abort();
@@ -145,13 +150,10 @@
 
   /* x86, x86-64 and s390 stack space allocation is handled in prep_machdep. */
 #if !defined FFI_TARGET_SPECIFIC_STACK_SPACE_ALLOCATION
   /* Make space for the return structure pointer */
   if (cif->rtype->type == FFI_TYPE_STRUCT
-#ifdef SPARC
-      && (cif->abi != FFI_V9 || cif->rtype->size > 32)
-#endif
 #ifdef TILE
       && (cif->rtype->size > 10 * FFI_SIZEOF_ARG)
 #endif
 #ifdef XTENSA
       && (cif->rtype->size > 16)
@@ -165,11 +167,12 @@
 
   for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)
     {
 
       /* Initialize any uninitialized aggregate type definitions */
-      if (((*ptr)->size == 0) && (initialize_aggregate((*ptr)) != FFI_OK))
+      if (((*ptr)->size == 0)
+      && (initialize_aggregate((*ptr), NULL) != FFI_OK))
     return FFI_BAD_TYPEDEF;
 
 #ifndef FFI_TARGET_HAS_COMPLEX_TYPE
       if ((*ptr)->type == FFI_TYPE_COMPLEX)
     abort();
@@ -177,22 +180,14 @@
       /* Perform a sanity check on the argument type, do this
      check after the initialization.  */
       FFI_ASSERT_VALID_TYPE(*ptr);
 
 #if !defined FFI_TARGET_SPECIFIC_STACK_SPACE_ALLOCATION
-#ifdef SPARC
-      if (((*ptr)->type == FFI_TYPE_STRUCT
-       && ((*ptr)->size > 16 || cif->abi != FFI_V9))
-      || ((*ptr)->type == FFI_TYPE_LONGDOUBLE
-          && cif->abi != FFI_V9))
-    bytes += sizeof(void*);
-      else
-#endif
     {
       /* Add any padding if necessary */
       if (((*ptr)->alignment - 1) & bytes)
-        bytes = (unsigned)ALIGN(bytes, (*ptr)->alignment);
+        bytes = (unsigned)FFI_ALIGN(bytes, (*ptr)->alignment);
 
 #ifdef TILE
       if (bytes < 10 * FFI_SIZEOF_ARG &&
           bytes + STACK_ARG_SIZE((*ptr)->size) > 10 * FFI_SIZEOF_ARG)
         {
@@ -204,11 +199,11 @@
 #ifdef XTENSA
       if (bytes <= 6*4 && bytes + STACK_ARG_SIZE((*ptr)->size) > 6*4)
         bytes = 6*4;
 #endif
 
-      bytes += STACK_ARG_SIZE((*ptr)->size);
+      bytes += (unsigned int)STACK_ARG_SIZE((*ptr)->size);
     }
 #endif
     }
 
   cif->bytes = bytes;
@@ -249,5 +244,20 @@
 {
   return ffi_prep_closure_loc (closure, cif, fun, user_data, closure);
 }
 
 #endif
+
+ffi_status
+ffi_get_struct_offsets (ffi_abi abi, ffi_type *struct_type, size_t *offsets)
+{
+  if (! (abi > FFI_FIRST_ABI && abi < FFI_LAST_ABI))
+    return FFI_BAD_ABI;
+  if (struct_type->type != FFI_TYPE_STRUCT)
+    return FFI_BAD_TYPEDEF;
+
+#if HAVE_LONG_DOUBLE_VARIANT
+  ffi_prep_types (abi);
+#endif
+
+  return initialize_aggregate(struct_type, offsets);
+}
