Add libogg wrapper for BOX32 (#3596)

Add 32-bit wrapper for libogg (libogg.so.0) to enable native wrapping
in BOX32 mode. This is a simple pass-through wrapper with no callbacks
or struct conversions needed.

New files:
- src/wrapped32/wrappedlibogg.c
- src/wrapped32/wrappedlibogg_private.h
- src/wrapped32/generated/wrappedlibogg{defs,types,undefs}32.h

New signature added to wrapper32 generated files:
- lFpi (intptr_t fn(void*, int32_t))

CMakeLists.txt

@@ -945,7 +945,8 @@ if(BOX32)
         "${BOX64_ROOT}/src/wrapped32/wrappeddbus.c"
         "${BOX64_ROOT}/src/wrapped32/wrappedcurl.c"
         "${BOX64_ROOT}/src/wrapped32/wrappednvml.c"
-        "${BOX64_ROOT}/src/wrapped32/wrappedpulsesimple.c"
+         "${BOX64_ROOT}/src/wrapped32/wrappedpulsesimple.c"
+         "${BOX64_ROOT}/src/wrapped32/wrappedlibogg.c"
     )
     endif()
     string(REPLACE ".c" "_private.h" MODROOT ${BOX64_ROOT})

src/library_list_32.h

@@ -86,6 +86,9 @@ GO("libopenal.so", openal)
 GO("libopenal-soft.so.1", openal)
 GO("openal.so", openal)
 
+GO("libogg.so.0", libogg)
+GO("libogg.so", libogg)
+
 GO("libexpat.so.1", expat)
 GO("libexpat.so", expat)
 

src/wrapped32/generated/functions_list.txt

@@ -327,11 +327,13 @@
 #() dFpp -> dFpp
 #() lEEi -> lEEi
 #() lEES -> lEES
+#() lFEp -> lFEp
 #() lEii -> lEii
 #() lFiL -> lFiL
 #() lFui -> lFui
 #() lFll -> lFll
 #() lEpi -> lEpi
+#() lFpi -> lFpi
 #() lFpu -> lFpu
 #() lFpl -> lFpl
 #() lFpL -> lFpL
@@ -466,6 +468,8 @@
 #() vFEip -> vFEip
 #() vEEpi -> vEEpi
 #() vEEpu -> vEEpu
+#() vFEpi -> vFEpi
+#() vFEpl -> vFEpl
 #() vFEpp -> vFEpp
 #() vFEpV -> vFEpV
 #() vFEXp -> vFEXp
@@ -702,6 +706,7 @@
 #() dEddd -> dEddd
 #() dEddp -> dEddp
 #() lEEuV -> lEEuV
+#() lFEpi -> lFEpi
 #() lEili -> lEili
 #() lEipi -> lEipi
 #() lEipL -> lEipL
@@ -1351,6 +1356,7 @@
 #() vFEuipp -> vFEuipp
 #() vEEpLLp -> vEEpLLp
 #() vEEppiV -> vEEppiV
+#() vFEppi -> vFEppi
 #() vFEpppp -> vFEpppp
 #() vFEXLpL -> vFEXLpL
 #() vFiiiii -> vFiiiii

src/wrapped32/generated/wrappedliboggdefs32.h

@@ -0,0 +1,8 @@
+/*********************************************************************
+ * File automatically generated by rebuild_wrappers_32.py (v0.0.2.2) *
+ *********************************************************************/
+#ifndef __wrappedliboggDEFS32_H_
+#define __wrappedliboggDEFS32_H_
+
+
+#endif // __wrappedliboggDEFS32_H_

src/wrapped32/generated/wrappedliboggtypes32.h

@@ -0,0 +1,79 @@
+/*********************************************************************
+ * File automatically generated by rebuild_wrappers_32.py (v0.0.2.2) *
+ *********************************************************************/
+#ifndef __wrappedliboggTYPES32_H_
+#define __wrappedliboggTYPES32_H_
+
+#ifndef LIBNAME
+#error You should only #include this file inside a wrapped*.c file
+#endif
+#ifndef ADDED_FUNCTIONS
+#define ADDED_FUNCTIONS() 
+#endif
+
+typedef void (*vFp_t)(void*);
+typedef void (*vFpi_t)(void*, int32_t);
+typedef void (*vFpl_t)(void*, long);
+typedef void (*vFpui_t)(void*, uint32_t, int32_t);
+typedef void (*vFppi_t)(void*, void*, int32_t);
+typedef int32_t (*iFp_t)(void*);
+typedef int32_t (*iFpi_t)(void*, int32_t);
+typedef int32_t (*iFpp_t)(void*, void*);
+typedef int32_t (*iFppi_t)(void*, void*, int32_t);
+typedef long (*lFp_t)(void*);
+typedef long (*lFpi_t)(void*, int32_t);
+typedef void* (*pFp_t)(void*);
+typedef void* (*pFpi_t)(void*, int32_t);
+typedef int64_t (*IFp_t)(void*);
+
+#define SUPER() ADDED_FUNCTIONS() \
+	GO(ogg_stream_init, iFpi_t) \
+	GO(ogg_stream_clear, iFp_t) \
+	GO(ogg_stream_reset, iFp_t) \
+	GO(ogg_stream_reset_serialno, iFpi_t) \
+	GO(ogg_stream_packetin, iFpp_t) \
+	GO(ogg_stream_pageout, iFpp_t) \
+	GO(ogg_stream_pageout_fill, iFppi_t) \
+	GO(ogg_stream_flush, iFpp_t) \
+	GO(ogg_stream_flush_fill, iFppi_t) \
+	GO(ogg_stream_pagein, iFpp_t) \
+	GO(ogg_stream_packetout, iFpp_t) \
+	GO(ogg_stream_packetpeek, iFpp_t) \
+	GO(ogg_sync_init, iFp_t) \
+	GO(ogg_sync_clear, iFp_t) \
+	GO(ogg_sync_reset, iFp_t) \
+	GO(ogg_sync_buffer, pFpi_t) \
+	GO(ogg_sync_wrote, iFpi_t) \
+	GO(ogg_sync_pageout, iFpp_t) \
+	GO(ogg_sync_pageseek, iFpp_t) \
+	GO(ogg_page_bos, iFp_t) \
+	GO(ogg_page_eos, iFp_t) \
+	GO(ogg_page_continued, iFp_t) \
+	GO(ogg_page_checksum_set, iFp_t) \
+	GO(ogg_page_granulepos, IFp_t) \
+	GO(ogg_page_packets, iFp_t) \
+	GO(ogg_page_pageno, lFp_t) \
+	GO(ogg_page_serialno, iFp_t) \
+	GO(oggpack_writeinit, vFp_t) \
+	GO(oggpack_writecheck, iFp_t) \
+	GO(oggpack_reset, vFp_t) \
+	GO(oggpack_writeclear, vFp_t) \
+	GO(oggpack_readinit, vFppi_t) \
+	GO(oggpack_write, vFpui_t) \
+	GO(oggpack_look, lFpi_t) \
+	GO(oggpack_read, lFpi_t) \
+	GO(oggpack_adv, vFpi_t) \
+	GO(oggpack_bytes, lFp_t) \
+	GO(oggpack_get_buffer, pFp_t) \
+	GO(oggpack_writetrunc, vFpl_t) \
+	GO(oggpackB_writeinit, vFp_t) \
+	GO(oggpackB_writecheck, iFp_t) \
+	GO(oggpackB_reset, vFp_t) \
+	GO(oggpackB_writeclear, vFp_t) \
+	GO(oggpackB_readinit, vFppi_t) \
+	GO(oggpackB_write, vFpui_t) \
+	GO(oggpackB_read, lFpi_t) \
+	GO(oggpackB_bytes, iFp_t) \
+	GO(oggpackB_get_buffer, pFp_t)
+
+#endif // __wrappedliboggTYPES32_H_

