* Add libpipewire

packages/fpmake_add.inc

@@ -135,6 +135,7 @@
   add_xforms(ADirectory+IncludeTrailingPathDelimiter('xforms'));
   add_zlib(ADirectory+IncludeTrailingPathDelimiter('zlib'));
   add_libenet(ADirectory+IncludeTrailingPathDelimiter('libenet'));
+  add_libpipewire(ADirectory+IncludeTrailingPathDelimiter('libpipewire'));
   add_zorba(ADirectory+IncludeTrailingPathDelimiter('zorba'));
   add_Google(ADirectory+IncludeTrailingPathDelimiter('googleapi'));
   add_fcl_pdf(ADirectory+IncludeTrailingPathDelimiter('fcl-pdf'));

packages/fpmake_proc.inc

@@ -791,6 +791,8 @@ begin
 {$include libenet/fpmake.pp}
 end;
 
+{$include libpipewire/fpmake.pp}
+
 procedure add_zorba(const ADirectory: string);
 begin
   with Installer do

packages/libpipewire/README.md

@@ -0,0 +1,30 @@
+# This package provides an interface to libPipeWire.
+
+Compiling:
+
+LibPipewire uses another "c library" called libspa.
+Unfortunately, libspa is not a real library, it is a collection of macros.
+This means there is nothing we can link to, to get libspa functionality.
+(Pascal is not the only language with this problem)
+
+To remedy this, a spabridge.o file is created by compiling a C file which
+contains references to all spa routines in a large table. 
+The C compiler then includes all the spa routines in the spabridge.o file.
+
+This file is compiled using gcc when compiling the libpipewire package. 
+It assumes that spa headers are available under /usr/include/spa-0.2
+
+If the spa headers are installed in a different location, you can change the
+fpmake.pp file and correct the include directory.
+
+If you don't have the headers, you must install libpipewire-dev (which in turn installs libspa). 
+
+On a debian machine, this means executing
+
+```
+apt-get install libpipewire-0.3-dev
+```
+
+If the file cannot be compiled, this will not cause an error in the build
+procedure, instead, a warning is printed to indicate that spabridge.c cannot
+be compiled. To see this message, add FPMAKEOPT=-v to the make command.

packages/libpipewire/fpmake.pp

@@ -0,0 +1,148 @@
+{$ifndef ALLPACKAGES}
+{$mode objfpc}{$H+}
+program fpmake;
+
+uses {$ifdef unix}cthreads,{$endif} sysutils, classes, fpmkunit;
+{$ENDIF ALLPACKAGES}
+
+Type
+  THackPackage = class(TPackage)
+    property Dictionary;
+  end;
+
+procedure BeforeInstall_LibPipeWire(Sender: TObject);
+
+Var
+  P : TPackage;
+  lInstDir,lDest : string;
+begin
+  P:=Sender as TPackage;
+  lDest:=P.GetUnitsOutputDir(Defaults.BuildTarget);
+  if P.Directory<>'' then
+    lDest:=IncludeTrailingPathDelimiter(P.Directory)+lDest;
+  lDest:=IncludeTrailingPathDelimiter(lDest)+'spabridge.o';
+  if FileExists(lDest) then
+    begin
+    // no prefix this time
+    lDest:=P.GetUnitsOutputDir(Defaults.BuildTarget);
+    lDest:=IncludeTrailingPathDelimiter(lDest)+'spabridge.o';
+    // not clear why packagename does not exist at this point?
+    THackPackage(P).Dictionary.AddVariable('packagename',P.Name);
+    Writeln('Defaults ',Defaults.UnitInstallDir);
+    lInstDir:=THackPackage(P).Dictionary.ReplaceStrings(Defaults.UnitInstallDir);
+    P.InstallFiles.Add(lDest,lInstDir);
+    end;
+end;
+
+procedure BeforeCompile_LibPipeWire(Sender: TObject);
+
+var
+  lGCC : string;
+  lArgs : TStrings;
+  lDest,lSrc : String;
+  P : TPackage;
+
+begin
+  P:=Sender as TPackage;
+  lDest:=P.GetUnitsOutputDir(Defaults.BuildTarget);
+  if P.Directory<>'' then
+    begin
+    lSrc:=IncludeTrailingPathDelimiter(P.Directory);
+    lDest:=IncludeTrailingPathDelimiter(P.Directory)+lDest;
+    end
+  else
+    lSrc:=IncludeTrailingPathDelimiter(Installer.BuildEngine.StartDir);
+  lSrc:=IncludeTrailingPathDelimiter(LSrc+'src')+'spabridge.c';
+  lDest:=IncludeTrailingPathDelimiter(lDest)+'spabridge.o';
+  lgcc:=ExeSearch('gcc',GetEnvironmentVariable('PATH'));
+  lArgs:=TStringList.Create();
+  try
+    lArgs.Add('-c');
+    lArgs.Add('-I/usr/include/spa-0.2/');
+    lArgs.Add(lSrc);
+    lArgs.Add('-o'+lDest);
+    try
+      Installer.BuildEngine.ExecuteCommand(lgcc,lArgs);
+    except
+      On E : Exception do
+        Installer.BuildEngine.Log(vlWarning,'Could not compile spabridge.c, it will need to be compiled manually. install libpipewire-0.3-dev package');
+    end;
+  finally
+    lArgs.Free;
+  end;
+end;
+
+procedure add_libpipewire(const ADirectory: string);
+
+Var
+  P : TPackage;
+  T : TTarget;
+begin
+  With Installer do
+    begin
+    P:=AddPackage('libpipewire');
+    P.ShortName:='libpw';
+    P.Directory:=ADirectory;
+    P.Version:='3.3.1';
+    P.SourcePath.Add('src');
+    P.IncludePath.Add('src');
+    { only enable for darwin after testing }
+    P.OSes := [linux];
+    if Defaults.CPU=jvm then
+      P.OSes := [];
+    P.SupportBuildModes:= [bmOneByOne];
+    P.BeforeCompileProc:=@BeforeCompile_LibPipeWire;
+    P.BeforeInstallProc:=@BeforeInstall_LibPipeWire;
+
+    T:=P.Targets.AddUnit('libspa.pp');
+    With T.Dependencies do
+      begin
+      AddInclude('spabridge.inc');
+      end;
+    T:=P.Targets.AddUnit('libpipewire.pp');
+    with T.Dependencies do
+      begin
+      AddUnit('libspa');
+      AddInclude('array.inc');
+      AddInclude('permission.inc');
+      AddInclude('client.inc');
+      AddInclude('loop.inc');
+      AddInclude('properties.inc');
+      AddInclude('work_queue.inc');
+      AddInclude('context.inc');
+      AddInclude('device.inc');
+      AddInclude('mem.inc');
+      AddInclude('buffers.inc');
+      AddInclude('core.inc');
+      AddInclude('factory.inc');
+      AddInclude('keys.inc');
+      AddInclude('log.inc');
+      AddInclude('link.inc');
+      AddInclude('main_loop.inc');
+      AddInclude('map.inc');
+      AddInclude('module.inc');
+      AddInclude('node.inc');
+      AddInclude('protocol.inc');
+      AddInclude('proxy.inc');
+      AddInclude('port.inc');
+      AddInclude('stream.inc');
+      AddInclude('filter.inc');
+      AddInclude('data_loop.inc');
+      AddInclude('type.inc');
+      AddInclude('utils.inc');
+      AddInclude('version.inc');
+      AddInclude('thread_loop.inc');
+      AddInclude('core_impl.inc');
+      AddInclude('loop_impl.inc');
+      end;
+    P.NamespaceMap:='namespaces.lst';
+    end;
+end;
+
+
+{$ifndef ALLPACKAGES}
+begin
+  add_libpipewire('');
+  Installer.Run;
+end.
+{$endif ALLPACKAGES}

packages/libpipewire/namespaced/Api.PipeWire.pp

@@ -0,0 +1,3 @@
+unit Api.PipeWire;
+{$DEFINE FPC_DOTTEDUNITS}
+{$i libpipewire.pp}

packages/libpipewire/namespaced/Api.SPA.pp

@@ -0,0 +1,3 @@
+unit Api.SPA;
+{$DEFINE FPC_DOTTEDUNITS}
+{$i libspa.pp}

packages/libpipewire/namespaces.lst

@@ -0,0 +1,4 @@
+src/libspa.pp=namespaced/Api.SPA.pp
+src/libpipewire.pp=namespaced/Api.PipeWire.pp
+{s*:src/}=namespaced/
+{i+:src/}

packages/libpipewire/src/array.inc

@@ -0,0 +1,125 @@
+
+
+type
+  Ppw_array = ^Tpw_array;
+  Tpw_array = record
+    data : pointer;
+    size : Tsize_t;
+    alloc : Tsize_t;
+    extend : Tsize_t;
+  end;
+
+  {
+  
+  static inline void pw_array_init(struct pw_array *arr, size_t extend)
+  
+   arr->data = 
+  # 92 "/usr/include/pipewire-0.3/pipewire/array.h" 3 4
+              ((void *)0)
+  # 92 "/usr/include/pipewire-0.3/pipewire/array.h"
+                  ;
+   arr->size = arr->alloc = 0;
+   arr->extend = extend;
+  
+  
+  
+  static inline void pw_array_clear(struct pw_array *arr)
+  
+   free(arr->data);
+   pw_array_init(arr, arr->extend);
+  
+  
+  
+  static inline void pw_array_reset(struct pw_array *arr)
+  
+   arr->size = 0;
+  
+  
+  
+  static inline int pw_array_ensure_size(struct pw_array *arr, size_t size)
+  
+   size_t alloc, need;
+  
+   alloc = arr->alloc;
+   need = arr->size + size;
+  
+   if ((__builtin_expect(!!(alloc < need),0))) 
+    void *data;
+    alloc = ( __typeof__(alloc) _max_a = (alloc); __typeof__(arr->extend) _max_b = (arr->extend); (__builtin_expect(!!(_max_a > _max_b),1)) ? _max_a : _max_b; );
+    do  if ((__builtin_expect(!!(!(alloc != 0)),0)))  fprintf(
+  # 121 "/usr/include/pipewire-0.3/pipewire/array.h" 3 4
+   stderr
+  # 121 "/usr/include/pipewire-0.3/pipewire/array.h"
+   , "'%s' failed at %s:%u %s()\n", "alloc != 0" , "/usr/include/pipewire-0.3/pipewire/array.h", 121, __func__); abort();   while (
+  # 121 "/usr/include/pipewire-0.3/pipewire/array.h" 3 4
+   0
+  # 121 "/usr/include/pipewire-0.3/pipewire/array.h"
+   );
+    while (alloc < need)
+     alloc *= 2;
+    if ((__builtin_expect(!!((data = realloc(arr->data, alloc)) == 
+  # 124 "/usr/include/pipewire-0.3/pipewire/array.h" 3 4
+       ((void *)0)
+  # 124 "/usr/include/pipewire-0.3/pipewire/array.h"
+       ),0)))
+     return -
+  # 125 "/usr/include/pipewire-0.3/pipewire/array.h" 3 4
+            (*__errno_location ())
+  # 125 "/usr/include/pipewire-0.3/pipewire/array.h"
+                 ;
+    arr->data = data;
+    arr->alloc = alloc;
+   
+   return 0;
+  
+  
+  
+  
+  static inline void *pw_array_add(struct pw_array *arr, size_t size)
+  
+   void *p;
+  
+   if (pw_array_ensure_size(arr, size) < 0)
+    return 
+  # 139 "/usr/include/pipewire-0.3/pipewire/array.h" 3 4
+          ((void *)0)
+  # 139 "/usr/include/pipewire-0.3/pipewire/array.h"
+              ;
+  
+   p = ((void*)((uintptr_t)(arr->data) + (ptrdiff_t)(arr->size)));
+   arr->size += size;
+  
+   return p;
+  
+  
+  
+  
+  static inline void *pw_array_add_fixed(struct pw_array *arr, size_t size)
+  
+   void *p;
+  
+   if ((__builtin_expect(!!(arr->alloc < arr->size + size),0))) 
+    
+  # 154 "/usr/include/pipewire-0.3/pipewire/array.h" 3 4
+   (*__errno_location ()) 
+  # 154 "/usr/include/pipewire-0.3/pipewire/array.h"
+         = 
+  # 154 "/usr/include/pipewire-0.3/pipewire/array.h" 3 4
+           28
+  # 154 "/usr/include/pipewire-0.3/pipewire/array.h"
+                 ;
+    return 
+  # 155 "/usr/include/pipewire-0.3/pipewire/array.h" 3 4
+          ((void *)0)
+  # 155 "/usr/include/pipewire-0.3/pipewire/array.h"
+              ;
+   
+  
+   p = ((void*)((uintptr_t)(arr->data) + (ptrdiff_t)(arr->size)));
+   arr->size += size;
+  
+   return p;
+  
+  
+   }
+

packages/libpipewire/src/buffers.inc

@@ -0,0 +1,19 @@
+
+type
+  Ppw_buffers = ^Tpw_buffers;
+
+
+  Tpw_buffers = record
+    mem: Ppw_memblock;
+    buffers: ^Pspa_buffer;
+    n_buffers: Tuint32_t;
+    flags: Tuint32_t;
+  end;
+
+
+function pw_buffers_negotiate(context: Ppw_context; flags: Tuint32_t; outnode: Pspa_node; out_port_id: Tuint32_t; innode: Pspa_node; in_port_id: Tuint32_t;
+  Result: Ppw_buffers) : longint; cdecl; external libpipewirename Name 'pw_buffers_negotiate';
+
+procedure pw_buffers_clear(buffers: Ppw_buffers); cdecl; external libpipewirename Name 'pw_buffers_clear';
+
+

packages/libpipewire/src/client.inc

@@ -0,0 +1,40 @@
+
+type
+  Ppw_client = ^Tpw_client;
+  Ppw_client_events = ^Tpw_client_events;
+  Ppw_client_info = ^Tpw_client_info;
+  Ppw_client_methods = ^Tpw_client_methods;
+
+  Tpw_client = record
+    {undefined structure}
+  end;
+
+  Tpw_client_info = record
+    id: Tuint32_t;
+    change_mask: Tuint64_t;
+    props: Pspa_dict;
+  end;
+
+  Tpw_client_events = record
+    version: Tuint32_t;
+    info: procedure(object_: pointer; info: Ppw_client_info); cdecl;
+    permissions: procedure(object_: pointer; index: Tuint32_t; n_permissions: Tuint32_t; permissions: Ppw_permission); cdecl;
+  end;
+
+  Tpw_client_methods = record
+    version: Tuint32_t;
+    add_listener: function(object_: pointer; listener: Pspa_hook; events: Ppw_client_events; Data: pointer) : longint; cdecl;
+    error: function(object_: pointer; id: Tuint32_t; res: longint; message: PChar) : longint; cdecl;
+    update_properties: function(object_: pointer; props: Pspa_dict) : longint; cdecl;
+    get_permissions: function(object_: pointer; index: Tuint32_t; num: Tuint32_t) : longint; cdecl;
+    update_permissions: function(object_: pointer; n_permissions: Tuint32_t; permissions: Ppw_permission) : longint; cdecl;
+  end;
+
+
+function pw_client_info_update(info: Ppw_client_info; update: Ppw_client_info) : Ppw_client_info; cdecl; external libpipewirename Name 'pw_client_info_update';
+
+function pw_client_info_merge(info: Ppw_client_info; update: Ppw_client_info; reset: T_Bool) : Ppw_client_info; cdecl; external libpipewirename Name 'pw_client_info_merge';
+
+procedure pw_client_info_free(info: Ppw_client_info); cdecl; external libpipewirename Name 'pw_client_info_free';
+
+

packages/libpipewire/src/conf.inc

@@ -0,0 +1,29 @@
+
+  const
+    libpipewire='libpipewire-0.3'; {Setup as you need}
+
+  { Pointers to basic pascal types, inserted by h2pas conversion program.}
+  Type
+    PLongint  = ^Longint;
+    PSmallInt = ^SmallInt;
+    PByte     = ^Byte;
+    PWord     = ^Word;
+    PDWord    = ^DWord;
+    PDouble   = ^Double;
+
+  Type
+    Pchar  = ^Tchar;
+    Ppw_properties  = ^Tpw_properties;
+{$IFDEF FPC}
+{$PACKRECORDS C}
+{$ENDIF}
+
+
+
+  function pw_conf_load_conf(prefix:Pchar; name:Pchar; conf:Ppw_properties):longint;cdecl;external libpipewire name 'pw_conf_load_conf';
+
+  function pw_conf_load_state(prefix:Pchar; name:Pchar; conf:Ppw_properties):longint;cdecl;external libpipewire name 'pw_conf_load_state';
+
+  function pw_conf_save_state(prefix:Pchar; name:Pchar; conf:Ppw_properties):longint;cdecl;external libpipewire name 'pw_conf_save_state';
+
+

packages/libpipewire/src/context.inc

@@ -0,0 +1,85 @@
+
+type
+  Ppw_context = ^Tpw_context;
+  Ppw_context_events = ^Tpw_context_events;
+  Ppw_core = ^Tpw_core;
+  Ppw_export_type = ^Tpw_export_type;
+  Ppw_global = ^Tpw_global;
+  Ppw_impl_client = ^Tpw_impl_client;
+  Ppw_proxy = ^Tpw_proxy;
+
+
+
+  Tpw_context_events = record
+    version: Tuint32_t;
+    Destroy: procedure(Data: pointer); cdecl;
+    Free: procedure(Data: pointer); cdecl;
+    check_access: procedure(Data: pointer; client: Ppw_impl_client); cdecl;
+    global_added: procedure(Data: pointer; global: Ppw_global); cdecl;
+    global_removed: procedure(Data: pointer; global: Ppw_global); cdecl;
+  end;
+
+  Tpw_export_type = record
+    link: Tspa_list;
+    _type: PChar;
+    func: function(core: Ppw_core; _type: PChar; props: Pspa_dict; object_: pointer; user_data_size: Tsize_t) : Ppw_proxy; cdecl;
+  end;
+
+
+  tpw_context_conf_section_for_eachcallback = function(Data: pointer; location: PChar; section: PChar; str: PChar; len: Tsize_t) : longint; cdecl;
+
+  tpw_context_conf_section_match_rulescallback = function(Data: pointer; location: PChar; action: PChar; str: PChar; len: Tsize_t) : longint; cdecl;
+
+  tpw_context_for_each_globalcallback = function(Data: pointer; global: Ppw_global) : longint; cdecl;
+
+function pw_context_new(main_loop: Ppw_loop; props: Ppw_properties; user_data_size: Tsize_t) : Ppw_context; cdecl; external libpipewirename Name 'pw_context_new';
+
+procedure pw_context_destroy(context: Ppw_context); cdecl; external libpipewirename Name 'pw_context_destroy';
+
+function pw_context_get_user_data(context: Ppw_context) : pointer; cdecl; external libpipewirename Name 'pw_context_get_user_data';
+
+procedure pw_context_add_listener(context: Ppw_context; listener: Pspa_hook; events: Ppw_context_events; Data: pointer); cdecl; external libpipewirename Name 'pw_context_add_listener';
+
+function pw_context_get_properties(context: Ppw_context) : Ppw_properties; cdecl; external libpipewirename Name 'pw_context_get_properties';
+
+function pw_context_update_properties(context: Ppw_context; dict: Pspa_dict) : longint; cdecl; external libpipewirename Name 'pw_context_update_properties';
+
+function pw_context_get_conf_section(context: Ppw_context; section: PChar) : PChar; cdecl; external libpipewirename Name 'pw_context_get_conf_section';
+
+function pw_context_parse_conf_section(context: Ppw_context; conf: Ppw_properties; section: PChar) : longint; cdecl; external libpipewirename Name 'pw_context_parse_conf_section';
+
+function pw_context_conf_update_props(context: Ppw_context; section: PChar; props: Ppw_properties) : longint; cdecl; external libpipewirename Name 'pw_context_conf_update_props';
+
+function pw_context_conf_section_for_each(context: Ppw_context; section: PChar; callback: tpw_context_conf_section_for_eachcallback; Data: pointer) : longint;
+  cdecl; external libpipewirename Name 'pw_context_conf_section_for_each';
+
+function pw_context_conf_section_match_rules(context: Ppw_context; section: PChar; props: Pspa_dict; callback: tpw_context_conf_section_match_rulescallback;
+  Data: pointer) : longint; cdecl; external libpipewirename Name 'pw_context_conf_section_match_rules';
+
+function pw_context_get_support(context: Ppw_context; n_support: Puint32_t) : Pspa_support; cdecl; external libpipewirename Name 'pw_context_get_support';
+
+function pw_context_get_main_loop(context: Ppw_context) : Ppw_loop; cdecl; external libpipewirename Name 'pw_context_get_main_loop';
+
+function pw_context_get_work_queue(context: Ppw_context) : Ppw_work_queue; cdecl; external libpipewirename Name 'pw_context_get_work_queue';
+
+function pw_context_for_each_global(context: Ppw_context; callback: tpw_context_for_each_globalcallback; Data: pointer) : longint; cdecl; external libpipewirename Name 'pw_context_for_each_global';
+
+function pw_context_find_global(context: Ppw_context; id: Tuint32_t) : Ppw_global; cdecl; external libpipewirename Name 'pw_context_find_global';
+
+function pw_context_add_spa_lib(context: Ppw_context; factory_regex: PChar; lib: PChar) : longint; cdecl; external libpipewirename Name 'pw_context_add_spa_lib';
+
+function pw_context_find_spa_lib(context: Ppw_context; factory_name: PChar) : PChar; cdecl; external libpipewirename Name 'pw_context_find_spa_lib';
+
+function pw_context_load_spa_handle(context: Ppw_context; factory_name: PChar; info: Pspa_dict) : Pspa_handle; cdecl; external libpipewirename Name 'pw_context_load_spa_handle';
+
+
+
+function pw_context_register_export_type(context: Ppw_context; _type: Ppw_export_type) : longint; cdecl; external libpipewirename Name 'pw_context_register_export_type';
+
+function pw_context_find_export_type(context: Ppw_context; _type: PChar) : Ppw_export_type; cdecl; external libpipewirename Name 'pw_context_find_export_type';
+
+function pw_context_set_object(context: Ppw_context; _type: PChar; Value: pointer) : longint; cdecl; external libpipewirename Name 'pw_context_set_object';
+
+function pw_context_get_object(context: Ppw_context; _type: PChar) : pointer; cdecl; external libpipewirename Name 'pw_context_get_object';
+
+

packages/libpipewire/src/control.inc

@@ -0,0 +1,40 @@
+
+  const
+    libpipewire='libpipewire-0.3'; {Setup as you need}
+
+  { Pointers to basic pascal types, inserted by h2pas conversion program.}
+  Type
+    PLongint  = ^Longint;
+    PSmallInt = ^SmallInt;
+    PByte     = ^Byte;
+    PWord     = ^Word;
+    PDWord    = ^DWord;
+    PDouble   = ^Double;
+
+  Type
+    Ppw_control  = ^Tpw_control;
+    Ppw_control_events  = ^Tpw_control_events;
+    Ppw_impl_port  = ^Tpw_impl_port;
+    Pspa_hook  = ^Tspa_hook;
+{$IFDEF FPC}
+{$PACKRECORDS C}
+{$ENDIF}
+
+
+
+  type
+    Ppw_control_events = ^Tpw_control_events;
+    Tpw_control_events = record
+        version : Tuint32_t;
+        destroy : procedure (data:pointer);cdecl;
+        free : procedure (data:pointer);cdecl;
+        linked : procedure (data:pointer; other:Ppw_control);cdecl;
+        unlinked : procedure (data:pointer; other:Ppw_control);cdecl;
+      end;
+
+
+  function pw_control_get_port(control:Ppw_control):Ppw_impl_port;cdecl;external libpipewire name 'pw_control_get_port';
+
+  procedure pw_control_add_listener(control:Ppw_control; listener:Pspa_hook; events:Ppw_control_events; data:pointer);cdecl;external libpipewire name 'pw_control_add_listener';
+
+

packages/libpipewire/src/core.inc

@@ -0,0 +1,200 @@
+
+const
+  PW_VERSION_CORE = 3;
+  PW_VERSION_REGISTRY = 3;
+  PW_DEFAULT_REMOTE = 'pipewire-0';
+  PW_ID_CORE = 0;
+  PW_ID_ANY = tuint32_t($ffffffff);
+
+  PW_VERSION_CORE_EVENTS = 0;
+
+type
+  Ppw_core_events = ^Tpw_core_events;
+  Ppw_core_info = ^Tpw_core_info;
+  Ppw_core_methods = ^Tpw_core_methods;
+  Ppw_registry = ^Tpw_registry;
+  Ppw_registry_events = ^Tpw_registry_events;
+  Ppw_registry_methods = ^Tpw_registry_methods;
+
+  Tpw_core_events = record
+    version: Tuint32_t;
+    info: procedure(object_: pointer; info: Ppw_core_info); cdecl;
+    done: procedure(object_: pointer; id: Tuint32_t; seq: longint); cdecl;
+    ping: procedure(object_: pointer; id: Tuint32_t; seq: longint); cdecl;
+    error: procedure(object_: pointer; id: Tuint32_t; seq: longint; res: longint; message: PChar); cdecl;
+    remove_id: procedure(object_: pointer; id: Tuint32_t); cdecl;
+    bound_id: procedure(object_: pointer; id: Tuint32_t; global_id: Tuint32_t); cdecl;
+    add_mem: procedure(object_: pointer; id: Tuint32_t; _type: Tuint32_t; fd: longint; flags: Tuint32_t); cdecl;
+    remove_mem: procedure(object_: pointer; id: Tuint32_t); cdecl;
+  end;
+
+  Tpw_core_methods = record
+    version: Tuint32_t;
+    add_listener: function(object_: pointer; listener: Pspa_hook; events: Ppw_core_events; Data: pointer) : longint; cdecl;
+    hello: function(object_: pointer; version: Tuint32_t) : longint; cdecl;
+    sync: function(object_: pointer; id: Tuint32_t; seq: longint) : longint; cdecl;
+    pong: function(object_: pointer; id: Tuint32_t; seq: longint) : longint; cdecl;
+    error: function(object_: pointer; id: Tuint32_t; seq: longint; res: longint; message: PChar) : longint; cdecl;
+    get_registry: function(object_: pointer; version: Tuint32_t; user_data_size: Tsize_t) : Ppw_registry; cdecl;
+    create_object: function(object_: pointer; factory_name: PChar; _type: PChar; version: Tuint32_t; props: Pspa_dict; user_data_size: Tsize_t) : pointer; cdecl;
+    Destroy: function(object_: pointer; proxy: pointer) : longint; cdecl;
+  end;
+
+  Tpw_registry_events = record
+    version: Tuint32_t;
+    global: procedure(object_: pointer; id: Tuint32_t; permissions: Tuint32_t; _type: PChar; version: Tuint32_t; props: Pspa_dict); cdecl;
+    global_remove: procedure(object_: pointer; id: Tuint32_t); cdecl;
+  end;
+
+  Tpw_registry_methods = record
+    version: Tuint32_t;
+    add_listener: function(object_: pointer; listener: Pspa_hook; events: Ppw_registry_events; Data: pointer) : longint; cdecl;
+    bind: function(object_: pointer; id: Tuint32_t; _type: PChar; version: Tuint32_t; use_data_size: Tsize_t) : pointer; cdecl;
+    Destroy: function(object_: pointer; id: Tuint32_t) : longint; cdecl;
+  end;
+
+
+function pw_core_info_update(info: Ppw_core_info; update: Ppw_core_info) : Ppw_core_info; cdecl; external libpipewirename Name 'pw_core_info_update';
+function pw_core_info_merge(info: Ppw_core_info; update: Ppw_core_info; reset: T_Bool) : Ppw_core_info; cdecl; external libpipewirename Name 'pw_core_info_merge';
+procedure pw_core_info_free(info: Ppw_core_info); cdecl; external libpipewirename Name 'pw_core_info_free';
+
+function pw_core_sync(pw_core: Ppw_core; aID, aSync: cint) : cint;
+
+
+
+  {
+  static inline
+  __attribute__((format(printf, 5, 0))) int
+  pw_core_errorv(struct pw_core *core, uint32_t id, int seq,
+    int res, const char *message, va_list args)
+  
+   char buffer[1024];
+   vsnprintf(buffer, sizeof(buffer), message, args);
+   buffer[1023] = '\0';
+   return ( int _res = -
+  # 342 "/usr/include/pipewire-0.3/pipewire/core.h" 3 4
+         95
+  # 342 "/usr/include/pipewire-0.3/pipewire/core.h"
+         ; ( const struct pw_core_methods *_f = (const struct pw_core_methods *) (&((struct spa_interface*)core)->cb)->funcs; if ((__builtin_expect(!!((((_f) && ((0) == 0 || (_f)->version > (0)-1)) && (_f)->error)),1))) _res = _f->error((&((struct spa_interface*)core)->cb)->data, id, seq, res, buffer); _res; ); _res; );
+  
+  
+  static inline
+  __attribute__((format(printf, 5, 6))) int
+  pw_core_errorf(struct pw_core *core, uint32_t id, int seq,
+    int res, const char *message, ...)
+  
+          va_list args;
+   int r;
+   
+  # 352 "/usr/include/pipewire-0.3/pipewire/core.h" 3 4
+  __builtin_va_start(
+  # 352 "/usr/include/pipewire-0.3/pipewire/core.h"
+  args
+  # 352 "/usr/include/pipewire-0.3/pipewire/core.h" 3 4
+  ,
+  # 352 "/usr/include/pipewire-0.3/pipewire/core.h"
+  message
+  # 352 "/usr/include/pipewire-0.3/pipewire/core.h" 3 4
+  )
+  # 352 "/usr/include/pipewire-0.3/pipewire/core.h"
+                         ;
+   r = pw_core_errorv(core, id, seq, res, message, args);
+   
+  # 354 "/usr/include/pipewire-0.3/pipewire/core.h" 3 4
+  __builtin_va_end(
+  # 354 "/usr/include/pipewire-0.3/pipewire/core.h"
+  args
+  # 354 "/usr/include/pipewire-0.3/pipewire/core.h" 3 4
+  )
+  # 354 "/usr/include/pipewire-0.3/pipewire/core.h"
+              ;
+   return r;
+  
+  
+  static inline struct pw_registry *
+  pw_core_get_registry(struct pw_core *core, uint32_t version, size_t user_data_size)
+  
+   struct pw_registry *res = 
+  # 361 "/usr/include/pipewire-0.3/pipewire/core.h" 3 4
+                            ((void *)0)
+  # 361 "/usr/include/pipewire-0.3/pipewire/core.h"
+                                ;
+   ( const struct pw_core_methods *_f = (const struct pw_core_methods *) (&((struct spa_interface*)core)->cb)->funcs; if ((__builtin_expect(!!((((_f) && ((0) == 0 || (_f)->version > (0)-1)) && (_f)->get_registry)),1))) res = _f->get_registry((&((struct spa_interface*)core)->cb)->data, version, user_data_size); res; )
+  
+                                              ;
+   return res;
+  
+  
+  static inline void *
+  pw_core_create_object(struct pw_core *core,
+         const char *factory_name,
+         const char *type,
+         uint32_t version,
+         const struct spa_dict *props,
+         size_t user_data_size)
+  
+   void *res = 
+  # 376 "/usr/include/pipewire-0.3/pipewire/core.h" 3 4
+              ((void *)0)
+  # 376 "/usr/include/pipewire-0.3/pipewire/core.h"
+                  ;
+   ( const struct pw_core_methods *_f = (const struct pw_core_methods *) (&((struct spa_interface*)core)->cb)->funcs; if ((__builtin_expect(!!((((_f) && ((0) == 0 || (_f)->version > (0)-1)) && (_f)->create_object)),1))) res = _f->create_object((&((struct spa_interface*)core)->cb)->data, factory_name, type, version, props, user_data_size); res; )
+  
+  
+                                          ;
+   return res;
+  
+  
+   }
+  {
+  # 511 "/usr/include/pipewire-0.3/pipewire/core.h"
+  
+  
+  static inline void *
+  pw_registry_bind(struct pw_registry *registry,
+           uint32_t id, const char *type, uint32_t version,
+           size_t user_data_size)
+  
+   void *res = 
+  # 516 "/usr/include/pipewire-0.3/pipewire/core.h" 3 4
+              ((void *)0)
+  # 516 "/usr/include/pipewire-0.3/pipewire/core.h"
+                  ;
+   ( const struct pw_registry_methods *_f = (const struct pw_registry_methods *) (&((struct spa_interface*)registry)->cb)->funcs; if ((__builtin_expect(!!((((_f) && ((0) == 0 || (_f)->version > (0)-1)) && (_f)->bind)),1))) res = _f->bind((&((struct spa_interface*)registry)->cb)->data, id, type, version, user_data_size); res; )
+  
+                                                ;
+   return res;
+  
+  
+   }
+
+function pw_context_connect(context: Ppw_context; properties: Ppw_properties; user_data_size: Tsize_t) : Ppw_core; cdecl; external libpipewirename Name 'pw_context_connect';
+
+function pw_context_connect_fd(context: Ppw_context; fd: longint; properties: Ppw_properties; user_data_size: Tsize_t) : Ppw_core; cdecl; external libpipewirename Name 'pw_context_connect_fd';
+
+function pw_context_connect_self(context: Ppw_context; properties: Ppw_properties; user_data_size: Tsize_t) : Ppw_core; cdecl; external libpipewirename Name 'pw_context_connect_self';
+
+function pw_core_steal_fd(core: Ppw_core) : longint; cdecl; external libpipewirename Name 'pw_core_steal_fd';
+
+function pw_core_set_paused(core: Ppw_core; paused: T_Bool) : longint; cdecl; external libpipewirename Name 'pw_core_set_paused';
+
+function pw_core_disconnect(core: Ppw_core) : longint; cdecl; external libpipewirename Name 'pw_core_disconnect';
+
+function pw_core_get_user_data(core: Ppw_core) : pointer; cdecl; external libpipewirename Name 'pw_core_get_user_data';
+
+function pw_core_get_client(core: Ppw_core) : Ppw_client; cdecl; external libpipewirename Name 'pw_core_get_client';
+
+function pw_core_get_context(core: Ppw_core) : Ppw_context; cdecl; external libpipewirename Name 'pw_core_get_context';
+
+function pw_core_get_properties(core: Ppw_core) : Ppw_properties; cdecl; external libpipewirename Name 'pw_core_get_properties';
+
+function pw_core_update_properties(core: Ppw_core; dict: Pspa_dict) : longint; cdecl; external libpipewirename Name 'pw_core_update_properties';
+
+function pw_core_get_mempool(core: Ppw_core) : Ppw_mempool; cdecl; external libpipewirename Name 'pw_core_get_mempool';
+
+function pw_core_find_proxy(core: Ppw_core; id: Tuint32_t) : Ppw_proxy; cdecl; external libpipewirename Name 'pw_core_find_proxy';
+
+function pw_core_export(core: Ppw_core; _type: PChar; props: Pspa_dict; object_: pointer; user_data_size: Tsize_t) : Ppw_proxy; cdecl; external libpipewirename Name 'pw_core_export';
+
+function pw_core_add_listener(pw_core: ppw_core; aListener: Pspa_hook; aEvents: Ppw_core_events; aData: Pointer) : cint;
+