src/wrapped32/generated/wrappedliboggundefs32.h

@@ -0,0 +1,8 @@
+/*********************************************************************
+ * File automatically generated by rebuild_wrappers_32.py (v0.0.2.2) *
+ *********************************************************************/
+#ifndef __wrappedliboggUNDEFS32_H_
+#define __wrappedliboggUNDEFS32_H_
+
+
+#endif // __wrappedliboggUNDEFS32_H_

src/wrapped32/generated/wrapper32.c

@@ -421,11 +421,14 @@ typedef double (*dEll_t)(intptr_t, intptr_t);
 typedef double (*dFpp_t)(void*, void*);
 typedef intptr_t (*lEEi_t)(x64emu_t*, int32_t);
 typedef intptr_t (*lEES_t)(x64emu_t*, void*);
+typedef intptr_t (*lFEp_t)(x64emu_t*, void*);
+typedef intptr_t (*lFEpi_t)(x64emu_t*, void*, int32_t);
 typedef intptr_t (*lEii_t)(int32_t, int32_t);
 typedef intptr_t (*lFiL_t)(int32_t, uintptr_t);
 typedef intptr_t (*lFui_t)(uint32_t, int32_t);
 typedef intptr_t (*lFll_t)(intptr_t, intptr_t);
 typedef intptr_t (*lEpi_t)(void*, int32_t);
+typedef intptr_t (*lFpi_t)(void*, int32_t);
 typedef intptr_t (*lFpu_t)(void*, uint32_t);
 typedef intptr_t (*lFpl_t)(void*, intptr_t);
 typedef intptr_t (*lFpL_t)(void*, uintptr_t);
@@ -560,6 +563,8 @@ typedef void (*vEEip_t)(x64emu_t*, int32_t, void*);
 typedef void (*vFEip_t)(x64emu_t*, int32_t, void*);
 typedef void (*vEEpi_t)(x64emu_t*, void*, int32_t);
 typedef void (*vEEpu_t)(x64emu_t*, void*, uint32_t);
+typedef void (*vFEpi_t)(x64emu_t*, void*, int32_t);
+typedef void (*vFEpl_t)(x64emu_t*, void*, intptr_t);
 typedef void (*vFEpp_t)(x64emu_t*, void*, void*);
 typedef void (*vFEpV_t)(x64emu_t*, void*, void*);
 typedef void (*vFEXp_t)(x64emu_t*, void*, void*);
@@ -1004,6 +1009,7 @@ typedef void (*vEEpuu_t)(x64emu_t*, void*, uint32_t, uint32_t);
 typedef void (*vEEpup_t)(x64emu_t*, void*, uint32_t, void*);
 typedef void (*vFEpup_t)(x64emu_t*, void*, uint32_t, void*);
 typedef void (*vFEpll_t)(x64emu_t*, void*, intptr_t, intptr_t);
+typedef void (*vFEppi_t)(x64emu_t*, void*, void*, int32_t);
 typedef void (*vEEppp_t)(x64emu_t*, void*, void*, void*);
 typedef void (*vFEppp_t)(x64emu_t*, void*, void*, void*);
 typedef void (*vFEXLp_t)(x64emu_t*, void*, uintptr_t, void*);
@@ -2649,11 +2655,13 @@ void dEll_32(x64emu_t *emu, uintptr_t fcn) { dEll_t fn = (dEll_t)fcn; errno = em
 void dFpp_32(x64emu_t *emu, uintptr_t fcn) { dFpp_t fn = (dFpp_t)fcn; double db = fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8)); fpu_do_push(emu); ST0val = db; }
 void lEEi_32(x64emu_t *emu, uintptr_t fcn) { lEEi_t fn = (lEEi_t)fcn; errno = emu->libc_err; R_EAX = to_long(fn(emu, from_ptri(int32_t, R_ESP + 4))); emu->libc_err = errno; }
 void lEES_32(x64emu_t *emu, uintptr_t fcn) { lEES_t fn = (lEES_t)fcn; errno = emu->libc_err; R_EAX = to_long(fn(emu, io_convert32(from_ptriv(R_ESP + 4)))); emu->libc_err = errno; }
+void lFEp_32(x64emu_t *emu, uintptr_t fcn) { lFEp_t fn = (lFEp_t)fcn; R_EAX = to_long(fn(emu, from_ptriv(R_ESP + 4))); }
 void lEii_32(x64emu_t *emu, uintptr_t fcn) { lEii_t fn = (lEii_t)fcn; errno = emu->libc_err; R_EAX = to_long(fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8))); emu->libc_err = errno; }
 void lFiL_32(x64emu_t *emu, uintptr_t fcn) { lFiL_t fn = (lFiL_t)fcn; R_EAX = to_long(fn(from_ptri(int32_t, R_ESP + 4), from_ulong(from_ptri(ulong_t, R_ESP + 8)))); }
 void lFui_32(x64emu_t *emu, uintptr_t fcn) { lFui_t fn = (lFui_t)fcn; R_EAX = to_long(fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8))); }
 void lFll_32(x64emu_t *emu, uintptr_t fcn) { lFll_t fn = (lFll_t)fcn; R_EAX = to_long(fn(from_long(from_ptri(long_t, R_ESP + 4)), from_long(from_ptri(long_t, R_ESP + 8)))); }
 void lEpi_32(x64emu_t *emu, uintptr_t fcn) { lEpi_t fn = (lEpi_t)fcn; errno = emu->libc_err; R_EAX = to_long(fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8))); emu->libc_err = errno; }
+void lFpi_32(x64emu_t *emu, uintptr_t fcn) { lFpi_t fn = (lFpi_t)fcn; R_EAX = to_long(fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8))); }
 void lFpu_32(x64emu_t *emu, uintptr_t fcn) { lFpu_t fn = (lFpu_t)fcn; R_EAX = to_long(fn(from_ptriv(R_ESP + 4), from_ptri(uint32_t, R_ESP + 8))); }
 void lFpl_32(x64emu_t *emu, uintptr_t fcn) { lFpl_t fn = (lFpl_t)fcn; R_EAX = to_long(fn(from_ptriv(R_ESP + 4), from_long(from_ptri(long_t, R_ESP + 8)))); }
 void lFpL_32(x64emu_t *emu, uintptr_t fcn) { lFpL_t fn = (lFpL_t)fcn; R_EAX = to_long(fn(from_ptriv(R_ESP + 4), from_ulong(from_ptri(ulong_t, R_ESP + 8)))); }
@@ -2788,6 +2796,8 @@ void vEEip_32(x64emu_t *emu, uintptr_t fcn) { vEEip_t fn = (vEEip_t)fcn; errno =
 void vFEip_32(x64emu_t *emu, uintptr_t fcn) { vFEip_t fn = (vFEip_t)fcn; fn(emu, from_ptri(int32_t, R_ESP + 4), from_ptriv(R_ESP + 8)); }
 void vEEpi_32(x64emu_t *emu, uintptr_t fcn) { vEEpi_t fn = (vEEpi_t)fcn; errno = emu->libc_err; fn(emu, from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8)); emu->libc_err = errno; }
 void vEEpu_32(x64emu_t *emu, uintptr_t fcn) { vEEpu_t fn = (vEEpu_t)fcn; errno = emu->libc_err; fn(emu, from_ptriv(R_ESP + 4), from_ptri(uint32_t, R_ESP + 8)); emu->libc_err = errno; }
+void vFEpi_32(x64emu_t *emu, uintptr_t fcn) { vFEpi_t fn = (vFEpi_t)fcn; fn(emu, from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8)); }
+void vFEpl_32(x64emu_t *emu, uintptr_t fcn) { vFEpl_t fn = (vFEpl_t)fcn; fn(emu, from_ptriv(R_ESP + 4), from_long(from_ptri(long_t, R_ESP + 8))); }
 void vFEpp_32(x64emu_t *emu, uintptr_t fcn) { vFEpp_t fn = (vFEpp_t)fcn; fn(emu, from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8)); }
 void vFEpV_32(x64emu_t *emu, uintptr_t fcn) { vFEpV_t fn = (vFEpV_t)fcn; fn(emu, from_ptriv(R_ESP + 4), from_ptrv(R_ESP + 8)); }
 void vFEXp_32(x64emu_t *emu, uintptr_t fcn) { vFEXp_t fn = (vFEXp_t)fcn; fn(emu, getDisplay(from_ptriv(R_ESP + 4)), from_ptriv(R_ESP + 8)); }
@@ -3024,6 +3034,7 @@ void fEffp_32(x64emu_t *emu, uintptr_t fcn) { fEffp_t fn = (fEffp_t)fcn; errno =
 void dEddd_32(x64emu_t *emu, uintptr_t fcn) { dEddd_t fn = (dEddd_t)fcn; errno = emu->libc_err; double db = fn(from_ptri(double, R_ESP + 4), from_ptri(double, R_ESP + 12), from_ptri(double, R_ESP + 20)); fpu_do_push(emu); ST0val = db; emu->libc_err = errno; }
 void dEddp_32(x64emu_t *emu, uintptr_t fcn) { dEddp_t fn = (dEddp_t)fcn; errno = emu->libc_err; double db = fn(from_ptri(double, R_ESP + 4), from_ptri(double, R_ESP + 12), from_ptriv(R_ESP + 20)); fpu_do_push(emu); ST0val = db; emu->libc_err = errno; }
 void lEEuV_32(x64emu_t *emu, uintptr_t fcn) { lEEuV_t fn = (lEEuV_t)fcn; errno = emu->libc_err; R_EAX = to_long(fn(emu, from_ptri(uint32_t, R_ESP + 4), from_ptrv(R_ESP + 8))); emu->libc_err = errno; }
+void lFEpi_32(x64emu_t *emu, uintptr_t fcn) { lFEpi_t fn = (lFEpi_t)fcn; R_EAX = to_long(fn(emu, from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8))); }
 void lEili_32(x64emu_t *emu, uintptr_t fcn) { lEili_t fn = (lEili_t)fcn; errno = emu->libc_err; R_EAX = to_long(fn(from_ptri(int32_t, R_ESP + 4), from_long(from_ptri(long_t, R_ESP + 8)), from_ptri(int32_t, R_ESP + 12))); emu->libc_err = errno; }
 void lEipi_32(x64emu_t *emu, uintptr_t fcn) { lEipi_t fn = (lEipi_t)fcn; errno = emu->libc_err; R_EAX = to_long(fn(from_ptri(int32_t, R_ESP + 4), from_ptriv(R_ESP + 8), from_ptri(int32_t, R_ESP + 12))); emu->libc_err = errno; }
 void lEipL_32(x64emu_t *emu, uintptr_t fcn) { lEipL_t fn = (lEipL_t)fcn; errno = emu->libc_err; R_EAX = to_long(fn(from_ptri(int32_t, R_ESP + 4), from_ptriv(R_ESP + 8), from_ulong(from_ptri(ulong_t, R_ESP + 12)))); emu->libc_err = errno; }
@@ -3673,6 +3684,7 @@ void vFEuipu_32(x64emu_t *emu, uintptr_t fcn) { vFEuipu_t fn = (vFEuipu_t)fcn; f
 void vFEuipp_32(x64emu_t *emu, uintptr_t fcn) { vFEuipp_t fn = (vFEuipp_t)fcn; fn(emu, from_ptri(uint32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16)); }
 void vEEpLLp_32(x64emu_t *emu, uintptr_t fcn) { vEEpLLp_t fn = (vEEpLLp_t)fcn; errno = emu->libc_err; fn(emu, from_ptriv(R_ESP + 4), from_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ulong(from_ptri(ulong_t, R_ESP + 12)), from_ptriv(R_ESP + 16)); emu->libc_err = errno; }
 void vEEppiV_32(x64emu_t *emu, uintptr_t fcn) { vEEppiV_t fn = (vEEppiV_t)fcn; errno = emu->libc_err; fn(emu, from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptrv(R_ESP + 16)); emu->libc_err = errno; }
+void vFEppi_32(x64emu_t *emu, uintptr_t fcn) { vFEppi_t fn = (vFEppi_t)fcn; fn(emu, from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptri(int32_t, R_ESP + 12)); }
 void vFEpppp_32(x64emu_t *emu, uintptr_t fcn) { vFEpppp_t fn = (vFEpppp_t)fcn; fn(emu, from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16)); }
 void vFEXLpL_32(x64emu_t *emu, uintptr_t fcn) { vFEXLpL_t fn = (vFEXLpL_t)fcn; fn(emu, getDisplay(from_ptriv(R_ESP + 4)), from_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ptriv(R_ESP + 12), from_ulong(from_ptri(ulong_t, R_ESP + 16))); }
 void vFiiiii_32(x64emu_t *emu, uintptr_t fcn) { vFiiiii_t fn = (vFiiiii_t)fcn; fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20)); }

src/wrapped32/generated/wrapper32.h

@@ -368,11 +368,13 @@ void dEll_32(x64emu_t *emu, uintptr_t fnc);
 void dFpp_32(x64emu_t *emu, uintptr_t fnc);
 void lEEi_32(x64emu_t *emu, uintptr_t fnc);
 void lEES_32(x64emu_t *emu, uintptr_t fnc);