packages/libpipewire/src/core_impl.inc

@@ -0,0 +1,28 @@
+{%MainUnit pipewire.pas}
+
+function pw_core_add_listener(pw_core: Ppw_core; aListener: Pspa_hook; aEvents: Ppw_core_events; aData: Pointer) : cint;
+
+var
+  intf: Pspa_interface;
+  F: Ppw_core_methods;
+
+begin
+  intf := Pspa_interface(pw_core);
+  F := Ppw_core_methods(Intf^.cb.funcs);
+  Result := F^.add_listener(Intf^.cb.Data, aListener, aEvents, aData);
+end;
+
+
+
+function pw_core_sync(pw_core: Ppw_core; aID, aSync: cint) : cint;
+
+var
+  intf: Pspa_interface;
+  F: Ppw_core_methods;
+
+begin
+  intf := Pspa_interface(pw_core);
+  F := Ppw_core_methods(intf^.cb.funcs);
+  Result := f^.sync(intf^.cb.Data, aID, aSync);
+end;
+

packages/libpipewire/src/data_loop.inc

@@ -0,0 +1,37 @@
+
+type
+  Tpw_data_loop = record
+  end;
+  Ppw_data_loop = ^Tpw_data_loop;
+  Ppw_data_loop_events = ^Tpw_data_loop_events;
+
+  Tpw_data_loop_events = record
+    version: Tuint32_t;
+    Destroy: procedure(Data: pointer); cdecl;
+  end;
+
+
+function pw_data_loop_new(props: Pspa_dict) : Ppw_data_loop; cdecl; external libpipewirename Name 'pw_data_loop_new';
+
+procedure pw_data_loop_add_listener(loop: Ppw_data_loop; listener: Pspa_hook; events: Ppw_data_loop_events; Data: pointer); cdecl; external libpipewirename Name 'pw_data_loop_add_listener';
+
+function pw_data_loop_wait(loop: Ppw_data_loop; timeout: longint) : longint; cdecl; external libpipewirename Name 'pw_data_loop_wait';
+
+procedure pw_data_loop_exit(loop: Ppw_data_loop); cdecl; external libpipewirename Name 'pw_data_loop_exit';
+
+function pw_data_loop_get_loop(loop: Ppw_data_loop) : Ppw_loop; cdecl; external libpipewirename Name 'pw_data_loop_get_loop';
+
+procedure pw_data_loop_destroy(loop: Ppw_data_loop); cdecl; external libpipewirename Name 'pw_data_loop_destroy';
+
+function pw_data_loop_start(loop: Ppw_data_loop) : longint; cdecl; external libpipewirename Name 'pw_data_loop_start';
+
+function pw_data_loop_stop(loop: Ppw_data_loop) : longint; cdecl; external libpipewirename Name 'pw_data_loop_stop';
+
+function pw_data_loop_in_thread(loop: Ppw_data_loop) : T_Bool; cdecl; external libpipewirename Name 'pw_data_loop_in_thread';
+
+function pw_data_loop_get_thread(loop: Ppw_data_loop) : Pspa_thread; cdecl; external libpipewirename Name 'pw_data_loop_get_thread';
+
+function pw_data_loop_invoke(loop: Ppw_data_loop; func: Tspa_invoke_func_t; seq: Tuint32_t; Data: pointer; size: Tsize_t; block: T_Bool; user_data: pointer) : longint;
+  cdecl; external libpipewirename Name 'pw_data_loop_invoke';
+
+

packages/libpipewire/src/device.inc

@@ -0,0 +1,42 @@
+
+type
+  Ppw_device = ^Tpw_device;
+  Ppw_device_events = ^Tpw_device_events;
+  Ppw_device_info = ^Tpw_device_info;
+  Ppw_device_methods = ^Tpw_device_methods;
+
+
+  Tpw_device = record
+    {undefined structure}
+  end;
+
+  Tpw_device_info = record
+    id: Tuint32_t;
+    change_mask: Tuint64_t;
+    props: Pspa_dict;
+    params: Pspa_param_info;
+    n_params: Tuint32_t;
+  end;
+
+  Tpw_device_events = record
+    version: Tuint32_t;
+    info: procedure(object_: pointer; info: Ppw_device_info); cdecl;
+    param: procedure(object_: pointer; seq: longint; id: Tuint32_t; index: Tuint32_t; Next: Tuint32_t; param: Pspa_pod); cdecl;
+  end;
+
+
+  Tpw_device_methods = record
+    version: Tuint32_t;
+    add_listener: function(object_: pointer; listener: Pspa_hook; events: Ppw_device_events; Data: pointer) : longint; cdecl;
+    subscribe_params: function(object_: pointer; ids: Puint32_t; n_ids: Tuint32_t) : longint; cdecl;
+    enum_params: function(object_: pointer; seq: longint; id: Tuint32_t; start: Tuint32_t; num: Tuint32_t; filter: Pspa_pod) : longint; cdecl;
+    set_param: function(object_: pointer; id: Tuint32_t; flags: Tuint32_t; param: Pspa_pod) : longint; cdecl;
+  end;
+
+
+function pw_device_info_update(info: Ppw_device_info; update: Ppw_device_info) : Ppw_device_info; cdecl; external libpipewirename Name 'pw_device_info_update';
+
+function pw_device_info_merge(info: Ppw_device_info; update: Ppw_device_info; reset: T_Bool) : Ppw_device_info; cdecl; external libpipewirename Name 'pw_device_info_merge';
+
+procedure pw_device_info_free(info: Ppw_device_info); cdecl; external libpipewirename Name 'pw_device_info_free';
+

packages/libpipewire/src/factory.inc

@@ -0,0 +1,39 @@
+
+type
+  Ppw_factory = ^Tpw_factory;
+  Ppw_factory_events = ^Tpw_factory_events;
+  Ppw_factory_info = ^Tpw_factory_info;
+  Ppw_factory_methods = ^Tpw_factory_methods;
+
+  Tpw_factory = record
+    {undefined structure}
+  end;
+
+  Tpw_factory_info = record
+    id: Tuint32_t;
+    Name: PChar;
+    _type: PChar;
+    version: Tuint32_t;
+    change_mask: Tuint64_t;
+    props: Pspa_dict;
+  end;
+
+  Tpw_factory_events = record
+    version: Tuint32_t;
+    info: procedure(object_: pointer; info: Ppw_factory_info); cdecl;
+  end;
+
+  Tpw_factory_methods = record
+    version: Tuint32_t;
+    add_listener: function(object_: pointer; listener: Pspa_hook; events: Ppw_factory_events; Data: pointer) : longint; cdecl;
+  end;
+
+
+function pw_factory_info_update(info: Ppw_factory_info; update: Ppw_factory_info) : Ppw_factory_info; cdecl; external libpipewirename Name 'pw_factory_info_update';
+
+function pw_factory_info_merge(info: Ppw_factory_info; update: Ppw_factory_info; reset: T_Bool) : Ppw_factory_info; cdecl; external libpipewirename Name 'pw_factory_info_merge';
+
+procedure pw_factory_info_free(info: Ppw_factory_info); cdecl; external libpipewirename Name 'pw_factory_info_free';
+
+
+

packages/libpipewire/src/files.inc

@@ -0,0 +1,30 @@
+#include <spa/support/plugin.h>
+
+#include <pipewire/array.h>
+#include <pipewire/client.h>
+#include <pipewire/context.h>
+#include <pipewire/device.h>
+#include <pipewire/buffers.h>
+#include <pipewire/core.h>
+#include <pipewire/factory.h>
+#include <pipewire/keys.h>
+#include <pipewire/log.h>
+#include <pipewire/loop.h>
+#include <pipewire/link.h>
+#include <pipewire/main-loop.h>
+#include <pipewire/map.h>
+#include <pipewire/mem.h>
+#include <pipewire/module.h>
+#include <pipewire/node.h>
+#include <pipewire/properties.h>
+#include <pipewire/proxy.h>
+#include <pipewire/permission.h>
+#include <pipewire/protocol.h>
+#include <pipewire/port.h>
+#include <pipewire/stream.h>
+#include <pipewire/filter.h>
+#include <pipewire/thread-loop.h>
+#include <pipewire/data-loop.h>
+#include <pipewire/type.h>
+#include <pipewire/utils.h>
+#include <pipewire/version.h>

packages/libpipewire/src/filter.inc

@@ -0,0 +1,97 @@
+
+type
+  Tpw_filter = record
+  end;
+
+  Ppw_filter = ^Tpw_filter;
+  Ppw_filter_events = ^Tpw_filter_events;
+  Ppw_filter_flags = ^Tpw_filter_flags;
+  Ppw_filter_port_flags = ^Tpw_filter_port_flags;
+  Ppw_filter_state = ^Tpw_filter_state;
+
+  Tpw_filter_state = (
+    PW_FILTER_STATE_ERROR := -(1),
+    PW_FILTER_STATE_UNCONNECTED := 0,
+    PW_FILTER_STATE_CONNECTING := 1,
+    PW_FILTER_STATE_PAUSED := 2,
+    PW_FILTER_STATE_STREAMING := 3);
+
+  Tpw_filter_events = record
+    version: Tuint32_t;
+    Destroy: procedure(Data: pointer); cdecl;
+    state_changed: procedure(Data: pointer; old: Tpw_filter_state; state: Tpw_filter_state; error: PChar); cdecl;
+    io_changed: procedure(Data: pointer; port_data: pointer; id: Tuint32_t; area: pointer; size: Tuint32_t); cdecl;
+    param_changed: procedure(Data: pointer; port_data: pointer; id: Tuint32_t; param: Pspa_pod); cdecl;
+    add_buffer: procedure(Data: pointer; port_data: pointer; buffer: Ppw_buffer); cdecl;
+    remove_buffer: procedure(Data: pointer; port_data: pointer; buffer: Ppw_buffer); cdecl;
+    process: procedure(Data: pointer; position: Pspa_io_position); cdecl;
+    drained: procedure(Data: pointer); cdecl;
+    command: procedure(Data: pointer; command: Pspa_command); cdecl;
+  end;
+
+  Tpw_filter_flags = (
+    PW_FILTER_FLAG_NONE := 0,
+    PW_FILTER_FLAG_INACTIVE := 1 shl 0,
+    PW_FILTER_FLAG_DRIVER := 1 shl 1,
+    PW_FILTER_FLAG_RT_PROCESS := 1 shl 2,
+    PW_FILTER_FLAG_CUSTOM_LATENCY := 1 shl 3
+  );
+
+  Tpw_filter_port_flags = (
+    PW_FILTER_PORT_FLAG_NONE := 0,
+    PW_FILTER_PORT_FLAG_MAP_BUFFERS := 1 shl 0,
+    PW_FILTER_PORT_FLAG_ALLOC_BUFFERS := 1 shl 1
+  );
+
+
+function pw_filter_state_as_string(state: Tpw_filter_state) : PChar; cdecl; external libpipewirename Name 'pw_filter_state_as_string';
+
+
+function pw_filter_new(core: Ppw_core; Name: PChar; props: Ppw_properties) : Ppw_filter; cdecl; external libpipewirename Name 'pw_filter_new';
+
+function pw_filter_new_simple(loop: Ppw_loop; Name: PChar; props: Ppw_properties; events: Ppw_filter_events; Data: pointer) : Ppw_filter; cdecl; external libpipewirename Name 'pw_filter_new_simple';
+
+procedure pw_filter_destroy(filter: Ppw_filter); cdecl; external libpipewirename Name 'pw_filter_destroy';
+
+procedure pw_filter_add_listener(filter: Ppw_filter; listener: Pspa_hook; events: Ppw_filter_events; Data: pointer); cdecl; external libpipewirename Name 'pw_filter_add_listener';
+
+function pw_filter_get_state(filter: Ppw_filter; error: PPchar) : Tpw_filter_state; cdecl; external libpipewirename Name 'pw_filter_get_state';
+
+function pw_filter_get_name(filter: Ppw_filter) : PChar; cdecl; external libpipewirename Name 'pw_filter_get_name';
+
+function pw_filter_get_core(filter: Ppw_filter) : Ppw_core; cdecl; external libpipewirename Name 'pw_filter_get_core';
+
+function pw_filter_connect(filter: Ppw_filter; flags: Tpw_filter_flags; params: PPspa_pod; n_params: Tuint32_t) : longint; cdecl; external libpipewirename Name 'pw_filter_connect';
+
+function pw_filter_get_node_id(filter: Ppw_filter) : Tuint32_t; cdecl; external libpipewirename Name 'pw_filter_get_node_id';
+
+function pw_filter_disconnect(filter: Ppw_filter) : longint; cdecl; external libpipewirename Name 'pw_filter_disconnect';
+
+function pw_filter_add_port(filter: Ppw_filter; direction: Tspa_direction; flags: Tpw_filter_port_flags; port_data_size: Tsize_t; props: Ppw_properties;
+  params: PPspa_pod; n_params: Tuint32_t) : pointer; cdecl; external libpipewirename Name 'pw_filter_add_port';
+
+function pw_filter_remove_port(port_data: pointer) : longint; cdecl; external libpipewirename Name 'pw_filter_remove_port';
+
+function pw_filter_get_properties(filter: Ppw_filter; port_data: pointer) : Ppw_properties; cdecl; external libpipewirename Name 'pw_filter_get_properties';
+
+function pw_filter_update_properties(filter: Ppw_filter; port_data: pointer; dict: Pspa_dict) : longint; cdecl; external libpipewirename Name 'pw_filter_update_properties';
+
+function pw_filter_set_error(filter: Ppw_filter; res: longint; error: PChar; args: array of const) : longint; cdecl; external libpipewirename Name 'pw_filter_set_error';
+
+function pw_filter_set_error(filter: Ppw_filter; res: longint; error: PChar) : longint; cdecl; external libpipewirename Name 'pw_filter_set_error';
+
+function pw_filter_update_params(filter: Ppw_filter; port_data: pointer; params: PPspa_pod; n_params: Tuint32_t) : longint; cdecl; external libpipewirename Name 'pw_filter_update_params';
+
+function pw_filter_get_time(filter: Ppw_filter; time: Ppw_time) : longint; cdecl; external libpipewirename Name 'pw_filter_get_time';
+
+function pw_filter_dequeue_buffer(port_data: pointer) : Ppw_buffer; cdecl; external libpipewirename Name 'pw_filter_dequeue_buffer';
+
+function pw_filter_queue_buffer(port_data: pointer; buffer: Ppw_buffer) : longint; cdecl; external libpipewirename Name 'pw_filter_queue_buffer';
+
+function pw_filter_get_dsp_buffer(port_data: pointer; n_samples: Tuint32_t) : pointer; cdecl; external libpipewirename Name 'pw_filter_get_dsp_buffer';
+
+function pw_filter_set_active(filter: Ppw_filter; active: T_Bool) : longint; cdecl; external libpipewirename Name 'pw_filter_set_active';
+
+function pw_filter_flush(filter: Ppw_filter; drain: T_Bool) : longint; cdecl; external libpipewirename Name 'pw_filter_flush';
+
+

packages/libpipewire/src/global.inc

@@ -0,0 +1,79 @@
+
+  const
+    libpipewire='libpipewire-0.3'; {Setup as you need}
+
+  { Pointers to basic pascal types, inserted by h2pas conversion program.}
+  Type
+    PLongint  = ^Longint;
+    PSmallInt = ^SmallInt;
+    PByte     = ^Byte;
+    PWord     = ^Word;
+    PDWord    = ^DWord;
+    PDouble   = ^Double;
+
+  Type
+    Pchar  = ^Tchar;
+    Ppw_context  = ^Tpw_context;
+    Ppw_global  = ^Tpw_global;
+    Ppw_global_events  = ^Tpw_global_events;
+    Ppw_impl_client  = ^Tpw_impl_client;
+    Ppw_properties  = ^Tpw_properties;
+    Ppw_resource  = ^Tpw_resource;
+    Pspa_dict  = ^Tspa_dict;
+    Pspa_hook  = ^Tspa_hook;
+{$IFDEF FPC}
+{$PACKRECORDS C}
+{$ENDIF}
+
+
+
+  type
+
+    Tpw_global_bind_func_t = function (object:pointer; client:Ppw_impl_client; permissions:Tuint32_t; version:Tuint32_t; id:Tuint32_t):longint;cdecl;
+    Ppw_global_events = ^Tpw_global_events;
+    Tpw_global_events = record
+        version : Tuint32_t;cdecl;
+        destroy : procedure (data:pointer);cdecl;
+        free : procedure (data:pointer);cdecl;
+        permissions_changed : procedure (data:pointer; client:Ppw_impl_client; old_permissions:Tuint32_t; new_permissions:Tuint32_t);cdecl;
+      end;
+
+
+  function pw_global_new(context:Ppw_context; _type:Pchar; version:Tuint32_t; properties:Ppw_properties; func:Tpw_global_bind_func_t; 
+             object:pointer):Ppw_global;cdecl;external libpipewire name 'pw_global_new';
+
+  function pw_global_register(global:Ppw_global):longint;cdecl;external libpipewire name 'pw_global_register';
+
+  procedure pw_global_add_listener(global:Ppw_global; listener:Pspa_hook; events:Ppw_global_events; data:pointer);cdecl;external libpipewire name 'pw_global_add_listener';
+
+  function pw_global_get_permissions(global:Ppw_global; client:Ppw_impl_client):Tuint32_t;cdecl;external libpipewire name 'pw_global_get_permissions';
+
+  function pw_global_get_context(global:Ppw_global):Ppw_context;cdecl;external libpipewire name 'pw_global_get_context';
+
+  function pw_global_get_type(global:Ppw_global):Pchar;cdecl;external libpipewire name 'pw_global_get_type';
+
+  function pw_global_is_type(global:Ppw_global; _type:Pchar):T_Bool;cdecl;external libpipewire name 'pw_global_is_type';
+
+  function pw_global_get_version(global:Ppw_global):Tuint32_t;cdecl;external libpipewire name 'pw_global_get_version';
+
+  function pw_global_get_properties(global:Ppw_global):Ppw_properties;cdecl;external libpipewire name 'pw_global_get_properties';
+
+  function pw_global_update_keys(global:Ppw_global; dict:Pspa_dict; keys:PPchar):longint;cdecl;external libpipewire name 'pw_global_update_keys';
+
+  function pw_global_get_object(global:Ppw_global):pointer;cdecl;external libpipewire name 'pw_global_get_object';
+
+  function pw_global_get_id(global:Ppw_global):Tuint32_t;cdecl;external libpipewire name 'pw_global_get_id';
+
+  function pw_global_get_serial(global:Ppw_global):Tuint64_t;cdecl;external libpipewire name 'pw_global_get_serial';
+
+  function pw_global_add_resource(global:Ppw_global; resource:Ppw_resource):longint;cdecl;external libpipewire name 'pw_global_add_resource';
+
+  function pw_global_for_each_resource(global:Ppw_global; callback:function (data:pointer; resource:Ppw_resource):longint; data:pointer):longint;cdecl;external libpipewire name 'pw_global_for_each_resource';
+
+  function pw_global_bind(global:Ppw_global; client:Ppw_impl_client; permissions:Tuint32_t; version:Tuint32_t; id:Tuint32_t):longint;cdecl;external libpipewire name 'pw_global_bind';
+
+  function pw_global_update_permissions(global:Ppw_global; client:Ppw_impl_client; old_permissions:Tuint32_t; new_permissions:Tuint32_t):longint;cdecl;external libpipewire name 'pw_global_update_permissions';
+
+  procedure pw_global_destroy(global:Ppw_global);cdecl;external libpipewire name 'pw_global_destroy';
+
+

packages/libpipewire/src/i18n.inc

@@ -0,0 +1,26 @@
+
+  const
+    libpipewire='libpipewire-0.3'; {Setup as you need}
+
+  { Pointers to basic pascal types, inserted by h2pas conversion program.}
+  Type
+    PLongint  = ^Longint;
+    PSmallInt = ^SmallInt;
+    PByte     = ^Byte;
+    PWord     = ^Word;
+    PDWord    = ^DWord;
+    PDouble   = ^Double;
+
+  Type
+    Pchar  = ^Tchar;
+{$IFDEF FPC}
+{$PACKRECORDS C}
+{$ENDIF}
+
+
+
+  function pw_gettext(msgid:Pchar):Pchar;cdecl;external libpipewire name 'pw_gettext';
+
+  function pw_ngettext(msgid:Pchar; msgid_plural:Pchar; n:dword):Pchar;cdecl;external libpipewire name 'pw_ngettext';
+
+

packages/libpipewire/src/impl.inc

@@ -0,0 +1,22 @@
+
+  const
+    libpipewire='libpipewire-0.3'; {Setup as you need}
+
+  { Pointers to basic pascal types, inserted by h2pas conversion program.}
+  Type
+    PLongint  = ^Longint;
+    PSmallInt = ^SmallInt;
+    PByte     = ^Byte;
+    PWord     = ^Word;
+    PDWord    = ^DWord;
+    PDouble   = ^Double;
+
+{$IFDEF FPC}
+{$PACKRECORDS C}
+{$ENDIF}
+
+
+
+  const
+    impl_h = 1;    
+

packages/libpipewire/src/keys.inc

@@ -0,0 +1,2 @@
+
+

packages/libpipewire/src/libpipewire.pp

@@ -0,0 +1,130 @@
+{
+  Interface to pipewire library. Generated by h2pas.
+}
+{$IFNDEF FPC_DOTTEDUNITS}
+unit libpipewire;
+{$ENDIF}
+
+{$IFDEF FPC}
+{$mode objfpc}
+{$h+}
+{$endif}
+
+interface
+
+{$IFDEF FPC_DOTTEDUNITS}
+uses System.CTypes, Api.SPA;
+{$ELSE}
+uses ctypes, libspa;
+{$ENDIF}
+const
+  libpipewirename = 'libpipewire-0.3';
+
+{ Pointers to basic pascal types, inserted by h2pas conversion program.}
+type
+  Psize_t = ^csize_t;
+
+
+  Tpw_proxy = record
+      {undefined structure}
+    end;
+
+  Tpw_protocol = record
+      {undefined structure}
+    end;
+
+  Tpw_context = record
+      {undefined structure}
+    end;
+
+  Tpw_global = record
+      {undefined structure}
+    end;
+
+  Tpw_impl_client = record
+      {undefined structure}
+    end;
+
+  Tpw_core = record
+      {undefined structure}
+    end;
+
+  Tpw_registry = record
+      {undefined structure}
+    end;
+  Tpw_core_info = record
+    id : Tuint32_t;
+    cookie : Tuint32_t;
+    user_name : pchar;
+    host_name : pchar;
+    version : pchar;
+    name : char;
+    change_mask : Tuint64_t;
+    props : pTspa_dict;
+  end;
+
+
+{$IFDEF FPC}
+{$PACKRECORDS C}
+{$ENDIF}
+
+{$i array.inc}
+// needed in client.inc
+{$i permission.inc}
+{$i client.inc}
+// needed in context.inc
+{$i loop.inc}
+// needed in context.inc
+{$i properties.inc}
+{$i work_queue.inc}
+{$i context.inc}
+{$i device.inc}
+// needed for buffers.inc
+{$i mem.inc}
+{$i buffers.inc}
+{$i core.inc}
+{$i factory.inc}
+{$i keys.inc}
+{$i log.inc}
+{$i link.inc}
+{$i main_loop.inc}
+{$i map.inc}
+{$i module.inc}
+{$i node.inc}
+// needed in proxy.inc
+{$i protocol.inc}
+{$i proxy.inc}
+{$i port.inc}
+{$i stream.inc}
+{$i filter.inc}
+{$i data_loop.inc}
+{$i type.inc}
+{$i utils.inc}
+{$i version.inc}
+{$i thread_loop.inc}
+
+
+procedure pw_init(argc: Plongint; argv: PPPchar); cdecl; external libpipewirename Name 'pw_init';
+procedure pw_deinit; cdecl; external libpipewirename Name 'pw_deinit';
+function pw_debug_is_category_enabled(Name: PChar) : T_Bool; cdecl; external libpipewirename Name 'pw_debug_is_category_enabled';
+function pw_get_application_name : PChar; cdecl; external libpipewirename Name 'pw_get_application_name';
+function pw_get_prgname : PChar; cdecl; external libpipewirename Name 'pw_get_prgname';
+function pw_get_user_name : PChar; cdecl; external libpipewirename Name 'pw_get_user_name';
+function pw_get_host_name : PChar; cdecl; external libpipewirename Name 'pw_get_host_name';
+function pw_get_client_name : PChar; cdecl; external libpipewirename Name 'pw_get_client_name';
+function pw_in_valgrind : T_Bool; cdecl; external libpipewirename Name 'pw_in_valgrind';
+function pw_check_option(option: PChar; Value: PChar) : T_Bool; cdecl; external libpipewirename Name 'pw_check_option';
+function pw_direction_reverse(direction: Tspa_direction) : Tspa_direction; cdecl; external libpipewirename Name 'pw_direction_reverse';
+function pw_set_domain(domain: PChar) : longint; cdecl; external libpipewirename Name 'pw_set_domain';
+function pw_get_domain : PChar; cdecl; external libpipewirename Name 'pw_get_domain';
+function pw_get_support(support: Pspa_support; max_support: Tuint32_t) : Tuint32_t; cdecl; external libpipewirename Name 'pw_get_support';
+function pw_load_spa_handle(lib: PChar; factory_name: PChar; info: Pspa_dict; n_support: Tuint32_t; support: Pspa_support) : Pspa_handle; cdecl; external libpipewirename Name 'pw_load_spa_handle';
+function pw_unload_spa_handle(handle: Pspa_handle) : longint; cdecl; external libpipewirename Name 'pw_unload_spa_handle';
+
+implementation
+
+{$i core_impl.inc}
+
+{$i loop_impl.inc}
+
+end.

packages/libpipewire/src/libspa.pp