+void lFEp_32(x64emu_t *emu, uintptr_t fnc);
 void lEii_32(x64emu_t *emu, uintptr_t fnc);
 void lFiL_32(x64emu_t *emu, uintptr_t fnc);
 void lFui_32(x64emu_t *emu, uintptr_t fnc);
 void lFll_32(x64emu_t *emu, uintptr_t fnc);
 void lEpi_32(x64emu_t *emu, uintptr_t fnc);
+void lFpi_32(x64emu_t *emu, uintptr_t fnc);
 void lFpu_32(x64emu_t *emu, uintptr_t fnc);
 void lFpl_32(x64emu_t *emu, uintptr_t fnc);
 void lFpL_32(x64emu_t *emu, uintptr_t fnc);
@@ -507,6 +509,8 @@ void vEEip_32(x64emu_t *emu, uintptr_t fnc);
 void vFEip_32(x64emu_t *emu, uintptr_t fnc);
 void vEEpi_32(x64emu_t *emu, uintptr_t fnc);
 void vEEpu_32(x64emu_t *emu, uintptr_t fnc);
+void vFEpi_32(x64emu_t *emu, uintptr_t fnc);
+void vFEpl_32(x64emu_t *emu, uintptr_t fnc);
 void vFEpp_32(x64emu_t *emu, uintptr_t fnc);
 void vFEpV_32(x64emu_t *emu, uintptr_t fnc);
 void vFEXp_32(x64emu_t *emu, uintptr_t fnc);
@@ -743,6 +747,7 @@ void fEffp_32(x64emu_t *emu, uintptr_t fnc);
 void dEddd_32(x64emu_t *emu, uintptr_t fnc);
 void dEddp_32(x64emu_t *emu, uintptr_t fnc);
 void lEEuV_32(x64emu_t *emu, uintptr_t fnc);
+void lFEpi_32(x64emu_t *emu, uintptr_t fnc);
 void lEili_32(x64emu_t *emu, uintptr_t fnc);
 void lEipi_32(x64emu_t *emu, uintptr_t fnc);
 void lEipL_32(x64emu_t *emu, uintptr_t fnc);
@@ -1392,6 +1397,7 @@ void vFEuipu_32(x64emu_t *emu, uintptr_t fnc);
 void vFEuipp_32(x64emu_t *emu, uintptr_t fnc);
 void vEEpLLp_32(x64emu_t *emu, uintptr_t fnc);
 void vEEppiV_32(x64emu_t *emu, uintptr_t fnc);
+void vFEppi_32(x64emu_t *emu, uintptr_t fnc);
 void vFEpppp_32(x64emu_t *emu, uintptr_t fnc);
 void vFEXLpL_32(x64emu_t *emu, uintptr_t fnc);
 void vFiiiii_32(x64emu_t *emu, uintptr_t fnc);

src/wrapped32/wrappedlibogg.c

@@ -0,0 +1,752 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#define _GNU_SOURCE         /* See feature_test_macros(7) */
+#include <dlfcn.h>
+
+#include "wrappedlibs.h"
+
+#include "debug.h"
+#include "wrapper32.h"
+#include "bridge.h"
+#include "librarian/library_private.h"
+#include "x64emu.h"
+#include "emu/x64emu_private.h"
+#include "box32context.h"
+#include "myalign32.h"
+
+static const char* liboggName = "libogg.so.0";
+#define ALTNAME "libogg.so"
+
+#define LIBNAME libogg
+
+#define ADDED_FUNCTIONS()                   \
+
+#include "generated/wrappedliboggtypes32.h"
+
+#include "wrappercallback32.h"
+
+// ============================================================================
+// Native (64-bit) struct definitions matching <ogg/ogg.h>
+// ============================================================================
+
+typedef struct {
+    unsigned char *body_data;
+    long    body_storage;
+    long    body_fill;
+    long    body_returned;
+    int     *lacing_vals;
+    int64_t *granule_vals;
+    long    lacing_storage;
+    long    lacing_fill;
+    long    lacing_packet;
+    long    lacing_returned;
+    unsigned char header[282];
+    int     header_fill;
+    int     e_o_s;
+    int     b_o_s;
+    long    serialno;
+    long    pageno;
+    int64_t packetno;
+    int64_t granulepos;
+} my_ogg_stream_state_t;
+
+typedef struct {
+    unsigned char *data;
+    int     storage;
+    int     fill;
+    int     returned;
+    int     unsynced;
+    int     headerbytes;
+    int     bodybytes;
+} my_ogg_sync_state_t;
+
+typedef struct {
+    unsigned char *header;
+    long    header_len;
+    unsigned char *body;
+    long    body_len;
+} my_ogg_page_t;
+
+typedef struct {
+    unsigned char *packet;
+    long    bytes;
+    long    b_o_s;
+    long    e_o_s;
+    int64_t granulepos;
+    int64_t packetno;
+} my_ogg_packet_t;
+
+typedef struct {
+    long    endbyte;
+    int     endbit;
+    unsigned char *buffer;
+    unsigned char *ptr;
+    long    storage;
+} my_oggpack_buffer_t;
+
+// ============================================================================
+// 32-bit struct definitions (i386 layout)
+// ============================================================================
+
+typedef struct {
+    ptr_t   body_data;          // unsigned char*
+    long_t  body_storage;
+    long_t  body_fill;
+    long_t  body_returned;
+    ptr_t   lacing_vals;        // int*
+    ptr_t   granule_vals;       // int64_t*
+    long_t  lacing_storage;
+    long_t  lacing_fill;
+    long_t  lacing_packet;
+    long_t  lacing_returned;
+    unsigned char header[282];
+    int     header_fill;
+    int     e_o_s;
+    int     b_o_s;
+    long_t  serialno;
+    long_t  pageno;
+    int64_t packetno;
+    int64_t granulepos;
+} my_ogg_stream_state_32_t;
+
+typedef struct {
+    ptr_t   data;               // unsigned char*
+    int     storage;
+    int     fill;
+    int     returned;
+    int     unsynced;
+    int     headerbytes;
+    int     bodybytes;
+} my_ogg_sync_state_32_t;
+
+typedef struct {
+    ptr_t   header;             // unsigned char*
+    long_t  header_len;
+    ptr_t   body;               // unsigned char*
+    long_t  body_len;
+} my_ogg_page_32_t;
+
+typedef struct {
+    ptr_t   packet;             // unsigned char*
+    long_t  bytes;
+    long_t  b_o_s;
+    long_t  e_o_s;
+    int64_t granulepos;
+    int64_t packetno;
+} my_ogg_packet_32_t;
+
+typedef struct {
+    long_t  endbyte;
+    int     endbit;
+    ptr_t   buffer;             // unsigned char*
+    ptr_t   ptr;                // unsigned char*
+    long_t  storage;
+} my_oggpack_buffer_32_t;
+
+// ============================================================================
+// Shadow struct management for ogg_stream_state using khash
+// ============================================================================
+
+KHASH_MAP_INIT_INT(streamstate, my_ogg_stream_state_t*);
+static kh_streamstate_t* stream_shadows = NULL;
+
+KHASH_MAP_INIT_INT(syncstate, my_ogg_sync_state_t*);
+static kh_syncstate_t* sync_shadows = NULL;
+
+// Get or create a native shadow for a 32-bit ogg_stream_state
+static my_ogg_stream_state_t* getStreamShadow(void* a)
+{
+    if(!a) return NULL;
+    ptr_t key = to_ptrv(a);
+    khint_t k = kh_get(streamstate, stream_shadows, key);
+    if(k == kh_end(stream_shadows)) {
+        int r;
+        k = kh_put(streamstate, stream_shadows, key, &r);
+        kh_value(stream_shadows, k) = (my_ogg_stream_state_t*)calloc(1, sizeof(my_ogg_stream_state_t));
+    }
+    return kh_value(stream_shadows, k);
+}
+
+static void delStreamShadow(void* a)
+{
+    if(!a) return;
+    ptr_t key = to_ptrv(a);
+    khint_t k = kh_get(streamstate, stream_shadows, key);
+    if(k != kh_end(stream_shadows)) {
+        free(kh_value(stream_shadows, k));
+        kh_del(streamstate, stream_shadows, k);
+    }
+}
+
+// Get or create a native shadow for a 32-bit ogg_sync_state
+static my_ogg_sync_state_t* getSyncShadow(void* a)
+{
+    if(!a) return NULL;
+    ptr_t key = to_ptrv(a);
+    khint_t k = kh_get(syncstate, sync_shadows, key);
+    if(k == kh_end(sync_shadows)) {
+        int r;
+        k = kh_put(syncstate, sync_shadows, key, &r);
+        kh_value(sync_shadows, k) = (my_ogg_sync_state_t*)calloc(1, sizeof(my_ogg_sync_state_t));
+    }
+    return kh_value(sync_shadows, k);
+}
+
+static void delSyncShadow(void* a)
+{
+    if(!a) return;
+    ptr_t key = to_ptrv(a);
+    khint_t k = kh_get(syncstate, sync_shadows, key);
+    if(k != kh_end(sync_shadows)) {
+        free(kh_value(sync_shadows, k));
+        kh_del(syncstate, sync_shadows, k);
+    }
+}
+
+// ============================================================================
+// Conversion: ogg_stream_state native <-> 32-bit
+// The native shadow is the authoritative copy. We sync back to 32-bit
+// after each call so the app can read fields like serialno, pageno, etc.
+// ============================================================================
+
+static void ogg_stream_state_to_32(my_ogg_stream_state_32_t* dst, const my_ogg_stream_state_t* src)
+{
+    dst->body_data = to_ptrv(src->body_data);
+    dst->body_storage = to_long(src->body_storage);
+    dst->body_fill = to_long(src->body_fill);
+    dst->body_returned = to_long(src->body_returned);
+    dst->lacing_vals = to_ptrv(src->lacing_vals);
+    dst->granule_vals = to_ptrv(src->granule_vals);
+    dst->lacing_storage = to_long(src->lacing_storage);
+    dst->lacing_fill = to_long(src->lacing_fill);
+    dst->lacing_packet = to_long(src->lacing_packet);
+    dst->lacing_returned = to_long(src->lacing_returned);
+    memcpy(dst->header, src->header, 282);
+    dst->header_fill = src->header_fill;
+    dst->e_o_s = src->e_o_s;
+    dst->b_o_s = src->b_o_s;
+    dst->serialno = to_long(src->serialno);
+    dst->pageno = to_long(src->pageno);
+    dst->packetno = src->packetno;
+    dst->granulepos = src->granulepos;
+}
+
+// ============================================================================
+// Conversion: ogg_sync_state native <-> 32-bit
+// ============================================================================
+
+static void ogg_sync_state_to_32(my_ogg_sync_state_32_t* dst, const my_ogg_sync_state_t* src)
+{
+    dst->data = to_ptrv(src->data);
+    dst->storage = src->storage;
+    dst->fill = src->fill;
+    dst->returned = src->returned;
+    dst->unsynced = src->unsynced;
+    dst->headerbytes = src->headerbytes;
+    dst->bodybytes = src->bodybytes;
+}
+
+// ============================================================================
+// Conversion: ogg_page native -> 32-bit and 32-bit -> native
+// ============================================================================
+
+static void ogg_page_to_native(my_ogg_page_t* dst, const my_ogg_page_32_t* src)
+{
+    dst->header = from_ptrv(src->header);
+    dst->header_len = from_long(src->header_len);
+    dst->body = from_ptrv(src->body);
+    dst->body_len = from_long(src->body_len);
+}
+
+static void ogg_page_to_32(my_ogg_page_32_t* dst, const my_ogg_page_t* src)
+{
+    dst->header = to_ptrv(src->header);
+    dst->header_len = to_long(src->header_len);
+    dst->body = to_ptrv(src->body);
+    dst->body_len = to_long(src->body_len);
+}
+
+// ============================================================================
+// Conversion: ogg_packet native <-> 32-bit
+// ============================================================================
+
+static void ogg_packet_to_native(my_ogg_packet_t* dst, const my_ogg_packet_32_t* src)
+{
+    dst->packet = from_ptrv(src->packet);
+    dst->bytes = from_long(src->bytes);
+    dst->b_o_s = from_long(src->b_o_s);
+    dst->e_o_s = from_long(src->e_o_s);
+    dst->granulepos = src->granulepos;
+    dst->packetno = src->packetno;
+}
+
+static void ogg_packet_to_32(my_ogg_packet_32_t* dst, const my_ogg_packet_t* src)
+{
+    dst->packet = to_ptrv(src->packet);
+    dst->bytes = to_long(src->bytes);
+    dst->b_o_s = to_long(src->b_o_s);
+    dst->e_o_s = to_long(src->e_o_s);
+    dst->granulepos = src->granulepos;
+    dst->packetno = src->packetno;
+}
+
+// ============================================================================
+// Conversion: oggpack_buffer native <-> 32-bit
+// ============================================================================
+
+static void oggpack_buffer_to_native(my_oggpack_buffer_t* dst, const my_oggpack_buffer_32_t* src)
+{
+    dst->endbyte = from_long(src->endbyte);
+    dst->endbit = src->endbit;
+    dst->buffer = from_ptrv(src->buffer);
+    dst->ptr = from_ptrv(src->ptr);
+    dst->storage = from_long(src->storage);
+}
+
+static void oggpack_buffer_to_32(my_oggpack_buffer_32_t* dst, const my_oggpack_buffer_t* src)
+{
+    dst->endbyte = to_long(src->endbyte);
+    dst->endbit = src->endbit;
+    dst->buffer = to_ptrv(src->buffer);
+    dst->ptr = to_ptrv(src->ptr);
+    dst->storage = to_long(src->storage);
+}
+
+// ============================================================================
+// ogg_stream_* wrappers
+// ============================================================================
+
+EXPORT int my32_ogg_stream_init(x64emu_t* emu, void* os, int serialno)
+{
+    my_ogg_stream_state_t* shadow = getStreamShadow(os);
+    int ret = my->ogg_stream_init(shadow, serialno);
+    ogg_stream_state_to_32(os, shadow);
+    return ret;
+}
+
+EXPORT int my32_ogg_stream_clear(x64emu_t* emu, void* os)
+{
+    my_ogg_stream_state_t* shadow = getStreamShadow(os);
+    int ret = my->ogg_stream_clear(shadow);
+    // After clear, the struct is zeroed; sync back and remove shadow
+    ogg_stream_state_to_32(os, shadow);
+    delStreamShadow(os);
+    return ret;
+}
+
+EXPORT int my32_ogg_stream_reset(x64emu_t* emu, void* os)
+{
+    my_ogg_stream_state_t* shadow = getStreamShadow(os);
+    int ret = my->ogg_stream_reset(shadow);
+    ogg_stream_state_to_32(os, shadow);
+    return ret;
+}
+
+EXPORT int my32_ogg_stream_reset_serialno(x64emu_t* emu, void* os, int serialno)
+{
+    my_ogg_stream_state_t* shadow = getStreamShadow(os);
+    int ret = my->ogg_stream_reset_serialno(shadow, serialno);
+    ogg_stream_state_to_32(os, shadow);
+    return ret;
+}
+
+EXPORT int my32_ogg_stream_packetin(x64emu_t* emu, void* os, void* op)
+{
+    my_ogg_stream_state_t* shadow = getStreamShadow(os);
+    my_ogg_packet_t op_l;
+    ogg_packet_to_native(&op_l, op);
+    int ret = my->ogg_stream_packetin(shadow, &op_l);
+    ogg_stream_state_to_32(os, shadow);
+    // ogg_stream_packetin doesn't modify the packet
+    return ret;
+}
+
+EXPORT int my32_ogg_stream_pageout(x64emu_t* emu, void* os, void* og)
+{
+    my_ogg_stream_state_t* shadow = getStreamShadow(os);
+    my_ogg_page_t og_l = {0};
+    int ret = my->ogg_stream_pageout(shadow, &og_l);
+    ogg_stream_state_to_32(os, shadow);
+    if(og) ogg_page_to_32(og, &og_l);
+    return ret;
+}
+
+EXPORT int my32_ogg_stream_pageout_fill(x64emu_t* emu, void* os, void* og, int nfill)
+{
+    my_ogg_stream_state_t* shadow = getStreamShadow(os);
+    my_ogg_page_t og_l = {0};
+    int ret = my->ogg_stream_pageout_fill(shadow, &og_l, nfill);
+    ogg_stream_state_to_32(os, shadow);
+    if(og) ogg_page_to_32(og, &og_l);
+    return ret;
+}
+
+EXPORT int my32_ogg_stream_flush(x64emu_t* emu, void* os, void* og)
+{
+    my_ogg_stream_state_t* shadow = getStreamShadow(os);
+    my_ogg_page_t og_l = {0};
+    int ret = my->ogg_stream_flush(shadow, &og_l);
+    ogg_stream_state_to_32(os, shadow);
+    if(og) ogg_page_to_32(og, &og_l);
+    return ret;
+}
+
+EXPORT int my32_ogg_stream_flush_fill(x64emu_t* emu, void* os, void* og, int nfill)
+{
+    my_ogg_stream_state_t* shadow = getStreamShadow(os);
+    my_ogg_page_t og_l = {0};
+    int ret = my->ogg_stream_flush_fill(shadow, &og_l, nfill);
+    ogg_stream_state_to_32(os, shadow);
+    if(og) ogg_page_to_32(og, &og_l);
+    return ret;
+}
+
+EXPORT int my32_ogg_stream_pagein(x64emu_t* emu, void* os, void* og)
+{
+    my_ogg_stream_state_t* shadow = getStreamShadow(os);
+    my_ogg_page_t og_l;
+    ogg_page_to_native(&og_l, og);
+    int ret = my->ogg_stream_pagein(shadow, &og_l);
+    ogg_stream_state_to_32(os, shadow);
+    return ret;
+}
+
+EXPORT int my32_ogg_stream_packetout(x64emu_t* emu, void* os, void* op)
+{
+    my_ogg_stream_state_t* shadow = getStreamShadow(os);
+    my_ogg_packet_t op_l = {0};
+    int ret = my->ogg_stream_packetout(shadow, op?(&op_l):NULL);
+    ogg_stream_state_to_32(os, shadow);
+    if(op) ogg_packet_to_32(op, &op_l);
+    return ret;
+}
+
+EXPORT int my32_ogg_stream_packetpeek(x64emu_t* emu, void* os, void* op)
+{
+    my_ogg_stream_state_t* shadow = getStreamShadow(os);
+    my_ogg_packet_t op_l = {0};
+    int ret = my->ogg_stream_packetpeek(shadow, op?(&op_l):NULL);
+    ogg_stream_state_to_32(os, shadow);
+    if(op) ogg_packet_to_32(op, &op_l);
+    return ret;
+}
+
+// ============================================================================
+// ogg_sync_* wrappers
+// ============================================================================
+
+EXPORT int my32_ogg_sync_init(x64emu_t* emu, void* oy)
+{
+    my_ogg_sync_state_t* shadow = getSyncShadow(oy);
+    int ret = my->ogg_sync_init(shadow);
+    ogg_sync_state_to_32(oy, shadow);
+    return ret;
+}
+
+EXPORT int my32_ogg_sync_clear(x64emu_t* emu, void* oy)
+{
+    my_ogg_sync_state_t* shadow = getSyncShadow(oy);
+    int ret = my->ogg_sync_clear(shadow);
+    ogg_sync_state_to_32(oy, shadow);
+    delSyncShadow(oy);
+    return ret;
+}
+
+EXPORT int my32_ogg_sync_reset(x64emu_t* emu, void* oy)
+{
+    my_ogg_sync_state_t* shadow = getSyncShadow(oy);
+    int ret = my->ogg_sync_reset(shadow);
+    ogg_sync_state_to_32(oy, shadow);
+    return ret;
+}
+
+EXPORT void* my32_ogg_sync_buffer(x64emu_t* emu, void* oy, int size)
+{
+    my_ogg_sync_state_t* shadow = getSyncShadow(oy);
+    void* ret = my->ogg_sync_buffer(shadow, size);
+    ogg_sync_state_to_32(oy, shadow);
+    return ret;
+}
+
+EXPORT int my32_ogg_sync_wrote(x64emu_t* emu, void* oy, int bytes)
+{
+    my_ogg_sync_state_t* shadow = getSyncShadow(oy);
+    int ret = my->ogg_sync_wrote(shadow, bytes);
+    ogg_sync_state_to_32(oy, shadow);
+    return ret;
+}
+
+EXPORT int my32_ogg_sync_pageout(x64emu_t* emu, void* oy, void* og)
+{
+    my_ogg_sync_state_t* shadow = getSyncShadow(oy);
+    my_ogg_page_t og_l = {0};
+    int ret = my->ogg_sync_pageout(shadow, &og_l);
+    ogg_sync_state_to_32(oy, shadow);
+    if(og) ogg_page_to_32(og, &og_l);
+    return ret;
+}
+
+EXPORT int my32_ogg_sync_pageseek(x64emu_t* emu, void* oy, void* og)
+{
+    my_ogg_sync_state_t* shadow = getSyncShadow(oy);
+    my_ogg_page_t og_l = {0};
+    int ret = my->ogg_sync_pageseek(shadow, og?(&og_l):NULL);
+    ogg_sync_state_to_32(oy, shadow);
+    if(og) ogg_page_to_32(og, &og_l);
+    return ret;
+}
+
+// ============================================================================
+// ogg_page_* wrappers (read-only accessors, page is ephemeral)
+// ============================================================================
+
+EXPORT int my32_ogg_page_bos(x64emu_t* emu, void* og)
+{
+    my_ogg_page_t og_l;
+    ogg_page_to_native(&og_l, og);
+    return my->ogg_page_bos(&og_l);
+}
+
+EXPORT int my32_ogg_page_eos(x64emu_t* emu, void* og)
+{
+    my_ogg_page_t og_l;
+    ogg_page_to_native(&og_l, og);
+    return my->ogg_page_eos(&og_l);
+}
+
+EXPORT int my32_ogg_page_continued(x64emu_t* emu, void* og)
+{
+    my_ogg_page_t og_l;
+    ogg_page_to_native(&og_l, og);
+    return my->ogg_page_continued(&og_l);
+}
+
+EXPORT int my32_ogg_page_checksum_set(x64emu_t* emu, void* og)
+{
+    my_ogg_page_t og_l;
+    ogg_page_to_native(&og_l, og);
+    // checksum_set modifies the page header in-place (the header data itself, not the struct)
+    my->ogg_page_checksum_set(&og_l);
+    // pointers haven't changed, no need to convert back
+    return 0;
+}
+
+EXPORT int64_t my32_ogg_page_granulepos(x64emu_t* emu, void* og)
+{
+    my_ogg_page_t og_l;
+    ogg_page_to_native(&og_l, og);
+    return my->ogg_page_granulepos(&og_l);
+}
+
+EXPORT int my32_ogg_page_packets(x64emu_t* emu, void* og)
+{
+    my_ogg_page_t og_l;
+    ogg_page_to_native(&og_l, og);
+    return my->ogg_page_packets(&og_l);
+}
+
+EXPORT long my32_ogg_page_pageno(x64emu_t* emu, void* og)
+{
+    my_ogg_page_t og_l;
+    ogg_page_to_native(&og_l, og);
+    return my->ogg_page_pageno(&og_l);
+}
+
+EXPORT int my32_ogg_page_serialno(x64emu_t* emu, void* og)
+{
+    my_ogg_page_t og_l;
+    ogg_page_to_native(&og_l, og);
+    return my->ogg_page_serialno(&og_l);
+}
+
+// ============================================================================
+// oggpack_* wrappers (bitpacking functions)
+// ============================================================================
+
+EXPORT void my32_oggpack_writeinit(x64emu_t* emu, void* b)
+{
+    my_oggpack_buffer_t b_l = {0};
+    my->oggpack_writeinit(&b_l);
+    oggpack_buffer_to_32(b, &b_l);
+}
+
+EXPORT int my32_oggpack_writecheck(x64emu_t* emu, void* b)
+{
+    my_oggpack_buffer_t b_l;
+    oggpack_buffer_to_native(&b_l, b);
+    int ret = my->oggpack_writecheck(&b_l);
+    oggpack_buffer_to_32(b, &b_l);
+    return ret;
+}
+
+EXPORT void my32_oggpack_reset(x64emu_t* emu, void* b)
+{
+    my_oggpack_buffer_t b_l;
+    oggpack_buffer_to_native(&b_l, b);
+    my->oggpack_reset(&b_l);
+    oggpack_buffer_to_32(b, &b_l);
+}
+
+EXPORT void my32_oggpack_writeclear(x64emu_t* emu, void* b)
+{
+    my_oggpack_buffer_t b_l;
+    oggpack_buffer_to_native(&b_l, b);
+    my->oggpack_writeclear(&b_l);
+    oggpack_buffer_to_32(b, &b_l);
+}
+
+EXPORT void my32_oggpack_readinit(x64emu_t* emu, void* b, void* buf, int bytes)
+{
+    my_oggpack_buffer_t b_l = {0};
+    my->oggpack_readinit(&b_l, buf, bytes);
+    oggpack_buffer_to_32(b, &b_l);
+}
+
+EXPORT void my32_oggpack_write(x64emu_t* emu, void* b, unsigned long value, int bits)
+{
+    my_oggpack_buffer_t b_l;
+    oggpack_buffer_to_native(&b_l, b);
+    my->oggpack_write(&b_l, value, bits);
+    oggpack_buffer_to_32(b, &b_l);
+}
+
+EXPORT long my32_oggpack_look(x64emu_t* emu, void* b, int bits)
+{
+    my_oggpack_buffer_t b_l;
+    oggpack_buffer_to_native(&b_l, b);
+    return my->oggpack_look(&b_l, bits);
+}
+
+EXPORT long my32_oggpack_read(x64emu_t* emu, void* b, int bits)
+{
+    my_oggpack_buffer_t b_l;
+    oggpack_buffer_to_native(&b_l, b);
+    long ret = my->oggpack_read(&b_l, bits);
+    oggpack_buffer_to_32(b, &b_l);
+    return ret;
+}
+
+EXPORT void my32_oggpack_adv(x64emu_t* emu, void* b, int bits)
+{
+    my_oggpack_buffer_t b_l;
+    oggpack_buffer_to_native(&b_l, b);
+    my->oggpack_adv(&b_l, bits);
+    oggpack_buffer_to_32(b, &b_l);
+}
+
+EXPORT long my32_oggpack_bytes(x64emu_t* emu, void* b)
+{
+    my_oggpack_buffer_t b_l;
+    oggpack_buffer_to_native(&b_l, b);
+    return my->oggpack_bytes(&b_l);
+}
+
+EXPORT void* my32_oggpack_get_buffer(x64emu_t* emu, void* b)
+{
+    my_oggpack_buffer_t b_l;
+    oggpack_buffer_to_native(&b_l, b);
+    return my->oggpack_get_buffer(&b_l);
+}
+
+EXPORT void my32_oggpack_writetrunc(x64emu_t* emu, void* b, long bits)
+{
+    my_oggpack_buffer_t b_l;
+    oggpack_buffer_to_native(&b_l, b);
+    my->oggpack_writetrunc(&b_l, bits);
+    oggpack_buffer_to_32(b, &b_l);
+}
+
+// ============================================================================
+// oggpackB_* wrappers (MSb bitpacking functions)
+// ============================================================================
+
+EXPORT void my32_oggpackB_writeinit(x64emu_t* emu, void* b)
+{
+    my_oggpack_buffer_t b_l = {0};
+    my->oggpackB_writeinit(&b_l);
+    oggpack_buffer_to_32(b, &b_l);
+}
+
+EXPORT int my32_oggpackB_writecheck(x64emu_t* emu, void* b)
+{
+    my_oggpack_buffer_t b_l;
+    oggpack_buffer_to_native(&b_l, b);
+    int ret = my->oggpackB_writecheck(&b_l);
+    oggpack_buffer_to_32(b, &b_l);
+    return ret;
+}
+
+EXPORT void my32_oggpackB_reset(x64emu_t* emu, void* b)
+{
+    my_oggpack_buffer_t b_l;
+    oggpack_buffer_to_native(&b_l, b);
+    my->oggpackB_reset(&b_l);
+    oggpack_buffer_to_32(b, &b_l);
+}
+
+EXPORT void my32_oggpackB_writeclear(x64emu_t* emu, void* b)
+{
+    my_oggpack_buffer_t b_l;
+    oggpack_buffer_to_native(&b_l, b);
+    my->oggpackB_writeclear(&b_l);
+    oggpack_buffer_to_32(b, &b_l);
+}
+
+EXPORT void my32_oggpackB_readinit(x64emu_t* emu, void* b, void* buf, int bytes)
+{
+    my_oggpack_buffer_t b_l = {0};
+    my->oggpackB_readinit(&b_l, buf, bytes);
+    oggpack_buffer_to_32(b, &b_l);
+}
+
+EXPORT void my32_oggpackB_write(x64emu_t* emu, void* b, unsigned long value, int bits)
+{
+    my_oggpack_buffer_t b_l;
+    oggpack_buffer_to_native(&b_l, b);
+    my->oggpackB_write(&b_l, value, bits);
+    oggpack_buffer_to_32(b, &b_l);
+}
+
+EXPORT long my32_oggpackB_read(x64emu_t* emu, void* b, int bits)
+{
+    my_oggpack_buffer_t b_l;
+    oggpack_buffer_to_native(&b_l, b);
+    long ret = my->oggpackB_read(&b_l, bits);
+    oggpack_buffer_to_32(b, &b_l);
+    return ret;
+}
+
+EXPORT int my32_oggpackB_bytes(x64emu_t* emu, void* b)
+{
+    my_oggpack_buffer_t b_l;
+    oggpack_buffer_to_native(&b_l, b);
+    return my->oggpackB_bytes(&b_l);
+}
+
+EXPORT void* my32_oggpackB_get_buffer(x64emu_t* emu, void* b)
+{
+    my_oggpack_buffer_t b_l;
+    oggpack_buffer_to_native(&b_l, b);
+    return my->oggpackB_get_buffer(&b_l);
+}
+
+// ============================================================================
+// Init / Fini
+// ============================================================================
+
+#define CUSTOM_INIT \
+    stream_shadows = kh_init(streamstate);  \
+    sync_shadows = kh_init(syncstate);
+
+#define CUSTOM_FINI \
+    my_ogg_stream_state_t* ss;                                  \
+    kh_foreach_value(stream_shadows, ss, free(ss));             \
+    kh_destroy(streamstate, stream_shadows);                    \
+    stream_shadows = NULL;                                      \
+    my_ogg_sync_state_t* sy;                                    \
+    kh_foreach_value(sync_shadows, sy, free(sy));               \
+    kh_destroy(syncstate, sync_shadows);                        \
+    sync_shadows = NULL;
+
+#include "wrappedlib_init32.h"