@@ -0,0 +1,1639 @@
+{$IFNDEF FPC_DOTTEDUNITS}
+unit libspa;
+{$ENDIF}
+
+{$mode objfpc}
+{$h+}
+
+interface
+
+{$IFDEF FPC_DOTTEDUNITS}
+uses System.CTypes;
+{$ELSE}
+uses ctypes;
+{$ENDIF}
+
+{$l spabridge.o}
+
+{$IFDEF FPC}
+{$PACKRECORDS C}
+{$ENDIF}
+
+
+// Aliases
+Type
+  tuint32_t = uint32;
+  PTuint32_t = ^tuint32_t;
+  Tint32_t = int32;
+  Pint32_t = ^Tint32_t;
+  Tsize_t = csize_t;
+  Tssize_t = csize_t;
+  Tuint64_t = uint64;
+  PTuint64_t = ^Tuint64_t;
+  TTimespec = record end;
+  PTTimespec = ^TTimespec;
+  Tint64_t = int64;
+  Tdouble = double;
+  Pint64_t = ^int64;
+
+  T_Bool = byte;
+  Tbool = T_bool;
+  _Bool = T_Bool;
+  P_Bool = ^T_Bool;
+  PBool = P_Bool;
+  PT_Bool = P_Bool;
+  Toff_t = ^coff_t;
+
+{
+  Automatically converted by H2Pas 1.0.0 from libspa.h
+  The following command line parameters were used:
+    -t
+    -e
+    libspa.h
+}
+
+// Enums
+
+Type
+  Tspa_direction =  Longint;
+
+Const
+  SPA_DIRECTION_INPUT = 0;
+  SPA_DIRECTION_OUTPUT = 1;
+
+
+Type
+  Tspa_param_type = Longint;
+
+Const
+  SPA_PARAM_Invalid = 0;
+  SPA_PARAM_PropInfo = 1;
+  SPA_PARAM_Props = 2;
+  SPA_PARAM_EnumFormat = 3;
+  SPA_PARAM_Format = 4;
+  SPA_PARAM_Buffers = 5;
+  SPA_PARAM_Meta = 6;
+  SPA_PARAM_IO = 7;
+  SPA_PARAM_EnumProfile = 8;
+  SPA_PARAM_Profile = 9;
+  SPA_PARAM_EnumPortConfig = 10;
+  SPA_PARAM_PortConfig = 11;
+  SPA_PARAM_EnumRoute = 12;
+  SPA_PARAM_Route = 13;
+  SPA_PARAM_Control = 14;
+  SPA_PARAM_Latency = 15;
+  SPA_PARAM_ProcessLatency = 16;
+
+Type
+  Tspa_param_buffers =  Longint;
+Const
+  SPA_PARAM_BUFFERS_START = 0;
+  SPA_PARAM_BUFFERS_buffers = 1;
+  SPA_PARAM_BUFFERS_blocks = 2;
+  SPA_PARAM_BUFFERS_size = 3;
+  SPA_PARAM_BUFFERS_stride = 4;
+  SPA_PARAM_BUFFERS_align = 5;
+  SPA_PARAM_BUFFERS_dataType = 6;
+
+
+type
+  Tspa_param_meta =  Longint;
+Const
+  SPA_PARAM_META_START = 0;
+  SPA_PARAM_META_type = 1;
+  SPA_PARAM_META_size = 2;
+
+
+type
+  Tspa_param_io =  Longint;
+Const
+  SPA_PARAM_IO_START = 0;
+  SPA_PARAM_IO_id = 1;
+  SPA_PARAM_IO_size = 2;
+
+
+type
+  Tspa_param_availability =  Longint;
+Const
+  SPA_PARAM_AVAILABILITY_unknown = 0;
+  SPA_PARAM_AVAILABILITY_no = 1;
+  SPA_PARAM_AVAILABILITY_yes = 2;
+
+
+type
+  Tspa_param_profile =  Longint;
+Const
+  SPA_PARAM_PROFILE_START = 0;
+  SPA_PARAM_PROFILE_index = 1;
+  SPA_PARAM_PROFILE_name = 2;
+  SPA_PARAM_PROFILE_description = 3;
+  SPA_PARAM_PROFILE_priority = 4;
+  SPA_PARAM_PROFILE_available = 5;
+  SPA_PARAM_PROFILE_info = 6;
+  SPA_PARAM_PROFILE_classes = 7;
+  SPA_PARAM_PROFILE_save = 8;
+
+
+type
+  Tspa_param_port_config_mode =  Longint;
+Const
+  SPA_PARAM_PORT_CONFIG_MODE_none = 0;
+  SPA_PARAM_PORT_CONFIG_MODE_passthrough = 1;
+  SPA_PARAM_PORT_CONFIG_MODE_convert = 2;
+  SPA_PARAM_PORT_CONFIG_MODE_dsp = 3;
+
+
+type
+  Tspa_param_port_config =  Longint;
+Const
+  SPA_PARAM_PORT_CONFIG_START = 0;
+  SPA_PARAM_PORT_CONFIG_direction = 1;
+  SPA_PARAM_PORT_CONFIG_mode = 2;
+  SPA_PARAM_PORT_CONFIG_monitor = 3;
+  SPA_PARAM_PORT_CONFIG_control = 4;
+  SPA_PARAM_PORT_CONFIG_format = 5;
+
+
+type
+  Tspa_param_route =  Longint;
+
+Const
+  SPA_PARAM_ROUTE_START = 0;
+  SPA_PARAM_ROUTE_index = 1;
+  SPA_PARAM_ROUTE_direction = 2;
+  SPA_PARAM_ROUTE_device = 3;
+  SPA_PARAM_ROUTE_name = 4;
+  SPA_PARAM_ROUTE_description = 5;
+  SPA_PARAM_ROUTE_priority = 6;
+  SPA_PARAM_ROUTE_available = 7;
+  SPA_PARAM_ROUTE_info = 8;
+  SPA_PARAM_ROUTE_profiles = 9;
+  SPA_PARAM_ROUTE_props = 10;
+  SPA_PARAM_ROUTE_devices = 11;
+  SPA_PARAM_ROUTE_profile = 12;
+  SPA_PARAM_ROUTE_save = 13;
+
+
+Type
+  Tspa_param_latency =  Longint;
+
+Const
+    SPA_PARAM_LATENCY_START = 0;
+    SPA_PARAM_LATENCY_direction = 1;
+    SPA_PARAM_LATENCY_minQuantum = 2;
+    SPA_PARAM_LATENCY_maxQuantum = 3;
+    SPA_PARAM_LATENCY_minRate = 4;
+    SPA_PARAM_LATENCY_maxRate = 5;
+    SPA_PARAM_LATENCY_minNs = 6;
+    SPA_PARAM_LATENCY_maxNs = 7;
+
+type
+  Tspa_param_process_latency =  Longint;
+Const
+  SPA_PARAM_PROCESS_LATENCY_START = 0;
+  SPA_PARAM_PROCESS_LATENCY_quantum = 1;
+  SPA_PARAM_PROCESS_LATENCY_rate = 2;
+  SPA_PARAM_PROCESS_LATENCY_ns = 3;
+
+
+type
+  Tspa_param_bitorder =  Longint;
+
+Const
+  SPA_PARAM_BITORDER_unknown = 0;
+  SPA_PARAM_BITORDER_msb = 1;
+  SPA_PARAM_BITORDER_lsb = 2;
+
+Type
+  Tspa_type =  Longint;
+
+Const
+  SPA_TYPE_START = $00000;
+  SPA_TYPE_None = 1;
+  SPA_TYPE_Bool = 2;
+  SPA_TYPE_Id = 3;
+  SPA_TYPE_Int = 4;
+  SPA_TYPE_Long = 5;
+  SPA_TYPE_Float = 6;
+  SPA_TYPE_Double = 7;
+  SPA_TYPE_String = 8;
+  SPA_TYPE_Bytes = 9;
+  SPA_TYPE_Rectangle = 10;
+  SPA_TYPE_Fraction = 11;
+  SPA_TYPE_Bitmap = 12;
+  SPA_TYPE_Array = 13;
+  SPA_TYPE_Struct = 14;
+  SPA_TYPE_Object = 15;
+  SPA_TYPE_Sequence = 16;
+  SPA_TYPE_Pointer = 17;
+  SPA_TYPE_Fd = 18;
+  SPA_TYPE_Choice = 19;
+  SPA_TYPE_Pod = 20;
+  _SPA_TYPE_LAST = 21;
+  SPA_TYPE_POINTER_START = $10000;
+  SPA_TYPE_POINTER_Buffer = 65537;
+  SPA_TYPE_POINTER_Meta = 65538;
+  SPA_TYPE_POINTER_Dict = 65539;
+  _SPA_TYPE_POINTER_LAST = 65540;
+  SPA_TYPE_EVENT_START = $20000;
+  SPA_TYPE_EVENT_Device = 131073;
+  SPA_TYPE_EVENT_Node = 131074;
+  _SPA_TYPE_EVENT_LAST = 131075;
+  SPA_TYPE_COMMAND_START = $30000;
+  SPA_TYPE_COMMAND_Device = 196609;
+  SPA_TYPE_COMMAND_Node = 196610;
+  _SPA_TYPE_COMMAND_LAST = 196611;
+  SPA_TYPE_OBJECT_START = $40000;
+  SPA_TYPE_OBJECT_PropInfo = 262145;
+  SPA_TYPE_OBJECT_Props = 262146;
+  SPA_TYPE_OBJECT_Format = 262147;
+  SPA_TYPE_OBJECT_ParamBuffers = 262148;
+  SPA_TYPE_OBJECT_ParamMeta = 262149;
+  SPA_TYPE_OBJECT_ParamIO = 262150;
+  SPA_TYPE_OBJECT_ParamProfile = 262151;
+  SPA_TYPE_OBJECT_ParamPortConfig = 262152;
+  SPA_TYPE_OBJECT_ParamRoute = 262153;
+  SPA_TYPE_OBJECT_Profiler = 262154;
+  SPA_TYPE_OBJECT_ParamLatency = 262155;
+  SPA_TYPE_OBJECT_ParamProcessLatency = 262156;
+  _SPA_TYPE_OBJECT_LAST = 262157;
+  SPA_TYPE_VENDOR_PipeWire = $02000000;
+  SPA_TYPE_VENDOR_Other = $7f000000;
+
+type
+  Tspa_choice_type =  Longint;
+Const
+  SPA_CHOICE_None = 0;
+  SPA_CHOICE_Range = 1;
+  SPA_CHOICE_Step = 2;
+  SPA_CHOICE_Enum = 3;
+  SPA_CHOICE_Flags = 4;
+
+Type
+  Tspa_meta_type =  Longint;
+Const
+  SPA_META_Invalid = 0;
+  SPA_META_Header = 1;
+  SPA_META_VideoCrop = 2;
+  SPA_META_VideoDamage = 3;
+  SPA_META_Bitmap = 4;
+  SPA_META_Cursor = 5;
+  SPA_META_Control = 6;
+  SPA_META_Busy = 7;
+  _SPA_META_LAST = 8;
+
+Type
+  Tspa_data_type =  Longint;
+
+Const
+  SPA_DATA_Invalid = 0;
+  SPA_DATA_MemPtr = 1;
+  SPA_DATA_MemFd = 2;
+  SPA_DATA_DmaBuf = 3;
+  SPA_DATA_MemId = 4;
+  _SPA_DATA_LAST = 5;
+
+Type
+  Tspa_node_event =  Longint;
+Const
+  SPA_NODE_EVENT_Error = 0;
+  SPA_NODE_EVENT_Buffering = 1;
+  SPA_NODE_EVENT_RequestRefresh = 2;
+  SPA_NODE_EVENT_RequestProcess = 3;
+
+
+Type
+  Tspa_event_node =  Longint;
+
+Const
+  SPA_EVENT_NODE_START = 0;
+
+type
+  Tspa_node_command =  Longint;
+
+Const
+  SPA_NODE_COMMAND_Suspend = 0;
+  SPA_NODE_COMMAND_Pause = 1;
+  SPA_NODE_COMMAND_Start = 2;
+  SPA_NODE_COMMAND_Enable = 3;
+  SPA_NODE_COMMAND_Disable = 4;
+  SPA_NODE_COMMAND_Flush = 5;
+  SPA_NODE_COMMAND_Drain = 6;
+  SPA_NODE_COMMAND_Marker = 7;
+  SPA_NODE_COMMAND_ParamBegin = 8;
+  SPA_NODE_COMMAND_ParamEnd = 9;
+  SPA_NODE_COMMAND_RequestProcess = 10;
+
+type
+  Tspa_log_level =  Longint;
+Const
+  SPA_LOG_LEVEL_NONE = 0;
+  SPA_LOG_LEVEL_ERROR = 1;
+  SPA_LOG_LEVEL_WARN = 2;
+  SPA_LOG_LEVEL_INFO = 3;
+  SPA_LOG_LEVEL_DEBUG = 4;
+  SPA_LOG_LEVEL_TRACE = 5;
+
+
+type
+  Tspa_io_type =  Longint;
+Const
+  SPA_IO_Invalid = 0;
+  SPA_IO_Buffers = 1;
+  SPA_IO_Range = 2;
+  SPA_IO_Clock = 3;
+  SPA_IO_Latency = 4;
+  SPA_IO_Control = 5;
+  SPA_IO_Notify = 6;
+  SPA_IO_Position = 7;
+  SPA_IO_RateMatch = 8;
+  SPA_IO_Memory = 9;
+
+Type
+  Tspa_io_position_state =  Longint;
+Const
+  SPA_IO_POSITION_STATE_STOPPED = 0;
+  SPA_IO_POSITION_STATE_STARTING = 1;
+  SPA_IO_POSITION_STATE_RUNNING = 2;
+
+Type
+  Pitimerspec  = ^Titimerspec;
+  Plongint  = ^longint;
+  Pspa_buffer  = ^Tspa_buffer;
+  PPspa_buffer = ^Pspa_buffer;
+  Pspa_command  = ^Tspa_command;
+  Pspa_dict  = ^Tspa_dict;
+  Pspa_event  = ^Tspa_event;
+  Pspa_handle  = ^Tspa_handle;
+  Pspa_handle_factory  = ^Tspa_handle_factory;
+  Pspa_hook  = ^Tspa_hook;
+  Pspa_interface_info  = ^Tspa_interface_info;
+  Pspa_log_topic  = ^Tspa_log_topic;
+  Pspa_loop  = ^Tspa_loop;
+  Pspa_loop_control_hooks  = ^Tspa_loop_control_hooks;
+  Pspa_node_callbacks  = ^Tspa_node_callbacks;
+  Pspa_node_events  = ^Tspa_node_events;
+  Pspa_node_info  = ^Tspa_node_info;
+  Pspa_pod  = ^Tspa_pod;
+  PPspa_pod = ^Pspa_pod;
+  Pspa_poll_event  = ^Tspa_poll_event;
+  Pspa_port_info  = ^Tspa_port_info;
+  Pspa_source  = ^Tspa_source;
+  Pspa_support  = ^Tspa_support;
+  Ptimespec  = ^Ttimespec;
+  Puint32_t  = ^Tuint32_t;
+  Puint64_t  = ^Tuint64_t;
+
+  Tspa_rectangle = record
+    width : Tuint32_t;
+    height : Tuint32_t;
+  end;
+  Pspa_rectangle = ^Tspa_rectangle;
+
+  Tspa_point = record
+    x : Tint32_t;
+    y : Tint32_t;
+  end;
+
+  Tspa_region = record
+    position : Tspa_point;
+    size : Tspa_rectangle;
+  end;
+
+  Tspa_fraction = record
+    num : Tuint32_t;
+    denom : Tuint32_t;
+  end;
+  Pspa_fraction = ^Tspa_fraction;
+
+
+
+  Tspa_dict_item = record
+    key : pchar;
+    value : pchar;
+  end;
+  Pspa_dict_item = ^Tspa_dict_item;
+
+
+  Tspa_dict = record
+    flags : Tuint32_t;
+    n_items : Tuint32_t;
+    items : ^Tspa_dict_item;
+  end;
+  PTspa_dict = ^Tspa_dict;
+
+  tspa_callbacks = record
+    funcs : pointer;
+    data : pointer;
+  end;
+
+
+  Tspa_interface  = record
+    type_ : pchar;
+    version : tuint32_t ;
+    cb : tspa_callbacks ;
+  end;
+  Pspa_interface = ^tspa_interface;
+
+
+  PTspa_handle = ^Tspa_handle;
+  Tspa_handle = record
+    version : Tuint32_t;
+    get_interface : function (handle:PTspa_handle; _type:Pchar; interface_:Ppointer):longint;cdecl;
+    clear : function (handle:PTspa_handle):longint;cdecl;
+  end;
+
+  Tspa_interface_info = record
+    _type : pchar;
+  end;
+  PTspa_interface_info = pspa_interface_info;
+
+  Tspa_support = record
+    _type : pchar;
+    data : pointer;
+  end;
+
+  PTspa_handle_factory = ^Tspa_handle_factory;
+  PTspa_support = Pspa_support;
+  PPTspa_interface_info = ^PTspa_interface_info;
+  PPTspa_handle_factory = ^PTspa_handle_factory;
+  Tspa_handle_factory = record
+    version : Tuint32_t;
+    name : pchar;
+    info : PTspa_dict;
+    get_size : function (factory:PTspa_handle_factory; params:PTspa_dict):Tsize_t;cdecl;
+    init : function (factory:PTspa_handle_factory; handle:PTspa_handle; info:PTspa_dict; support:PTspa_support; n_support:Tuint32_t):longint;cdecl;
+    enum_interface_info : function (factory:PTspa_handle_factory; info:PPTspa_interface_info; index:PTuint32_t):longint;cdecl;
+  end;
+
+
+
+  Tspa_handle_factory_enum_func_t = function (factory:PPTspa_handle_factory; index:PTuint32_t):longint;cdecl;
+
+
+// This needs to be defined in a plugin
+// function spa_handle_factory_enum(factory:PPTspa_handle_factory; index:PTuint32_t):longint;
+
+
+  Tpw_array = record
+    data : pointer;
+    size : Tsize_t;
+    alloc : Tsize_t;
+    extend : Tsize_t;
+  end;
+
+
+
+  Tspa_param_info = record
+    id : Tuint32_t;
+    flags : Tuint32_t;
+    user : Tuint32_t;
+    padding : array[0..4] of Tuint32_t;
+  end;
+  Pspa_param_info = ^Tspa_param_info;
+
+
+  Tspa_list = record
+    next : ^Tspa_list;
+    prev : ^Tspa_list;
+  end;
+  pspa_list = ^tspa_list;
+
+  tspa_ringbuffer = record
+      readindex : tuint32_t;
+      writeindex : tuint32_t;
+    end;
+  Pspa_ringbuffer = ^Tspa_ringbuffer;
+
+  Tspa_system = record
+    iface : Tspa_interface;
+  end;
+  Pspa_system = ^Tspa_system;
+  PTspa_system = Pspa_system;
+
+  PTspa_poll_event = ^Tspa_poll_event;
+  Tspa_poll_event = record
+    events : Tuint32_t;
+    data : pointer;
+  end;
+
+  Titimerspec = record end;
+  PTitimerspec = ^Titimerspec;
+
+  Tspa_system_methods = record
+    version : Tuint32_t;
+    read : function (object_:pointer; fd:longint; buf:pointer; count:Tsize_t):Tssize_t;cdecl;
+    write : function (object_:pointer; fd:longint; buf:pointer; count:Tsize_t):Tssize_t;cdecl;
+    ioctl : function (object_:pointer; fd:longint; request:dword; args:array of const):longint;cdecl;
+    close : function (object_:pointer; fd:longint):longint;cdecl;
+    clock_gettime : function (object_:pointer; clockid:longint; value:PTtimespec):longint;cdecl;
+    clock_getres : function (object_:pointer; clockid:longint; res:PTtimespec):longint;cdecl;
+    pollfd_create : function (object_:pointer; flags:longint):longint;cdecl;
+    pollfd_add : function (object_:pointer; pfd:longint; fd:longint; events:Tuint32_t; data:pointer):longint;cdecl;
+    pollfd_mod : function (object_:pointer; pfd:longint; fd:longint; events:Tuint32_t; data:pointer):longint;cdecl;
+    pollfd_del : function (object_:pointer; pfd:longint; fd:longint):longint;cdecl;
+    pollfd_wait : function (object_:pointer; pfd:longint; ev:PTspa_poll_event; n_ev:longint; timeout:longint):longint;cdecl;
+    timerfd_create : function (object_:pointer; clockid:longint; flags:longint):longint;cdecl;
+    timerfd_settime : function (object_:pointer; fd:longint; flags:longint; new_value:PTitimerspec; old_value:PTitimerspec):longint;cdecl;
+    timerfd_gettime : function (object_:pointer; fd:longint; curr_value:PTitimerspec):longint;cdecl;
+    timerfd_read : function (object_:pointer; fd:longint; expirations:PTuint64_t):longint;cdecl;
+    eventfd_create : function (object_:pointer; flags:longint):longint;cdecl;
+    eventfd_write : function (object_:pointer; fd:longint; count:Tuint64_t):longint;cdecl;
+    eventfd_read : function (object_:pointer; fd:longint; count:PTuint64_t):longint;cdecl;
+    signalfd_create : function (object_:pointer; signal:longint; flags:longint):longint;cdecl;
+    signalfd_read : function (object_:pointer; fd:longint; signal:Plongint):longint;cdecl;
+  end;
+
+  Tspa_loop = record
+    iface : Tspa_interface;
+  end;
+  PTspa_loop = ^Tspa_loop;
+
+  Tspa_loop_control = record
+    iface : Tspa_interface;
+  end;
+  pspa_loop_control = ^tspa_loop_control;
+
+  Tspa_loop_utils = record
+    iface : Tspa_interface;
+  end;
+  Pspa_loop_utils = ^tspa_loop_utils;
+
+
+  PTspa_source = ^Tspa_source;
+  Tspa_source_func_t = procedure (source:PTspa_source);cdecl;
+  Tspa_source = record
+    loop : ^Tspa_loop;
+    func : Tspa_source_func_t;
+    data : pointer;
+    fd : longint;
+    mask : Tuint32_t;
+    rmask : Tuint32_t;
+    priv : pointer;
+  end;
+
+
+
+  Tspa_invoke_func_t = function (loop:PTspa_loop; async:T_Bool; seq:Tuint32_t; data:pointer; size:Tsize_t;
+               user_data:pointer):longint;cdecl;
+
+  Tspa_loop_methods = record
+    version : Tuint32_t;
+    add_source : function (object_:pointer; source:PTspa_source):longint;cdecl;
+    update_source : function (object_:pointer; source:PTspa_source):longint;cdecl;
+    remove_source : function (object_:pointer; source:PTspa_source):longint;cdecl;
+    invoke : function (object_:pointer; func:Tspa_invoke_func_t; seq:Tuint32_t; data:pointer; size:Tsize_t;
+                 block:T_Bool; user_data:pointer):longint;cdecl;
+  end;
+
+  Tspa_loop_control_hooks = record
+    version : Tuint32_t;
+    before : procedure (data:pointer);cdecl;
+    after : procedure (data:pointer);cdecl;
+  end;
+
+  PTspa_hook = Pspa_hook;
+  PTspa_loop_control_hooks = Pspa_loop_control_hooks;
+
+  Tspa_loop_control_methods = record
+    version : Tuint32_t;
+    get_fd : function (object_:pointer):longint;cdecl;
+    add_hook : procedure (object_:pointer; hook:PTspa_hook; hooks:PTspa_loop_control_hooks; data:pointer);cdecl;
+    enter : procedure (object_:pointer);cdecl;
+    leave : procedure (object_:pointer);cdecl;
+    iterate : function (object_:pointer; timeout:longint):longint;cdecl;
+  end;
+
+
+  Tspa_source_io_func_t = procedure (data:pointer; fd:longint; mask:Tuint32_t);cdecl;
+
+  Tspa_source_idle_func_t = procedure (data:pointer);cdecl;
+
+  Tspa_source_event_func_t = procedure (data:pointer; count:Tuint64_t);cdecl;
+
+  Tspa_source_timer_func_t = procedure (data:pointer; expirations:Tuint64_t);cdecl;
+
+  Tspa_source_signal_func_t = procedure (data:pointer; signal_number:longint);cdecl;
+  Tspa_loop_utils_methods = record
+    version : Tuint32_t;
+    add_io : function (object_:pointer; fd:longint; mask:Tuint32_t; close:T_Bool; func:Tspa_source_io_func_t;
+                 data:pointer):PTspa_source;cdecl;
+    update_io : function (object_:pointer; source:PTspa_source; mask:Tuint32_t):longint;cdecl;
+    add_idle : function (object_:pointer; enabled:T_Bool; func:Tspa_source_idle_func_t; data:pointer):PTspa_source;cdecl;
+    enable_idle : function (object_:pointer; source:PTspa_source; enabled:T_Bool):longint;cdecl;
+    add_event : function (object_:pointer; func:Tspa_source_event_func_t; data:pointer):PTspa_source;cdecl;
+    signal_event : function (object_:pointer; source:PTspa_source):longint;cdecl;
+    add_timer : function (object_:pointer; func:Tspa_source_timer_func_t; data:pointer):PTspa_source;cdecl;
+    update_timer : function (object_:pointer; source:PTspa_source; value:PTtimespec; interval:PTtimespec; absolute:T_Bool):longint;cdecl;
+    add_signal : function (object_:pointer; signal_number:longint; func:Tspa_source_signal_func_t; data:pointer):PTspa_source;cdecl;
+    destroy_source : procedure (object_:pointer; source:PTspa_source);cdecl;
+  end;
+  Pspa_loop_utils_methods = ^Tspa_loop_utils_methods;
+
+  Tspa_type_info = record
+    _type : Tuint32_t;
+    parent : Tuint32_t;
+    name : ^char;
+    values : ^Tspa_type_info;
+  end;
+  Pspa_type_info =  ^Tspa_type_info;
+  Tspa_pod = record
+    size : Tuint32_t;
+    _type : Tuint32_t;
+  end;
+
+  Tspa_pod_bool = record
+    pod : Tspa_pod;
+    value : Tint32_t;
+    _padding : Tint32_t;
+  end;
+
+  Tspa_pod_id = record
+    pod : Tspa_pod;
+    value : Tuint32_t;
+    _padding : Tint32_t;
+  end;
+
+  Tspa_pod_int = record
+    pod : Tspa_pod;
+    value : Tint32_t;
+    _padding : Tint32_t;
+  end;
+
+  Tspa_pod_long = record
+    pod : Tspa_pod;
+    value : Tint64_t;
+  end;
+
+  Tspa_pod_float = record
+    pod : Tspa_pod;
+    value : single;
+    _padding : Tint32_t;
+  end;
+
+  Tspa_pod_double = record
+    pod : Tspa_pod;
+    value : Tdouble;
+  end;
+
+  Tspa_pod_string = record
+    pod : Tspa_pod;
+  end;
+
+  Tspa_pod_bytes = record
+    pod : Tspa_pod;
+  end;
+
+  Tspa_pod_rectangle = record
+    pod : Tspa_pod;
+    value : Tspa_rectangle;
+  end;
+
+  Tspa_pod_fraction = record
+    pod : Tspa_pod;
+    value : Tspa_fraction;
+  end;
+
+  Tspa_pod_bitmap = record
+    pod : Tspa_pod;
+  end;
+
+  Tspa_pod_array_body = record
+    child : Tspa_pod;
+  end;
+
+  Tspa_pod_array = record
+    pod : Tspa_pod;
+    body : Tspa_pod_array_body;
+  end;
+
+  Tspa_pod_choice_body = record
+    _type : Tuint32_t;
+    flags : Tuint32_t;
+    child : Tspa_pod;
+  end;
+  pspa_pod_choice_body = ^tspa_pod_choice_body;
+
+  Tspa_pod_choice = record
+    pod : Tspa_pod;
+    body : Tspa_pod_choice_body;
+  end;
+  Pspa_pod_choice = ^Tspa_pod_choice;
+
+  Tspa_pod_struct = record
+    pod : Tspa_pod;
+  end;
+  pspa_pod_struct = ^Tspa_pod_struct;
+
+  Tspa_pod_object_body = record
+    _type : Tuint32_t;
+    id : Tuint32_t;
+  end;
+  Pspa_pod_object_body = ^Tspa_pod_object_body;
+
+  Tspa_pod_object = record
+    pod : Tspa_pod;
+    body : Tspa_pod_object_body;
+  end;
+  Pspa_pod_object = ^Tspa_pod_object;
+
+  Tspa_pod_pointer_body = record
+    _type : Tuint32_t;
+    _padding : Tuint32_t;
+    value : pointer;
+  end;
+  Pspa_pod_pointer_body = ^Tspa_pod_pointer_body;
+
+  Tspa_pod_pointer = record
+    pod : Tspa_pod;
+    body : Tspa_pod_pointer_body;
+  end;
+  Pspa_pod_pointer = ^Tspa_pod_pointer;
+
+  Tspa_pod_fd = record
+    pod : Tspa_pod;
+    value : Tint64_t;
+  end;
+  Pspa_pod_fd = ^Tspa_pod_fd;
+
+  Tspa_pod_prop = record
+    key : Tuint32_t;
+    flags : Tuint32_t;
+    value : Tspa_pod;
+  end;
+  pspa_pod_prop = ^Tspa_pod_prop;
+
+  Tspa_pod_control = record
+    offset : Tuint32_t;
+    _type : Tuint32_t;
+    value : Tspa_pod;
+  end;
+  pspa_pod_control = ^Tspa_pod_control;
+
+  Tspa_pod_sequence_body = record
+    unit_ : Tuint32_t;
+    pad : Tuint32_t;
+  end;
+  Pspa_pod_sequence_body = ^Tspa_pod_sequence_body;
+
+  Tspa_pod_sequence = record
+    pod : Tspa_pod;
+    body : Tspa_pod_sequence_body;
+  end;
+  Pspa_pod_sequence = ^Tspa_pod_sequence;
+
+
+  Tspa_meta = record
+    _type : Tuint32_t;
+    size : Tuint32_t;
+    data : pointer;
+  end;
+  Pspa_meta = ^tspa_meta;
+  Tspa_meta_header = record
+    flags : Tuint32_t;
+    offset : Tuint32_t;
+    pts : Tint64_t;
+    dts_offset : Tint64_t;
+    seq : Tuint64_t;
+  end;
+
+  Tspa_meta_region = record
+    region : Tspa_region;
+  end;
+  Pspa_meta_region = ^Tspa_meta_region;
+  PTspa_meta_region = Pspa_meta_region;
+
+  Tspa_meta_bitmap = record
+    format : Tuint32_t;
+    size : Tspa_rectangle;
+    stride : Tint32_t;
+    offset : Tuint32_t;
+  end;
+  PTspa_meta_bitmap = ^Tspa_meta_bitmap;
+  Pspa_meta_bitmap = PTspa_meta_bitmap;
+
+  Tspa_meta_cursor = record
+    id : Tuint32_t;
+    flags : Tuint32_t;
+    position : Tspa_point;
+    hotspot : Tspa_point;
+    bitmap_offset : Tuint32_t;
+  end;
+  Pspa_meta_cursor = ^Tspa_meta_cursor;
+  PTspa_meta_cursor = Pspa_meta_cursor;
+
+  Tspa_meta_control = record
+    sequence : Tspa_pod_sequence;
+  end;
+
+  Tspa_meta_busy = record
+    flags : Tuint32_t;
+    count : Tuint32_t;
+  end;
+
+
+
+  Tspa_chunk = record
+    offset : Tuint32_t;
+    size : Tuint32_t;
+    stride : Tint32_t;
+    flags : Tint32_t;
+  end;
+  Pspa_chunk = ^Tspa_chunk;
+
+  Pspa_data = ^Tspa_data;
+  Tspa_data = record
+    _type : Tuint32_t;
+    flags : Tuint32_t;
+    fd : Tint64_t;
+    mapoffset : Tuint32_t;
+    maxsize : Tuint32_t;
+    data : pointer;
+    chunk : ^Tspa_chunk;
+  end;
+
+  Tspa_buffer = record
+    n_metas : Tuint32_t;
+    n_datas : Tuint32_t;
+    metas : ^Tspa_meta;
+    datas : ^Tspa_data;
+  end;
+
+  Tspa_event_body = record
+    body : Tspa_pod_object_body;
+  end;
+
+  Tspa_event = record
+    pod : Tspa_pod;
+    body : Tspa_event_body;
+  end;
+
+
+
+  Tspa_command_body = record
+    body : Tspa_pod_object_body;
+  end;
+
+  Tspa_command = record
+    pod : Tspa_pod;
+    body : Tspa_command_body;
+  end;
+
+
+  Tspa_node = record
+    iface : Tspa_interface;
+  end;
+
+  Tspa_node_info = record
+    max_input_ports : Tuint32_t;
+    max_output_ports : Tuint32_t;
+    change_mask : Tuint64_t;
+    flags : Tuint64_t;
+    props : ^Tspa_dict;
+    params : ^Tspa_param_info;
+    n_params : Tuint32_t;
+  end;
+
+
+  Tspa_port_info = record
+    change_mask : Tuint64_t;
+    flags : Tuint64_t;
+    rate : Tspa_fraction;
+    props : ^Tspa_dict;
+    params : ^Tspa_param_info;
+    n_params : Tuint32_t;
+  end;
+
+  Tspa_result_node_error = record
+    message : ^char;
+  end;
+
+  Tspa_result_node_params = record
+    id : Tuint32_t;
+    index : Tuint32_t;
+    next : Tuint32_t;
+    param : ^Tspa_pod;
+  end;
+
+  PTspa_node_info =  Pspa_node_info;
+  PTspa_port_info = Pspa_port_info;
+  PTspa_event = Pspa_event;
+  PTspa_pod = Pspa_pod;
+
+  Tspa_node_events = record
+    version : Tuint32_t;
+    info : procedure (data:pointer; info: PTspa_node_info);cdecl;
+    port_info : procedure (data:pointer; direction:Tspa_direction; port:Tuint32_t; info:PTspa_port_info);cdecl;
+    result : procedure (data:pointer; seq:longint; res:longint; _type:Tuint32_t; result:pointer);cdecl;
+    event : procedure (data:pointer; event:PTspa_event);cdecl;
+  end;
+  PTspa_node_events = Pspa_node_events;
+
+  Tspa_node_callbacks = record
+    version : Tuint32_t;
+    ready : function (data:pointer; state:longint):longint;cdecl;
+    reuse_buffer : function (data:pointer; port_id:Tuint32_t; buffer_id:Tuint32_t):longint;cdecl;
+    xrun : function (data:pointer; trigger:Tuint64_t; delay:Tuint64_t; info:PTspa_pod):longint;cdecl;
+  end;
+
+  PTspa_node_callbacks = pspa_node_callbacks;
+  PTspa_command = Pspa_command;
+  PPTspa_buffer = ^PTspa_buffer;
+  PTspa_buffer = ^Tspa_buffer;
+
+  Tspa_node_methods = record
+    version : Tuint32_t;
+    add_listener : function (object_:pointer; listener:PTspa_hook; events:PTspa_node_events; data:pointer):longint;cdecl;
+    set_callbacks : function (object_:pointer; callbacks:PTspa_node_callbacks; data:pointer):longint;cdecl;
+    sync : function (object_:pointer; seq:longint):longint;cdecl;
+    enum_params : function (object_:pointer; seq:longint; id:Tuint32_t; start:Tuint32_t; max:Tuint32_t;
+                 filter:PTspa_pod):longint;cdecl;
+    set_param : function (object_:pointer; id:Tuint32_t; flags:Tuint32_t; param:PTspa_pod):longint;cdecl;
+    set_io : function (object_:pointer; id:Tuint32_t; data:pointer; size:Tsize_t):longint;cdecl;
+    send_command : function (object_:pointer; command:PTspa_command):longint;cdecl;
+    add_port : function (object_:pointer; direction:Tspa_direction; port_id:Tuint32_t; props:PTspa_dict):longint;cdecl;
+    remove_port : function (object_:pointer; direction:Tspa_direction; port_id:Tuint32_t):longint;cdecl;
+    port_enum_params : function (object_:pointer; seq:longint; direction:Tspa_direction; port_id:Tuint32_t; id:Tuint32_t;
+                 start:Tuint32_t; max:Tuint32_t; filter:PTspa_pod):longint;cdecl;
+    port_set_param : function (object_:pointer; direction:Tspa_direction; port_id:Tuint32_t; id:Tuint32_t; flags:Tuint32_t;
+                 param:PTspa_pod):longint;cdecl;
+    port_use_buffers : function (object_:pointer; direction:Tspa_direction; port_id:Tuint32_t; flags:Tuint32_t; buffers:PPTspa_buffer;
+                 n_buffers:Tuint32_t):longint;cdecl;
+    port_set_io : function (object_:pointer; direction:Tspa_direction; port_id:Tuint32_t; id:Tuint32_t; data:pointer;
+                 size:Tsize_t):longint;cdecl;
+    port_reuse_buffer : function (object_:pointer; port_id:Tuint32_t; buffer_id:Tuint32_t):longint;cdecl;
+    process : function (object_:pointer):longint;cdecl;
+  end;
+
+  Tspa_log = record
+    iface : Tspa_interface;
+    level : Tspa_log_level;
+  end;
+
+
+  Tspa_log_topic = record
+    version : Tuint32_t;
+    topic : ^char;
+    level : Tspa_log_level;
+    has_custom_level : T_Bool;
+  end;
+
+  PTspa_log_topic = Pspa_log_topic;
+
+  Tspa_log_methods = record
+    version : Tuint32_t;
+    log : procedure (object_:pointer; level:Tspa_log_level; file_:Pchar; line:longint; func:Pchar;
+                  fmt:Pchar; args:array of const);cdecl;
+    logv : procedure (object_:pointer; level:Tspa_log_level; file_:Pchar; line:longint; func:Pchar;
+                  fmt:Pchar; args: pointer);cdecl;
+    logt : procedure (object_:pointer; level:Tspa_log_level; topic: PTspa_log_topic; file_:Pchar; line:longint;
+                  func:Pchar; fmt:Pchar; args:array of const);cdecl;
+    logtv : procedure (object_:pointer; level:Tspa_log_level; topic:PTspa_log_topic; file_:Pchar; line:longint;
+                  func:Pchar; fmt:Pchar; args:pointer);cdecl;
+    topic_init : procedure (object_:pointer; topic:PTspa_log_topic);cdecl;
+  end;
+
+
+  Tspa_io_buffers = record
+    status : Tint32_t;
+    buffer_id : Tuint32_t;
+  end;
+
+  Tspa_io_memory = record
+    status : Tint32_t;
+    size : Tuint32_t;
+    data : pointer;
+  end;
+
+  Tspa_io_range = record
+    offset : Tuint64_t;
+    min_size : Tuint32_t;
+    max_size : Tuint32_t;
+  end;
+
+  Tspa_io_clock = record
+    flags : Tuint32_t;
+    id : Tuint32_t;
+    name : array[0..63] of char;
+    nsec : Tuint64_t;
+    rate : Tspa_fraction;
+    position : Tuint64_t;
+    duration : Tuint64_t;
+    delay : Tint64_t;
+    rate_diff : Tdouble;
+    next_nsec : Tuint64_t;
+    padding : array[0..7] of Tuint32_t;
+  end;
+
+  Tspa_io_video_size = record
+    flags : Tuint32_t;
+    stride : Tuint32_t;
+    size : Tspa_rectangle;
+    framerate : Tspa_fraction;
+    padding : array[0..3] of Tuint32_t;
+  end;
+
+  Tspa_io_latency = record
+    rate : Tspa_fraction;
+    min : Tuint64_t;
+    max : Tuint64_t;
+  end;
+
+  Tspa_io_sequence = record
+    sequence : Tspa_pod_sequence;
+  end;
+
+  Tspa_io_segment_bar = record
+    flags : Tuint32_t;
+    offset : Tuint32_t;
+    signature_num : single;
+    signature_denom : single;
+    bpm : Tdouble;
+    beat : Tdouble;
+    padding : array[0..7] of Tuint32_t;
+  end;
+
+  Tspa_io_segment_video = record
+    flags : Tuint32_t;
+    offset : Tuint32_t;
+    framerate : Tspa_fraction;
+    hours : Tuint32_t;
+    minutes : Tuint32_t;
+    seconds : Tuint32_t;
+    frames : Tuint32_t;
+    field_count : Tuint32_t;
+    padding : array[0..10] of Tuint32_t;
+  end;
+
+  Tspa_io_segment = record
+    version : Tuint32_t;
+    flags : Tuint32_t;
+    start : Tuint64_t;
+    duration : Tuint64_t;
+    rate : Tdouble;
+    position : Tuint64_t;
+    bar : Tspa_io_segment_bar;
+    video : Tspa_io_segment_video;
+  end;
+
+
+
+  Tspa_io_position = record
+    clock : Tspa_io_clock;
+    video : Tspa_io_video_size;
+    offset : Tint64_t;
+    state : Tuint32_t;
+    n_segments : Tuint32_t;
+    segments : array[0..7] of Tspa_io_segment;
+  end;
+  Pspa_io_position = ^Tspa_io_position;
+
+  Tspa_io_rate_match = record
+    delay : Tuint32_t;
+    size : Tuint32_t;
+    rate : Tdouble;
+    flags : Tuint32_t;
+    padding : array[0..6] of Tuint32_t;
+  end;
+
+  tspa_hook = record
+    link : tspa_list ;
+    cb: tspa_callbacks;
+    removed : procedure (hook: pspa_hook);
+    priv : pointer;
+  end;
+
+  tspa_hook_list = record
+    list : tspa_list ;
+  end;
+
+  Pspa_node = ^Tspa_node;
+  Pspa_log = ^Tspa_log;
+  Pspa_hook_list = ^Tspa_hook_list;
+  Tspa_thread = record end;
+  Pspa_thread = ^Tspa_thread;
+
+
+const
+  SPA_VIDEO_MAX_PLANES = 4;
+  SPA_VIDEO_MAX_COMPONENTS = 4;
+
+type
+  Tspa_video_multiview_mode =  Longint;
+Const
+  SPA_VIDEO_MULTIVIEW_MODE_NONE = -(1);
+  SPA_VIDEO_MULTIVIEW_MODE_MONO = 0;
+  SPA_VIDEO_MULTIVIEW_MODE_LEFT = 1;
+  SPA_VIDEO_MULTIVIEW_MODE_RIGHT = 2;
+  SPA_VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE = 3;
+  SPA_VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE_QUINCUNX = 4;
+  SPA_VIDEO_MULTIVIEW_MODE_COLUMN_INTERLEAVED = 5;
+  SPA_VIDEO_MULTIVIEW_MODE_ROW_INTERLEAVED = 6;
+  SPA_VIDEO_MULTIVIEW_MODE_TOP_BOTTOM = 7;
+  SPA_VIDEO_MULTIVIEW_MODE_CHECKERBOARD = 8;
+  SPA_VIDEO_MULTIVIEW_MODE_FRAME_BY_FRAME = 32;
+  SPA_VIDEO_MULTIVIEW_MODE_MULTIVIEW_FRAME_BY_FRAME = 33;
+  SPA_VIDEO_MULTIVIEW_MODE_SEPARATED = 34;
+
+type
+  Tspa_video_multiview_flags =  Longint;
+
+Const
+  SPA_VIDEO_MULTIVIEW_FLAGS_NONE = 0;
+  SPA_VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST = 1 shl 0;
+  SPA_VIDEO_MULTIVIEW_FLAGS_LEFT_FLIPPED = 1 shl 1;
+  SPA_VIDEO_MULTIVIEW_FLAGS_LEFT_FLOPPED = 1 shl 2;
+  SPA_VIDEO_MULTIVIEW_FLAGS_RIGHT_FLIPPED = 1 shl 3;
+  SPA_VIDEO_MULTIVIEW_FLAGS_RIGHT_FLOPPED = 1 shl 4;
+  SPA_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT = 1 shl 14;
+  SPA_VIDEO_MULTIVIEW_FLAGS_MIXED_MONO = 1 shl 15;
+
+type
+  Tspa_video_format =  Longint;
+Const
+  SPA_VIDEO_FORMAT_UNKNOWN = 0;
+  SPA_VIDEO_FORMAT_ENCODED = 1;
+  SPA_VIDEO_FORMAT_I420 = 2;
+  SPA_VIDEO_FORMAT_YV12 = 3;
+  SPA_VIDEO_FORMAT_YUY2 = 4;
+  SPA_VIDEO_FORMAT_UYVY = 5;
+  SPA_VIDEO_FORMAT_AYUV = 6;
+  SPA_VIDEO_FORMAT_RGBx = 7;
+  SPA_VIDEO_FORMAT_BGRx = 8;
+  SPA_VIDEO_FORMAT_xRGB = 9;
+  SPA_VIDEO_FORMAT_xBGR = 10;
+  SPA_VIDEO_FORMAT_RGBA = 11;
+  SPA_VIDEO_FORMAT_BGRA = 12;
+  SPA_VIDEO_FORMAT_ARGB = 13;
+  SPA_VIDEO_FORMAT_ABGR = 14;
+  SPA_VIDEO_FORMAT_RGB = 15;
+  SPA_VIDEO_FORMAT_BGR = 16;
+  SPA_VIDEO_FORMAT_Y41B = 17;
+  SPA_VIDEO_FORMAT_Y42B = 18;
+  SPA_VIDEO_FORMAT_YVYU = 19;
+  SPA_VIDEO_FORMAT_Y444 = 20;
+  SPA_VIDEO_FORMAT_v210 = 21;
+  SPA_VIDEO_FORMAT_v216 = 22;
+  SPA_VIDEO_FORMAT_NV12 = 23;
+  SPA_VIDEO_FORMAT_NV21 = 24;
+  SPA_VIDEO_FORMAT_GRAY8 = 25;
+  SPA_VIDEO_FORMAT_GRAY16_BE = 26;
+  SPA_VIDEO_FORMAT_GRAY16_LE = 27;
+  SPA_VIDEO_FORMAT_v308 = 28;
+  SPA_VIDEO_FORMAT_RGB16 = 29;
+  SPA_VIDEO_FORMAT_BGR16 = 30;
+  SPA_VIDEO_FORMAT_RGB15 = 31;
+  SPA_VIDEO_FORMAT_BGR15 = 32;
+  SPA_VIDEO_FORMAT_UYVP = 33;
+  SPA_VIDEO_FORMAT_A420 = 34;
+  SPA_VIDEO_FORMAT_RGB8P = 35;
+  SPA_VIDEO_FORMAT_YUV9 = 36;
+  SPA_VIDEO_FORMAT_YVU9 = 37;
+  SPA_VIDEO_FORMAT_IYU1 = 38;
+  SPA_VIDEO_FORMAT_ARGB64 = 39;
+  SPA_VIDEO_FORMAT_AYUV64 = 40;
+  SPA_VIDEO_FORMAT_r210 = 41;
+  SPA_VIDEO_FORMAT_I420_10BE = 42;
+  SPA_VIDEO_FORMAT_I420_10LE = 43;
+  SPA_VIDEO_FORMAT_I422_10BE = 44;
+  SPA_VIDEO_FORMAT_I422_10LE = 45;
+  SPA_VIDEO_FORMAT_Y444_10BE = 46;
+  SPA_VIDEO_FORMAT_Y444_10LE = 47;
+  SPA_VIDEO_FORMAT_GBR = 48;
+  SPA_VIDEO_FORMAT_GBR_10BE = 49;
+  SPA_VIDEO_FORMAT_GBR_10LE = 50;
+  SPA_VIDEO_FORMAT_NV16 = 51;
+  SPA_VIDEO_FORMAT_NV24 = 52;
+  SPA_VIDEO_FORMAT_NV12_64Z32 = 53;
+  SPA_VIDEO_FORMAT_A420_10BE = 54;
+  SPA_VIDEO_FORMAT_A420_10LE = 55;
+  SPA_VIDEO_FORMAT_A422_10BE = 56;
+  SPA_VIDEO_FORMAT_A422_10LE = 57;
+  SPA_VIDEO_FORMAT_A444_10BE = 58;
+  SPA_VIDEO_FORMAT_A444_10LE = 59;
+  SPA_VIDEO_FORMAT_NV61 = 60;
+  SPA_VIDEO_FORMAT_P010_10BE = 61;
+  SPA_VIDEO_FORMAT_P010_10LE = 62;
+  SPA_VIDEO_FORMAT_IYU2 = 63;
+  SPA_VIDEO_FORMAT_VYUY = 64;
+  SPA_VIDEO_FORMAT_GBRA = 65;
+  SPA_VIDEO_FORMAT_GBRA_10BE = 66;
+  SPA_VIDEO_FORMAT_GBRA_10LE = 67;
+  SPA_VIDEO_FORMAT_GBR_12BE = 68;
+  SPA_VIDEO_FORMAT_GBR_12LE = 69;
+  SPA_VIDEO_FORMAT_GBRA_12BE = 70;
+  SPA_VIDEO_FORMAT_GBRA_12LE = 71;
+  SPA_VIDEO_FORMAT_I420_12BE = 72;
+  SPA_VIDEO_FORMAT_I420_12LE = 73;
+  SPA_VIDEO_FORMAT_I422_12BE = 74;
+  SPA_VIDEO_FORMAT_I422_12LE = 75;
+  SPA_VIDEO_FORMAT_Y444_12BE = 76;
+  SPA_VIDEO_FORMAT_Y444_12LE = 77;
+  SPA_VIDEO_FORMAT_RGBA_F16 = 78;
+  SPA_VIDEO_FORMAT_RGBA_F32 = 79;
+  SPA_VIDEO_FORMAT_xRGB_210LE = 80;
+  SPA_VIDEO_FORMAT_xBGR_210LE = 81;
+  SPA_VIDEO_FORMAT_RGBx_102LE = 82;
+  SPA_VIDEO_FORMAT_BGRx_102LE = 83;
+  SPA_VIDEO_FORMAT_ARGB_210LE = 84;
+  SPA_VIDEO_FORMAT_ABGR_210LE = 85;
+  SPA_VIDEO_FORMAT_RGBA_102LE = 86;
+  SPA_VIDEO_FORMAT_BGRA_102LE = 87;
+  SPA_VIDEO_FORMAT_DSP_F32 = SPA_VIDEO_FORMAT_RGBA_F32;
+
+
+type
+  Tspa_video_flags =  Longint;
+Const
+  SPA_VIDEO_FLAG_NONE = 0;
+  SPA_VIDEO_FLAG_VARIABLE_FPS = 1 shl 0;
+  SPA_VIDEO_FLAG_PREMULTIPLIED_ALPHA = 1 shl 1;
+
+Type
+  Tspa_video_interlace_mode =  Longint;
+Const
+  SPA_VIDEO_INTERLACE_MODE_PROGRESSIVE = 0;
+  SPA_VIDEO_INTERLACE_MODE_INTERLEAVED = 1;
+  SPA_VIDEO_INTERLACE_MODE_MIXED = 2;
+  SPA_VIDEO_INTERLACE_MODE_FIELDS = 3;
+
+type
+  Tspa_video_chroma_site =  Longint;
+Const
+  SPA_VIDEO_CHROMA_SITE_UNKNOWN = 0;
+  SPA_VIDEO_CHROMA_SITE_NONE = 1 shl 0;
+  SPA_VIDEO_CHROMA_SITE_H_COSITED = 1 shl 1;
+  SPA_VIDEO_CHROMA_SITE_V_COSITED = 1 shl 2;
+  SPA_VIDEO_CHROMA_SITE_ALT_LINE = 1 shl 3;
+  SPA_VIDEO_CHROMA_SITE_COSITED = SPA_VIDEO_CHROMA_SITE_H_COSITED or SPA_VIDEO_CHROMA_SITE_V_COSITED;
+  SPA_VIDEO_CHROMA_SITE_JPEG = SPA_VIDEO_CHROMA_SITE_NONE;
+  SPA_VIDEO_CHROMA_SITE_MPEG2 = SPA_VIDEO_CHROMA_SITE_H_COSITED;
+  SPA_VIDEO_CHROMA_SITE_DV = SPA_VIDEO_CHROMA_SITE_COSITED or SPA_VIDEO_CHROMA_SITE_ALT_LINE;
+
+type
+    Tspa_video_color_range =  Longint;
+    Const
+      SPA_VIDEO_COLOR_RANGE_UNKNOWN = 0;
+      SPA_VIDEO_COLOR_RANGE_0_255 = 1;
+      SPA_VIDEO_COLOR_RANGE_16_235 = 2;
+
+  {*
+   * The color matrix is used to convert between Y'PbPr and
+   * non-linear RGB (R'G'B')
+    }
+  {*< unknown matrix  }
+  {*< identity matrix  }
+  {*< FCC color matrix  }
+  {*< ITU BT.709 color matrix  }
+  {*< ITU BT.601 color matrix  }
+  {*< SMTPE  240M color matrix  }
+  {*<  ITU-R BT.2020 color matrix. since 1.6.  }
+
+  type
+    Tspa_video_color_matrix =  Longint;
+    Const
+      SPA_VIDEO_COLOR_MATRIX_UNKNOWN = 0;
+      SPA_VIDEO_COLOR_MATRIX_RGB = 1;
+      SPA_VIDEO_COLOR_MATRIX_FCC = 2;
+      SPA_VIDEO_COLOR_MATRIX_BT709 = 3;
+      SPA_VIDEO_COLOR_MATRIX_BT601 = 4;
+      SPA_VIDEO_COLOR_MATRIX_SMPTE240M = 5;
+      SPA_VIDEO_COLOR_MATRIX_BT2020 = 6;
+
+  {*
+   * The video transfer function defines the formula for converting between
+   * non-linear RGB (R'G'B') and linear RGB
+    }
+  {*< unknown transfer function  }
+  {*< linear RGB, gamma 1.0 curve  }
+  {*< Gamma 1.8 curve  }
+  {*< Gamma 2.0 curve  }
+  {*< Gamma 2.2 curve  }
+  {*< Gamma 2.2 curve with a linear segment in the lower range  }
+  {*< Gamma 2.2 curve with a linear segment in the lower range  }
+  {*< Gamma 2.4 curve with a linear segment in the lower range  }
+  {*< Gamma 2.8 curve  }
+  {*< Logarithmic transfer characteristic 100:1 range  }
+  {*< Logarithmic transfer characteristic 316.22777:1 range  }
+  {*< Gamma 2.2 curve with a linear segment in the lower
+  					 *   range. Used for BT.2020 with 12 bits per
+  					 *   component. \since 1.6.  }
+  {*< Gamma 2.19921875. \since 1.8  }
+
+  type
+    Tspa_video_transfer_function =  Longint;
+    Const
+      SPA_VIDEO_TRANSFER_UNKNOWN = 0;
+      SPA_VIDEO_TRANSFER_GAMMA10 = 1;
+      SPA_VIDEO_TRANSFER_GAMMA18 = 2;
+      SPA_VIDEO_TRANSFER_GAMMA20 = 3;
+      SPA_VIDEO_TRANSFER_GAMMA22 = 4;
+      SPA_VIDEO_TRANSFER_BT709 = 5;
+      SPA_VIDEO_TRANSFER_SMPTE240M = 6;
+      SPA_VIDEO_TRANSFER_SRGB = 7;
+      SPA_VIDEO_TRANSFER_GAMMA28 = 8;
+      SPA_VIDEO_TRANSFER_LOG100 = 9;
+      SPA_VIDEO_TRANSFER_LOG316 = 10;
+      SPA_VIDEO_TRANSFER_BT2020_12 = 11;
+      SPA_VIDEO_TRANSFER_ADOBERGB = 12;
+
+  {*
+   * The color primaries define the how to transform linear RGB values to and from
+   * the CIE XYZ colorspace.
+    }
+  {*< unknown color primaries  }
+  {*< BT709 primaries  }
+  {*< BT470M primaries  }
+  {*< BT470BG primaries  }
+  {*< SMPTE170M primaries  }
+  {*< SMPTE240M primaries  }
+  {*< Generic film  }
+  {*< BT2020 primaries. \since 1.6.  }
+  {*< Adobe RGB primaries. \since 1.8  }
+
+type
+  Tspa_video_color_primaries =  Longint;
+Const
+  SPA_VIDEO_COLOR_PRIMARIES_UNKNOWN = 0;
+  SPA_VIDEO_COLOR_PRIMARIES_BT709 = 1;
+  SPA_VIDEO_COLOR_PRIMARIES_BT470M = 2;
+  SPA_VIDEO_COLOR_PRIMARIES_BT470BG = 3;
+  SPA_VIDEO_COLOR_PRIMARIES_SMPTE170M = 4;
+  SPA_VIDEO_COLOR_PRIMARIES_SMPTE240M = 5;
+  SPA_VIDEO_COLOR_PRIMARIES_FILM = 6;
+  SPA_VIDEO_COLOR_PRIMARIES_BT2020 = 7;
+  SPA_VIDEO_COLOR_PRIMARIES_ADOBERGB = 8;
+
+type
+  Tspa_video_colorimetry = record
+    range : Tspa_video_color_range;
+    matrix : Tspa_video_color_matrix;
+    transfer : Tspa_video_transfer_function;
+    primaries : Tspa_video_color_primaries;
+  end;
+  Pspa_video_colorimetry = ^Tspa_video_colorimetry;
+
+
+  Tspa_video_info_raw = record
+    format : Tspa_video_format;
+    modifier : Tint64_t;
+    size : Tspa_rectangle;
+    framerate : Tspa_fraction;
+    max_framerate : Tspa_fraction;
+    views : Tuint32_t;
+    interlace_mode : Tspa_video_interlace_mode;
+    pixel_aspect_ratio : Tspa_fraction;
+    multiview_mode : Tspa_video_multiview_mode;
+    multiview_flags : Tspa_video_multiview_flags;
+    chroma_site : Tspa_video_chroma_site;
+    color_range : Tspa_video_color_range;
+    color_matrix : Tspa_video_color_matrix;
+    transfer_function : Tspa_video_transfer_function;
+    color_primaries : Tspa_video_color_primaries;
+  end;
+  Pspa_video_info_raw = ^tspa_video_info_raw;
+
+  Tspa_video_info_dsp = record
+    format : Tspa_video_format;
+    modifier : Tint64_t;
+  end;
+  Pspa_video_info_dsp = ^Tspa_video_info_dsp;
+
+  Pspa_pod_frame = ^Tspa_pod_frame;
+  Tspa_pod_frame = record
+          pod : Tspa_pod ;
+          parent : Pspa_pod_frame;
+          offset : tuint32_t ;
+          flags : tuint32_t ;
+  end;
+
+
+  Tspa_pod_parser_state = record
+    offset : Tuint32_t;
+    flags : Tuint32_t;
+    frame : ^Tspa_pod_frame;
+  end;
+
+  Tspa_pod_parser = record
+    data : pointer;
+    size : Tuint32_t;
+    _padding : Tuint32_t;
+    state : Tspa_pod_parser_state;
+  end;
+  PTspa_pod_parser = ^Tspa_pod_parser;
+  Pspa_pod_parser = ^Tspa_pod_parser;
+
+  Pspa_graph_node  = ^Tspa_graph_node;
+  PTspa_graph_node = Pspa_graph_node;
+
+  Tspa_graph_link = record
+      {undefined structure}
+  end;
+  Pspa_graph_link = ^Tspa_graph_link;
+
+  Tspa_graph_state = record
+    status : longint;
+    required : Tint32_t;
+    pending : Tint32_t;
+  end;
+  Pspa_graph_state = ^Tspa_graph_state;
+
+  Tspa_graph = record
+    flags : Tuint32_t;
+    parent : pspa_graph_node;
+    state : pspa_graph_state;
+    nodes : Tspa_list;
+  end;
+  Pspa_graph = ^Tspa_graph;
+
+  Tspa_graph_node_callbacks = record
+    version : Tuint32_t;
+    process : function (data:pointer; node:PTspa_graph_node):longint;cdecl;
+    reuse_buffer : function (data:pointer; node:PTspa_graph_node; port_id:Tuint32_t; buffer_id:Tuint32_t):longint;cdecl;
+  end;
+  Pspa_graph_node_callbacks = ^Tspa_graph_node_callbacks;
+
+  Tspa_graph_node = record
+    link : Tspa_list;
+    graph : ^Tspa_graph;
+    ports : array[0..1] of Tspa_list;
+    links : Tspa_list;
+    flags : Tuint32_t;
+    state : ^Tspa_graph_state;
+    graph_link : Tspa_graph_link;
+    subgraph : ^Tspa_graph;
+    callbacks : Tspa_callbacks;
+    sched_link : Tspa_list;
+  end;
+
+  Tspa_graph_port = record
+    link : Tspa_list;
+    node : ^Tspa_graph_node;
+    direction : Tspa_direction;
+    port_id : Tuint32_t;
+    flags : Tuint32_t;
+    peer : ^Tspa_graph_port;
+  end;
+  Pspa_graph_port = ^Tspa_graph_port;
+
+  Tspa_pod_builder_state = record
+    offset : Tuint32_t;
+    flags : Tuint32_t;
+    frame : ^Tspa_pod_frame;
+  end;
+  Pspa_pod_builder_state  = ^Tspa_pod_builder_state ;
+
+  Tspa_pod_builder_callbacks = record
+    version : Tuint32_t;
+    overflow : function (data:pointer; size:Tuint32_t):longint;cdecl;
+  end;
+  Pspa_pod_builder_callbacks = ^Tspa_pod_builder_callbacks;
+
+  Tspa_pod_builder = record
+    data : pointer;
+    size : Tuint32_t;
+    _padding : Tuint32_t;
+    state : Tspa_pod_builder_state;
+    callbacks : Tspa_callbacks;
+  end;
+  Pspa_pod_builder = ^Tspa_pod_builder;
+
+  Tspa_pod_dynamic_builder = record
+    b : Tspa_pod_builder;
+    data : pointer;
+    extend : Tuint32_t;
+    _padding : Tuint32_t;
+  end;
+  pspa_pod_dynamic_builder = ^tspa_pod_dynamic_builder;
+
+  Pspa_json = ^Tspa_json;
+  Tspa_json = record
+      cur : pchar;
+      end_ : pchar;
+      parent : Pspa_json;
+      state : Tuint32_t;
+      depth : Tuint32_t;
+    end;
+
+type
+  Tspa_media_type =  Longint;
+Const
+  SPA_MEDIA_TYPE_unknown = 0;
+  SPA_MEDIA_TYPE_audio = 1;
+  SPA_MEDIA_TYPE_video = 2;
+  SPA_MEDIA_TYPE_image = 3;
+  SPA_MEDIA_TYPE_binary = 4;
+  SPA_MEDIA_TYPE_stream = 5;
+  SPA_MEDIA_TYPE_application = 6;
+
+type
+  Tspa_media_subtype =  Longint;
+Const
+  SPA_MEDIA_SUBTYPE_unknown = 0;
+  SPA_MEDIA_SUBTYPE_raw = 1;
+  SPA_MEDIA_SUBTYPE_dsp = 2;
+  SPA_MEDIA_SUBTYPE_iec958 = 3;
+  SPA_MEDIA_SUBTYPE_dsd = 4;
+  SPA_MEDIA_SUBTYPE_START_Audio = $10000;
+  SPA_MEDIA_SUBTYPE_mp3 = 65537;
+  SPA_MEDIA_SUBTYPE_aac = 65538;
+  SPA_MEDIA_SUBTYPE_vorbis = 65539;
+  SPA_MEDIA_SUBTYPE_wma = 65540;
+  SPA_MEDIA_SUBTYPE_ra = 65541;
+  SPA_MEDIA_SUBTYPE_sbc = 65542;
+  SPA_MEDIA_SUBTYPE_adpcm = 65543;
+  SPA_MEDIA_SUBTYPE_g723 = 65544;
+  SPA_MEDIA_SUBTYPE_g726 = 65545;
+  SPA_MEDIA_SUBTYPE_g729 = 65546;
+  SPA_MEDIA_SUBTYPE_amr = 65547;
+  SPA_MEDIA_SUBTYPE_gsm = 65548;
+  SPA_MEDIA_SUBTYPE_START_Video = $20000;
+  SPA_MEDIA_SUBTYPE_h264 = 131073;
+  SPA_MEDIA_SUBTYPE_mjpg = 131074;
+  SPA_MEDIA_SUBTYPE_dv = 131075;
+  SPA_MEDIA_SUBTYPE_mpegts = 131076;
+  SPA_MEDIA_SUBTYPE_h263 = 131077;
+  SPA_MEDIA_SUBTYPE_mpeg1 = 131078;
+  SPA_MEDIA_SUBTYPE_mpeg2 = 131079;
+  SPA_MEDIA_SUBTYPE_mpeg4 = 131080;
+  SPA_MEDIA_SUBTYPE_xvid = 131081;
+  SPA_MEDIA_SUBTYPE_vc1 = 131082;
+  SPA_MEDIA_SUBTYPE_vp8 = 131083;
+  SPA_MEDIA_SUBTYPE_vp9 = 131084;
+  SPA_MEDIA_SUBTYPE_bayer = 131085;
+  SPA_MEDIA_SUBTYPE_START_Image = $30000;
+  SPA_MEDIA_SUBTYPE_jpeg = 196609;
+  SPA_MEDIA_SUBTYPE_START_Binary = $40000;
+  SPA_MEDIA_SUBTYPE_START_Stream = $50000;
+  SPA_MEDIA_SUBTYPE_midi = 327681;
+  SPA_MEDIA_SUBTYPE_START_Application = $60000;
+  SPA_MEDIA_SUBTYPE_control = 393217;
+
+type
+  Tspa_format =  Longint;
+Const
+  SPA_FORMAT_START = 0;
+  SPA_FORMAT_mediaType = 1;
+  SPA_FORMAT_mediaSubtype = 2;
+  SPA_FORMAT_START_Audio = $10000;
+  SPA_FORMAT_AUDIO_format = 65537;
+  SPA_FORMAT_AUDIO_flags = 65538;
+  SPA_FORMAT_AUDIO_rate = 65539;
+  SPA_FORMAT_AUDIO_channels = 65540;
+  SPA_FORMAT_AUDIO_position = 65541;
+  SPA_FORMAT_AUDIO_iec958Codec = 65542;
+  SPA_FORMAT_AUDIO_bitorder = 65543;
+  SPA_FORMAT_AUDIO_interleave = 65544;
+  SPA_FORMAT_START_Video = $20000;
+  SPA_FORMAT_VIDEO_format = 131073;
+  SPA_FORMAT_VIDEO_modifier = 131074;
+  SPA_FORMAT_VIDEO_size = 131075;
+  SPA_FORMAT_VIDEO_framerate = 131076;
+  SPA_FORMAT_VIDEO_maxFramerate = 131077;
+  SPA_FORMAT_VIDEO_views = 131078;
+  SPA_FORMAT_VIDEO_interlaceMode = 131079;
+  SPA_FORMAT_VIDEO_pixelAspectRatio = 131080;
+  SPA_FORMAT_VIDEO_multiviewMode = 131081;
+  SPA_FORMAT_VIDEO_multiviewFlags = 131082;
+  SPA_FORMAT_VIDEO_chromaSite = 131083;
+  SPA_FORMAT_VIDEO_colorRange = 131084;
+  SPA_FORMAT_VIDEO_colorMatrix = 131085;
+  SPA_FORMAT_VIDEO_transferFunction = 131086;
+  SPA_FORMAT_VIDEO_colorPrimaries = 131087;
+  SPA_FORMAT_VIDEO_profile = 131088;
+  SPA_FORMAT_VIDEO_level = 131089;
+  SPA_FORMAT_VIDEO_H264_streamFormat = 131090;
+  SPA_FORMAT_VIDEO_H264_alignment = 131091;
+  SPA_FORMAT_START_Image = $30000;
+  SPA_FORMAT_START_Binary = $40000;
+  SPA_FORMAT_START_Stream = $50000;
+  SPA_FORMAT_START_Application = $60000;
+
+  SPA_KEY_FORMAT_DSP = 'format.dsp';
+
+const
+  SPA_POD_PROP_FLAG_READONLY = 1 shl 0;
+  SPA_POD_PROP_FLAG_HARDWARE = 1 shl 1;
+  SPA_POD_PROP_FLAG_HINT_DICT = 1 shl 2;
+  SPA_POD_PROP_FLAG_MANDATORY = 1 shl 3;
+  SPA_POD_PROP_FLAG_DONT_FIXATE = 1 shl 4;
+
+{$i spabridge.inc}
+
+Function spa_meta_cursor_is_valid(m : Pspa_meta_cursor) : boolean;
+
+
+implementation
+
+  function spa_handle_factory_enum(factory:PPTspa_handle_factory; index:PTuint32_t):longint;
+  begin
+    Result:=0;
+  end;
+
+Function spa_meta_cursor_is_valid(m : Pspa_meta_cursor) : boolean;
+
+begin
+  Result:=(m^.id <> 0);
+end;
+
+end.

packages/libpipewire/src/link.inc

@@ -0,0 +1,59 @@
+
+type
+  Ppw_link = ^Tpw_link;
+  Ppw_link_events = ^Tpw_link_events;
+  Ppw_link_info = ^Tpw_link_info;
+  Ppw_link_methods = ^Tpw_link_methods;
+  Ppw_link_state = ^Tpw_link_state;
+
+  Tpw_link = record
+    {undefined structure}
+  end;
+
+  Tpw_link_state = (
+    PW_LINK_STATE_ERROR := -(2),
+    PW_LINK_STATE_UNLINKED := -(1),
+    PW_LINK_STATE_INIT := 0,
+    PW_LINK_STATE_NEGOTIATING := 1,
+    PW_LINK_STATE_ALLOCATING := 2,
+    PW_LINK_STATE_PAUSED := 3,
+    PW_LINK_STATE_ACTIVE := 4);
+
+
+
+
+  Tpw_link_info = record
+    id: Tuint32_t;
+    output_node_id: Tuint32_t;
+    output_port_id: Tuint32_t;
+    input_node_id: Tuint32_t;
+    input_port_id: Tuint32_t;
+    change_mask: Tuint64_t;
+    state: Tpw_link_state;
+    error: PChar;
+    format: Pspa_pod;
+    props: Pspa_dict;
+  end;
+
+  Tpw_link_events = record
+    version: Tuint32_t;
+    info: procedure(object_: pointer; info: Ppw_link_info); cdecl;
+  end;
+
+  Tpw_link_methods = record
+    version: Tuint32_t;
+    add_listener: function(object_: pointer; listener: Pspa_hook; events: Ppw_link_events; Data: pointer) : longint; cdecl;
+  end;
+
+
+
+function pw_link_state_as_string(state: Tpw_link_state) : PChar; cdecl; external libpipewirename Name 'pw_link_state_as_string';
+
+function pw_link_info_update(info: Ppw_link_info; update: Ppw_link_info) : Ppw_link_info; cdecl; external libpipewirename Name 'pw_link_info_update';
+
+function pw_link_info_merge(info: Ppw_link_info; update: Ppw_link_info; reset: T_Bool) : Ppw_link_info; cdecl; external libpipewirename Name 'pw_link_info_merge';
+
+procedure pw_link_info_free(info: Ppw_link_info); cdecl; external libpipewirename Name 'pw_link_info_free';
+
+
+

packages/libpipewire/src/log.inc

@@ -0,0 +1,26 @@
+
+var
+  pw_log_level: Tspa_log_level; cvar;external;
+  PW_LOG_TOPIC_DEFAULT: Pspa_log_topic; cvar;external;
+
+procedure pw_log_set(log: Pspa_log); cdecl; external libpipewirename Name 'pw_log_set';
+
+function pw_log_get : Pspa_log; cdecl; external libpipewirename Name 'pw_log_get';
+
+procedure pw_log_set_level(level: Tspa_log_level); cdecl; external libpipewirename Name 'pw_log_set_level';
+
+procedure pw_log_logt(level: Tspa_log_level; topic: Pspa_log_topic; file_: PChar; line: longint; func: PChar; fmt: PChar; args: array of const); cdecl; external libpipewirename Name 'pw_log_logt';
+
+procedure pw_log_logt(level: Tspa_log_level; topic: Pspa_log_topic; file_: PChar; line: longint; func: PChar; fmt: PChar); cdecl; external libpipewirename Name 'pw_log_logt';
+
+procedure pw_log_logtv(level: Tspa_log_level; topic: Pspa_log_topic; file_: PChar; line: longint; func: PChar; fmt: PChar; args: pointer); cdecl; external libpipewirename Name 'pw_log_logtv';
+
+procedure pw_log_log(level: Tspa_log_level; file_: PChar; line: longint; func: PChar; fmt: PChar; args: array of const); cdecl; external libpipewirename Name 'pw_log_log';
+
+procedure pw_log_log(level: Tspa_log_level; file_: PChar; line: longint; func: PChar; fmt: PChar); cdecl; external libpipewirename Name 'pw_log_log';
+
+procedure pw_log_logv(level: Tspa_log_level; file_: PChar; line: longint; func: PChar; fmt: PChar; args: pointer); cdecl; external libpipewirename Name 'pw_log_logv';
+
+procedure _pw_log_topic_new(topic: Pspa_log_topic); cdecl; external libpipewirename Name '_pw_log_topic_new';
+
+

packages/libpipewire/src/loop.inc

@@ -0,0 +1,64 @@
+
+type
+  Ppw_loop = ^Tpw_loop;
+
+  Tpw_loop = record
+    system: Pspa_system;
+    loop: Pspa_loop;
+    control: Pspa_loop_control;
+    utils: Pspa_loop_utils;
+  end;
+
+
+
+function pw_loop_new(props: Pspa_dict) : Ppw_loop; cdecl; external libpipewirename Name 'pw_loop_new';
+
+procedure pw_loop_destroy(loop: Ppw_loop); cdecl; external libpipewirename Name 'pw_loop_destroy';
+
+function pw_loop_signal_event(loop : Ppw_loop; aData : pspa_source) : cint;
+
+(*
+
+procedure pw_loop_add_source(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_add_source((l)->loop,__VA_ARGS__)
+procedure pw_loop_update_source(loop : Ppw_loop); varargs; cdecl;
+//spa_loop_update_source((l)->loop,__VA_ARGS__)
+procedure pw_loop_remove_source(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_remove_source((l)->loop,__VA_ARGS__)
+procedure pw_loop_invoke(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_invoke((l)->loop,__VA_ARGS__)
+procedure pw_loop_get_fd(l : ppw_loop); cdecl;
+// spa_loop_control_get_fd((l)->control)
+procedure pw_loop_add_hook(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_control_add_hook((l)->controloop : Ppw_loop,__VA_ARGS__)
+procedure pw_loop_enter(l : ppw_loop);cdecl;
+// 	spa_loop_control_enter((l)->control)
+procedure pw_loop_iterate(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_control_iterate((l)->controloop : Ppw_loop,__VA_ARGS__)
+procedure pw_loop_leave(l : Ppw_loop); cdecl;
+//		spa_loop_control_leave((l)->control)
+procedure pw_loop_add_io(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_utils_add_io((l)->utils,__VA_ARGS__)
+procedure pw_loop_update_io(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_utils_update_io((l)->utils,__VA_ARGS__)
+procedure pw_loop_add_idle(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_utils_add_idle((l)->utils,__VA_ARGS__)
+procedure pw_loop_enable_idle(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_utils_enable_idle((l)->utils,__VA_ARGS__)
+procedure pw_loop_add_event(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_utils_add_event((l)->utils,__VA_ARGS__)
+procedure pw_loop_signal_event(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_utils_signal_event((l)->utils,__VA_ARGS__)
+procedure pw_loop_add_timer(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_utils_add_timer((l)->utils,__VA_ARGS__)
+procedure pw_loop_update_timer(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_utils_update_timer((l)->utils,__VA_ARGS__)
+procedure pw_loop_add_signal(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_utils_add_signal((l)->utils,__VA_ARGS__)
+procedure pw_loop_destroy_source(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_utils_destroy_source((l)->utils,__VA_ARGS__
+
+*)
+
+function pw_loop_add_event(loop : Ppw_loop; aEvent : Tspa_source_event_func_t; aData : Pointer) : pspa_source;
+

packages/libpipewire/src/loop_impl.inc

@@ -0,0 +1,72 @@
+{%mainunit pipewire}
+(*
+
+procedure pw_loop_add_source(loop : Ppw_loop); varargs; cdecl;
+
+begin
+  spa_loop_add_source(loop^.loop); __VA_ARGS__)
+end;
+
+procedure pw_loop_update_source(loop : Ppw_loop); varargs; cdecl;
+//spa_loop_update_source((l)->loop,__VA_ARGS__)
+procedure pw_loop_remove_source(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_remove_source((l)->loop,__VA_ARGS__)
+procedure pw_loop_invoke(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_invoke((l)->loop,__VA_ARGS__)
+procedure pw_loop_get_fd(l)
+// spa_loop_control_get_fd((l)->control)
+procedure pw_loop_add_hook(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_control_add_hook((l)->controloop : Ppw_loop,__VA_ARGS__)
+procedure pw_loop_enter(l);
+// 	spa_loop_control_enter((l)->control)
+procedure pw_loop_iterate(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_control_iterate((l)->controloop : Ppw_loop,__VA_ARGS__)
+procedure pw_loop_leave(l);
+//		spa_loop_control_leave((l)->control)
+procedure pw_loop_add_io(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_utils_add_io((l)->utils,__VA_ARGS__)
+procedure pw_loop_update_io(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_utils_update_io((l)->utils,__VA_ARGS__)
+procedure pw_loop_add_idle(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_utils_add_idle((l)->utils,__VA_ARGS__)
+procedure pw_loop_enable_idle(loop : Ppw_loop); varargs;
+// cdecl;	spa_loop_utils_enable_idle((l)->utils,__VA_ARGS__)
+procedure pw_loop_add_event(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_utils_add_event((l)->utils,__VA_ARGS__)
+procedure pw_loop_signal_event(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_utils_signal_event((l)->utils,__VA_ARGS__)
+procedure pw_loop_add_timer(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_utils_add_timer((l)->utils,__VA_ARGS__)
+procedure pw_loop_update_timer(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_utils_update_timer((l)->utils,__VA_ARGS__)
+procedure pw_loop_add_signal(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_utils_add_signal((l)->utils,__VA_ARGS__)
+procedure pw_loop_destroy_source(loop : Ppw_loop); varargs; cdecl;
+// spa_loop_utils_destroy_source((l)->utils,__VA_ARGS__
+
+*)
+
+function pw_loop_signal_event(loop : ppw_loop; aData : pspa_source) : cint;
+
+var
+  _o : pspa_loop_utils;
+  _f : pspa_loop_utils_methods;
+
+begin
+  _o:=loop^.utils;
+  _f:=(_o^.iface.cb.funcs);
+  Result := _f^.signal_event(_o^.iface.cb.data,aData);
+end;
+
+function pw_loop_add_event(loop : Ppw_loop; aEvent : Tspa_source_event_func_t; aData : Pointer) : pspa_source;
+
+
+var
+  _o : pspa_loop_utils;
+  _f : pspa_loop_utils_methods;
+
+begin
+  _o:=loop^.utils;
+  _f:=(_o^.iface.cb.funcs);
+  Result := _f^.add_event(_o^.iface.cb.data,aEvent,aData);
+end;

packages/libpipewire/src/main_loop.inc

@@ -0,0 +1,26 @@
+
+
+  Type
+    Tpw_main_loop = record end;
+    Ppw_main_loop  = ^Tpw_main_loop;
+    Ppw_main_loop_events  = ^Tpw_main_loop_events;
+
+    Tpw_main_loop_events = record
+        version : Tuint32_t;
+        destroy : procedure (data:pointer);cdecl;
+      end;
+
+
+  function pw_main_loop_new(props:Pspa_dict):Ppw_main_loop;cdecl;external libpipewirename name 'pw_main_loop_new';
+
+  procedure pw_main_loop_add_listener(loop:Ppw_main_loop; listener:Pspa_hook; events:Ppw_main_loop_events; data:pointer);cdecl;external libpipewirename name 'pw_main_loop_add_listener';
+
+  function pw_main_loop_get_loop(loop:Ppw_main_loop):Ppw_loop;cdecl;external libpipewirename name 'pw_main_loop_get_loop';
+
+  procedure pw_main_loop_destroy(loop:Ppw_main_loop);cdecl;external libpipewirename name 'pw_main_loop_destroy';
+
+  function pw_main_loop_run(loop:Ppw_main_loop):longint;cdecl;external libpipewirename name 'pw_main_loop_run';
+
+  function pw_main_loop_quit(loop:Ppw_main_loop):longint;cdecl;external libpipewirename name 'pw_main_loop_quit';
+
+

packages/libpipewire/src/map.inc

@@ -0,0 +1,157 @@
+
+type
+  Ppw_map = ^Tpw_map;
+  Ppw_map_item = ^Tpw_map_item;
+
+  Tuintptr_t = Pointer;
+  Tpw_map_item = record
+    case longint of
+      0: (Next: Tuintptr_t);
+      1: (Data: pointer);
+  end;
+
+  Tpw_map = record
+    items: Tpw_array;
+    free_list: Tuint32_t;
+  end;
+
+  {
+  static inline void pw_map_init(struct pw_map *map, size_t size, size_t extend)
+  
+   pw_array_init(&map->items, extend * sizeof(union pw_map_item));
+   pw_array_ensure_size(&map->items, size * sizeof(union pw_map_item));
+   map->free_list = ((uint32_t)0xffffffff);
+  
+  
+  
+  
+  
+  static inline void pw_map_clear(struct pw_map *map)
+  
+   pw_array_clear(&map->items);
+  
+  
+  
+  
+  
+  static inline void pw_map_reset(struct pw_map *map)
+  
+   pw_array_reset(&map->items);
+   map->free_list = ((uint32_t)0xffffffff);
+  
+  
+  
+  
+  
+  
+  
+  
+  static inline uint32_t pw_map_insert_new(struct pw_map *map, void *data)
+  
+   union pw_map_item *start, *item;
+   uint32_t id;
+  
+   if (map->free_list != ((uint32_t)0xffffffff)) 
+    start = (union pw_map_item *) map->items.data;
+    item = &start[map->free_list >> 1];
+    map->free_list = item->next;
+    else 
+    item = (union pw_map_item *) pw_array_add(&map->items, sizeof(union pw_map_item));
+    if (item == 
+  # 157 "/usr/include/pipewire-0.3/pipewire/map.h" 3 4
+               ((void *)0)
+  # 157 "/usr/include/pipewire-0.3/pipewire/map.h"
+                   )
+     return ((uint32_t)0xffffffff);
+    start = (union pw_map_item *) map->items.data;
+   
+   item->data = data;
+   id = (item - start);
+   return id;
+  
+  # 173 "/usr/include/pipewire-0.3/pipewire/map.h"
+  static inline int pw_map_insert_at(struct pw_map *map, uint32_t id, void *data)
+  
+   size_t size = ((&(map)->items)->size / (sizeof(union pw_map_item)));
+   union pw_map_item *item;
+  
+   if (id > size)
+    return -
+  # 179 "/usr/include/pipewire-0.3/pipewire/map.h" 3 4
+           28
+  # 179 "/usr/include/pipewire-0.3/pipewire/map.h"
+                 ;
+   else if (id == size) 
+    item = (union pw_map_item *) pw_array_add(&map->items, sizeof(union pw_map_item));
+    if (item == 
+  # 182 "/usr/include/pipewire-0.3/pipewire/map.h" 3 4
+               ((void *)0)
+  # 182 "/usr/include/pipewire-0.3/pipewire/map.h"
+                   )
+     return -
+  # 183 "/usr/include/pipewire-0.3/pipewire/map.h" 3 4
+            (*__errno_location ())
+  # 183 "/usr/include/pipewire-0.3/pipewire/map.h"
+                 ;
+    else 
+    item = ((union pw_map_item*)((uintptr_t)((&(map)->items)->data) + (ptrdiff_t)((id)*(sizeof(union pw_map_item)))));
+    if (((item)->next & 0x1))
+     return -
+  # 187 "/usr/include/pipewire-0.3/pipewire/map.h" 3 4
+            22
+  # 187 "/usr/include/pipewire-0.3/pipewire/map.h"
+                  ;
+   
+   item->data = data;
+   return 0;
+  
+  
+  
+  
+  
+  
+  
+  static inline void pw_map_remove(struct pw_map *map, uint32_t id)
+  
+   if ((((((union pw_map_item*)((uintptr_t)((&(map)->items)->data) + (ptrdiff_t)((id)*(sizeof(union pw_map_item))))))->next & 0x1)))
+    return;
+  
+   ((union pw_map_item*)((uintptr_t)((&(map)->items)->data) + (ptrdiff_t)((id)*(sizeof(union pw_map_item)))))->next = map->free_list;
+   map->free_list = (id << 1) | 1;
+  
+  
+  
+  
+  
+  
+  
+  static inline void *pw_map_lookup(struct pw_map *map, uint32_t id)
+  
+   if ((__builtin_expect(!!(((id) < ((&(map)->items)->size / (sizeof(union pw_map_item))))),1))) 
+    union pw_map_item *item = ((union pw_map_item*)((uintptr_t)((&(map)->items)->data) + (ptrdiff_t)((id)*(sizeof(union pw_map_item)))));
+    if (!((item)->next & 0x1))
+     return item->data;
+   
+   return 
+  # 219 "/usr/include/pipewire-0.3/pipewire/map.h" 3 4
+         ((void *)0)
+  # 219 "/usr/include/pipewire-0.3/pipewire/map.h"
+             ;
+  
+  # 230 "/usr/include/pipewire-0.3/pipewire/map.h"
+  static inline int pw_map_for_each(struct pw_map *map,
+         int (*func) (void *item_data, void *data), void *data)
+  
+   union pw_map_item *item;
+   int res = 0;
+  
+   for (item = (__typeof__(item)) ((&map->items)->data); (((void*)((uintptr_t)(item) + (ptrdiff_t)(sizeof(*item)))) <= ((void*)((uintptr_t)((&map->items)->data) + (ptrdiff_t)((&map->items)->size)))); (item)++) 
+    if (!((item)->next & 0x1))
+     if ((res = func(item->data, data)) != 0)
+      break;
+   
+   return res;
+  
+  
+   }
+

packages/libpipewire/src/mem.inc

@@ -0,0 +1,131 @@
+
+type
+  Ppw_map_range = ^Tpw_map_range;
+  Ppw_memblock = ^Tpw_memblock;
+  Ppw_memblock_flags = ^Tpw_memblock_flags;
+  Ppw_memchunk = ^Tpw_memchunk;
+  Ppw_memmap = ^Tpw_memmap;
+  Ppw_memmap_flags = ^Tpw_memmap_flags;
+  Ppw_mempool = ^Tpw_mempool;
+  Ppw_mempool_events = ^Tpw_mempool_events;
+
+  Tpw_memblock_flags = (
+    PW_MEMBLOCK_FLAG_NONE := 0,
+    PW_MEMBLOCK_FLAG_READABLE := 1 shl 0,
+    PW_MEMBLOCK_FLAG_WRITABLE := 1 shl 1,
+    PW_MEMBLOCK_FLAG_SEAL := 1 shl 2,
+    PW_MEMBLOCK_FLAG_MAP := 1 shl 3,
+    PW_MEMBLOCK_FLAG_DONT_CLOSE := 1 shl 4,
+    PW_MEMBLOCK_FLAG_DONT_NOTIFY := 1 shl 5,
+    PW_MEMBLOCK_FLAG_READWRITE := Ord(PW_MEMBLOCK_FLAG_READABLE) or Ord(PW_MEMBLOCK_FLAG_WRITABLE)
+    );
+
+  Tpw_memmap_flags = (
+    PW_MEMMAP_FLAG_NONE := 0,
+    PW_MEMMAP_FLAG_READ := 1 shl 0,
+    PW_MEMMAP_FLAG_WRITE := 1 shl 1,
+    PW_MEMMAP_FLAG_TWICE := 1 shl 2,
+    PW_MEMMAP_FLAG_PRIVATE := 1 shl 3,
+    PW_MEMMAP_FLAG_LOCKED := 1 shl 4,
+    PW_MEMMAP_FLAG_READWRITE := Ord(PW_MEMMAP_FLAG_READ) or Ord(PW_MEMMAP_FLAG_WRITE)
+    );
+
+  Tpw_memchunk = record
+    {undefined structure}
+  end;
+
+  Tpw_mempool = record
+    props: Ppw_properties;
+  end;
+
+  Tpw_memblock = record
+    pool: Ppw_mempool;
+    id: Tuint32_t;
+    ref: longint;
+    flags: Tuint32_t;
+    _type: Tuint32_t;
+    fd: longint;
+    size: Tuint32_t;
+    map: Ppw_memmap;
+  end;
+
+  Tpw_memmap = record
+    block: Ppw_memblock;
+    ptr: pointer;
+    flags: Tuint32_t;
+    offset: Tuint32_t;
+    size: Tuint32_t;
+    tag: array[0..4] of Tuint32_t;
+  end;
+
+  Tpw_mempool_events = record
+    version: Tuint32_t;
+    Destroy: procedure(Data: pointer); cdecl;
+    added: procedure(Data: pointer; block: Ppw_memblock); cdecl;
+    removed: procedure(Data: pointer; block: Ppw_memblock); cdecl;
+  end;
+
+  Tpw_map_range = record
+    start: Tuint32_t;
+    offset: Tuint32_t;
+    size: Tuint32_t;
+  end;
+
+
+  tpw_memblock_maptagarray = array[0..4] of Tuint32_t;
+
+function pw_mempool_new(props: Ppw_properties) : Ppw_mempool; cdecl; external libpipewirename Name 'pw_mempool_new';
+
+procedure pw_mempool_add_listener(pool: Ppw_mempool; listener: Pspa_hook; events: Ppw_mempool_events; Data: pointer); cdecl; external libpipewirename Name 'pw_mempool_add_listener';
+
+procedure pw_mempool_clear(pool: Ppw_mempool); cdecl; external libpipewirename Name 'pw_mempool_clear';
+
+procedure pw_mempool_destroy(pool: Ppw_mempool); cdecl; external libpipewirename Name 'pw_mempool_destroy';
+
+function pw_mempool_alloc(pool: Ppw_mempool; flags: Tpw_memblock_flags; _type: Tuint32_t; size: Tsize_t) : Ppw_memblock; cdecl; external libpipewirename Name 'pw_mempool_alloc';
+
+function pw_mempool_import_block(pool: Ppw_mempool; mem: Ppw_memblock) : Ppw_memblock; cdecl; external libpipewirename Name 'pw_mempool_import_block';
+
+function pw_mempool_import(pool: Ppw_mempool; flags: Tpw_memblock_flags; _type: Tuint32_t; fd: longint) : Ppw_memblock; cdecl; external libpipewirename Name 'pw_mempool_import';
+
+procedure pw_memblock_free(mem: Ppw_memblock); cdecl; external libpipewirename Name 'pw_memblock_free';
+
+  {
+  static inline void pw_memblock_unref(struct pw_memblock *mem)
+  
+   if (--mem->ref == 0)
+    pw_memblock_free(mem);
+  
+   }
+function pw_mempool_remove_id(pool: Ppw_mempool; id: Tuint32_t) : longint; cdecl; external libpipewirename Name 'pw_mempool_remove_id';
+
+function pw_mempool_find_ptr(pool: Ppw_mempool; ptr: pointer) : Ppw_memblock; cdecl; external libpipewirename Name 'pw_mempool_find_ptr';
+
+function pw_mempool_find_id(pool: Ppw_mempool; id: Tuint32_t) : Ppw_memblock; cdecl; external libpipewirename Name 'pw_mempool_find_id';
+
+function pw_mempool_find_fd(pool: Ppw_mempool; fd: longint) : Ppw_memblock; cdecl; external libpipewirename Name 'pw_mempool_find_fd';
+function pw_memblock_map(block: Ppw_memblock; flags: Tpw_memmap_flags; offset: Tuint32_t; size: Tuint32_t; tag: tpw_memblock_maptagarray) : Ppw_memmap; cdecl; external libpipewirename Name 'pw_memblock_map';
+
+function pw_mempool_map_id(pool: Ppw_mempool; id: Tuint32_t; flags: Tpw_memmap_flags; offset: Tuint32_t; size: Tuint32_t; tag: tpw_memblock_maptagarray) : Ppw_memmap;
+  cdecl; external libpipewirename Name 'pw_mempool_map_id';
+
+function pw_mempool_import_map(pool: Ppw_mempool; other: Ppw_mempool; Data: pointer; size: Tuint32_t; tag: tpw_memblock_maptagarray) : Ppw_memmap; cdecl; external libpipewirename Name 'pw_mempool_import_map';
+
+function pw_mempool_find_tag(pool: Ppw_mempool; tag: tpw_memblock_maptagarray; size: Tsize_t) : Ppw_memmap; cdecl; external libpipewirename Name 'pw_mempool_find_tag';
+
+function pw_memmap_free(map: Ppw_memmap) : longint; cdecl; external libpipewirename Name 'pw_memmap_free';
+
+
+  {
+  
+  static inline void pw_map_range_init(struct pw_map_range *range,
+           uint32_t offset, uint32_t size,
+           uint32_t page_size)
+  
+   range->offset = ((offset) & ~((page_size) - 1));
+   range->start = offset - range->offset;
+   range->size = (((range->start + size) + ((page_size) - 1)) & ~((page_size) - 1));
+  
+  
+   }
+

packages/libpipewire/src/module.inc

@@ -0,0 +1,40 @@
+
+
+Type
+  Ppw_module  = ^Tpw_module;
+  Ppw_module_events  = ^Tpw_module_events;
+  Ppw_module_info  = ^Tpw_module_info;
+  Ppw_module_methods  = ^Tpw_module_methods;
+
+  Tpw_module = record
+    {undefined structure}
+  end;
+
+  Tpw_module_info = record
+    id : Tuint32_t;
+    name : Pchar;
+    filename : Pchar;
+    args : Pchar;
+    change_mask : Tuint64_t;
+    props : Pspa_dict;
+  end;
+
+  Tpw_module_events = record
+    version : Tuint32_t;
+    info : procedure (object_:pointer; info:Ppw_module_info);cdecl;
+  end;
+
+  Tpw_module_methods = record
+    version : Tuint32_t;
+    add_listener : function (object_:pointer; listener:Pspa_hook; events:Ppw_module_events; data:pointer):longint;cdecl;
+  end;
+
+
+function pw_module_info_update(info:Ppw_module_info; update:Ppw_module_info):Ppw_module_info;cdecl;external libpipewirename name 'pw_module_info_update';
+
+function pw_module_info_merge(info:Ppw_module_info; update:Ppw_module_info; reset:T_Bool):Ppw_module_info;cdecl;external libpipewirename name 'pw_module_info_merge';
+
+procedure pw_module_info_free(info:Ppw_module_info);cdecl;external libpipewirename name 'pw_module_info_free';
+
+
+

packages/libpipewire/src/node.inc

@@ -0,0 +1,61 @@
+
+type
+  Ppw_node = ^Tpw_node;
+  Ppw_node_events = ^Tpw_node_events;
+  Ppw_node_info = ^Tpw_node_info;
+  Ppw_node_methods = ^Tpw_node_methods;
+  Ppw_node_state = ^Tpw_node_state;
+
+  Tpw_node = record
+    {undefined structure}
+  end;
+
+  Tpw_node_state = (
+    PW_NODE_STATE_ERROR := -(1),
+    PW_NODE_STATE_CREATING := 0,
+    PW_NODE_STATE_SUSPENDED := 1,
+    PW_NODE_STATE_IDLE := 2,
+    PW_NODE_STATE_RUNNING := 3);
+
+
+
+
+  Tpw_node_info = record
+    id: Tuint32_t;
+    max_input_ports: Tuint32_t;
+    max_output_ports: Tuint32_t;
+    change_mask: Tuint64_t;
+    n_input_ports: Tuint32_t;
+    n_output_ports: Tuint32_t;
+    state: Tpw_node_state;
+    error: PChar;
+    props: Pspa_dict;
+    params: Pspa_param_info;
+    n_params: Tuint32_t;
+  end;
+
+  Tpw_node_events = record
+    version: Tuint32_t;
+    info: procedure(object_: pointer; info: Ppw_node_info); cdecl;
+    param: procedure(object_: pointer; seq: longint; id: Tuint32_t; index: Tuint32_t; Next: Tuint32_t; param: Pspa_pod); cdecl;
+  end;
+
+  Tpw_node_methods = record
+    version: Tuint32_t;
+    add_listener: function(object_: pointer; listener: Pspa_hook; events: Ppw_node_events; Data: pointer) : longint; cdecl;
+    subscribe_params: function(object_: pointer; ids: Puint32_t; n_ids: Tuint32_t) : longint; cdecl;
+    enum_params: function(object_: pointer; seq: longint; id: Tuint32_t; start: Tuint32_t; num: Tuint32_t; filter: Pspa_pod) : longint; cdecl;
+    set_param: function(object_: pointer; id: Tuint32_t; flags: Tuint32_t; param: Pspa_pod) : longint; cdecl;
+    send_command: function(object_: pointer; command: Pspa_command) : longint; cdecl;
+  end;
+
+
+
+function pw_node_state_as_string(state: Tpw_node_state) : PChar; cdecl; external libpipewirename Name 'pw_node_state_as_string';
+function pw_node_info_update(info: Ppw_node_info; update: Ppw_node_info) : Ppw_node_info; cdecl; external libpipewirename Name 'pw_node_info_update';
+
+function pw_node_info_merge(info: Ppw_node_info; update: Ppw_node_info; reset: T_Bool) : Ppw_node_info; cdecl; external libpipewirename Name 'pw_node_info_merge';
+
+procedure pw_node_info_free(info: Ppw_node_info); cdecl; external libpipewirename Name 'pw_node_info_free';
+
+

packages/libpipewire/src/permission.inc

@@ -0,0 +1,10 @@
+
+Type
+
+  Ppw_permission  = ^Tpw_permission;
+  Tpw_permission = record
+    id : Tuint32_t;
+    permissions : Tuint32_t;
+  end;
+
+

packages/libpipewire/src/port.inc

@@ -0,0 +1,48 @@
+
+const
+  PW_DIRECTION_INPUT = SPA_DIRECTION_INPUT;
+
+type
+  Ppw_port = ^Tpw_port;
+  Ppw_port_events = ^Tpw_port_events;
+  Ppw_port_info = ^Tpw_port_info;
+  Ppw_port_methods = ^Tpw_port_methods;
+
+  Tpw_port = record
+    {undefined structure}
+  end;
+
+
+  Tpw_port_info = record
+    id: Tuint32_t;
+    direction: Tspa_direction;
+    change_mask: Tuint64_t;
+    props: Pspa_dict;
+    params: Pspa_param_info;
+    n_params: Tuint32_t;
+  end;
+
+  Tpw_port_events = record
+    version: Tuint32_t;
+    info: procedure(object_: pointer; info: Ppw_port_info); cdecl;
+    param: procedure(object_: pointer; seq: longint; id: Tuint32_t; index: Tuint32_t; Next: Tuint32_t; param: Pspa_pod); cdecl;
+  end;
+
+  Tpw_port_methods = record
+    version: Tuint32_t;
+    add_listener: function(object_: pointer; listener: Pspa_hook; events: Ppw_port_events; Data: pointer) : longint; cdecl;
+    subscribe_params: function(object_: pointer; ids: Puint32_t; n_ids: Tuint32_t) : longint; cdecl;
+    enum_params: function(object_: pointer; seq: longint; id: Tuint32_t; start: Tuint32_t; num: Tuint32_t; filter: Pspa_pod) : longint; cdecl;
+  end;
+
+
+
+function pw_direction_as_string(direction: Tspa_direction) : PChar; cdecl; external libpipewirename Name 'pw_direction_as_string';
+
+function pw_port_info_update(info: Ppw_port_info; update: Ppw_port_info) : Ppw_port_info; cdecl; external libpipewirename Name 'pw_port_info_update';
+
+function pw_port_info_merge(info: Ppw_port_info; update: Ppw_port_info; reset: T_Bool) : Ppw_port_info; cdecl; external libpipewirename Name 'pw_port_info_merge';
+
+procedure pw_port_info_free(info: Ppw_port_info); cdecl; external libpipewirename Name 'pw_port_info_free';
+
+

packages/libpipewire/src/properties.inc

@@ -0,0 +1,150 @@
+
+type
+  Ppw_properties = ^Tpw_properties;
+
+  Tpw_properties = record
+    dict: Tspa_dict;
+    flags: Tuint32_t;
+  end;
+
+
+function pw_properties_new(key: PChar; args: array of const) : Ppw_properties; cdecl; external libpipewirename Name 'pw_properties_new';
+
+function pw_properties_new(key: PChar) : Ppw_properties; cdecl; external libpipewirename Name 'pw_properties_new';
+
+function pw_properties_new_dict(dict: Pspa_dict) : Ppw_properties; cdecl; external libpipewirename Name 'pw_properties_new_dict';
+
+function pw_properties_new_string(args: PChar) : Ppw_properties; cdecl; external libpipewirename Name 'pw_properties_new_string';
+
+function pw_properties_copy(properties: Ppw_properties) : Ppw_properties; cdecl; external libpipewirename Name 'pw_properties_copy';
+
+function pw_properties_update_keys(props: Ppw_properties; dict: Pspa_dict; keys: PPchar) : longint; cdecl; external libpipewirename Name 'pw_properties_update_keys';
+
+function pw_properties_update_ignore(props: Ppw_properties; dict: Pspa_dict; ignore: PPchar) : longint; cdecl; external libpipewirename Name 'pw_properties_update_ignore';
+
+function pw_properties_update(props: Ppw_properties; dict: Pspa_dict) : longint; cdecl; external libpipewirename Name 'pw_properties_update';
+
+function pw_properties_update_string(props: Ppw_properties; str: PChar; size: Tsize_t) : longint; cdecl; external libpipewirename Name 'pw_properties_update_string';
+
+function pw_properties_add(oldprops: Ppw_properties; dict: Pspa_dict) : longint; cdecl; external libpipewirename Name 'pw_properties_add';
+
+function pw_properties_add_keys(oldprops: Ppw_properties; dict: Pspa_dict; keys: PPchar) : longint; cdecl; external libpipewirename Name 'pw_properties_add_keys';
+
+procedure pw_properties_clear(properties: Ppw_properties); cdecl; external libpipewirename Name 'pw_properties_clear';
+
+procedure pw_properties_free(properties: Ppw_properties); cdecl; external libpipewirename Name 'pw_properties_free';
+
+function pw_properties_set(properties: Ppw_properties; key: PChar; Value: PChar) : longint; cdecl; external libpipewirename Name 'pw_properties_set';
+
+function pw_properties_setf(properties: Ppw_properties; key: PChar; format: PChar; args: array of const) : longint; cdecl; external libpipewirename Name 'pw_properties_setf';
+
+function pw_properties_setf(properties: Ppw_properties; key: PChar; format: PChar) : longint; cdecl; external libpipewirename Name 'pw_properties_setf';
+
+function pw_properties_setva(properties: Ppw_properties; key: PChar; format: PChar; args: pointer) : longint; cdecl; external libpipewirename Name 'pw_properties_setva';
+
+function pw_properties_get(properties: Ppw_properties; key: PChar) : PChar; cdecl; external libpipewirename Name 'pw_properties_get';
+
+function pw_properties_fetch_uint32(properties: Ppw_properties; key: PChar; Value: Puint32_t) : longint; cdecl; external libpipewirename Name 'pw_properties_fetch_uint32';
+
+function pw_properties_fetch_int32(properties: Ppw_properties; key: PChar; Value: Pint32_t) : longint; cdecl; external libpipewirename Name 'pw_properties_fetch_int32';
+
+function pw_properties_fetch_uint64(properties: Ppw_properties; key: PChar; Value: Puint64_t) : longint; cdecl; external libpipewirename Name 'pw_properties_fetch_uint64';
+
+function pw_properties_fetch_int64(properties: Ppw_properties; key: PChar; Value: Pint64_t) : longint; cdecl; external libpipewirename Name 'pw_properties_fetch_int64';
+
+function pw_properties_fetch_bool(properties: Ppw_properties; key: PChar; Value: P_Bool) : longint; cdecl; external libpipewirename Name 'pw_properties_fetch_bool';
+
+  {
+  
+  static inline uint32_t
+  pw_properties_get_uint32(const struct pw_properties *properties, const char *key, uint32_t deflt)
+  
+   uint32_t val = deflt;
+   pw_properties_fetch_uint32(properties, key, &val);
+   return val;
+  
+  
+  static inline int32_t
+  pw_properties_get_int32(const struct pw_properties *properties, const char *key, int32_t deflt)
+  
+   int32_t val = deflt;
+   pw_properties_fetch_int32(properties, key, &val);
+   return val;
+  
+  
+  static inline uint64_t
+  pw_properties_get_uint64(const struct pw_properties *properties, const char *key, uint64_t deflt)
+  
+   uint64_t val = deflt;
+   pw_properties_fetch_uint64(properties, key, &val);
+   return val;
+  
+  
+  static inline int64_t
+  pw_properties_get_int64(const struct pw_properties *properties, const char *key, int64_t deflt)
+  
+   int64_t val = deflt;
+   pw_properties_fetch_int64(properties, key, &val);
+   return val;
+  
+  
+  
+  static inline 
+  # 148 "/usr/include/pipewire-0.3/pipewire/properties.h" 3 4
+               _Bool
+  
+  # 149 "/usr/include/pipewire-0.3/pipewire/properties.h"
+  pw_properties_get_bool(const struct pw_properties *properties, const char *key, 
+  # 149 "/usr/include/pipewire-0.3/pipewire/properties.h" 3 4
+                                                                                 _Bool 
+  # 149 "/usr/include/pipewire-0.3/pipewire/properties.h"
+                                                                                      deflt)
+  
+   
+  # 151 "/usr/include/pipewire-0.3/pipewire/properties.h" 3 4
+  _Bool 
+  # 151 "/usr/include/pipewire-0.3/pipewire/properties.h"
+       val = deflt;
+   pw_properties_fetch_bool(properties, key, &val);
+   return val;
+  
+   }
+function pw_properties_iterate(properties: Ppw_properties; state: Ppointer) : PChar; cdecl; external libpipewirename Name 'pw_properties_iterate';
+
+function pw_properties_serialize_dict(f: pointer; dict: Pspa_dict; flags: Tuint32_t) : longint; cdecl; external libpipewirename Name 'pw_properties_serialize_dict';
+
+  {
+  static inline 
+  # 162 "/usr/include/pipewire-0.3/pipewire/properties.h" 3 4
+               _Bool 
+  # 162 "/usr/include/pipewire-0.3/pipewire/properties.h"
+                    pw_properties_parse_bool(const char *value) 
+   return spa_atob(value);
+  
+  
+  static inline int pw_properties_parse_int(const char *value) 
+   int v;
+   return spa_atoi32(value, &v, 0) ? v: 0;
+  
+  
+  static inline int64_t pw_properties_parse_int64(const char *value) 
+   int64_t v;
+   return spa_atoi64(value, &v, 0) ? v : 0;
+  
+  
+  static inline uint64_t pw_properties_parse_uint64(const char *value) 
+   uint64_t v;
+   return spa_atou64(value, &v, 0) ? v : 0;
+  
+  
+  static inline float pw_properties_parse_float(const char *value) 
+   float v;
+   return spa_atof(value, &v) ? v : 0.0f;
+  
+  
+  static inline double pw_properties_parse_double(const char *value) 
+   double v;
+   return spa_atod(value, &v) ? v : 0.0;
+  
+   }
+

packages/libpipewire/src/protocol.inc

@@ -0,0 +1,80 @@
+
+type
+  Tpw_impl_core = record
+  end;
+
+  Ppw_impl_core = ^Tpw_impl_core;
+  Ppw_protocol = ^Tpw_protocol;
+  Ppw_protocol_client = ^Tpw_protocol_client;
+  Ppw_protocol_events = ^Tpw_protocol_events;
+  Ppw_protocol_implementation = ^Tpw_protocol_implementation;
+  Ppw_protocol_marshal = ^Tpw_protocol_marshal;
+  Ppw_protocol_server = ^Tpw_protocol_server;
+
+  Tpw_protocol_clientconnectdonecallback = procedure(Data: pointer; Result: longint); cdecl;
+
+  Tpw_protocol_client = record
+    link: Tspa_list;
+    protocol: Ppw_protocol;
+    core: Ppw_core;
+    connect: function(client: Ppw_protocol_client; props: Pspa_dict; done_callback: Tpw_protocol_clientconnectdonecallback; Data: pointer) : longint; cdecl;
+    connect_fd: function(client: Ppw_protocol_client; fd: longint; Close: T_Bool) : longint; cdecl;
+    steal_fd: function(client: Ppw_protocol_client) : longint; cdecl;
+    disconnect: procedure(client: Ppw_protocol_client); cdecl;
+    Destroy: procedure(client: Ppw_protocol_client); cdecl;
+    set_paused: function(client: Ppw_protocol_client; paused: T_Bool) : longint; cdecl;
+  end;
+
+  Tpw_protocol_server = record
+    link: Tspa_list;
+    protocol: Ppw_protocol;
+    core: Ppw_impl_core;
+    client_list: Tspa_list;
+    Destroy: procedure(listen: Ppw_protocol_server); cdecl;
+  end;
+
+  Tpw_protocol_marshal = record
+    _type: PChar;
+    version: Tuint32_t;
+    flags: Tuint32_t;
+    n_client_methods: Tuint32_t;
+    n_server_methods: Tuint32_t;
+    client_marshal: pointer;
+    server_demarshal: pointer;
+    server_marshal: pointer;
+    client_demarshal: pointer;
+  end;
+
+  Tpw_protocol_implementation = record
+    version: Tuint32_t;
+    new_client: function(protocol: Ppw_protocol; core: Ppw_core; props: Pspa_dict) : Ppw_protocol_client; cdecl;
+    add_server: function(protocol: Ppw_protocol; core: Ppw_impl_core; props: Pspa_dict) : Ppw_protocol_server; cdecl;
+  end;
+
+  Tpw_protocol_events = record
+    version: Tuint32_t;
+    Destroy: procedure(Data: pointer); cdecl;
+  end;
+
+
+function pw_protocol_new(context: Ppw_context; Name: PChar; user_data_size: Tsize_t) : Ppw_protocol; cdecl; external libpipewirename Name 'pw_protocol_new';
+
+procedure pw_protocol_destroy(protocol: Ppw_protocol); cdecl; external libpipewirename Name 'pw_protocol_destroy';
+
+function pw_protocol_get_context(protocol: Ppw_protocol) : Ppw_context; cdecl; external libpipewirename Name 'pw_protocol_get_context';
+
+function pw_protocol_get_user_data(protocol: Ppw_protocol) : pointer; cdecl; external libpipewirename Name 'pw_protocol_get_user_data';
+
+function pw_protocol_get_implementation(protocol: Ppw_protocol) : Ppw_protocol_implementation; cdecl; external libpipewirename Name 'pw_protocol_get_implementation';
+
+function pw_protocol_get_extension(protocol: Ppw_protocol) : pointer; cdecl; external libpipewirename Name 'pw_protocol_get_extension';
+
+procedure pw_protocol_add_listener(protocol: Ppw_protocol; listener: Pspa_hook; events: Ppw_protocol_events; Data: pointer); cdecl; external libpipewirename Name 'pw_protocol_add_listener';
+
+function pw_protocol_add_marshal(protocol: Ppw_protocol; marshal: Ppw_protocol_marshal) : longint; cdecl; external libpipewirename Name 'pw_protocol_add_marshal';
+
+function pw_protocol_get_marshal(protocol: Ppw_protocol; _type: PChar; version: Tuint32_t; flags: Tuint32_t) : Ppw_protocol_marshal; cdecl; external libpipewirename Name 'pw_protocol_get_marshal';
+
+function pw_context_find_protocol(context: Ppw_context; Name: PChar) : Ppw_protocol; cdecl; external libpipewirename Name 'pw_context_find_protocol';
+
+

packages/libpipewire/src/proxy.inc

@@ -0,0 +1,53 @@
+
+Type
+  Ppw_proxy_events  = ^Tpw_proxy_events;
+
+  Tpw_proxy_events = record
+    version : Tuint32_t;
+    destroy : procedure (data:pointer);cdecl;
+    bound : procedure (data:pointer; global_id:Tuint32_t);cdecl;
+    removed : procedure (data:pointer);cdecl;
+    done : procedure (data:pointer; seq:longint);cdecl;
+    error : procedure (data:pointer; seq:longint; res:longint; message:Pchar);cdecl;
+  end;
+
+
+function pw_proxy_new(factory:Ppw_proxy; _type:Pchar; version:Tuint32_t; user_data_size:Tsize_t):Ppw_proxy;cdecl;external libpipewirename name 'pw_proxy_new';
+
+procedure pw_proxy_add_listener(proxy:Ppw_proxy; listener:Pspa_hook; events:Ppw_proxy_events; data:pointer);cdecl;external libpipewirename name 'pw_proxy_add_listener';
+
+procedure pw_proxy_add_object_listener(proxy:Ppw_proxy; listener:Pspa_hook; funcs:pointer; data:pointer);cdecl;external libpipewirename name 'pw_proxy_add_object_listener';
+
+procedure pw_proxy_destroy(proxy:Ppw_proxy);cdecl;external libpipewirename name 'pw_proxy_destroy';
+
+procedure pw_proxy_ref(proxy:Ppw_proxy);cdecl;external libpipewirename name 'pw_proxy_ref';
+
+procedure pw_proxy_unref(proxy:Ppw_proxy);cdecl;external libpipewirename name 'pw_proxy_unref';
+
+function pw_proxy_get_user_data(proxy:Ppw_proxy):pointer;cdecl;external libpipewirename name 'pw_proxy_get_user_data';
+
+function pw_proxy_get_id(proxy:Ppw_proxy):Tuint32_t;cdecl;external libpipewirename name 'pw_proxy_get_id';
+
+function pw_proxy_get_type(proxy:Ppw_proxy; version:Puint32_t):Pchar;cdecl;external libpipewirename name 'pw_proxy_get_type';
+
+function pw_proxy_get_protocol(proxy:Ppw_proxy):Ppw_protocol;cdecl;external libpipewirename name 'pw_proxy_get_protocol';
+
+function pw_proxy_sync(proxy:Ppw_proxy; seq:longint):longint;cdecl;external libpipewirename name 'pw_proxy_sync';
+
+function pw_proxy_set_bound_id(proxy:Ppw_proxy; global_id:Tuint32_t):longint;cdecl;external libpipewirename name 'pw_proxy_set_bound_id';
+
+function pw_proxy_get_bound_id(proxy:Ppw_proxy):Tuint32_t;cdecl;external libpipewirename name 'pw_proxy_get_bound_id';
+
+function pw_proxy_error(proxy:Ppw_proxy; res:longint; error:Pchar):longint;cdecl;external libpipewirename name 'pw_proxy_error';
+
+function pw_proxy_errorf(proxy:Ppw_proxy; res:longint; error:Pchar; args:array of const):longint;cdecl;external libpipewirename name 'pw_proxy_errorf';
+
+function pw_proxy_errorf(proxy:Ppw_proxy; res:longint; error:Pchar):longint;cdecl;external libpipewirename name 'pw_proxy_errorf';
+
+function pw_proxy_get_object_listeners(proxy:Ppw_proxy):Pspa_hook_list;cdecl;external libpipewirename name 'pw_proxy_get_object_listeners';
+
+function pw_proxy_get_marshal(proxy:Ppw_proxy):Ppw_protocol_marshal;cdecl;external libpipewirename name 'pw_proxy_get_marshal';
+
+function pw_proxy_install_marshal(proxy:Ppw_proxy; implementor:T_Bool):longint;cdecl;external libpipewirename name 'pw_proxy_install_marshal';
+
+

packages/libpipewire/src/resource.inc

@@ -0,0 +1,85 @@
+
+  const
+    libpipewire='libpipewire-0.3'; {Setup as you need}
+
+  { Pointers to basic pascal types, inserted by h2pas conversion program.}
+  Type
+    PLongint  = ^Longint;
+    PSmallInt = ^SmallInt;
+    PByte     = ^Byte;
+    PWord     = ^Word;
+    PDWord    = ^DWord;
+    PDouble   = ^Double;
+
+  Type
+    Pchar  = ^Tchar;
+    Ppw_impl_client  = ^Tpw_impl_client;
+    Ppw_protocol  = ^Tpw_protocol;
+    Ppw_protocol_marshal  = ^Tpw_protocol_marshal;
+    Ppw_resource  = ^Tpw_resource;
+    Ppw_resource_events  = ^Tpw_resource_events;
+    Pspa_hook  = ^Tspa_hook;
+    Pspa_hook_list  = ^Tspa_hook_list;
+    Puint32_t  = ^Tuint32_t;
+{$IFDEF FPC}
+{$PACKRECORDS C}
+{$ENDIF}
+
+
+
+  type
+    Ppw_resource_events = ^Tpw_resource_events;
+    Tpw_resource_events = record
+        version : Tuint32_t;
+        destroy : procedure (data:pointer);cdecl;
+        pong : procedure (data:pointer; seq:longint);cdecl;
+        error : procedure (data:pointer; seq:longint; res:longint; message:Pchar);cdecl;
+      end;
+
+
+  function pw_resource_new(client:Ppw_impl_client; id:Tuint32_t; permissions:Tuint32_t; _type:Pchar; version:Tuint32_t; 
+             user_data_size:Tsize_t):Ppw_resource;cdecl;external libpipewire name 'pw_resource_new';
+
+  procedure pw_resource_destroy(resource:Ppw_resource);cdecl;external libpipewire name 'pw_resource_destroy';
+
+  procedure pw_resource_remove(resource:Ppw_resource);cdecl;external libpipewire name 'pw_resource_remove';
+
+  function pw_resource_get_client(resource:Ppw_resource):Ppw_impl_client;cdecl;external libpipewire name 'pw_resource_get_client';
+
+  function pw_resource_get_id(resource:Ppw_resource):Tuint32_t;cdecl;external libpipewire name 'pw_resource_get_id';
+
+  function pw_resource_get_permissions(resource:Ppw_resource):Tuint32_t;cdecl;external libpipewire name 'pw_resource_get_permissions';
+
+  function pw_resource_get_type(resource:Ppw_resource; version:Puint32_t):Pchar;cdecl;external libpipewire name 'pw_resource_get_type';
+
+  function pw_resource_get_protocol(resource:Ppw_resource):Ppw_protocol;cdecl;external libpipewire name 'pw_resource_get_protocol';
+
+  function pw_resource_get_user_data(resource:Ppw_resource):pointer;cdecl;external libpipewire name 'pw_resource_get_user_data';
+
+  procedure pw_resource_add_listener(resource:Ppw_resource; listener:Pspa_hook; events:Ppw_resource_events; data:pointer);cdecl;external libpipewire name 'pw_resource_add_listener';
+
+  procedure pw_resource_add_object_listener(resource:Ppw_resource; listener:Pspa_hook; funcs:pointer; data:pointer);cdecl;external libpipewire name 'pw_resource_add_object_listener';
+
+  function pw_resource_ping(resource:Ppw_resource; seq:longint):longint;cdecl;external libpipewire name 'pw_resource_ping';
+
+  function pw_resource_set_bound_id(resource:Ppw_resource; global_id:Tuint32_t):longint;cdecl;external libpipewire name 'pw_resource_set_bound_id';
+
+  function pw_resource_get_bound_id(resource:Ppw_resource):Tuint32_t;cdecl;external libpipewire name 'pw_resource_get_bound_id';
+
+  procedure pw_resource_error(resource:Ppw_resource; res:longint; error:Pchar);cdecl;external libpipewire name 'pw_resource_error';
+
+  procedure pw_resource_errorf(resource:Ppw_resource; res:longint; error:Pchar; args:array of const);cdecl;external libpipewire name 'pw_resource_errorf';
+
+  procedure pw_resource_errorf(resource:Ppw_resource; res:longint; error:Pchar);cdecl;external libpipewire name 'pw_resource_errorf';
+
+  procedure pw_resource_errorf_id(resource:Ppw_resource; id:Tuint32_t; res:longint; error:Pchar; args:array of const);cdecl;external libpipewire name 'pw_resource_errorf_id';
+
+  procedure pw_resource_errorf_id(resource:Ppw_resource; id:Tuint32_t; res:longint; error:Pchar);cdecl;external libpipewire name 'pw_resource_errorf_id';
+
+  function pw_resource_get_object_listeners(resource:Ppw_resource):Pspa_hook_list;cdecl;external libpipewire name 'pw_resource_get_object_listeners';
+
+  function pw_resource_get_marshal(resource:Ppw_resource):Ppw_protocol_marshal;cdecl;external libpipewire name 'pw_resource_get_marshal';
+
+  function pw_resource_install_marshal(resource:Ppw_resource; implementor:T_Bool):longint;cdecl;external libpipewire name 'pw_resource_install_marshal';
+
+

packages/libpipewire/src/spabridge.c

@@ -0,0 +1,373 @@
+#include <spa/control/control.h>
+#include <spa/control/type-info.h>
+#include <spa/support/log-impl.h>
+#include <spa/support/thread.h>
+#include <spa/support/cpu.h>
+#include <spa/support/plugin.h>
+#include <spa/support/system.h>
+#include <spa/support/dbus.h>
+#include <spa/support/log.h>
+#include <spa/support/plugin-loader.h>
+#include <spa/support/i18n.h>
+#include <spa/support/loop.h>
+#include <spa/graph/graph.h>
+#include <spa/debug/dict.h>
+#include <spa/debug/pod.h>
+#include <spa/debug/mem.h>
+#include <spa/debug/log.h>
+#include <spa/debug/buffer.h>
+#include <spa/debug/types.h>
+#include <spa/debug/format.h>
+#include <spa/debug/node.h>
+#include <spa/pod/parser.h>
+#include <spa/pod/iter.h>
+#include <spa/pod/command.h>
+#include <spa/pod/vararg.h>
+#include <spa/pod/pod.h>
+#include <spa/pod/event.h>
+#include <spa/pod/builder.h>
+#include <spa/pod/dynamic.h>
+#include <spa/pod/filter.h>
+#include <spa/pod/compare.h>
+#include <spa/monitor/device.h>
+#include <spa/monitor/event.h>
+#include <spa/monitor/utils.h>
+#include <spa/monitor/type-info.h>
+#include <spa/interfaces/audio/aec.h>
+#include <spa/param/format-utils.h>
+#include <spa/param/param.h>
+#include <spa/param/profiler.h>
+#include <spa/param/props.h>
+#include <spa/param/bluetooth/audio.h>
+#include <spa/param/bluetooth/type-info.h>
+#include <spa/param/video/format-utils.h>
+#include <spa/param/video/color.h>
+#include <spa/param/video/encoded.h>
+#include <spa/param/video/multiview.h>
+#include <spa/param/video/raw.h>
+#include <spa/param/video/type-info.h>
+#include <spa/param/video/chroma.h>
+#include <spa/param/video/format.h>
+#include <spa/param/audio/format-utils.h>
+#include <spa/param/audio/raw.h>
+#include <spa/param/audio/layout.h>
+#include <spa/param/audio/iec958.h>
+#include <spa/param/audio/dsd.h>
+#include <spa/param/audio/type-info.h>
+#include <spa/param/audio/format.h>
+#include <spa/param/type-info.h>
+#include <spa/param/format.h>
+#include <spa/param/latency-utils.h>
+#include <spa/node/command.h>
+#include <spa/node/io.h>
+#include <spa/node/event.h>
+#include <spa/node/utils.h>
+#include <spa/node/keys.h>
+#include <spa/node/type-info.h>
+#include <spa/node/node.h>
+#include <spa/buffer/alloc.h>
+#include <spa/buffer/meta.h>
+#include <spa/buffer/buffer.h>
+#include <spa/buffer/type-info.h>
+#include <spa/utils/list.h>
+#include <spa/utils/names.h>
+#include <spa/utils/json-pod.h>
+#include <spa/utils/dict.h>
+#include <spa/utils/hook.h>
+#include <spa/utils/defs.h>
+#include <spa/utils/type.h>
+#include <spa/utils/ansi.h>
+#include <spa/utils/ringbuffer.h>
+#include <spa/utils/json.h>
+#include <spa/utils/result.h>
+#include <spa/utils/keys.h>
+#include <spa/utils/string.h>
+#include <spa/utils/type-info.h>
+ int dummy; 
+ void * spamethodtable[284+1] = {
+    &spa_atob,
+    &spa_atod,
+    &spa_atof,
+    &spa_atoi32,
+    &spa_atoi64,
+    &spa_atou32,
+    &spa_atou64,
+    &spa_buffer_alloc_fill_info,
+    &spa_buffer_alloc_layout,
+    &spa_buffer_alloc_layout_array,
+    &spa_buffer_find_meta,
+    &spa_buffer_find_meta_data,
+    &spa_choice_from_id,
+    &spa_dbus_get_connection,
+    &spa_debug_buffer,
+    &spa_debug_dict,
+    &spa_debug_format,
+    &spa_debug_format_value,
+    &spa_debug_mem,
+    &spa_debug_pod,
+    &spa_debug_pod_value,
+    &spa_debug_port_info,
+    &spa_debug_type_find,
+    &spa_debug_type_find_name,
+    &spa_debug_type_find_short,
+    &spa_debug_type_find_short_name,
+    &spa_debug_type_find_type,
+    &spa_debug_type_find_type_short,
+    &spa_debug_type_short_name,
+    &spa_device_enum_params_sync,
+    &spa_dict_item_compare,
+    &spa_dict_lookup,
+    &spa_dict_lookup_item,
+    &spa_dict_qsort,
+    &spa_format_audio_dsd_build,
+    &spa_format_audio_dsd_parse,
+    &spa_format_audio_dsp_build,
+    &spa_format_audio_dsp_parse,
+    &spa_format_audio_iec958_build,
+    &spa_format_audio_iec958_parse,
+    &spa_format_audio_raw_build,
+    &spa_format_audio_raw_parse,
+    &spa_format_parse,
+    &spa_format_video_dsp_build,
+    &spa_format_video_dsp_parse,
+    &spa_format_video_h264_build,
+    &spa_format_video_h264_parse,
+    &spa_format_video_mjpg_build,
+    &spa_format_video_mjpg_parse,
+    &spa_format_video_raw_build,
+    &spa_format_video_raw_parse,
+    &spa_graph_finish,
+    &spa_graph_init,
+    &spa_graph_link_add,
+    &spa_graph_link_remove,
+    &spa_graph_link_signal_graph,
+    &spa_graph_link_signal_node,
+    &spa_graph_link_trigger,
+    &spa_graph_node_add,
+    &spa_graph_node_impl_process,
+    &spa_graph_node_impl_reuse_buffer,
+    &spa_graph_node_impl_sub_process,
+    &spa_graph_node_init,
+    &spa_graph_node_remove,
+    &spa_graph_node_set_callbacks,
+    &spa_graph_node_set_subgraph,
+    &spa_graph_node_trigger,
+    &spa_graph_port_add,
+    &spa_graph_port_init,
+    &spa_graph_port_link,
+    &spa_graph_port_remove,
+    &spa_graph_port_unlink,
+    &spa_graph_run,
+    &spa_graph_state_reset,
+    &spa_hook_list_append,
+    &spa_hook_list_clean,
+    &spa_hook_list_init,
+    &spa_hook_list_is_empty,
+    &spa_hook_list_isolate,
+    &spa_hook_list_join,
+    &spa_hook_list_prepend,
+    &spa_hook_remove,
+    &spa_i18n_ntext,
+    &spa_i18n_text,
+    &spa_json_container_len,
+    &spa_json_encode_string,
+    &spa_json_enter,
+    &spa_json_enter_array,
+    &spa_json_enter_container,
+    &spa_json_enter_object,
+    &spa_json_get_bool,
+    &spa_json_get_float,
+    &spa_json_get_int,
+    &spa_json_get_string,
+    &spa_json_init,
+    &spa_json_is_array,
+    &spa_json_is_bool,
+    &spa_json_is_container,
+    &spa_json_is_false,
+    &spa_json_is_float,
+    &spa_json_is_int,
+    &spa_json_is_null,
+    &spa_json_is_object,
+    &spa_json_is_string,
+    &spa_json_is_true,
+    &spa_json_next,
+    &spa_json_parse_bool,
+    &spa_json_parse_float,
+    &spa_json_parse_int,
+    &spa_json_parse_string,
+    &spa_json_parse_stringn,
+    &spa_json_to_pod,
+    &spa_json_to_pod_part,
+    &spa_latency_build,
+    &spa_latency_info_combine,
+    &spa_latency_info_combine_finish,
+    &spa_latency_info_combine_start,
+    &spa_latency_info_compare,
+    &spa_latency_parse,
+    &spa_list_init,
+    &spa_list_insert,
+    &spa_list_insert_list,
+    &spa_list_remove,
+    &spa_log_impl_topic_init,
+    &spa_node_enum_params_sync,
+    &spa_node_port_enum_params_sync,
+    &spa_plugin_loader_load,
+    &spa_plugin_loader_unload,
+    &spa_pod_builder_add,
+    &spa_pod_builder_addv,
+    &spa_pod_builder_array,
+    &spa_pod_builder_bool,
+    &spa_pod_builder_bytes,
+    &spa_pod_builder_child,
+    &spa_pod_builder_control,
+    &spa_pod_builder_deref,
+    &spa_pod_builder_double,
+    &spa_pod_builder_fd,
+    &spa_pod_builder_float,
+    &spa_pod_builder_fraction,
+    &spa_pod_builder_frame,
+    &spa_pod_builder_get_state,
+    &spa_pod_builder_id,
+    &spa_pod_builder_init,
+    &spa_pod_builder_int,
+    &spa_pod_builder_long,
+    &spa_pod_builder_none,
+    &spa_pod_builder_pad,
+    &spa_pod_builder_pointer,
+    &spa_pod_builder_pop,
+    &spa_pod_builder_primitive,
+    &spa_pod_builder_prop,
+    &spa_pod_builder_push,
+    &spa_pod_builder_push_array,
+    &spa_pod_builder_push_choice,
+    &spa_pod_builder_push_object,
+    &spa_pod_builder_push_sequence,
+    &spa_pod_builder_push_struct,
+    &spa_pod_builder_raw,
+    &spa_pod_builder_raw_padded,
+    &spa_pod_builder_rectangle,
+    &spa_pod_builder_reserve_bytes,
+    &spa_pod_builder_reset,
+    &spa_pod_builder_set_callbacks,
+    &spa_pod_builder_string,
+    &spa_pod_builder_string_len,
+    &spa_pod_builder_write_string,
+    &spa_pod_choice_fix_default,
+    &spa_pod_compare,
+    &spa_pod_compare_value,
+    &spa_pod_control_first,
+    &spa_pod_control_is_inside,
+    &spa_pod_control_next,
+    &spa_pod_copy,
+    &spa_pod_copy_array,
+    &spa_pod_copy_string,
+    &spa_pod_dynamic_builder_clean,
+    &spa_pod_dynamic_builder_init,
+    &spa_pod_filter,
+    &spa_pod_filter_flags_value,
+    &spa_pod_filter_part,
+    &spa_pod_filter_prop,
+    &spa_pod_find_prop,
+    &spa_pod_fixate,
+    &spa_pod_from_data,
+    &spa_pod_get_array,
+    &spa_pod_get_bool,
+    &spa_pod_get_bytes,
+    &spa_pod_get_double,
+    &spa_pod_get_fd,
+    &spa_pod_get_float,
+    &spa_pod_get_fraction,
+    &spa_pod_get_id,
+    &spa_pod_get_int,
+    &spa_pod_get_long,
+    &spa_pod_get_pointer,
+    &spa_pod_get_rectangle,
+    &spa_pod_get_string,
+    &spa_pod_get_values,
+    &spa_pod_is_array,
+    &spa_pod_is_bitmap,
+    &spa_pod_is_bool,
+    &spa_pod_is_bytes,
+    &spa_pod_is_choice,
+    &spa_pod_is_double,
+    &spa_pod_is_fd,
+    &spa_pod_is_fixated,
+    &spa_pod_is_float,
+    &spa_pod_is_fraction,
+    &spa_pod_is_id,
+    &spa_pod_is_inside,
+    &spa_pod_is_int,
+    &spa_pod_is_long,
+    &spa_pod_is_none,
+    &spa_pod_is_object,
+    &spa_pod_is_object_id,
+    &spa_pod_is_object_type,
+    &spa_pod_is_pointer,
+    &spa_pod_is_rectangle,
+    &spa_pod_is_sequence,
+    &spa_pod_is_string,
+    &spa_pod_is_struct,
+    &spa_pod_next,
+    &spa_pod_object_find_prop,
+    &spa_pod_object_fixate,
+    &spa_pod_object_is_fixated,
+    &spa_pod_parser_advance,
+    &spa_pod_parser_can_collect,
+    &spa_pod_parser_current,
+    &spa_pod_parser_deref,
+    &spa_pod_parser_frame,
+    &spa_pod_parser_get,
+    &spa_pod_parser_get_bool,
+    &spa_pod_parser_get_bytes,
+    &spa_pod_parser_get_double,
+    &spa_pod_parser_get_fd,
+    &spa_pod_parser_get_float,
+    &spa_pod_parser_get_fraction,
+    &spa_pod_parser_get_id,
+    &spa_pod_parser_get_int,
+    &spa_pod_parser_get_long,
+    &spa_pod_parser_get_pod,
+    &spa_pod_parser_get_pointer,
+    &spa_pod_parser_get_rectangle,
+    &spa_pod_parser_get_state,
+    &spa_pod_parser_get_string,
+    &spa_pod_parser_getv,
+    &spa_pod_parser_init,
+    &spa_pod_parser_next,
+    &spa_pod_parser_pod,
+    &spa_pod_parser_pop,
+    &spa_pod_parser_push,
+    &spa_pod_parser_push_object,
+    &spa_pod_parser_push_struct,
+    &spa_pod_parser_reset,
+    &spa_pod_prop_first,
+    &spa_pod_prop_is_inside,
+    &spa_pod_prop_next,
+    &spa_process_latency_build,
+    &spa_process_latency_info_add,
+    &spa_process_latency_parse,
+    &spa_result_func_device_params,
+    &spa_result_func_node_params,
+    &spa_ringbuffer_get_read_index,
+    &spa_ringbuffer_get_write_index,
+    &spa_ringbuffer_init,
+    &spa_ringbuffer_read_data,
+    &spa_ringbuffer_read_update,
+    &spa_ringbuffer_set_avail,
+    &spa_ringbuffer_write_data,
+    &spa_ringbuffer_write_update,
+    &spa_scnprintf,
+    &spa_strendswith,
+    &spa_streq,
+    &spa_strneq,
+    &spa_strstartswith,
+    &spa_support_find,
+    &spa_thread_utils_acquire_rt,
+    &spa_thread_utils_create,
+    &spa_thread_utils_drop_rt,
+    &spa_thread_utils_get_rt_range,
+    &spa_thread_utils_join,
+    &spa_type_is_a,
+    &spa_vscnprintf,
+&dummy
+}; 

packages/libpipewire/src/spabridge.inc

@@ -0,0 +1,655 @@
+
+
+type
+  Tspa_buffer_alloc_info = record
+  end;
+  Pspa_buffer_alloc_info = ^Tspa_buffer_alloc_info;
+
+  Tspa_latency_info = record
+  end;
+  Pspa_latency_info = ^Tspa_latency_info;
+
+  Tspa_process_latency_info = record
+  end;
+  Pspa_process_latency_info = ^Tspa_process_latency_info;
+
+  Tspa_audio_info_raw = record
+  end;
+  Pspa_audio_info_raw = ^Tspa_audio_info_raw;
+
+  Tspa_audio_info_dsp = record
+  end;
+  Pspa_audio_info_dsp = ^Tspa_audio_info_dsp;
+
+  Tspa_audio_info_iec958 = record
+  end;
+  Pspa_audio_info_iec958 = ^Tspa_audio_info_iec958;
+
+  Tspa_audio_info_dsd = record
+  end;
+  Pspa_audio_info_dsd = ^Tspa_audio_info_dsd;
+
+
+  Tspa_video_info_mjpg = record
+  end;
+  Pspa_video_info_mjpg = ^Tspa_video_info_mjpg;
+
+  Tspa_video_info_h264 = record
+  end;
+  Pspa_video_info_h264 = ^Tspa_video_info_h264;
+
+  Pspa_pod_parser_state = ^Tspa_pod_parser_state;
+
+  tspa_dbus_connection = record
+  end;
+  pspa_dbus_connection = ^Tspa_dbus_connection;
+
+  tspa_dbus_type = record
+  end;
+  pspa_dbus_type = ^tspa_dbus_type;
+
+  tspa_dbus = record
+  end;
+  pspa_dbus = ^Tspa_dbus;
+
+  Tspa_thread_utils = record
+  end;
+  Pspa_thread_utils = ^Tspa_thread_utils;
+
+  Tspa_thread_utils_createStart = function(para1: pointer) : pointer; cdecl;
+
+  tspa_plugin_loader = record
+  end;
+  pspa_plugin_loader = ^tspa_plugin_loader;
+
+  Tspa_i18n = record
+  end;
+  Pspa_i18n = ^Tspa_i18n;
+
+  Tspa_device = record
+  end;
+  Pspa_device = ^Tspa_device;
+
+procedure spa_log_impl_topic_init(object_: pointer; topic: Pspa_log_topic); cdecl; external;
+
+function spa_thread_utils_create(o: Pspa_thread_utils; props: Pspa_dict; start_routine: Tspa_thread_utils_createStart; arg: pointer) : Pspa_thread; cdecl; external;
+
+function spa_thread_utils_join(o: Pspa_thread_utils; thread: Pspa_thread; retval: Ppointer) : longint; cdecl; external;
+
+function spa_thread_utils_get_rt_range(o: Pspa_thread_utils; props: Pspa_dict; min: Plongint; max: Plongint) : longint; cdecl; external;
+
+function spa_thread_utils_acquire_rt(o: Pspa_thread_utils; thread: Pspa_thread; priority: longint) : longint; cdecl; external;
+
+function spa_thread_utils_drop_rt(o: Pspa_thread_utils; thread: Pspa_thread) : longint; cdecl; external;
+
+function spa_support_find(support: Pspa_support; n_support: Tuint32_t; _type: PChar) : pointer; cdecl; external;
+
+function spa_dbus_get_connection(dbus: Pspa_dbus; _type: Tspa_dbus_type) : Pspa_dbus_connection; cdecl; external;
+
+function spa_plugin_loader_load(loader: Pspa_plugin_loader; factory_name: PChar; info: Pspa_dict) : Pspa_handle; cdecl; external;
+
+function spa_plugin_loader_unload(loader: Pspa_plugin_loader; handle: Pspa_handle) : longint; cdecl; external;
+
+function spa_i18n_text(i18n: Pspa_i18n; msgid: PChar) : PChar; cdecl; external;
+
+function spa_i18n_ntext(i18n: Pspa_i18n; msgid: PChar; msgid_plural: PChar; n: dword) : PChar; cdecl; external;
+
+procedure spa_graph_state_reset(state: Pspa_graph_state); cdecl; external;
+
+function spa_graph_link_trigger(link: Pspa_graph_link) : longint; cdecl; external;
+
+function spa_graph_node_trigger(node: Pspa_graph_node) : longint; cdecl; external;
+
+function spa_graph_run(graph: Pspa_graph) : longint; cdecl; external;
+
+function spa_graph_finish(graph: Pspa_graph) : longint; cdecl; external;
+
+function spa_graph_link_signal_node(Data: pointer) : longint; cdecl; external;
+
+function spa_graph_link_signal_graph(Data: pointer) : longint; cdecl; external;
+
+procedure spa_graph_init(graph: Pspa_graph; state: Pspa_graph_state); cdecl; external;
+
+procedure spa_graph_link_add(_out: Pspa_graph_node; state: Pspa_graph_state; link: Pspa_graph_link); cdecl; external;
+
+procedure spa_graph_link_remove(link: Pspa_graph_link); cdecl; external;
+
+procedure spa_graph_node_init(node: Pspa_graph_node; state: Pspa_graph_state); cdecl; external;
+
+function spa_graph_node_impl_sub_process(Data: pointer; node: Pspa_graph_node) : longint; cdecl; external;
+
+procedure spa_graph_node_set_subgraph(node: Pspa_graph_node; subgraph: Pspa_graph); cdecl; external;
+
+procedure spa_graph_node_set_callbacks(node: Pspa_graph_node; callbacks: Pspa_graph_node_callbacks; Data: pointer); cdecl; external;
+
+procedure spa_graph_node_add(graph: Pspa_graph; node: Pspa_graph_node); cdecl; external;
+
+procedure spa_graph_node_remove(node: Pspa_graph_node); cdecl; external;
+
+procedure spa_graph_port_init(port: Pspa_graph_port; direction: Tspa_direction; port_id: Tuint32_t; flags: Tuint32_t); cdecl; external;
+
+procedure spa_graph_port_add(node: Pspa_graph_node; port: Pspa_graph_port); cdecl; external;
+
+procedure spa_graph_port_remove(port: Pspa_graph_port); cdecl; external;
+
+procedure spa_graph_port_link(_out: Pspa_graph_port; _in: Pspa_graph_port); cdecl; external;
+
+procedure spa_graph_port_unlink(port: Pspa_graph_port); cdecl; external;
+
+function spa_graph_node_impl_process(Data: pointer; node: Pspa_graph_node) : longint; cdecl; external;
+
+function spa_graph_node_impl_reuse_buffer(Data: pointer; node: Pspa_graph_node; port_id: Tuint32_t; buffer_id: Tuint32_t) : longint; cdecl; external;
+
+function spa_debug_dict(indent: longint; dict: Pspa_dict) : longint; cdecl; external;
+
+function spa_debug_pod_value(indent: longint; info: Pspa_type_info; _type: Tuint32_t; body: pointer; size: Tuint32_t) : longint; cdecl; external;
+
+function spa_debug_pod(indent: longint; info: Pspa_type_info; pod: Pspa_pod) : longint; cdecl; external;
+
+function spa_debug_mem(indent: longint; Data: pointer; size: Tsize_t) : longint; cdecl; external;
+
+function spa_debug_buffer(indent: longint; buffer: Pspa_buffer) : longint; cdecl; external;
+
+function spa_debug_type_find(info: Pspa_type_info; _type: Tuint32_t) : Pspa_type_info; cdecl; external;
+
+function spa_debug_type_short_name(Name: PChar) : PChar; cdecl; external;
+
+function spa_debug_type_find_name(info: Pspa_type_info; _type: Tuint32_t) : PChar; cdecl; external;
+
+function spa_debug_type_find_short_name(info: Pspa_type_info; _type: Tuint32_t) : PChar; cdecl; external;
+
+function spa_debug_type_find_type(info: Pspa_type_info; Name: PChar) : Tuint32_t; cdecl; external;
+
+function spa_debug_type_find_short(info: Pspa_type_info; Name: PChar) : Pspa_type_info; cdecl; external;
+
+function spa_debug_type_find_type_short(info: Pspa_type_info; Name: PChar) : Tuint32_t; cdecl; external;
+
+function spa_debug_format_value(info: Pspa_type_info; _type: Tuint32_t; body: pointer; size: Tuint32_t) : longint; cdecl; external;
+
+function spa_debug_format(indent: longint; info: Pspa_type_info; format: Pspa_pod) : longint; cdecl; external;
+
+function spa_debug_port_info(indent: longint; info: Pspa_port_info) : longint; cdecl; external;
+
+procedure spa_pod_parser_init(parser: Pspa_pod_parser; Data: pointer; size: Tuint32_t); cdecl; external;
+
+procedure spa_pod_parser_pod(parser: Pspa_pod_parser; pod: Pspa_pod); cdecl; external;
+
+procedure spa_pod_parser_get_state(parser: Pspa_pod_parser; state: Pspa_pod_parser_state); cdecl; external;
+
+procedure spa_pod_parser_reset(parser: Pspa_pod_parser; state: Pspa_pod_parser_state); cdecl; external;
+
+function spa_pod_parser_deref(parser: Pspa_pod_parser; offset: Tuint32_t; size: Tuint32_t) : Pspa_pod; cdecl; external;
+
+function spa_pod_parser_frame(parser: Pspa_pod_parser; frame: Pspa_pod_frame) : Pspa_pod; cdecl; external;
+
+procedure spa_pod_parser_push(parser: Pspa_pod_parser; frame: Pspa_pod_frame; pod: Pspa_pod; offset: Tuint32_t); cdecl; external;
+
+function spa_pod_parser_current(parser: Pspa_pod_parser) : Pspa_pod; cdecl; external;
+
+procedure spa_pod_parser_advance(parser: Pspa_pod_parser; pod: Pspa_pod); cdecl; external;
+
+function spa_pod_parser_next(parser: Pspa_pod_parser) : Pspa_pod; cdecl; external;
+
+function spa_pod_parser_pop(parser: Pspa_pod_parser; frame: Pspa_pod_frame) : longint; cdecl; external;
+
+function spa_pod_parser_get_bool(parser: Pspa_pod_parser; Value: Pbool) : longint; cdecl; external;
+
+function spa_pod_parser_get_id(parser: Pspa_pod_parser; Value: Puint32_t) : longint; cdecl; external;
+
+function spa_pod_parser_get_int(parser: Pspa_pod_parser; Value: Pint32_t) : longint; cdecl; external;
+
+function spa_pod_parser_get_long(parser: Pspa_pod_parser; Value: Pint64_t) : longint; cdecl; external;
+
+function spa_pod_parser_get_float(parser: Pspa_pod_parser; Value: Psingle) : longint; cdecl; external;
+
+function spa_pod_parser_get_double(parser: Pspa_pod_parser; Value: Pdouble) : longint; cdecl; external;
+
+function spa_pod_parser_get_string(parser: Pspa_pod_parser; Value: PPchar) : longint; cdecl; external;
+
+function spa_pod_parser_get_bytes(parser: Pspa_pod_parser; Value: Ppointer; len: Puint32_t) : longint; cdecl; external;
+
+function spa_pod_parser_get_pointer(parser: Pspa_pod_parser; _type: Puint32_t; Value: Ppointer) : longint; cdecl; external;
+
+function spa_pod_parser_get_fd(parser: Pspa_pod_parser; Value: Pint64_t) : longint; cdecl; external;
+
+function spa_pod_parser_get_rectangle(parser: Pspa_pod_parser; Value: Pspa_rectangle) : longint; cdecl; external;
+
+function spa_pod_parser_get_fraction(parser: Pspa_pod_parser; Value: Pspa_fraction) : longint; cdecl; external;
+
+function spa_pod_parser_get_pod(parser: Pspa_pod_parser; Value: PPspa_pod) : longint; cdecl; external;
+
+function spa_pod_parser_push_struct(parser: Pspa_pod_parser; frame: Pspa_pod_frame) : longint; cdecl; external;
+
+function spa_pod_parser_push_object(parser: Pspa_pod_parser; frame: Pspa_pod_frame; _type: Tuint32_t; id: Puint32_t) : longint; cdecl; external;
+
+function spa_pod_parser_can_collect(pod: Pspa_pod; _type: char) : Tbool; cdecl; external;
+
+function spa_pod_parser_getv(parser: Pspa_pod_parser; args: pointer) : longint; cdecl; external;
+
+function spa_pod_parser_get(parser: Pspa_pod_parser; args: array of const) : longint; cdecl; external; overload;
+
+function spa_pod_parser_get(parser: Pspa_pod_parser) : longint; cdecl; external; overload;
+
+function spa_pod_is_inside(pod: pointer; size: Tuint32_t; iter: pointer) : Tbool; cdecl; external;
+
+function spa_pod_next(iter: pointer) : pointer; cdecl; external;
+
+function spa_pod_prop_first(body: Pspa_pod_object_body) : Pspa_pod_prop; cdecl; external;
+
+function spa_pod_prop_is_inside(body: Pspa_pod_object_body; size: Tuint32_t; iter: Pspa_pod_prop) : Tbool; cdecl; external;
+
+function spa_pod_prop_next(iter: Pspa_pod_prop) : Pspa_pod_prop; cdecl; external;
+
+function spa_pod_control_first(body: Pspa_pod_sequence_body) : Pspa_pod_control; cdecl; external;
+
+function spa_pod_control_is_inside(body: Pspa_pod_sequence_body; size: Tuint32_t; iter: Pspa_pod_control) : Tbool; cdecl; external;
+
+function spa_pod_control_next(iter: Pspa_pod_control) : Pspa_pod_control; cdecl; external;
+
+function spa_pod_from_data(Data: pointer; maxsize: Tsize_t; offset: Toff_t; size: Tsize_t) : pointer; cdecl; external;
+
+function spa_pod_is_none(pod: Pspa_pod) : longint; cdecl; external;
+
+function spa_pod_is_bool(pod: Pspa_pod) : longint; cdecl; external;
+
+function spa_pod_get_bool(pod: Pspa_pod; Value: Pbool) : longint; cdecl; external;
+
+function spa_pod_is_id(pod: Pspa_pod) : longint; cdecl; external;
+
+function spa_pod_get_id(pod: Pspa_pod; Value: Puint32_t) : longint; cdecl; external;
+
+function spa_pod_is_int(pod: Pspa_pod) : longint; cdecl; external;
+
+function spa_pod_get_int(pod: Pspa_pod; Value: Pint32_t) : longint; cdecl; external;
+
+function spa_pod_is_long(pod: Pspa_pod) : longint; cdecl; external;
+
+function spa_pod_get_long(pod: Pspa_pod; Value: Pint64_t) : longint; cdecl; external;
+
+function spa_pod_is_float(pod: Pspa_pod) : longint; cdecl; external;
+
+function spa_pod_get_float(pod: Pspa_pod; Value: Psingle) : longint; cdecl; external;
+
+function spa_pod_is_double(pod: Pspa_pod) : longint; cdecl; external;
+
+function spa_pod_get_double(pod: Pspa_pod; Value: Pdouble) : longint; cdecl; external;
+
+function spa_pod_is_string(pod: Pspa_pod) : longint; cdecl; external;
+
+function spa_pod_get_string(pod: Pspa_pod; Value: PPchar) : longint; cdecl; external;
+
+function spa_pod_copy_string(pod: Pspa_pod; maxlen: Tsize_t; dest: PChar) : longint; cdecl; external;
+
+function spa_pod_is_bytes(pod: Pspa_pod) : longint; cdecl; external;
+
+function spa_pod_get_bytes(pod: Pspa_pod; Value: Ppointer; len: Puint32_t) : longint; cdecl; external;
+
+function spa_pod_is_pointer(pod: Pspa_pod) : longint; cdecl; external;
+
+function spa_pod_get_pointer(pod: Pspa_pod; _type: Puint32_t; Value: Ppointer) : longint; cdecl; external;
+
+function spa_pod_is_fd(pod: Pspa_pod) : longint; cdecl; external;
+
+function spa_pod_get_fd(pod: Pspa_pod; Value: Pint64_t) : longint; cdecl; external;
+
+function spa_pod_is_rectangle(pod: Pspa_pod) : longint; cdecl; external;
+
+function spa_pod_get_rectangle(pod: Pspa_pod; Value: Pspa_rectangle) : longint; cdecl; external;
+
+function spa_pod_is_fraction(pod: Pspa_pod) : longint; cdecl; external;
+
+function spa_pod_get_fraction(pod: Pspa_pod; Value: Pspa_fraction) : longint; cdecl; external;
+
+function spa_pod_is_bitmap(pod: Pspa_pod) : longint; cdecl; external;
+
+function spa_pod_is_array(pod: Pspa_pod) : longint; cdecl; external;
+
+function spa_pod_get_array(pod: Pspa_pod; n_values: Puint32_t) : pointer; cdecl; external;
+
+function spa_pod_copy_array(pod: Pspa_pod; _type: Tuint32_t; values: pointer; max_values: Tuint32_t) : Tuint32_t; cdecl; external;
+
+function spa_pod_is_choice(pod: Pspa_pod) : longint; cdecl; external;
+
+function spa_pod_get_values(pod: Pspa_pod; n_vals: Puint32_t; choice: Puint32_t) : Pspa_pod; cdecl; external;
+
+function spa_pod_is_struct(pod: Pspa_pod) : longint; cdecl; external;
+
+function spa_pod_is_object(pod: Pspa_pod) : longint; cdecl; external;
+
+function spa_pod_is_object_type(pod: Pspa_pod; _type: Tuint32_t) : Tbool; cdecl; external;
+
+function spa_pod_is_object_id(pod: Pspa_pod; id: Tuint32_t) : Tbool; cdecl; external;
+
+function spa_pod_is_sequence(pod: Pspa_pod) : longint; cdecl; external;
+
+function spa_pod_object_find_prop(pod: Pspa_pod_object; start: Pspa_pod_prop; key: Tuint32_t) : Pspa_pod_prop; cdecl; external;
+
+function spa_pod_find_prop(pod: Pspa_pod; start: Pspa_pod_prop; key: Tuint32_t) : Pspa_pod_prop; cdecl; external;
+
+function spa_pod_object_fixate(pod: Pspa_pod_object) : longint; cdecl; external;
+
+function spa_pod_fixate(pod: Pspa_pod) : longint; cdecl; external;
+
+function spa_pod_object_is_fixated(pod: Pspa_pod_object) : longint; cdecl; external;
+
+function spa_pod_is_fixated(pod: Pspa_pod) : longint; cdecl; external;
+
+procedure spa_pod_builder_get_state(builder: Pspa_pod_builder; state: Pspa_pod_builder_state); cdecl; external;
+
+procedure spa_pod_builder_set_callbacks(builder: Pspa_pod_builder; callbacks: Pspa_pod_builder_callbacks; Data: pointer); cdecl; external;
+
+procedure spa_pod_builder_reset(builder: Pspa_pod_builder; state: Pspa_pod_builder_state); cdecl; external;
+
+procedure spa_pod_builder_init(builder: Pspa_pod_builder; Data: pointer; size: Tuint32_t); cdecl; external;
+
+function spa_pod_builder_deref(builder: Pspa_pod_builder; offset: Tuint32_t) : Pspa_pod; cdecl; external;
+
+function spa_pod_builder_frame(builder: Pspa_pod_builder; frame: Pspa_pod_frame) : Pspa_pod; cdecl; external;
+
+procedure spa_pod_builder_push(builder: Pspa_pod_builder; frame: Pspa_pod_frame; pod: Pspa_pod; offset: Tuint32_t); cdecl; external;
+
+function spa_pod_builder_raw(builder: Pspa_pod_builder; Data: pointer; size: Tuint32_t) : longint; cdecl; external;
+
+function spa_pod_builder_pad(builder: Pspa_pod_builder; size: Tuint32_t) : longint; cdecl; external;
+
+function spa_pod_builder_raw_padded(builder: Pspa_pod_builder; Data: pointer; size: Tuint32_t) : longint; cdecl; external;
+
+function spa_pod_builder_pop(builder: Pspa_pod_builder; frame: Pspa_pod_frame) : pointer; cdecl; external;
+
+function spa_pod_builder_primitive(builder: Pspa_pod_builder; p: Pspa_pod) : longint; cdecl; external;
+
+function spa_pod_builder_none(builder: Pspa_pod_builder) : longint; cdecl; external;
+
+function spa_pod_builder_child(builder: Pspa_pod_builder; size: Tuint32_t; _type: Tuint32_t) : longint; cdecl; external;
+
+function spa_pod_builder_bool(builder: Pspa_pod_builder; val: Tbool) : longint; cdecl; external;
+
+function spa_pod_builder_id(builder: Pspa_pod_builder; val: Tuint32_t) : longint; cdecl; external;
+
+function spa_pod_builder_int(builder: Pspa_pod_builder; val: Tint32_t) : longint; cdecl; external;
+
+function spa_pod_builder_long(builder: Pspa_pod_builder; val: Tint64_t) : longint; cdecl; external;
+
+function spa_pod_builder_float(builder: Pspa_pod_builder; val: single) : longint; cdecl; external;
+
+function spa_pod_builder_double(builder: Pspa_pod_builder; val: Tdouble) : longint; cdecl; external;
+
+function spa_pod_builder_write_string(builder: Pspa_pod_builder; str: PChar; len: Tuint32_t) : longint; cdecl; external;
+
+function spa_pod_builder_string_len(builder: Pspa_pod_builder; str: PChar; len: Tuint32_t) : longint; cdecl; external;
+
+function spa_pod_builder_string(builder: Pspa_pod_builder; str: PChar) : longint; cdecl; external;
+
+function spa_pod_builder_bytes(builder: Pspa_pod_builder; bytes: pointer; len: Tuint32_t) : longint; cdecl; external;
+
+function spa_pod_builder_reserve_bytes(builder: Pspa_pod_builder; len: Tuint32_t) : pointer; cdecl; external;
+
+function spa_pod_builder_pointer(builder: Pspa_pod_builder; _type: Tuint32_t; val: pointer) : longint; cdecl; external;
+
+function spa_pod_builder_fd(builder: Pspa_pod_builder; fd: Tint64_t) : longint; cdecl; external;
+
+function spa_pod_builder_rectangle(builder: Pspa_pod_builder; Width: Tuint32_t; Height: Tuint32_t) : longint; cdecl; external;
+
+function spa_pod_builder_fraction(builder: Pspa_pod_builder; num: Tuint32_t; denom: Tuint32_t) : longint; cdecl; external;
+
+function spa_pod_builder_push_array(builder: Pspa_pod_builder; frame: Pspa_pod_frame) : longint; cdecl; external;
+
+function spa_pod_builder_array(builder: Pspa_pod_builder; child_size: Tuint32_t; child_type: Tuint32_t; n_elems: Tuint32_t; elems: pointer) : longint; cdecl; external;
+
+function spa_pod_builder_push_choice(builder: Pspa_pod_builder; frame: Pspa_pod_frame; _type: Tuint32_t; flags: Tuint32_t) : longint; cdecl; external;
+
+function spa_pod_builder_push_struct(builder: Pspa_pod_builder; frame: Pspa_pod_frame) : longint; cdecl; external;
+
+function spa_pod_builder_push_object(builder: Pspa_pod_builder; frame: Pspa_pod_frame; _type: Tuint32_t; id: Tuint32_t) : longint; cdecl; external;
+
+function spa_pod_builder_prop(builder: Pspa_pod_builder; key: Tuint32_t; flags: Tuint32_t) : longint; cdecl; external;
+
+function spa_pod_builder_push_sequence(builder: Pspa_pod_builder; frame: Pspa_pod_frame; _unit: Tuint32_t) : longint; cdecl; external;
+
+function spa_pod_builder_control(builder: Pspa_pod_builder; offset: Tuint32_t; _type: Tuint32_t) : Tuint32_t; cdecl; external;
+
+function spa_choice_from_id(id: char) : Tuint32_t; cdecl; external;
+
+function spa_pod_builder_addv(builder: Pspa_pod_builder; args: pointer) : longint; cdecl; external;
+
+function spa_pod_builder_add(builder: Pspa_pod_builder; args: array of const) : longint; cdecl; external; overload;
+
+function spa_pod_builder_add(builder: Pspa_pod_builder) : longint; cdecl; external; overload;
+
+function spa_pod_copy(pod: Pspa_pod) : Pspa_pod; cdecl; external;
+
+procedure spa_pod_dynamic_builder_init(builder: Pspa_pod_dynamic_builder; Data: pointer; size: Tuint32_t; extend: Tuint32_t); cdecl; external;
+
+procedure spa_pod_dynamic_builder_clean(builder: Pspa_pod_dynamic_builder); cdecl; external;
+
+function spa_pod_choice_fix_default(choice: Pspa_pod_choice) : longint; cdecl; external;
+
+function spa_pod_filter_flags_value(b: Pspa_pod_builder; _type: Tuint32_t; r1: pointer; r2: pointer; size: Tuint32_t) : longint; cdecl; external;
+
+function spa_pod_filter_prop(b: Pspa_pod_builder; p1: Pspa_pod_prop; p2: Pspa_pod_prop) : longint; cdecl; external;
+
+function spa_pod_filter_part(b: Pspa_pod_builder; pod: Pspa_pod; pod_size: Tuint32_t; filter: Pspa_pod; filter_size: Tuint32_t) : longint; cdecl; external;
+
+function spa_pod_filter(b: Pspa_pod_builder; Result: PPspa_pod; pod: Pspa_pod; filter: Pspa_pod) : longint; cdecl; external;
+
+function spa_pod_compare_value(_type: Tuint32_t; r1: pointer; r2: pointer; size: Tuint32_t) : longint; cdecl; external;
+
+function spa_pod_compare(pod1: Pspa_pod; pod2: Pspa_pod) : longint; cdecl; external;
+
+procedure spa_result_func_device_params(Data: pointer; seq: longint; res: longint; _type: Tuint32_t; Result: pointer); cdecl; external;
+
+function spa_device_enum_params_sync(device: Pspa_device; id: Tuint32_t; index: Puint32_t; filter: Pspa_pod; param: PPspa_pod; builder: Pspa_pod_builder) : longint; cdecl; external;
+
+function spa_format_parse(format: Pspa_pod; media_type: Puint32_t; media_subtype: Puint32_t) : longint; cdecl; external;
+
+function spa_format_video_raw_parse(format: Pspa_pod; info: Pspa_video_info_raw) : longint; cdecl; external;
+
+function spa_format_video_dsp_parse(format: Pspa_pod; info: Pspa_video_info_dsp) : longint; cdecl; external;
+
+function spa_format_video_raw_build(builder: Pspa_pod_builder; id: Tuint32_t; info: Pspa_video_info_raw) : Pspa_pod; cdecl; external;
+
+function spa_format_video_dsp_build(builder: Pspa_pod_builder; id: Tuint32_t; info: Pspa_video_info_dsp) : Pspa_pod; cdecl; external;
+
+function spa_format_video_h264_parse(format: Pspa_pod; info: Pspa_video_info_h264) : longint; cdecl; external;
+
+function spa_format_video_h264_build(builder: Pspa_pod_builder; id: Tuint32_t; info: Pspa_video_info_h264) : Pspa_pod; cdecl; external;
+
+function spa_format_video_mjpg_parse(format: Pspa_pod; info: Pspa_video_info_mjpg) : longint; cdecl; external;
+
+function spa_format_video_mjpg_build(builder: Pspa_pod_builder; id: Tuint32_t; info: Pspa_video_info_mjpg) : Pspa_pod; cdecl; external;
+
+function spa_format_audio_raw_parse(format: Pspa_pod; info: Pspa_audio_info_raw) : longint; cdecl; external;
+
+function spa_format_audio_dsp_parse(format: Pspa_pod; info: Pspa_audio_info_dsp) : longint; cdecl; external;
+
+function spa_format_audio_iec958_parse(format: Pspa_pod; info: Pspa_audio_info_iec958) : longint; cdecl; external;
+
+function spa_format_audio_dsd_parse(format: Pspa_pod; info: Pspa_audio_info_dsd) : longint; cdecl; external;
+
+function spa_format_audio_raw_build(builder: Pspa_pod_builder; id: Tuint32_t; info: Pspa_audio_info_raw) : Pspa_pod; cdecl; external;
+
+function spa_format_audio_dsp_build(builder: Pspa_pod_builder; id: Tuint32_t; info: Pspa_audio_info_dsp) : Pspa_pod; cdecl; external;
+
+function spa_format_audio_iec958_build(builder: Pspa_pod_builder; id: Tuint32_t; info: Pspa_audio_info_iec958) : Pspa_pod; cdecl; external;
+
+function spa_format_audio_dsd_build(builder: Pspa_pod_builder; id: Tuint32_t; info: Pspa_audio_info_dsd) : Pspa_pod; cdecl; external;
+
+function spa_latency_info_compare(a: Pspa_latency_info; b: Pspa_latency_info) : longint; cdecl; external;
+
+procedure spa_latency_info_combine_start(info: Pspa_latency_info; direction: Tspa_direction); cdecl; external;
+
+procedure spa_latency_info_combine_finish(info: Pspa_latency_info); cdecl; external;
+
+function spa_latency_info_combine(info: Pspa_latency_info; other: Pspa_latency_info) : longint; cdecl; external;
+
+function spa_latency_parse(latency: Pspa_pod; info: Pspa_latency_info) : longint; cdecl; external;
+
+function spa_latency_build(builder: Pspa_pod_builder; id: Tuint32_t; info: Pspa_latency_info) : Pspa_pod; cdecl; external;
+
+function spa_process_latency_parse(latency: Pspa_pod; info: Pspa_process_latency_info) : longint; cdecl; external;
+
+function spa_process_latency_build(builder: Pspa_pod_builder; id: Tuint32_t; info: Pspa_process_latency_info) : Pspa_pod; cdecl; external;
+
+function spa_process_latency_info_add(process: Pspa_process_latency_info; info: Pspa_latency_info) : longint; cdecl; external;
+
+procedure spa_result_func_node_params(Data: pointer; seq: longint; res: longint; _type: Tuint32_t; Result: pointer); cdecl; external;
+
+function spa_node_enum_params_sync(node: Pspa_node; id: Tuint32_t; index: Puint32_t; filter: Pspa_pod; param: PPspa_pod; builder: Pspa_pod_builder) : longint; cdecl; external;
+
+function spa_node_port_enum_params_sync(node: Pspa_node; direction: Tspa_direction; port_id: Tuint32_t; id: Tuint32_t; index: Puint32_t; filter: Pspa_pod;
+  param: PPspa_pod; builder: Pspa_pod_builder) : longint; cdecl; external;
+
+function spa_buffer_alloc_fill_info(info: Pspa_buffer_alloc_info; n_metas: Tuint32_t; metas: Pspa_meta; n_datas: Tuint32_t; datas: Pspa_data; data_aligns: Puint32_t) : longint; cdecl; external;
+
+function spa_buffer_alloc_layout(info: Pspa_buffer_alloc_info; skel_mem: pointer; data_mem: pointer) : Pspa_buffer; cdecl; external;
+
+function spa_buffer_alloc_layout_array(info: Pspa_buffer_alloc_info; n_buffers: Tuint32_t; buffers: PPspa_buffer; skel_mem: pointer; data_mem: pointer) : longint; cdecl; external;
+
+function spa_buffer_alloc_array(n_buffers: Tuint32_t; flags: Tuint32_t; n_metas: Tuint32_t; metas: Pspa_meta; n_datas: Tuint32_t; datas: Pspa_data;
+  data_aligns: Puint32_t) : PPspa_buffer; cdecl; external;
+
+function spa_buffer_find_meta(b: Pspa_buffer; _type: Tuint32_t) : Pspa_meta; cdecl; external;
+
+function spa_buffer_find_meta_data(b: Pspa_buffer; _type: Tuint32_t; size: Tsize_t) : pointer; cdecl; external;
+
+procedure spa_list_init(list: Pspa_list); cdecl; external;
+
+procedure spa_list_insert(list: Pspa_list; elem: Pspa_list); cdecl; external;
+
+procedure spa_list_insert_list(list: Pspa_list; other: Pspa_list); cdecl; external;
+
+procedure spa_list_remove(elem: Pspa_list); cdecl; external;
+
+function spa_json_to_pod_part(b: Pspa_pod_builder; flags: Tuint32_t; id: Tuint32_t; info: Pspa_type_info; iter: Pspa_json; Value: PChar; len: longint) : longint; cdecl; external;
+
+function spa_json_to_pod(b: Pspa_pod_builder; flags: Tuint32_t; info: Pspa_type_info; Value: PChar; len: longint) : longint; cdecl; external;
+
+function spa_dict_item_compare(i1: pointer; i2: pointer) : longint; cdecl; external;
+
+procedure spa_dict_qsort(dict: Pspa_dict); cdecl; external;
+
+function spa_dict_lookup_item(dict: Pspa_dict; key: PChar) : Pspa_dict_item; cdecl; external;
+
+function spa_dict_lookup(dict: Pspa_dict; key: PChar) : PChar; cdecl; external;
+
+procedure spa_hook_list_init(list: Pspa_hook_list); cdecl; external;
+
+function spa_hook_list_is_empty(list: Pspa_hook_list) : Tbool; cdecl; external;
+
+procedure spa_hook_list_append(list: Pspa_hook_list; hook: Pspa_hook; funcs: pointer; Data: pointer); cdecl; external;
+
+procedure spa_hook_list_prepend(list: Pspa_hook_list; hook: Pspa_hook; funcs: pointer; Data: pointer); cdecl; external;
+
+procedure spa_hook_remove(hook: Pspa_hook); cdecl; external;
+
+procedure spa_hook_list_clean(list: Pspa_hook_list); cdecl; external;
+
+procedure spa_hook_list_isolate(list: Pspa_hook_list; save: Pspa_hook_list; hook: Pspa_hook; funcs: pointer; Data: pointer); cdecl; external;
+
+procedure spa_hook_list_join(list: Pspa_hook_list; save: Pspa_hook_list); cdecl; external;
+
+procedure spa_ringbuffer_init(rbuf: Pspa_ringbuffer); cdecl; external;
+
+procedure spa_ringbuffer_set_avail(rbuf: Pspa_ringbuffer; size: Tuint32_t); cdecl; external;
+
+function spa_ringbuffer_get_read_index(rbuf: Pspa_ringbuffer; index: Puint32_t) : Tint32_t; cdecl; external;
+
+procedure spa_ringbuffer_read_data(rbuf: Pspa_ringbuffer; buffer: pointer; size: Tuint32_t; offset: Tuint32_t; Data: pointer; len: Tuint32_t); cdecl; external;
+
+procedure spa_ringbuffer_read_update(rbuf: Pspa_ringbuffer; index: Tint32_t); cdecl; external;
+
+function spa_ringbuffer_get_write_index(rbuf: Pspa_ringbuffer; index: Puint32_t) : Tint32_t; cdecl; external;
+
+procedure spa_ringbuffer_write_data(rbuf: Pspa_ringbuffer; buffer: pointer; size: Tuint32_t; offset: Tuint32_t; Data: pointer; len: Tuint32_t); cdecl; external;
+
+procedure spa_ringbuffer_write_update(rbuf: Pspa_ringbuffer; index: Tint32_t); cdecl; external;
+
+procedure spa_json_init(iter: Pspa_json; Data: PChar; size: Tsize_t); cdecl; external;
+
+procedure spa_json_enter(iter: Pspa_json; sub: Pspa_json); cdecl; external;
+
+function spa_json_next(iter: Pspa_json; Value: PPchar) : longint; cdecl; external;
+
+function spa_json_enter_container(iter: Pspa_json; sub: Pspa_json; _type: char) : longint; cdecl; external;
+
+function spa_json_is_container(val: PChar; len: longint) : longint; cdecl; external;
+
+function spa_json_container_len(iter: Pspa_json; Value: PChar; len: longint) : longint; cdecl; external;
+
+function spa_json_is_object(val: PChar; len: longint) : longint; cdecl; external;
+
+function spa_json_enter_object(iter: Pspa_json; sub: Pspa_json) : longint; cdecl; external;
+
+function spa_json_is_array(val: PChar; len: longint) : Tbool; cdecl; external;
+
+function spa_json_enter_array(iter: Pspa_json; sub: Pspa_json) : longint; cdecl; external;
+
+function spa_json_is_null(val: PChar; len: longint) : Tbool; cdecl; external;
+
+function spa_json_parse_float(val: PChar; len: longint; Result: Psingle) : longint; cdecl; external;
+
+function spa_json_is_float(val: PChar; len: longint) : Tbool; cdecl; external;
+
+function spa_json_get_float(iter: Pspa_json; res: Psingle) : longint; cdecl; external;
+
+function spa_json_parse_int(val: PChar; len: longint; Result: Plongint) : longint; cdecl; external;
+
+function spa_json_is_int(val: PChar; len: longint) : Tbool; cdecl; external;
+
+function spa_json_get_int(iter: Pspa_json; res: Plongint) : longint; cdecl; external;
+
+function spa_json_is_true(val: PChar; len: longint) : Tbool; cdecl; external;
+
+function spa_json_is_false(val: PChar; len: longint) : Tbool; cdecl; external;
+
+function spa_json_is_bool(val: PChar; len: longint) : Tbool; cdecl; external;
+
+function spa_json_parse_bool(val: PChar; len: longint; Result: Pbool) : longint; cdecl; external;
+
+function spa_json_get_bool(iter: Pspa_json; res: Pbool) : longint; cdecl; external;
+
+function spa_json_is_string(val: PChar; len: longint) : Tbool; cdecl; external;
+
+function spa_json_parse_stringn(val: PChar; len: longint; Result: PChar; maxlen: longint) : longint; cdecl; external;
+
+function spa_json_parse_string(val: PChar; len: longint; Result: PChar) : longint; cdecl; external;
+
+function spa_json_get_string(iter: Pspa_json; res: PChar; maxlen: longint) : longint; cdecl; external;
+
+function spa_json_encode_string(str: PChar; size: longint; val: PChar) : longint; cdecl; external;
+
+function spa_streq(s1: PChar; s2: PChar) : Tbool; cdecl; external;
+
+function spa_strneq(s1: PChar; s2: PChar; len: Tsize_t) : Tbool; cdecl; external;
+
+function spa_strstartswith(s: PChar; prefix: PChar) : Tbool; cdecl; external;
+
+function spa_strendswith(s: PChar; suffix: PChar) : Tbool; cdecl; external;
+
+function spa_atoi32(str: PChar; val: Pint32_t; base: longint) : Tbool; cdecl; external;
+
+function spa_atou32(str: PChar; val: Puint32_t; base: longint) : Tbool; cdecl; external;
+
+function spa_atoi64(str: PChar; val: Pint64_t; base: longint) : Tbool; cdecl; external;
+
+function spa_atou64(str: PChar; val: Puint64_t; base: longint) : Tbool; cdecl; external;
+
+function spa_atob(str: PChar) : Tbool; cdecl; external;
+
+function spa_vscnprintf(buffer: PChar; size: Tsize_t; format: PChar; args: pointer) : longint; cdecl; external;
+
+function spa_scnprintf(buffer: PChar; size: Tsize_t; format: PChar; args: array of const) : longint; cdecl; external; overload;
+
+function spa_scnprintf(buffer: PChar; size: Tsize_t; format: PChar) : longint; cdecl; external; overload;
+
+function spa_atof(str: PChar; val: Psingle) : Tbool; cdecl; external;
+
+function spa_atod(str: PChar; val: Pdouble) : Tbool; cdecl; external;
+
+function spa_type_is_a(_type: PChar; parent: PChar) : Tbool; cdecl; external;
+
+
+
+{$l spabridge.o}
+
+

packages/libpipewire/src/stream.inc

@@ -0,0 +1,138 @@
+
+const
+  PW_VERSION_STREAM_EVENTS = 2;
+
+type
+  Ppw_buffer = ^Tpw_buffer;
+  Ppw_stream = ^Tpw_stream;
+  Ppw_stream_control = ^Tpw_stream_control;
+  Ppw_stream_events = ^Tpw_stream_events;
+  Ppw_stream_flags = ^Tpw_stream_flags;
+  Ppw_time = ^Tpw_time;
+
+  float = double;
+
+  tpw_buffer = record
+    buffer: pspa_buffer;
+    user_data: Pointer;
+    size: tuint64_t;
+  end;
+  tpw_stream = record
+  end;
+
+  tpw_stream_control = record
+    Name: PChar;
+    flags: tuint32_t;
+    def: float;
+    min: float;
+    max: float;
+    values: float;
+    n_values: tuint32_t;
+    max_values: tuint32_t;
+  end;
+
+
+  tpw_time = record
+    now: int64;
+    rate: tspa_fraction;
+    ticks: tuint64_t;
+    delay: int64;
+    queued: tuint64_t;
+  end;
+
+
+  tpw_stream_state = (
+    PW_STREAM_STATE_ERROR := -1,
+    PW_STREAM_STATE_UNCONNECTED := 0,
+    PW_STREAM_STATE_CONNECTING := 1,
+    PW_STREAM_STATE_PAUSED := 2,
+    PW_STREAM_STATE_STREAMING := 3
+    );
+
+  Tpw_stream_events = record
+    version: Tuint32_t;
+    Destroy: procedure(Data: pointer); cdecl;
+    state_changed: procedure(Data: pointer; old: Tpw_stream_state; state: Tpw_stream_state; error: PChar); cdecl;
+    control_info: procedure(Data: pointer; id: Tuint32_t; control: Ppw_stream_control); cdecl;
+    io_changed: procedure(Data: pointer; id: Tuint32_t; area: pointer; size: Tuint32_t); cdecl;
+    param_changed: procedure(Data: pointer; id: Tuint32_t; param: Pspa_pod); cdecl;
+    add_buffer: procedure(Data: pointer; buffer: Ppw_buffer); cdecl;
+    remove_buffer: procedure(Data: pointer; buffer: Ppw_buffer); cdecl;
+    process: procedure(Data: pointer); cdecl;
+    drained: procedure(Data: pointer); cdecl;
+    command: procedure(Data: pointer; command: Pspa_command); cdecl;
+    trigger_done: procedure(Data: pointer); cdecl;
+  end;
+
+
+  Tpw_stream_flags = (
+    PW_STREAM_FLAG_NONE := 0,
+    PW_STREAM_FLAG_AUTOCONNECT := 1 shl 0,
+    PW_STREAM_FLAG_INACTIVE := 1 shl 1,
+    PW_STREAM_FLAG_MAP_BUFFERS := 1 shl 2,
+    PW_STREAM_FLAG_DRIVER := 1 shl 3,
+    PW_STREAM_FLAG_RT_PROCESS := 1 shl 4,
+    PW_STREAM_FLAG_NO_CONVERT := 1 shl 5,
+    PW_STREAM_FLAG_EXCLUSIVE := 1 shl 6,
+    PW_STREAM_FLAG_DONT_RECONNECT := 1 shl 7,
+    PW_STREAM_FLAG_ALLOC_BUFFERS := 1 shl 8,
+    PW_STREAM_FLAG_TRIGGER := 1 shl 9
+    );
+
+
+
+function pw_stream_state_as_string(state: Tpw_stream_state) : PChar; cdecl; external libpipewirename Name 'pw_stream_state_as_string';
+
+
+function pw_stream_new(core: Ppw_core; Name: PChar; props: Ppw_properties) : Ppw_stream; cdecl; external libpipewirename Name 'pw_stream_new';
+
+function pw_stream_new_simple(loop: Ppw_loop; Name: PChar; props: Ppw_properties; events: Ppw_stream_events; Data: pointer) : Ppw_stream; cdecl; external libpipewirename Name 'pw_stream_new_simple';
+
+procedure pw_stream_destroy(stream: Ppw_stream); cdecl; external libpipewirename Name 'pw_stream_destroy';
+
+procedure pw_stream_add_listener(stream: Ppw_stream; listener: Pspa_hook; events: Ppw_stream_events; Data: pointer); cdecl; external libpipewirename Name 'pw_stream_add_listener';
+
+function pw_stream_get_state(stream: Ppw_stream; error: PPchar) : Tpw_stream_state; cdecl; external libpipewirename Name 'pw_stream_get_state';
+
+function pw_stream_get_name(stream: Ppw_stream) : PChar; cdecl; external libpipewirename Name 'pw_stream_get_name';
+
+function pw_stream_get_core(stream: Ppw_stream) : Ppw_core; cdecl; external libpipewirename Name 'pw_stream_get_core';
+
+function pw_stream_get_properties(stream: Ppw_stream) : Ppw_properties; cdecl; external libpipewirename Name 'pw_stream_get_properties';
+
+function pw_stream_update_properties(stream: Ppw_stream; dict: Pspa_dict) : longint; cdecl; external libpipewirename Name 'pw_stream_update_properties';
+
+function pw_stream_connect(stream: Ppw_stream; direction: Tspa_direction; target_id: Tuint32_t; flags: Tpw_stream_flags; params: PPspa_pod; n_params: Tuint32_t) : longint;
+  cdecl; external libpipewirename Name 'pw_stream_connect';
+
+function pw_stream_get_node_id(stream: Ppw_stream) : Tuint32_t; cdecl; external libpipewirename Name 'pw_stream_get_node_id';
+
+function pw_stream_disconnect(stream: Ppw_stream) : longint; cdecl; external libpipewirename Name 'pw_stream_disconnect';
+
+function pw_stream_set_error(stream: Ppw_stream; res: longint; error: PChar; args: array of const) : longint; cdecl; external libpipewirename Name 'pw_stream_set_error';
+
+function pw_stream_set_error(stream: Ppw_stream; res: longint; error: PChar) : longint; cdecl; external libpipewirename Name 'pw_stream_set_error';
+
+function pw_stream_update_params(stream: Ppw_stream; params: PPspa_pod; n_params: Tuint32_t) : longint; cdecl; external libpipewirename Name 'pw_stream_update_params';
+
+function pw_stream_get_control(stream: Ppw_stream; id: Tuint32_t) : Ppw_stream_control; cdecl; external libpipewirename Name 'pw_stream_get_control';
+
+function pw_stream_set_control(stream: Ppw_stream; id: Tuint32_t; n_values: Tuint32_t; values: Psingle; args: array of const) : longint; cdecl; external libpipewirename Name 'pw_stream_set_control';
+
+function pw_stream_set_control(stream: Ppw_stream; id: Tuint32_t; n_values: Tuint32_t; values: Psingle) : longint; cdecl; external libpipewirename Name 'pw_stream_set_control';
+
+function pw_stream_get_time(stream: Ppw_stream; time: Ppw_time) : longint; cdecl; external libpipewirename Name 'pw_stream_get_time';
+
+function pw_stream_dequeue_buffer(stream: Ppw_stream) : Ppw_buffer; cdecl; external libpipewirename Name 'pw_stream_dequeue_buffer';
+
+function pw_stream_queue_buffer(stream: Ppw_stream; buffer: Ppw_buffer) : longint; cdecl; external libpipewirename Name 'pw_stream_queue_buffer';
+
+function pw_stream_set_active(stream: Ppw_stream; active: T_Bool) : longint; cdecl; external libpipewirename Name 'pw_stream_set_active';
+
+function pw_stream_flush(stream: Ppw_stream; drain: T_Bool) : longint; cdecl; external libpipewirename Name 'pw_stream_flush';
+
+function pw_stream_is_driving(stream: Ppw_stream) : T_Bool; cdecl; external libpipewirename Name 'pw_stream_is_driving';
+
+function pw_stream_trigger_process(stream: Ppw_stream) : longint; cdecl; external libpipewirename Name 'pw_stream_trigger_process';
+
+

packages/libpipewire/src/thread.inc

@@ -0,0 +1,26 @@
+
+  const
+    libpipewire='libpipewire-0.3'; {Setup as you need}
+
+  { Pointers to basic pascal types, inserted by h2pas conversion program.}
+  Type
+    PLongint  = ^Longint;
+    PSmallInt = ^SmallInt;
+    PByte     = ^Byte;
+    PWord     = ^Word;
+    PDWord    = ^DWord;
+    PDouble   = ^Double;
+
+  Type
+    Pspa_thread_utils  = ^Tspa_thread_utils;
+{$IFDEF FPC}
+{$PACKRECORDS C}
+{$ENDIF}
+
+
+
+  procedure pw_thread_utils_set(impl:Pspa_thread_utils);cdecl;external libpipewire name 'pw_thread_utils_set';
+
+  function pw_thread_utils_get:Pspa_thread_utils;cdecl;external libpipewire name 'pw_thread_utils_get';
+
+

packages/libpipewire/src/thread_loop.inc

@@ -0,0 +1,47 @@
+
+Type
+  Ppw_thread_loop  = ^Tpw_thread_loop;
+  Ppw_thread_loop_events  = ^Tpw_thread_loop_events;
+  Ptimespec  = ^Ttimespec;
+
+  tpw_thread_loop = record end;
+
+  Tpw_thread_loop_events = record
+    version : Tuint32_t;
+    destroy : procedure (data:pointer);cdecl;
+  end;
+
+
+function pw_thread_loop_new(name:Pchar; props:Pspa_dict):Ppw_thread_loop;cdecl;external libpipewirename name 'pw_thread_loop_new';
+
+function pw_thread_loop_new_full(loop:Ppw_loop; name:Pchar; props:Pspa_dict):Ppw_thread_loop;cdecl;external libpipewirename name 'pw_thread_loop_new_full';
+
+procedure pw_thread_loop_destroy(loop:Ppw_thread_loop);cdecl;external libpipewirename name 'pw_thread_loop_destroy';
+
+procedure pw_thread_loop_add_listener(loop:Ppw_thread_loop; listener:Pspa_hook; events:Ppw_thread_loop_events; data:pointer);cdecl;external libpipewirename name 'pw_thread_loop_add_listener';
+
+function pw_thread_loop_get_loop(loop:Ppw_thread_loop):Ppw_loop;cdecl;external libpipewirename name 'pw_thread_loop_get_loop';
+
+function pw_thread_loop_start(loop:Ppw_thread_loop):longint;cdecl;external libpipewirename name 'pw_thread_loop_start';
+
+procedure pw_thread_loop_stop(loop:Ppw_thread_loop);cdecl;external libpipewirename name 'pw_thread_loop_stop';
+
+procedure pw_thread_loop_lock(loop:Ppw_thread_loop);cdecl;external libpipewirename name 'pw_thread_loop_lock';
+
+procedure pw_thread_loop_unlock(loop:Ppw_thread_loop);cdecl;external libpipewirename name 'pw_thread_loop_unlock';
+
+procedure pw_thread_loop_wait(loop:Ppw_thread_loop);cdecl;external libpipewirename name 'pw_thread_loop_wait';
+
+function pw_thread_loop_timed_wait(loop:Ppw_thread_loop; wait_max_sec:longint):longint;cdecl;external libpipewirename name 'pw_thread_loop_timed_wait';
+
+function pw_thread_loop_get_time(loop:Ppw_thread_loop; abstime:Ptimespec; timeout:Tint64_t):longint;cdecl;external libpipewirename name 'pw_thread_loop_get_time';
+
+function pw_thread_loop_timed_wait_full(loop:Ppw_thread_loop; abstime:Ptimespec):longint;cdecl;external libpipewirename name 'pw_thread_loop_timed_wait_full';
+
+procedure pw_thread_loop_signal(loop:Ppw_thread_loop; wait_for_accept:T_Bool);cdecl;external libpipewirename name 'pw_thread_loop_signal';
+
+procedure pw_thread_loop_accept(loop:Ppw_thread_loop);cdecl;external libpipewirename name 'pw_thread_loop_accept';
+
+function pw_thread_loop_in_thread(loop:Ppw_thread_loop):T_Bool;cdecl;external libpipewirename name 'pw_thread_loop_in_thread';
+
+

packages/libpipewire/src/type.inc

@@ -0,0 +1,9 @@
+
+Type
+  Ptdummy  = ^Ttdummy;
+  Ttdummy = (PW_TYPE_FIRST := SPA_TYPE_VENDOR_PipeWire);
+
+  {
+    const struct spa_type_info * pw_type_info(void);
+   }
+

packages/libpipewire/src/utils.inc

@@ -0,0 +1,17 @@
+
+
+type
+  Tpw_destroy_t = procedure (object_:pointer);cdecl;
+
+
+function pw_split_walk(str:Pchar; delimiter:Pchar; len: Psize_t; state:PPchar):Pchar;cdecl;external libpipewirename name 'pw_split_walk';
+
+function pw_split_strv(str:Pchar; delimiter:Pchar; max_tokens:longint; n_tokens:Plongint):PPchar;cdecl;external libpipewirename name 'pw_split_strv';
+
+procedure pw_free_strv(str:PPchar);cdecl;external libpipewirename name 'pw_free_strv';
+
+function pw_strip(str:Pchar; whitespace:Pchar):Pchar;cdecl;external libpipewirename name 'pw_strip';
+
+function pw_getrandom(buf:pointer; buflen:Tsize_t; flags:dword):Tssize_t;cdecl;external libpipewirename name 'pw_getrandom';
+
+

packages/libpipewire/src/version.inc

@@ -0,0 +1,4 @@
+
+function pw_get_library_version:Pchar;cdecl;external libpipewirename name 'pw_get_library_version';
+
+

packages/libpipewire/src/work_queue.inc

@@ -0,0 +1,18 @@
+
+Type
+  Ppw_work_queue  = ^Tpw_work_queue;
+
+  Tpw_work_func_t = procedure(obj: pointer; Data: pointer; res: longint; id: Tuint32_t); cdecl;
+
+  tpw_work_queue = record
+  end;
+
+procedure pw_work_queue_destroy(queue: Ppw_work_queue); cdecl; external libpipewirename Name 'pw_work_queue_destroy';
+
+function pw_work_queue_add(queue: Ppw_work_queue; obj: pointer; res: longint; func: Tpw_work_func_t; Data: pointer) : Tuint32_t; cdecl; external libpipewirename Name 'pw_work_queue_add';
+
+function pw_work_queue_cancel(queue: Ppw_work_queue; obj: pointer; id: Tuint32_t) : longint; cdecl; external libpipewirename Name 'pw_work_queue_cancel';
+
+function pw_work_queue_complete(queue: Ppw_work_queue; obj: pointer; seq: Tuint32_t; res: longint) : longint; cdecl; external libpipewirename Name 'pw_work_queue_complete';
+
+