src/wrapped32/wrappedlibogg_private.h

@@ -0,0 +1,79 @@
+#if !(defined(GO) && defined(GOM) && defined(GO2) && defined(DATA))
+#error meh!
+#endif
+
+//oggpack functions - all take oggpack_buffer*
+GOM(oggpack_adv, vFEpi)
+//GO(oggpack_adv1,
+//GO(oggpackB_adv,
+//GO(oggpackB_adv1,
+//GO(oggpackB_bits,
+GOM(oggpackB_bytes, iFEp)
+GOM(oggpackB_get_buffer, pFEp)
+//GO(oggpack_bits,
+//GO(oggpackB_look,
+//GO(oggpackB_look1,
+GOM(oggpackB_read, lFEpi)
+//GO(oggpackB_read1,
+GOM(oggpackB_readinit, vFEppi)
+GOM(oggpackB_reset, vFEp)
+GOM(oggpackB_write, vFEpui)
+//GO(oggpackB_writealign,
+GOM(oggpackB_writecheck, iFEp)
+GOM(oggpackB_writeclear, vFEp)
+//GO(oggpackB_writecopy,
+GOM(oggpackB_writeinit, vFEp)
+//GO(oggpackB_writetrunc,
+GOM(oggpack_bytes, lFEp)
+//GO(ogg_packet_clear,
+GOM(oggpack_get_buffer, pFEp)
+GOM(oggpack_look, lFEpi)
+//GO(oggpack_look1,
+GOM(oggpack_read, lFEpi)
+//GO(oggpack_read1,
+GOM(oggpack_readinit, vFEppi)
+GOM(oggpack_reset, vFEp)
+GOM(oggpack_write, vFEpui)
+//GO(oggpack_writealign,
+GOM(oggpack_writecheck, iFEp)
+GOM(oggpack_writeclear, vFEp)
+//GO(oggpack_writecopy,
+GOM(oggpack_writeinit, vFEp)
+GOM(oggpack_writetrunc, vFEpl)
+//ogg_page functions - all take ogg_page*
+GOM(ogg_page_bos, iFEp)
+GOM(ogg_page_checksum_set, iFEp)
+GOM(ogg_page_continued, iFEp)
+GOM(ogg_page_eos, iFEp)
+GOM(ogg_page_granulepos, IFEp)
+GOM(ogg_page_packets, iFEp)
+GOM(ogg_page_pageno, lFEp)
+GOM(ogg_page_serialno, iFEp)
+//GO(ogg_page_version,
+//ogg_stream functions - take ogg_stream_state* and optionally ogg_page*/ogg_packet*
+//GO(ogg_stream_check,
+GOM(ogg_stream_clear, iFEp)
+//GO(ogg_stream_destroy,
+//GO(ogg_stream_eos,
+GOM(ogg_stream_flush, iFEpp)
+GOM(ogg_stream_flush_fill, iFEppi)
+GOM(ogg_stream_init, iFEpi)
+//GO(ogg_stream_iovecin,
+GOM(ogg_stream_packetin, iFEpp)
+GOM(ogg_stream_packetout, iFEpp)
+GOM(ogg_stream_packetpeek, iFEpp)
+GOM(ogg_stream_pagein, iFEpp)
+GOM(ogg_stream_pageout, iFEpp)
+GOM(ogg_stream_pageout_fill, iFEppi)
+GOM(ogg_stream_reset, iFEp)
+GOM(ogg_stream_reset_serialno, iFEpi)
+//ogg_sync functions - take ogg_sync_state* and optionally ogg_page*
+GOM(ogg_sync_buffer, pFEpi)
+//GO(ogg_sync_check,
+GOM(ogg_sync_clear, iFEp)
+//GO(ogg_sync_destroy,
+GOM(ogg_sync_init, iFEp)
+GOM(ogg_sync_pageout, iFEpp)
+GOM(ogg_sync_pageseek, iFEpp)
+GOM(ogg_sync_reset, iFEp)
+GOM(ogg_sync_wrote, iFEpi)