FMODEX-include

[Froggerprogger]

Change the fmodex.pb to the following:

Code: Select all

Procedure.l FMOD_Sound_GetTag (Sound.l, pNameOrNull.l, Index.l, *Tag.l)
  ProcedureReturn CallFunction(fmodLib, "FMOD_Sound_GetTag", Sound.l, pNameOrNull.l, Index.l, *Tag.l)
EndProcedure

(or download the updated version). It seems that the NULL-String in VB even if passed by value is different to PB's. I think in VB it is a nullpointer, while in PB the constant #NULL$ is the String "", so you requested an empty title with your call. The only way to pass the compiler is now to change the parameter to a long as done above. To pass a String you will have to use now e.g. @"TITLE", but you can pass 0 or #NULL as well, as in the following:

Code: Select all

IncludeFile "fmodex.pb" 

Init_FMOD() 
FMOD_System_Create(@System) 
FMOD_System_Init(System,1,#FMOD_INIT_NORMAL,#Null) 

File$ = OpenFileRequester("Open media:","","",0) 

If File$ 
  Define TagCount, i, Tag.FMOD_TAG 
  FMOD_System_CreateStream(System,@File$,#FMOD_DEFAULT,#Null,@Sound) 
  FMOD_Sound_GetNumTags(Sound,@TagCount,#Null) 
  Debug "Number of tags: " + Str(TagCount) 
  For i=0 To TagCount-1 
    FMOD_Sound_GetTag(Sound,0,i,@Tag) 
    Debug "TAG Struct:" 
    Debug Tag\type 
    Debug Tag\datatype 
    Debug Tag\name 
    Debug Tag\_data 
    Debug Tag\datalen 
    Debug Tag\udated
    Debug PeekS(Tag\name) + " : " + PeekS(Tag\_data, Tag\datalen)
    Debug "" 
  Next 
EndIf 

FMOD_Sound_Release(Sound) 
FMOD_System_Release(System)

Could be that this occurs in some other functions, too. In fact everywhere, where in VB a String is passed by value, but with NULL a valid value.

[Joakim Christiansen]

Thanks! You're great!

[Flype]

Hi everybody,

Generally i prefer to use Import/EndImport rather than using OpenLibrary().
And fortunately, the FMod API provide the '/FMOD Programmers API Win32/api/lib/fmodex_vc.lib'.

I modified for my own use the 'fmodex.pb' include to use Import/EndImport.
This should be faster than wrapping all FMod functions with procedures.

If you are interested, it's here : fmodex.zip

Best regards.

[Inner]

nice job, it works on linux too although Flype's will only work on windows, but that's minor change to fix that for linux.

[GregBUG]

nice job, it works on linux too although Flype's will only work on windows, but that's minor change to fix that for linux.

hi! i'm trying to use this lib (by Froggerprogger) on linux (ubuntu 8.10) with PB 4.30
i changed Init_FMOD() to load .so lib and it works...

Code: Select all

Procedure Init_FMOD()
  fmodLib = OpenLibrary(#PB_Any, "libfmodex.so")
  ProcedureReturn IsLibrary(fmodLib)
EndProcedure

but when i try to compile the test source (view original first post)

pb stop with the error:

invalid memory access.
on line:

Code: Select all

Procedure.l FMOD_System_Create (*system.l)
  ProcedureReturn CallFunction(fmodLib, "FMOD_System_Create", *system.l)
EndProcedure

can you help me?
thanks!

[GregBUG]

Solved!

just replace CallFunction with CallCFunction and work fine!!!

thanks.!

[Delonra]

G'day All,

This is my first post to this board so please excuse if I muck something up and have to come back and correct it.

I'm the newest of noobs when it comes to PB but having discovered it a week or so ago I've been having lots of fun learning to program again.

I'm posting to this thread because I had a little project in mind that will make extensive use of sound and also sound recordings (not a game). So looking around I quickly found FMOD and this thread.

Unfortunately time had moved on since the original posts and no longer would the posted examples in this thread compile properly. FMOD itself was many version later and PB had undergone substantial change as well.

So I set about trying to update the original Froggerprogger FMODex include file so that all would work again. Mostly I have had some success much to my surprise because I really am just a total newbie to all this.

This is still work in progress and I'm sure (even hopeful) that many will point out better ways of doing things.

WARNING! I have NOT been carefully through all the FMODex API calls and verified that they all function correctly. All I have done is make a very few example code programs work that I have been playing with while learning both PB and FMOD. So expect to find other things broken in there!

I'm now going to attempt pasting my modified version of Froggerprogger FMODex include file (I'm worried that this won't work because it is rather long).

I'll post an example program next which uses this include and hopefully this may help some people like me who come along after.

Then I'll own up to what I know doesn't work properly and ask for some HELP!!!

73, Delonra.

Yep, I've got a problem. This code sample is too large to be posted in the message body. It gets truncated. Hang in there and I'll try to post it to my web server and provide a link

Alright, let's try this. Code available here:-

http://www.mscarc.org/pb/fmodex.pbi

Still learning to drive all this so someone please let me know if this doesn't work.

[Delonra]

G'day again,

This is an updated example FMOD program which shows both playback and recording sound into/from a 5 second sound buffer. It also shows how to record that 5 seconds to disk in a WAV format file.

It uses my updated FMODex include file (see previous post).

I'm a Linux type here but most of my mates still use Windows. This was one of the BIG attractions of PB. Now I can write code for myself but still share the results with everybody else. So I've tried hard to make this code (and the code of the modified FMODex include file) compile on either platform without modification.

Next post, what is still broken and a plea for help.

73, Delonra

Code: Select all

;=== Filename: record_new.pb
;
; ===============================================================================================
; Record example
; Copyright (c), Firelight Technologies Pty, Ltd 2004-2005.
;
; This example shows how to record a sound, then write it To a wav file.
; It then shows how to play a sound While it is being recorded to.  Because it is recording, the
; sound playback has to be delayed a little bit so that the playback doesn't play part of the
; buffer that is still being written To.
; ===============================================================================================

; ===============================================================================================
; Dlonra Fri Mar 27, 2009
;
; This file was originally examples\recording\main.c as distributed with the FMOD Sound System
; distribution package.
;
; Converted to PureBasic by KarLKoX? At least he posted the original PureBasic source to the
; PureBasic Forum on Sun Jan 14, 2007, as found here: 
; http://www.purebasic.fr/english/viewtopic.php?p=177516#177516
; Thanks KarLKoX!
;
; I modified KarLKoX's code to work with an updated version of Froggerprogger's include-file
; for fmodex as originally found here:
; http://www.purebasic.fr/english/viewtopic.php?p=175424#175424
; Thanks Froggerprogger!
; I also corrected a few errors that had crept into the original code conversion.
; 
; A couple of hopefully helpful notes:
;
; The five second timer for record and playback is determined by the actual size of the audio buffer
; as declared in the exinfo\length variable. This program records or plays until the buffer is
; exhausted which just happens to be exactly 5 seconds in length.
;
; The original Firelight Technologies comment above mentions that simultaneous recording and
; playback to/from a shared sound buffer is possible. It then talks about slightly delaying
; playback so that it does not run into a part of the buffer still being recorded to. The original
; C source code appears to have a 10 second delay built into the main program loop which may
; have been intended for this purpose. But I can see no option in the code that automatically
; launches both record and then playback. The user must manually start both and since the ten second
; delay is twice as long as it takes to play/record the buffer it appears entirely impossible
; to start playing and recording at the same time. This appears to me to be a logic flaw in the
; original example or an error in my understanding of the original C source code.
;
; The code below *will* allow you to start playing immediately after starting a
; recording but it must be done manually. In fact it is possible to start playing a buffer *before*
; the recording even starts. So be careful as this code make no attempt to sanity check the users actions
; in this regard.
;
; By Dlonra, 27/03/2009
; for contact see the PB-forums at http://www.purebasic.fr/english/
; ===============================================================================================

EnableGraphicalConsole(1)
OpenConsole()
    
XIncludeFile "fmodex.pbi"

Global System.i, Sound.i, Channel.i
Global Result.i

Structure RIFF_HEADER
  RIFF.i
  riffBlockSize.i
  riffBlockType.i
EndStructure

Structure WAVE_HEADER
  dataBlockType.i
  dataBlockSize.i
EndStructure

Structure WAVE_FORMAT
  wfBlockType.i
  wfBlockSize.i
  wFormatTag.w
  nChannels.w
  nSamplesPerSec.i
  nAvgBytesPerSec.i
  nBlockAlign.w
  wBitsPerSample.w
EndStructure 

#OUTPUT_FILE = 0

Procedure ERRCHECK(the_Result.i)
  If the_Result <> #FMOD_OK
    PrintN("FMOD error! " + Str(the_Result) + FMOD_ErrorString(the_Result))
    Delay(2000)
    End
  EndIf
EndProcedure

Procedure SaveToWav(ptrSound.i)
    Protected ptr1.i, ptr2.i, len1.i, len2.i
    Protected lenbytes.i, channels.i, bits.i, rate.f
    Protected m_structRIFF.RIFF_HEADER
    Protected m_structWAVEHdr.WAVE_HEADER
    Protected m_structWAVEFmt.WAVE_FORMAT
   
    If ptrSound = 0
       ProcedureReturn
    EndIf
   
    FMOD_Sound_GetFormat(ptrSound, 0, 0, @channels, @bits)
    FMOD_Sound_GetDefaults(ptrSound, @rate, 0, 0, 0)
    FMOD_Sound_GetLength(ptrSound, @lenbytes, #FMOD_TIMEUNIT_PCMBYTES)

    ; Prepare the Wave Header
    m_structWAVEFmt\wFormatTag              = 1
    m_structWAVEFmt\nChannels               = channels
    m_structWAVEFmt\nSamplesPerSec          = rate
    m_structWAVEFmt\wBitsPerSample          = bits

    m_structWAVEFmt\nBlockAlign             = m_structWAVEFmt\nChannels * m_structWAVEFmt\wBitsPerSample / 8
    m_structWAVEFmt\nAvgBytesPerSec         = m_structWAVEFmt\nSamplesPerSec * m_structWAVEFmt\nBlockAlign
    m_structWAVEFmt\wfBlockType             = $20746D66         ; 'f' 'm' 't'
    m_structWAVEFmt\wfBlockSize             = 16                ; SizeOf(FmtChunk) - SizeOf(RiffChunk)
   
    m_structRIFF\RIFF                       = $46464952         ; 'R' 'I' 'F' 'F'
    m_structRIFF\riffBlockSize              = lenbytes + 44 - 12
    m_structRIFF\riffBlockType              = $45564157         ; 'W' 'A' 'V' 'E'
   
    m_structWAVEHdr\dataBlockType           = $61746164
    m_structWAVEHdr\dataBlockSize           = lenbytes
   
    m_hNewFile = CreateFile(#OUTPUT_FILE, "record.wav")
    If m_hNewFile = 0
      MessageRequester("Error", "An error occured while creating record.wav file", 0)
      ProcedureReturn
    EndIf
   
    ; Write out the WAV Header
    WriteData(0, m_structRIFF,    SizeOf(RIFF_HEADER))
    WriteData(0, m_structWAVEFmt, SizeOf(WAVE_FORMAT))
    WriteData(0, m_structWAVEHdr, SizeOf(WAVE_HEADER))

    ; Lock the sound to get access to the raw data.
    FMOD_Sound_Lock(ptrSound, 0, lenbytes, @ptr1, @ptr2, @len1, @len2)
   
    ; Write it to disk.
    WriteData(0, ptr1, len1)
     
    ; Unlock the sound to allow FMOD to use it again.
    FMOD_Sound_Unlock(ptrSound, ptr1, ptr2, len1, len2)
   
    ; And close the output file
    CloseFile(#OUTPUT_FILE)       
EndProcedure

    Define name.s{80}
   
    EnableGraphicalConsole(1)
    OpenConsole()
   
    WorkDir.s = GetCurrentDirectory()
    PrintN ("Working directory is >" + WorkDir + "<")

    Init_FMOD()
    If fmodLib = 0
        PrintN("")
        PrintN("Error! Failed to initialise FMOD sound.")
        PrintN("Could not find the specified shared FMOD sound library file.")
        End
    EndIf
    
   ; Create a System object And initialize.
    Result = FMOD_System_Create(@System)
    ERRCHECK(Result)
 
    Result = FMOD_System_GetVersion(System, @version)
    ERRCHECK(Result)
    
    If version < #FMOD_VERSION
        MessageRequester("Error",  "Error! You are using an old version of FMOD " + Hex(version) + ". This program requires " + Hex(#FMOD_VERSION) + ".")
        End
    EndIf

   ; System initialization
    PrintN("---------------------------------------------------------");
    PrintN("Select OUTPUT type")
    PrintN("---------------------------------------------------------")
    PrintN("1 :  FMOD Default for your OS")
    PrintN("")
    PrintN("2 :  Windows - DirectSound")
    PrintN("3 :  Windows - Windows Multimedia WaveOut")
    PrintN("4 :  Windows - ASIO")
    PrintN("")
    PrintN("5 :  Linux - Open Sound System OSS")
    PrintN("6 :  Linux - Advanced Linux Sound Architecture ALSA")
    PrintN("7 :  Linux - Enlightment Sound Daemon ESD")
    PrintN("---------------------------------------------------------")
    PrintN("Press a corresponding number or ESC to quit")
   
    Repeat
      ch.s = Inkey()
      If Asc(ch) = 27
        CloseConsole()
        End
      EndIf
        value = Val(Left(ch, 1))
      Delay(10)
    Until (value >= 1 And value <= 7)

    Select value
        Case 1 :  Result = FMOD_System_SetOutput(System, #FMOD_OUTPUTTYPE_AUTODETECT)
        Case 2 :  Result = FMOD_System_SetOutput(System, #FMOD_OUTPUTTYPE_DSOUND)
        Case 3 :  Result = FMOD_System_SetOutput(System, #FMOD_OUTPUTTYPE_WINMM)
        Case 4 :  Result = FMOD_System_SetOutput(System, #FMOD_OUTPUTTYPE_ASIO)
        Case 5 :  Result = FMOD_System_SetOutput(System, #FMOD_OUTPUTTYPE_OSS)
        Case 6 :  Result = FMOD_System_SetOutput(System, #FMOD_OUTPUTTYPE_ALSA)
        Case 7 :  Result = FMOD_System_SetOutput(System, #FMOD_OUTPUTTYPE_ESD)
    EndSelect
    ERRCHECK(Result)
            
   ; Enumerate playback devices
    Result = FMOD_System_GetNumDrivers(System, @numdrivers)
    ERRCHECK(Result)
       
    PrintN("---------------------------------------------------------")   
    PrintN("Choose a PLAYBACK driver")
    PrintN("---------------------------------------------------------")
    
    
    For count=0 To numdrivers - 1
        name = Space(80)
        Result = FMOD_System_GetDriverInfo(System, count, @name, 80, 0)
        ERRCHECK(Result)
        PrintN(Str(count+1) + " : " + name)
        Debug Len(name)
        ;PrintN(Str(count+1))        
    Next count
    
    PrintN("---------------------------------------------------------")
    PrintN("Press a corresponding number or ESC to quit\n")
           
    Repeat
      ch.s = Inkey()
      value = Val(Left(ch, 1))
      Delay(10)
    Until value > 0 And value <= numdrivers
    Result = FMOD_System_SetDriver(system,value-1)
    ERRCHECK(Result)
   
   ; Enumerate record devices
    Result = FMOD_System_GetRecordNumDrivers(System, @numdrivers)
    ERRCHECK(Result)
   
    PrintN("---------------------------------------------------------") 
    PrintN("Choose a RECORD driver")
    PrintN("---------------------------------------------------------")
    
    For count=0 To numdrivers - 1
        name = Space(80)
        Result = FMOD_System_GetRecordDriverInfo(System, count, @name, 80, 0)
        ERRCHECK(Result)
        PrintN(Str(count+1) + " : " + name)
        ;PrintN(Str(count+1))
        Debug Len(name)
    Next count
    
    PrintN("---------------------------------------------------------")
    PrintN("Press a corresponding number or ESC to quit")
       
    Repeat
      ch.s = Inkey()
      value = Val(Left(ch, 1))
      If value = 27
        CloseConsole()
        End
      EndIf
      Delay(10)
    Until value > 0 And value <= numdrivers
    
    rec_driverID = value - 1
       
    Result = FMOD_System_SetRecordDriver(System, rec_driverID)
    ERRCHECK(Result)
 
    Result = FMOD_System_Init(System, 32, #FMOD_INIT_NORMAL, 0)
    ERRCHECK(Result)
   
    exinfo.FMOD_CREATESOUNDEXINFO
    
    ; The original conversion code used the Windows OS call RtlZeroMemory_ to clear memory
    ; occupied by the FMOD_CREATESOUNDEXINFO structure with nulls but this function call
    ; is not available under Linux.
    ; So we use the following "hack" to RAM clear the structure.
    
    *DestMemID = @exinfo.FMOD_CREATESOUNDEXINFO                         ; Setup our destination in memory
    *SrceMemID = AllocateMemory(SizeOf(FMOD_CREATESOUNDEXINFO))         ; Create a new memory buffer the same size as FMOD_CREATESOUNDEXINFO which is zero filled 
    CopyMemory(*SrceMemID, *DestMemID, SizeOf(FMOD_CREATESOUNDEXINFO))  ; Now copy the new zero filled buffer over the top of the structure
    FreeMemory(*SrceMemID)                                              ; We don't need the new buffer any longer so release the memory

    exinfo\cbsize                    = SizeOf(FMOD_CREATESOUNDEXINFO)
    exinfo\numchannels               = 1
    exinfo\format                    = #FMOD_SOUND_FORMAT_PCM16
    exinfo\defaultfrequency          = 44100
    exinfo\length                    = exinfo\defaultfrequency * 2 * exinfo\numchannels * 5
   
    Result = FMOD_System_CreateSound(System, 0, #FMOD_2D | #FMOD_SOFTWARE | #FMOD_OPENUSER, @exinfo, @Sound)
    ERRCHECK(Result)
   
    PrintN("===================================================================")
    PrintN("Recording example.  Copyright (c) Firelight Technologies 2004-2005.")
    PrintN("===================================================================")
    PrintN("")
    PrintN("Press 'r' to record a 5 second segment of audio.")
    PrintN("Press 'p' to play the 5 second segment of audio.")
    PrintN("Press 'l' to turn looping on/off.")
    PrintN("Press 's' to stop recording and playback.")
    PrintN("Press 'w' to save the 5 second segment to a wav file.")
    PrintN("Press 'Esc' to quit")
    PrintN("")
   
    looping      = 0
    recording    = 0
    playing      = 0
    recordpos    = 0
    playpos      = 0
    
   Repeat
      key.s = LCase(Left(Inkey(),1))
      
      Select key
         Case "r"
            Result = FMOD_System_RecordStart(System, rec_driverID, Sound, looping)
            ERRCHECK(Result)
               
         Case "p"
            If (looping)
                FMOD_Sound_SetMode(Sound, #FMOD_LOOP_NORMAL)
            Else
                FMOD_Sound_SetMode(Sound, #FMOD_LOOP_OFF)
            EndIf
            ERRCHECK(Result)

            Result = FMOD_System_PlaySound(System, #FMOD_CHANNEL_REUSE, Sound, 0, @Channel)
            ERRCHECK(Result)

         Case "l"
            looping ! 1
                                    
         Case "s"
            If recording
                Result = FMOD_System_RecordStop(System, rec_driverID)
                ERRCHECK(Result)
                recording = 0
            EndIf
            If Channel
                FMOD_Channel_Stop(Channel)
                ERRCHECK(Result)
                channel = 0
                playing = 0
                playpos = 0
            EndIf
            
         Case "w"
            Print(Space(79) + Chr(13))
            Print("Writing buffer to record.wav")
            SaveToWav(Sound)
            Delay(3000)
            Print(Chr(13))
            
      EndSelect

      FMOD_Sound_GetLength(Sound, @length, #FMOD_TIMEUNIT_PCM)
      ERRCHECK(Result)

      FMOD_System_IsRecording(System, rec_driverID, @recording)
      ERRCHECK(Result)

      FMOD_System_GetRecordPosition(System, rec_driverID, @recordpos)
      ERRCHECK(Result)
       
      If (Channel)
          FMOD_Channel_IsPlaying(Channel, @playing)
          ERRCHECK(Result)
          FMOD_Channel_GetPosition(Channel, @playpos, #FMOD_TIMEUNIT_PCM)
          ERRCHECK(Result)
      EndIf
     
      playback_status.s   = Space(20)
      playback_status     = ""
      If recording
         If playing
            playback_status = "Recording/Playing"
         Else
            playback_status = "Recording"
      EndIf
      ElseIf playing
         playback_status = "Playing"
      Else
         playback_status = "Idle"
      EndIf
      loop.s   = Space(4)
      loop     = ""
      If looping
         loop = "On"
      Else
         loop = "Off"
      EndIf

      Statusline.s = "Status: " + playback_status + " - Record pos = " + Str(recordpos) + " : Play pos = " + Str(playpos) + " : Loop = " + loop
      Statusline.s = Statusline.s + Space(80-Len(Statusline.s))
      Print(StatusLine + Chr(13))
      FMOD_System_Update(System)
      Delay(10)

   Until Asc(key) = 27
   
      PrintN("")

   ;Shut down
    Result = FMOD_Sound_Release(sound)
    ERRCHECK(Result)

    Result = FMOD_System_Release(system)
    ERRCHECK(Result)
   
    CloseConsole()
    End

[Delonra]

G'day (for the 3rd time in quick succession).

Now I have to own up and admit that all is not perfect with the code above (see last two posts).

I have two issues which may or may not be related.

The example code is for a console program and it uses the simple trick of outputting a Carriage-Return ASCII character Chr(13) at the end of a particular status line without a matching Line-Feed LF character so as to give the illusion of the status line updating itself without moving down the screen. If this makes little sense then just run the code example and you'll see immediately what I'm getting at.

Under Linux this code seems to work perfectly. But under Windows something *very* odd happens when the user selects "w" to write the buffer to a WAV file. A text message saying that it is going to write a file appears which is supposed to happen. After this the status bar should just return as per normal and on Linux it does but not Windows. On my Windows XP SP2 PC I see one or two non standard ASCII characters displayed, followed by a few characters from the very end of the status line. The code appears still to be running correctly but no status line!

To me this looks like some sort of corruption of the stack or a buffer over-run somewhere. I'm worried that some of the procedures that I had to modify in FMODex may not be correctly passing the required values. So that I'm leaving something on the stack that I should not be or vice versa. But so far I have not been able to spot the problem.

I should also mention that the Linux version which seems to run perfectly from the IDE when compiled to an executable seems to produce an error the second time you go to record something but I'm still looking into this.

So if you can spot my mistake(s) and point me in the right direction that would be great!

Even with bugs the code still manages to give a working FMOD example with the current version of PB and FMOD which may be of assistance to someone.

73, Delonra

[X]

Thanks for the posts. Unfortunately, your link to the include is missing ...

Also, have there been an update to this fmod include for 4.30 32bit and 64bit?

[Perkin]

I've adapted Froggerprogger' original include.
Works with PB v4.40b7

Code: Select all

; UPDATED for PB v4.40b7 by Perkin - 23.11.2009
; Now uses Prototypes for all Library commands
; Just adapted Froggerprogger's include, rather than using new one
; To save even more on exe size, comment out FMOD_****** = GetFunction(....) lines
; for all commands you don't use.
; (I could have commented them all, then uncomment ones you did use, but safer for distro as is.)

Alter 'fmodex.pb' as follows

In 'Init_FMOD()' procedure, comment out the 'fmodLib = OpenLibrary(#PB_Any, "fmodex.dll")' line

Leaving final FMOD_ErrorString procedure intact,
Replace all the Procedures FMOD_*****() (around line 677)
With following code and code in following post.

Code: Select all

;- ### Main part
fmodLib = OpenLibrary(#PB_Any, "fmodex.dll")
If fmodLib

	;- FMOD_Memory_Initialize
	Prototype.l FMOD_Memory_Initialize_Prototype(poolmem.l, poollen.l, useralloc.l, userrealloc.l, userfree.l)
	Global FMOD_Memory_Initialize.FMOD_Memory_Initialize_Prototype
	FMOD_Memory_Initialize = GetFunction(fmodLib, "FMOD_Memory_Initialize")
	
	Prototype.l FMOD_Memory_GetStats_Prototype(*currentalloced.l, *maxalloced.l)
	Global FMOD_Memory_GetStats.FMOD_Memory_GetStats_Prototype
	FMOD_Memory_GetStats= GetFunction(fmodLib, "FMOD_Memory_GetStats")
	
	;- FMOD_Debug_SetLevel
	Prototype.l FMOD_Debug_SetLevel_Prototype(level.l)
	Global FMOD_Debug_SetLevel.FMOD_Debug_SetLevel_Prototype
	FMOD_Debug_SetLevel = GetFunction(fmodLib, "FMOD_Debug_SetLevel")
	
	;- FMOD_Debug_GetLevel
	Prototype.l FMOD_Debug_GetLevel_Prototype(*level.l)
	Global FMOD_Debug_GetLevel.FMOD_Debug_GetLevel_Prototype
	FMOD_Debug_GetLevel = GetFunction(fmodLib, "FMOD_Debug_GetLevel")
	
	;- FMOD_File_SetDiskBusy
	Prototype.l FMOD_File_SetDiskBusy_Prototype(busy.l)
	Global FMOD_File_SetDiskBusy.FMOD_File_SetDiskBusy_Prototype
	FMOD_File_SetDiskBusy = GetFunction(fmodLib, "FMOD_File_SetDiskBusy")
	
	;- FMOD_File_GetDiskBusy
	Prototype.l FMOD_File_GetDiskBusy_Prototype(*busy.l)
	Global FMOD_File_GetDiskBusy.FMOD_File_GetDiskBusy_Prototype
	FMOD_File_GetDiskBusy = GetFunction(fmodLib, "FMOD_File_GetDiskBusy")
	
	;- FMOD_System_Create
	Prototype.l FMOD_System_Create_Prototype(*system.l)
	Global FMOD_System_Create.FMOD_System_Create_Prototype
	FMOD_System_Create = GetFunction(fmodLib, "FMOD_System_Create")
	
	;- FMOD_System_Release
	Prototype.l FMOD_System_Release_Prototype(system.l)
	Global FMOD_System_Release.FMOD_System_Release_Prototype
	FMOD_System_Release = GetFunction(fmodLib, "FMOD_System_Release")
	
	;- FMOD_System_SetOutput
	Prototype.l FMOD_System_SetOutput_Prototype(system.l, Output.l)
	Global FMOD_System_SetOutput.FMOD_System_SetOutput_Prototype
	FMOD_System_SetOutput = GetFunction(fmodLib, "FMOD_System_SetOutput")
	
	;- FMOD_System_GetOutput
	Prototype.l FMOD_System_GetOutput_Prototype(system.l, *Output.l)
	Global FMOD_System_GetOutput.FMOD_System_GetOutput_Prototype
	FMOD_System_GetOutput = GetFunction(fmodLib, "FMOD_System_GetOutput")
	
	;- FMOD_System_GetNumDrivers
	Prototype.l FMOD_System_GetNumDrivers_Prototype(system.l, *Numdrivers.l)
	Global FMOD_System_GetNumDrivers.FMOD_System_GetNumDrivers_Prototype
	FMOD_System_GetNumDrivers = GetFunction(fmodLib, "FMOD_System_GetNumDrivers")
	
	;- FMOD_System_GetDriverName
	Prototype.l FMOD_System_GetDriverName_Prototype(system.l, id.l, *name.b, Namelen.l)
	Global FMOD_System_GetDriverName.FMOD_System_GetDriverName_Prototype
	FMOD_System_GetDriverName = GetFunction(fmodLib, "FMOD_System_GetDriverName")
	
	;- FMOD_System_GetDriverCaps
	Prototype.l FMOD_System_GetDriverCaps_Prototype(system.l, id.l, *caps.l, *minfrequency.l, *maxfrequency.l, *controlpanelspeakermode.l)
	Global FMOD_System_GetDriverCaps.FMOD_System_GetDriverCaps_Prototype
	FMOD_System_GetDriverCaps = GetFunction(fmodLib, "FMOD_System_GetDriverCaps")
	
	;- FMOD_System_SetDriver_
	Prototype.l FMOD_System_SetDriver_Prototype (system.l, Driver.l)
	Global FMOD_System_SetDriver.FMOD_System_SetDriver_Prototype
	FMOD_System_SetDriver = GetFunction(fmodLib, "FMOD_System_SetDriver")
	
	;- FMOD_System_GetDriver_
	Prototype.l FMOD_System_GetDriver_Prototype (system.l, *Driver.l)
	Global FMOD_System_GetDriver.FMOD_System_GetDriver_Prototype
	FMOD_System_GetDriver = GetFunction(fmodLib, "FMOD_System_GetDriver")
	
	;- FMOD_System_SetHardwareChannels_
	Prototype.l FMOD_System_SetHardwareChannels_Prototype (system.l, Min2d.l, Max2d.l, Min3d.l, Max3d.l)
	Global FMOD_System_SetHardwareChannels.FMOD_System_SetHardwareChannels_Prototype
	FMOD_System_SetHardwareChannels = GetFunction(fmodLib, "FMOD_System_SetHardwareChannels")
	
	;- FMOD_System_GetHardwareChannels_
	Prototype.l FMOD_System_GetHardwareChannels_Prototype (system.l, *Num2d.l, *Num3d.l, *total.l)
	Global FMOD_System_GetHardwareChannels.FMOD_System_GetHardwareChannels_Prototype
	FMOD_System_GetHardwareChannels = GetFunction(fmodLib, "FMOD_System_GetHardwareChannels")
	
	;- FMOD_System_SetSoftwareChannels_
	Prototype.l FMOD_System_SetSoftwareChannels_Prototype (system.l, Numsoftwarechannels.l)
	Global FMOD_System_SetSoftwareChannels.FMOD_System_SetSoftwareChannels_Prototype
	FMOD_System_SetSoftwareChannels = GetFunction(fmodLib, "FMOD_System_SetSoftwareChannels")
	
	;- FMOD_System_GetSoftwareChannels_
	Prototype.l FMOD_System_GetSoftwareChannels_Prototype (system.l, *Numsoftwarechannels.l)
	Global FMOD_System_GetSoftwareChannels.FMOD_System_GetSoftwareChannels_Prototype
	FMOD_System_GetSoftwareChannels = GetFunction(fmodLib, "FMOD_System_GetSoftwareChannels")
	
	;- FMOD_System_SetSoftwareFormat_
	Prototype.l FMOD_System_SetSoftwareFormat_Prototype (system.l, Samplerate.l, Format.l, Numoutputchannels.l, Maxinputchannels.l, Resamplemethod.l)
	Global FMOD_System_SetSoftwareFormat.FMOD_System_SetSoftwareFormat_Prototype
	FMOD_System_SetSoftwareFormat = GetFunction(fmodLib, "FMOD_System_SetSoftwareFormat")
	
	;- FMOD_System_GetSoftwareFormat_
	Prototype.l FMOD_System_GetSoftwareFormat_Prototype (system.l, *Samplerate.l, *Format.l, *Numoutputchannels.l, *Maxinputchannels.l, *Resamplemethod.l, *Bits.l)
	Global FMOD_System_GetSoftwareFormat.FMOD_System_GetSoftwareFormat_Prototype
	FMOD_System_GetSoftwareFormat = GetFunction(fmodLib, "FMOD_System_GetSoftwareFormat")
	
	;- FMOD_System_SetDSPBufferSize_
	Prototype.l FMOD_System_SetDSPBufferSize_Prototype (system.l, Bufferlength.l, Numbuffers.l)
	Global FMOD_System_SetDSPBufferSize.FMOD_System_SetDSPBufferSize_Prototype
	FMOD_System_SetDSPBufferSize = GetFunction(fmodLib, "FMOD_System_SetDSPBufferSize")
	
	;- FMOD_System_GetDSPBufferSize_
	Prototype.l FMOD_System_GetDSPBufferSize_Prototype (system.l, *Bufferlength.l, *Numbuffers.l)
	Global FMOD_System_GetDSPBufferSize.FMOD_System_GetDSPBufferSize_Prototype
	FMOD_System_GetDSPBufferSize = GetFunction(fmodLib, "FMOD_System_GetDSPBufferSize")
	
	;- FMOD_System_SetFileSystem_
	Prototype.l FMOD_System_SetFileSystem_Prototype (system.l, useropen.l, userclose.l, userread.l, userseek.l, Buffersize.l)
	Global FMOD_System_SetFileSystem.FMOD_System_SetFileSystem_Prototype
	FMOD_System_SetFileSystem = GetFunction(fmodLib, "FMOD_System_SetFileSystem")
	
	;- FMOD_System_AttachFileSystem_
	Prototype.l FMOD_System_AttachFileSystem_Prototype (system.l, useropen.l, userclose.l, userread.l, userseek.l)
	Global FMOD_System_AttachFileSystem.FMOD_System_AttachFileSystem_Prototype
	FMOD_System_AttachFileSystem = GetFunction(fmodLib, "FMOD_System_AttachFileSystem")
	
	;- FMOD_System_SetAdvancedSettings_
	Prototype.l FMOD_System_SetAdvancedSettings_Prototype (system.l, *settings.l)
	Global FMOD_System_SetAdvancedSettings.FMOD_System_SetAdvancedSettings_Prototype
	FMOD_System_SetAdvancedSettings = GetFunction(fmodLib, "FMOD_System_SetAdvancedSettings")
	
	;- FMOD_System_GetAdvancedSettings_
	Prototype.l FMOD_System_GetAdvancedSettings_Prototype (system.l, *settings.l)
	Global FMOD_System_GetAdvancedSettings.FMOD_System_GetAdvancedSettings_Prototype
	FMOD_System_GetAdvancedSettings = GetFunction(fmodLib, "FMOD_System_GetAdvancedSettings")
	
	;- FMOD_System_SetSpeakerMode_
	Prototype.l FMOD_System_SetSpeakerMode_Prototype (system.l, Speakermode.l)
	Global FMOD_System_SetSpeakerMode.FMOD_System_SetSpeakerMode_Prototype
	FMOD_System_SetSpeakerMode = GetFunction(fmodLib, "FMOD_System_SetSpeakerMode")
	
	;- FMOD_System_GetSpeakerMode_
	Prototype.l FMOD_System_GetSpeakerMode_Prototype (system.l, *Speakermode.l)
	Global FMOD_System_GetSpeakerMode.FMOD_System_GetSpeakerMode_Prototype
	FMOD_System_GetSpeakerMode = GetFunction(fmodLib, "FMOD_System_GetSpeakerMode")
	
	;- FMOD_System_SetPluginPath_
	Prototype.l FMOD_System_SetPluginPath_Prototype (system.l, Path.s)
	Global FMOD_System_SetPluginPath.FMOD_System_SetPluginPath_Prototype
	FMOD_System_SetPluginPath = GetFunction(fmodLib, "FMOD_System_SetPluginPath")
	
	;- FMOD_System_LoadPlugin_
	Prototype.l FMOD_System_LoadPlugin_Prototype (system.l, Filename.s, *Plugintype.l, *Index.l)
	Global FMOD_System_LoadPlugin.FMOD_System_LoadPlugin_Prototype
	FMOD_System_LoadPlugin = GetFunction(fmodLib, "FMOD_System_LoadPlugin")
	
	;- FMOD_System_GetNumPlugins_
	Prototype.l FMOD_System_GetNumPlugins_Prototype (system.l, Plugintype.l, *Numplugins.l)
	Global FMOD_System_GetNumPlugins.FMOD_System_GetNumPlugins_Prototype
	FMOD_System_GetNumPlugins = GetFunction(fmodLib, "FMOD_System_GetNumPlugins")
	
	;- FMOD_System_GetPluginInfo_
	Prototype.l FMOD_System_GetPluginInfo_Prototype (system.l, Plugintype.l, Index.l, *name.b, Namelen.l, *version.l)
	Global FMOD_System_GetPluginInfo.FMOD_System_GetPluginInfo_Prototype
	FMOD_System_GetPluginInfo = GetFunction(fmodLib, "FMOD_System_GetPluginInfo")
	
	;- FMOD_System_UnloadPlugin_
	Prototype.l FMOD_System_UnloadPlugin_Prototype (system.l, Plugintype.l, *Index.l)
	Global FMOD_System_UnloadPlugin.FMOD_System_UnloadPlugin_Prototype
	FMOD_System_UnloadPlugin = GetFunction(fmodLib, "FMOD_System_UnloadPlugin")
	
	;- FMOD_System_SetOutputByPlugin_
	Prototype.l FMOD_System_SetOutputByPlugin_Prototype (system.l, Index.l)
	Global FMOD_System_SetOutputByPlugin.FMOD_System_SetOutputByPlugin_Prototype
	FMOD_System_SetOutputByPlugin = GetFunction(fmodLib, "FMOD_System_SetOutputByPlugin")
	
	;- FMOD_System_GetOutputByPlugin_
	Prototype.l FMOD_System_GetOutputByPlugin_Prototype (system.l, *Index.l)
	Global FMOD_System_GetOutputByPlugin.FMOD_System_GetOutputByPlugin_Prototype
	FMOD_System_GetOutputByPlugin = GetFunction(fmodLib, "FMOD_System_GetOutputByPlugin")
	
	;- FMOD_System_CreateCodec_
	Prototype.l FMOD_System_CreateCodec_Prototype (system.l, CodecDescription.l)
	Global FMOD_System_CreateCodec.FMOD_System_CreateCodec_Prototype
	FMOD_System_CreateCodec = GetFunction(fmodLib, "FMOD_System_CreateCodec")
	
	;- FMOD_System_Init_
	Prototype.l FMOD_System_Init_Prototype (system.l, Maxchannels.l, flags.l, Extradriverdata.l)
	Global FMOD_System_Init.FMOD_System_Init_Prototype
	FMOD_System_Init = GetFunction(fmodLib, "FMOD_System_Init")
	
	;- FMOD_System_Close_
	Prototype.l FMOD_System_Close_Prototype (system.l)
	Global FMOD_System_Close.FMOD_System_Close_Prototype
	FMOD_System_Close = GetFunction(fmodLib, "FMOD_System_Close")
	
	;- FMOD_System_Update_
	Prototype.l FMOD_System_Update_Prototype (system.l)
	Global FMOD_System_Update.FMOD_System_Update_Prototype
	FMOD_System_Update = GetFunction(fmodLib, "FMOD_System_Update")
	
	;- FMOD_System_UpdateFinished_
	Prototype.l FMOD_System_UpdateFinished_Prototype (system.l)
	Global FMOD_System_UpdateFinished.FMOD_System_UpdateFinished_Prototype
	FMOD_System_UpdateFinished = GetFunction(fmodLib, "FMOD_System_UpdateFinished")
	
	;- FMOD_System_Set3DSettings_
	Prototype.l FMOD_System_Set3DSettings_Prototype (system.l, Dopplerscale.f, Distancefactor.f, Rolloffscale.f)
	Global FMOD_System_Set3DSettings.FMOD_System_Set3DSettings_Prototype
	FMOD_System_Set3DSettings = GetFunction(fmodLib, "FMOD_System_Set3DSettings")
	
	;- FMOD_System_Get3DSettings_
	Prototype.l FMOD_System_Get3DSettings_Prototype (system.l, *Dopplerscale.f, *Distancefactor.f, *Rolloffscale.f)
	Global FMOD_System_Get3DSettings.FMOD_System_Get3DSettings_Prototype
	FMOD_System_Get3DSettings = GetFunction(fmodLib, "FMOD_System_Get3DSettings")
	
	;- FMOD_System_Set3DNumListeners_
	Prototype.l FMOD_System_Set3DNumListeners_Prototype (system.l, Numlisteners.l)
	Global FMOD_System_Set3DNumListeners.FMOD_System_Set3DNumListeners_Prototype
	FMOD_System_Set3DNumListeners = GetFunction(fmodLib, "FMOD_System_Set3DNumListeners")
	
	;- FMOD_System_Get3DNumListeners_
	Prototype.l FMOD_System_Get3DNumListeners_Prototype (system.l, *Numlisteners.l)
	Global FMOD_System_Get3DNumListeners.FMOD_System_Get3DNumListeners_Prototype
	FMOD_System_Get3DNumListeners = GetFunction(fmodLib, "FMOD_System_Get3DNumListeners")
	
	;- FMOD_System_Set3DListenerAttributes_
	Prototype.l FMOD_System_Set3DListenerAttributes_Prototype (system.l, Listener.l, *Pos.l, *Vel.l, *Forward.l, *Up.l)
	Global FMOD_System_Set3DListenerAttributes.FMOD_System_Set3DListenerAttributes_Prototype
	FMOD_System_Set3DListenerAttributes = GetFunction(fmodLib, "FMOD_System_Set3DListenerAttributes")
	
	;- FMOD_System_Get3DListenerAttributes_
	Prototype.l FMOD_System_Get3DListenerAttributes_Prototype (system.l, Listener.l, *Pos.l, *Vel.l, *Forward.l, *Up.l)
	Global FMOD_System_Get3DListenerAttributes.FMOD_System_Get3DListenerAttributes_Prototype
	FMOD_System_Get3DListenerAttributes = GetFunction(fmodLib, "FMOD_System_Get3DListenerAttributes")
	
	;- FMOD_System_SetSpeakerPosition_
	Prototype.l FMOD_System_SetSpeakerPosition_Prototype (system.l, Speaker.l, x.f, y.f)
	Global FMOD_System_SetSpeakerPosition.FMOD_System_SetSpeakerPosition_Prototype
	FMOD_System_SetSpeakerPosition = GetFunction(fmodLib, "FMOD_System_SetSpeakerPosition")
	
	;- FMOD_System_GetSpeakerPosition_
	Prototype.l FMOD_System_GetSpeakerPosition_Prototype (system.l, *Speaker.l, *X.f, *Y.f)
	Global FMOD_System_GetSpeakerPosition.FMOD_System_GetSpeakerPosition_Prototype
	FMOD_System_GetSpeakerPosition = GetFunction(fmodLib, "FMOD_System_GetSpeakerPosition")
	
	;- FMOD_System_SetStreamBufferSize_
	Prototype.l FMOD_System_SetStreamBufferSize_Prototype (system.l, Filebuffersize.l, Filebuffersizetype.l)
	Global FMOD_System_SetStreamBufferSize.FMOD_System_SetStreamBufferSize_Prototype
	FMOD_System_SetStreamBufferSize = GetFunction(fmodLib, "FMOD_System_SetStreamBufferSize")
	
	;- FMOD_System_GetStreamBufferSize_
	Prototype.l FMOD_System_GetStreamBufferSize_Prototype (system.l, *Filebuffersize.l, *Filebuffersizetype.l)
	Global FMOD_System_GetStreamBufferSize.FMOD_System_GetStreamBufferSize_Prototype
	FMOD_System_GetStreamBufferSize = GetFunction(fmodLib, "FMOD_System_GetStreamBufferSize")
	
	;- FMOD_System_GetVersion_
	Prototype.l FMOD_System_GetVersion_Prototype (system.l, *version.l)
	Global FMOD_System_GetVersion.FMOD_System_GetVersion_Prototype
	FMOD_System_GetVersion = GetFunction(fmodLib, "FMOD_System_GetVersion")
	
	;- FMOD_System_GetOutputHandle_
	Prototype.l FMOD_System_GetOutputHandle_Prototype (system.l, *Handle.l)
	Global FMOD_System_GetOutputHandle.FMOD_System_GetOutputHandle_Prototype
	FMOD_System_GetOutputHandle = GetFunction(fmodLib, "FMOD_System_GetOutputHandle")
	
	;- FMOD_System_GetChannelsPlaying_
	Prototype.l FMOD_System_GetChannelsPlaying_Prototype (system.l, *Channels.l)
	Global FMOD_System_GetChannelsPlaying.FMOD_System_GetChannelsPlaying_Prototype
	FMOD_System_GetChannelsPlaying = GetFunction(fmodLib, "FMOD_System_GetChannelsPlaying")
	
	;- FMOD_System_GetCPUUsage_
	Prototype.l FMOD_System_GetCPUUsage_Prototype (system.l, *Dsp.f, *Stream.f, *Update.f, *total.f)
	Global FMOD_System_GetCPUUsage.FMOD_System_GetCPUUsage_Prototype
	FMOD_System_GetCPUUsage = GetFunction(fmodLib, "FMOD_System_GetCPUUsage")
	
	;- FMOD_System_GetSoundRAM_
	Prototype.l FMOD_System_GetSoundRAM_Prototype (system.l, *currentalloced.l, *maxalloced.l, *total.l)
	Global FMOD_System_GetSoundRAM.FMOD_System_GetSoundRAM_Prototype
	FMOD_System_GetSoundRAM = GetFunction(fmodLib, "FMOD_System_GetSoundRAM")
	
	;- FMOD_System_GetNumCDROMDrives_
	Prototype.l FMOD_System_GetNumCDROMDrives_Prototype (system.l, *Numdrives.l)
	Global FMOD_System_GetNumCDROMDrives.FMOD_System_GetNumCDROMDrives_Prototype
	FMOD_System_GetNumCDROMDrives = GetFunction(fmodLib, "FMOD_System_GetNumCDROMDrives")
	
	;- FMOD_System_GetCDROMDriveName_
	Prototype.l FMOD_System_GetCDROMDriveName_Prototype (system.l, Drive.l, *Drivename.b, Drivenamelen.l, *Scsiname.b, Scsinamelen.l, *Devicename.b, Devicenamelen.l)
	Global FMOD_System_GetCDROMDriveName.FMOD_System_GetCDROMDriveName_Prototype
	FMOD_System_GetCDROMDriveName = GetFunction(fmodLib, "FMOD_System_GetCDROMDriveName")
	
	;- FMOD_System_GetSpectrum_
	Prototype.l FMOD_System_GetSpectrum_Prototype (system.l, *Spectrumarray.f, Numvalues.l, Channeloffset.l, *Windowtype.l)
	Global FMOD_System_GetSpectrum.FMOD_System_GetSpectrum_Prototype
	FMOD_System_GetSpectrum = GetFunction(fmodLib, "FMOD_System_GetSpectrum")
	
	;- FMOD_System_GetWaveData_
	Prototype.l FMOD_System_GetWaveData_Prototype (system.l, *Wavearray.f, Numvalues.l, Channeloffset.l)
	Global FMOD_System_GetWaveData.FMOD_System_GetWaveData_Prototype
	FMOD_System_GetWaveData = GetFunction(fmodLib, "FMOD_System_GetWaveData")
	
	;- FMOD_System_CreateSound_
	Prototype.l FMOD_System_CreateSound_Prototype (system.l, Name_or_data.l, Mode.l, *exinfo.l, *Sound.l)
	Global FMOD_System_CreateSound.FMOD_System_CreateSound_Prototype
	FMOD_System_CreateSound = GetFunction(fmodLib, "FMOD_System_CreateSound")
	
	;- FMOD_System_CreateStream_
	Prototype.l FMOD_System_CreateStream_Prototype (system.l, Name_or_data.l, Mode.l, *exinfo.l, *Sound.l)
	Global FMOD_System_CreateStream.FMOD_System_CreateStream_Prototype
	FMOD_System_CreateStream = GetFunction(fmodLib, "FMOD_System_CreateStream")
	
	;- FMOD_System_CreateDSP_
	Prototype.l FMOD_System_CreateDSP_Prototype (system.l, *description.l, *Dsp.l)
	Global FMOD_System_CreateDSP.FMOD_System_CreateDSP_Prototype
	FMOD_System_CreateDSP = GetFunction(fmodLib, "FMOD_System_CreateDSP")
	
	;- FMOD_System_CreateDSPByType_
	Prototype.l FMOD_System_CreateDSPByType_Prototype (system.l, dsptype.l, *Dsp.l)
	Global FMOD_System_CreateDSPByType.FMOD_System_CreateDSPByType_Prototype
	FMOD_System_CreateDSPByType = GetFunction(fmodLib, "FMOD_System_CreateDSPByType")
	
	;- FMOD_System_CreateDSPByIndex_
	Prototype.l FMOD_System_CreateDSPByIndex_Prototype (system.l, Index.l, *Dsp.l)
	Global FMOD_System_CreateDSPByIndex.FMOD_System_CreateDSPByIndex_Prototype
	FMOD_System_CreateDSPByIndex = GetFunction(fmodLib, "FMOD_System_CreateDSPByIndex")
	
	;- FMOD_System_CreateChannelGroup_
	Prototype.l FMOD_System_CreateChannelGroup_Prototype (system.l, name.s, *Channelgroup.l)
	Global FMOD_System_CreateChannelGroup.FMOD_System_CreateChannelGroup_Prototype
	FMOD_System_CreateChannelGroup = GetFunction(fmodLib, "FMOD_System_CreateChannelGroup")
	
	;- FMOD_System_PlaySound_
	Prototype.l FMOD_System_PlaySound_Prototype (system.l, channelid.l, sound.l, paused.l, *channel.l)
	Global FMOD_System_PlaySound.FMOD_System_PlaySound_Prototype
	FMOD_System_PlaySound = GetFunction(fmodLib, "FMOD_System_PlaySound")
	
	;- FMOD_System_PlayDSP_
	Prototype.l FMOD_System_PlayDSP_Prototype (system.l, channelid.l, Dsp.l, paused.l, *channel.l)
	Global FMOD_System_PlayDSP.FMOD_System_PlayDSP_Prototype
	FMOD_System_PlayDSP = GetFunction(fmodLib, "FMOD_System_PlayDSP")
	
	;- FMOD_System_GetChannel_
	Prototype.l FMOD_System_GetChannel_Prototype (system.l, channelid.l, *channel.l)
	Global FMOD_System_GetChannel.FMOD_System_GetChannel_Prototype
	FMOD_System_GetChannel = GetFunction(fmodLib, "FMOD_System_GetChannel")
	
	;- FMOD_System_GetMasterChannelGroup_
	Prototype.l FMOD_System_GetMasterChannelGroup_Prototype (system.l, *Channelgroup.l)
	Global FMOD_System_GetMasterChannelGroup.FMOD_System_GetMasterChannelGroup_Prototype
	FMOD_System_GetMasterChannelGroup = GetFunction(fmodLib, "FMOD_System_GetMasterChannelGroup")
	
	;- FMOD_System_SetReverbProperties_
	Prototype.l FMOD_System_SetReverbProperties_Prototype (system.l, *Prop.l)
	Global FMOD_System_SetReverbProperties.FMOD_System_SetReverbProperties_Prototype
	FMOD_System_SetReverbProperties = GetFunction(fmodLib, "FMOD_System_SetReverbProperties")
	
	;- FMOD_System_GetReverbProperties_
	Prototype.l FMOD_System_GetReverbProperties_Prototype (system.l, *Prop.l)
	Global FMOD_System_GetReverbProperties.FMOD_System_GetReverbProperties_Prototype
	FMOD_System_GetReverbProperties = GetFunction(fmodLib, "FMOD_System_GetReverbProperties")
	
	;- FMOD_System_GetDSPHead_
	Prototype.l FMOD_System_GetDSPHead_Prototype (system.l, *Dsp.l)
	Global FMOD_System_GetDSPHead.FMOD_System_GetDSPHead_Prototype
	FMOD_System_GetDSPHead = GetFunction(fmodLib, "FMOD_System_GetDSPHead")
	
	;- FMOD_System_AddDSP_
	Prototype.l FMOD_System_AddDSP_Prototype (system.l, Dsp.l)
	Global FMOD_System_AddDSP.FMOD_System_AddDSP_Prototype
	FMOD_System_AddDSP = GetFunction(fmodLib, "FMOD_System_AddDSP")
	
	;- FMOD_System_LockDSP_
	Prototype.l FMOD_System_LockDSP_Prototype (system.l)
	Global FMOD_System_LockDSP.FMOD_System_LockDSP_Prototype
	FMOD_System_LockDSP = GetFunction(fmodLib, "FMOD_System_LockDSP")
	
	;- FMOD_System_UnlockDSP_
	Prototype.l FMOD_System_UnlockDSP_Prototype (system.l)
	Global FMOD_System_UnlockDSP.FMOD_System_UnlockDSP_Prototype
	FMOD_System_UnlockDSP = GetFunction(fmodLib, "FMOD_System_UnlockDSP")
	
	;- FMOD_System_SetRecordDriver_
	Prototype.l FMOD_System_SetRecordDriver_Prototype (system.l, Driver.l)
	Global FMOD_System_SetRecordDriver.FMOD_System_SetRecordDriver_Prototype
	FMOD_System_SetRecordDriver = GetFunction(fmodLib, "FMOD_System_SetRecordDriver")
	
	;- FMOD_System_GetRecordDriver_
	Prototype.l FMOD_System_GetRecordDriver_Prototype (system.l, *Driver.l)
	Global FMOD_System_GetRecordDriver.FMOD_System_GetRecordDriver_Prototype
	FMOD_System_GetRecordDriver = GetFunction(fmodLib, "FMOD_System_GetRecordDriver")
	
	;- FMOD_System_GetRecordNumDrivers_
	Prototype.l FMOD_System_GetRecordNumDrivers_Prototype (system.l, *Numdrivers.l)
	Global FMOD_System_GetRecordNumDrivers.FMOD_System_GetRecordNumDrivers_Prototype
	FMOD_System_GetRecordNumDrivers = GetFunction(fmodLib, "FMOD_System_GetRecordNumDrivers")
	
	;- FMOD_System_GetRecordDriverName_
	Prototype.l FMOD_System_GetRecordDriverName_Prototype (system.l, id.l, *name.b, Namelen.l)
	Global FMOD_System_GetRecordDriverName.FMOD_System_GetRecordDriverName_Prototype
	FMOD_System_GetRecordDriverName = GetFunction(fmodLib, "FMOD_System_GetRecordDriverName")
	
	;- FMOD_System_GetRecordPosition_
	Prototype.l FMOD_System_GetRecordPosition_Prototype (system.l, *Position.l)
	Global FMOD_System_GetRecordPosition.FMOD_System_GetRecordPosition_Prototype
	FMOD_System_GetRecordPosition = GetFunction(fmodLib, "FMOD_System_GetRecordPosition")
	
	;- FMOD_System_RecordStart_
	Prototype.l FMOD_System_RecordStart_Prototype (system.l, sound.l, Loop.l)
	Global FMOD_System_RecordStart.FMOD_System_RecordStart_Prototype
	FMOD_System_RecordStart = GetFunction(fmodLib, "FMOD_System_RecordStart")
	
	;- FMOD_System_RecordStop_
	Prototype.l FMOD_System_RecordStop_Prototype (system.l)
	Global FMOD_System_RecordStop.FMOD_System_RecordStop_Prototype
	FMOD_System_RecordStop = GetFunction(fmodLib, "FMOD_System_RecordStop")
	
	;- FMOD_System_IsRecording_
	Prototype.l FMOD_System_IsRecording_Prototype (system.l, *Recording.l)
	Global FMOD_System_IsRecording.FMOD_System_IsRecording_Prototype
	FMOD_System_IsRecording = GetFunction(fmodLib, "FMOD_System_IsRecording")
	
	;- FMOD_System_CreateGeometry_
	Prototype.l FMOD_System_CreateGeometry_Prototype (system.l, MaxPolygons.l, MaxVertices.l, *Geometryf.l)
	Global FMOD_System_CreateGeometry.FMOD_System_CreateGeometry_Prototype
	FMOD_System_CreateGeometry = GetFunction(fmodLib, "FMOD_System_CreateGeometry")
	
	;- FMOD_System_SetGeometrySettings_
	Prototype.l FMOD_System_SetGeometrySettings_Prototype (system.l, Maxworldsize.f)
	Global FMOD_System_SetGeometrySettings.FMOD_System_SetGeometrySettings_Prototype
	FMOD_System_SetGeometrySettings = GetFunction(fmodLib, "FMOD_System_SetGeometrySettings")
	
	;- FMOD_System_GetGeometrySettings_
	Prototype.l FMOD_System_GetGeometrySettings_Prototype (system.l, *Maxworldsize.f)
	Global FMOD_System_GetGeometrySettings.FMOD_System_GetGeometrySettings_Prototype
	FMOD_System_GetGeometrySettings = GetFunction(fmodLib, "FMOD_System_GetGeometrySettings")
	
	;- FMOD_System_LoadGeometry_
	Prototype.l FMOD_System_LoadGeometry_Prototype (system.l, _data.l, _dataSize.l, *Geometry.l)
	Global FMOD_System_LoadGeometry.FMOD_System_LoadGeometry_Prototype
	FMOD_System_LoadGeometry = GetFunction(fmodLib, "FMOD_System_LoadGeometry")
	
	;- FMOD_System_SetNetworkProxy_
	Prototype.l FMOD_System_SetNetworkProxy_Prototype (system.l, Proxy.s)
	Global FMOD_System_SetNetworkProxy.FMOD_System_SetNetworkProxy_Prototype
	FMOD_System_SetNetworkProxy = GetFunction(fmodLib, "FMOD_System_SetNetworkProxy")
	
	;- FMOD_System_GetNetworkProxy_
	Prototype.l FMOD_System_GetNetworkProxy_Prototype (system.l, *Proxy.b, Proxylen.l)
	Global FMOD_System_GetNetworkProxy.FMOD_System_GetNetworkProxy_Prototype
	FMOD_System_GetNetworkProxy = GetFunction(fmodLib, "FMOD_System_GetNetworkProxy")
	
	;- FMOD_System_SetNetworkTimeout_
	Prototype.l FMOD_System_SetNetworkTimeout_Prototype (system.l, timeout.l)
	Global FMOD_System_SetNetworkTimeout.FMOD_System_SetNetworkTimeout_Prototype
	FMOD_System_SetNetworkTimeout = GetFunction(fmodLib, "FMOD_System_SetNetworkTimeout")
	
	;- FMOD_System_GetNetworkTimeout_
	Prototype.l FMOD_System_GetNetworkTimeout_Prototype (system.l, *timeout.l)
	Global FMOD_System_GetNetworkTimeout.FMOD_System_GetNetworkTimeout_Prototype
	FMOD_System_GetNetworkTimeout = GetFunction(fmodLib, "FMOD_System_GetNetworkTimeout")
	
	;- FMOD_System_SetUserData_
	Prototype.l FMOD_System_SetUserData_Prototype (system.l, userdata.l)
	Global FMOD_System_SetUserData.FMOD_System_SetUserData_Prototype
	FMOD_System_SetUserData = GetFunction(fmodLib, "FMOD_System_SetUserData")
	
	;- FMOD_System_GetUserData_
	Prototype.l FMOD_System_GetUserData_Prototype (system.l, *userdata.l)
	Global FMOD_System_GetUserData.FMOD_System_GetUserData_Prototype
	FMOD_System_GetUserData = GetFunction(fmodLib, "FMOD_System_GetUserData")
	
	;- FMOD_Sound_Release_
	Prototype.l FMOD_Sound_Release_Prototype (sound.l)
	Global FMOD_Sound_Release.FMOD_Sound_Release_Prototype
	FMOD_Sound_Release = GetFunction(fmodLib, "FMOD_Sound_Release")
	
	;- FMOD_Sound_GetSystemObject_
	Prototype.l FMOD_Sound_GetSystemObject_Prototype (sound.l, *system.l)
	Global FMOD_Sound_GetSystemObject.FMOD_Sound_GetSystemObject_Prototype
	FMOD_Sound_GetSystemObject = GetFunction(fmodLib, "FMOD_Sound_GetSystemObject")
	
	;- FMOD_Sound_Lock_
	Prototype.l FMOD_Sound_Lock_Prototype (sound.l, Offset.l, Length.l, *Ptr1.l, *Ptr2.l, *Len1.l, *Len2.l)
	Global FMOD_Sound_Lock.FMOD_Sound_Lock_Prototype
	FMOD_Sound_Lock = GetFunction(fmodLib, "FMOD_Sound_Lock")
	
	;- FMOD_Sound_Unlock_
	Prototype.l FMOD_Sound_Unlock_Prototype (sound.l, Ptr1.l, Ptr2.l, Len1.l, Len2.l)
	Global FMOD_Sound_Unlock.FMOD_Sound_Unlock_Prototype
	FMOD_Sound_Unlock = GetFunction(fmodLib, "FMOD_Sound_Unlock")
	
	;- FMOD_Sound_SetDefaults_
	Prototype.l FMOD_Sound_SetDefaults_Prototype (sound.l, Frequency.f, Volume.f, Pan.f, Priority.l)
	Global FMOD_Sound_SetDefaults.FMOD_Sound_SetDefaults_Prototype
	FMOD_Sound_SetDefaults = GetFunction(fmodLib, "FMOD_Sound_SetDefaults")
	
	;- FMOD_Sound_GetDefaults_
	Prototype.l FMOD_Sound_GetDefaults_Prototype (sound.l, *Frequency.f, *Volume.f, *Pan.f, *Priority.l)
	Global FMOD_Sound_GetDefaults.FMOD_Sound_GetDefaults_Prototype
	FMOD_Sound_GetDefaults = GetFunction(fmodLib, "FMOD_Sound_GetDefaults")
	
	;- FMOD_Sound_SetVariations_
	Prototype.l FMOD_Sound_SetVariations_Prototype (sound.l, Frequencyvar.f, Volumevar.f, Panvar.f)
	Global FMOD_Sound_SetVariations.FMOD_Sound_SetVariations_Prototype
	FMOD_Sound_SetVariations = GetFunction(fmodLib, "FMOD_Sound_SetVariations")
	
	;- FMOD_Sound_GetVariations_
	Prototype.l FMOD_Sound_GetVariations_Prototype (sound.l, *Frequencyvar.f, *Volumevar.f, *Panvar.f)
	Global FMOD_Sound_GetVariations.FMOD_Sound_GetVariations_Prototype
	FMOD_Sound_GetVariations = GetFunction(fmodLib, "FMOD_Sound_GetVariations")
	
	;- FMOD_Sound_Set3DMinMaxDistance_
	Prototype.l FMOD_Sound_Set3DMinMaxDistance_Prototype (sound.l, min.f, max.f)
	Global FMOD_Sound_Set3DMinMaxDistance.FMOD_Sound_Set3DMinMaxDistance_Prototype
	FMOD_Sound_Set3DMinMaxDistance = GetFunction(fmodLib, "FMOD_Sound_Set3DMinMaxDistance")
	
	;- FMOD_Sound_Get3DMinMaxDistance_
	Prototype.l FMOD_Sound_Get3DMinMaxDistance_Prototype (sound.l, *min.f, *max.f)
	Global FMOD_Sound_Get3DMinMaxDistance.FMOD_Sound_Get3DMinMaxDistance_Prototype
	FMOD_Sound_Get3DMinMaxDistance = GetFunction(fmodLib, "FMOD_Sound_Get3DMinMaxDistance")
	
	;- FMOD_Sound_Set3DConeSettings_
	Prototype.l FMOD_Sound_Set3DConeSettings_Prototype (sound.l, Insideconeangle.f, Outsideconeangle.f, Outsidevolume.f)
	Global FMOD_Sound_Set3DConeSettings.FMOD_Sound_Set3DConeSettings_Prototype
	FMOD_Sound_Set3DConeSettings = GetFunction(fmodLib, "FMOD_Sound_Set3DConeSettings")
	
	;- FMOD_Sound_Get3DConeSettings_
	Prototype.l FMOD_Sound_Get3DConeSettings_Prototype (sound.l, *Insideconeangle.f, *Outsideconeangle.f, *Outsidevolume.f)
	Global FMOD_Sound_Get3DConeSettings.FMOD_Sound_Get3DConeSettings_Prototype
	FMOD_Sound_Get3DConeSettings = GetFunction(fmodLib, "FMOD_Sound_Get3DConeSettings")
	
	;- FMOD_Sound_Set3DCustomRolloff_
	Prototype.l FMOD_Sound_Set3DCustomRolloff_Prototype (sound.l, *Points.l, numpoints.l)
	Global FMOD_Sound_Set3DCustomRolloff.FMOD_Sound_Set3DCustomRolloff_Prototype
	FMOD_Sound_Set3DCustomRolloff = GetFunction(fmodLib, "FMOD_Sound_Set3DCustomRolloff")
	
	;- FMOD_Sound_Get3DCustomRolloff_
	Prototype.l FMOD_Sound_Get3DCustomRolloff_Prototype (sound.l, *Points.l, *numpoints.l)
	Global FMOD_Sound_Get3DCustomRolloff.FMOD_Sound_Get3DCustomRolloff_Prototype
	FMOD_Sound_Get3DCustomRolloff = GetFunction(fmodLib, "FMOD_Sound_Get3DCustomRolloff")
	
	;- FMOD_Sound_SetSubSound_
	Prototype.l FMOD_Sound_SetSubSound_Prototype (sound.l, Index.l, Subsound.l)
	Global FMOD_Sound_SetSubSound.FMOD_Sound_SetSubSound_Prototype
	FMOD_Sound_SetSubSound = GetFunction(fmodLib, "FMOD_Sound_SetSubSound")
	
	;- FMOD_Sound_GetSubSound_
	Prototype.l FMOD_Sound_GetSubSound_Prototype (sound.l, Index.l, *Subsound.l)
	Global FMOD_Sound_GetSubSound.FMOD_Sound_GetSubSound_Prototype
	FMOD_Sound_GetSubSound = GetFunction(fmodLib, "FMOD_Sound_GetSubSound")
	
	;- FMOD_Sound_SetSubSoundSentence_
	Prototype.l FMOD_Sound_SetSubSoundSentence_Prototype (sound.l, *Subsoundlist.l, Numsubsounds.l)
	Global FMOD_Sound_SetSubSoundSentence.FMOD_Sound_SetSubSoundSentence_Prototype
	FMOD_Sound_SetSubSoundSentence = GetFunction(fmodLib, "FMOD_Sound_SetSubSoundSentence")
	
	;- FMOD_Sound_GetName_
	Prototype.l FMOD_Sound_GetName_Prototype (sound.l, *name.b, Namelen.l)
	Global FMOD_Sound_GetName.FMOD_Sound_GetName_Prototype
	FMOD_Sound_GetName = GetFunction(fmodLib, "FMOD_Sound_GetName")
	
	;- FMOD_Sound_GetLength_
	Prototype.l FMOD_Sound_GetLength_Prototype (sound.l, *Length.l, Lengthtype.l)
	Global FMOD_Sound_GetLength.FMOD_Sound_GetLength_Prototype
	FMOD_Sound_GetLength = GetFunction(fmodLib, "FMOD_Sound_GetLength")
	
	;- FMOD_Sound_GetFormat_
	Prototype.l FMOD_Sound_GetFormat_Prototype (sound.l, *Soundtype.l, *Format.l, *Channels.l, *Bits.l)
	Global FMOD_Sound_GetFormat.FMOD_Sound_GetFormat_Prototype
	FMOD_Sound_GetFormat = GetFunction(fmodLib, "FMOD_Sound_GetFormat")
	
	;- FMOD_Sound_GetNumSubSounds_
	Prototype.l FMOD_Sound_GetNumSubSounds_Prototype (sound.l, *Numsubsounds.l)
	Global FMOD_Sound_GetNumSubSounds.FMOD_Sound_GetNumSubSounds_Prototype
	FMOD_Sound_GetNumSubSounds = GetFunction(fmodLib, "FMOD_Sound_GetNumSubSounds")
	
	;- FMOD_Sound_GetNumTags_
	Prototype.l FMOD_Sound_GetNumTags_Prototype (sound.l, *Numtags.l, *Numtagsupdated.l)
	Global FMOD_Sound_GetNumTags.FMOD_Sound_GetNumTags_Prototype
	FMOD_Sound_GetNumTags = GetFunction(fmodLib, "FMOD_Sound_GetNumTags")
	
	;- FMOD_Sound_GetTag_
	Prototype.l FMOD_Sound_GetTag_Prototype (sound.l, pNameOrNull.l, Index.l, *Tag.l)
	Global FMOD_Sound_GetTag.FMOD_Sound_GetTag_Prototype
	FMOD_Sound_GetTag = GetFunction(fmodLib, "FMOD_Sound_GetTag")
	
	;- FMOD_Sound_GetOpenState_
	Prototype.l FMOD_Sound_GetOpenState_Prototype (sound.l, *Openstate.l, *Percentbuffered.l, *Starving.l)
	Global FMOD_Sound_GetOpenState.FMOD_Sound_GetOpenState_Prototype
	FMOD_Sound_GetOpenState = GetFunction(fmodLib, "FMOD_Sound_GetOpenState")
	
	;- FMOD_Sound_ReadData_
	Prototype.l FMOD_Sound_ReadData_Prototype (sound.l, Buffer.l, Lenbytes.l, *_Read.l)
	Global FMOD_Sound_ReadData.FMOD_Sound_ReadData_Prototype
	FMOD_Sound_ReadData = GetFunction(fmodLib, "FMOD_Sound_ReadData")
	
	;- FMOD_Sound_SeekData_
	Prototype.l FMOD_Sound_SeekData_Prototype (sound.l, Pcm.l)
	Global FMOD_Sound_SeekData.FMOD_Sound_SeekData_Prototype
	FMOD_Sound_SeekData = GetFunction(fmodLib, "FMOD_Sound_SeekData")
	
	;- FMOD_Sound_GetNumSyncPoints_
	Prototype.l FMOD_Sound_GetNumSyncPoints_Prototype (sound.l, *Numsyncpoints.l)
	Global FMOD_Sound_GetNumSyncPoints.FMOD_Sound_GetNumSyncPoints_Prototype
	FMOD_Sound_GetNumSyncPoints = GetFunction(fmodLib, "FMOD_Sound_GetNumSyncPoints")
	
	;- FMOD_Sound_GetSyncPoint_
	Prototype.l FMOD_Sound_GetSyncPoint_Prototype (sound.l, Index.l, *Point.l)
	Global FMOD_Sound_GetSyncPoint.FMOD_Sound_GetSyncPoint_Prototype
	FMOD_Sound_GetSyncPoint = GetFunction(fmodLib, "FMOD_Sound_GetSyncPoint")
	
	;- FMOD_Sound_GetSyncPointInfo_
	Prototype.l FMOD_Sound_GetSyncPointInfo_Prototype (sound.l, Point.l, *name.b, Namelen.l, *Offset.l, Offsettype.l)
	Global FMOD_Sound_GetSyncPointInfo.FMOD_Sound_GetSyncPointInfo_Prototype
	FMOD_Sound_GetSyncPointInfo = GetFunction(fmodLib, "FMOD_Sound_GetSyncPointInfo")
	
	;- FMOD_Sound_AddSyncPoint_
	Prototype.l FMOD_Sound_AddSyncPoint_Prototype (sound.l, Offset.l, Offsettype.l, name.s, *Point.l)
	Global FMOD_Sound_AddSyncPoint.FMOD_Sound_AddSyncPoint_Prototype
	FMOD_Sound_AddSyncPoint = GetFunction(fmodLib, "FMOD_Sound_AddSyncPoint")
	
	;- FMOD_Sound_DeleteSyncPoint_
	Prototype.l FMOD_Sound_DeleteSyncPoint_Prototype (sound.l, Point.l)
	Global FMOD_Sound_DeleteSyncPoint.FMOD_Sound_DeleteSyncPoint_Prototype
	FMOD_Sound_DeleteSyncPoint = GetFunction(fmodLib, "FMOD_Sound_DeleteSyncPoint")
	
	;- FMOD_Sound_SetMode_
	Prototype.l FMOD_Sound_SetMode_Prototype (sound.l, Mode.l)
	Global FMOD_Sound_SetMode.FMOD_Sound_SetMode_Prototype
	FMOD_Sound_SetMode = GetFunction(fmodLib, "FMOD_Sound_SetMode")
	
	;- FMOD_Sound_GetMode_
	Prototype.l FMOD_Sound_GetMode_Prototype (sound.l, *Mode.l)
	Global FMOD_Sound_GetMode.FMOD_Sound_GetMode_Prototype
	FMOD_Sound_GetMode = GetFunction(fmodLib, "FMOD_Sound_GetMode")
	
	;- FMOD_Sound_SetLoopCount_
	Prototype.l FMOD_Sound_SetLoopCount_Prototype (sound.l, Loopcount.l)
	Global FMOD_Sound_SetLoopCount.FMOD_Sound_SetLoopCount_Prototype
	FMOD_Sound_SetLoopCount = GetFunction(fmodLib, "FMOD_Sound_SetLoopCount")
	
	;- FMOD_Sound_GetLoopCount_
	Prototype.l FMOD_Sound_GetLoopCount_Prototype (sound.l, *Loopcount.l)
	Global FMOD_Sound_GetLoopCount.FMOD_Sound_GetLoopCount_Prototype
	FMOD_Sound_GetLoopCount = GetFunction(fmodLib, "FMOD_Sound_GetLoopCount")
	
	;- FMOD_Sound_SetLoopPoints_
	Prototype.l FMOD_Sound_SetLoopPoints_Prototype (sound.l, Loopstart.l, Loopstarttype.l, Loopend.l, Loopendtype.l)
	Global FMOD_Sound_SetLoopPoints.FMOD_Sound_SetLoopPoints_Prototype
	FMOD_Sound_SetLoopPoints = GetFunction(fmodLib, "FMOD_Sound_SetLoopPoints")
	
	;- FMOD_Sound_GetLoopPoints_
	Prototype.l FMOD_Sound_GetLoopPoints_Prototype (sound.l, *Loopstart.l, Loopstarttype.l, *Loopend.l, Loopendtype.l)
	Global FMOD_Sound_GetLoopPoints.FMOD_Sound_GetLoopPoints_Prototype
	FMOD_Sound_GetLoopPoints = GetFunction(fmodLib, "FMOD_Sound_GetLoopPoints")
	
	;- FMOD_Sound_SetUserData_
	Prototype.l FMOD_Sound_SetUserData_Prototype (sound.l, userdata.l)
	Global FMOD_Sound_SetUserData.FMOD_Sound_SetUserData_Prototype
	FMOD_Sound_SetUserData = GetFunction(fmodLib, "FMOD_Sound_SetUserData")
	
	;- FMOD_Sound_GetUserData_
	Prototype.l FMOD_Sound_GetUserData_Prototype (sound.l, *userdata.l)
	Global FMOD_Sound_GetUserData.FMOD_Sound_GetUserData_Prototype
	FMOD_Sound_GetUserData = GetFunction(fmodLib, "FMOD_Sound_GetUserData")

[Perkin]

Also add this code (See previous post)

Code: Select all

	
	;- FMOD_Channel_GetSystemObject_
	Prototype.l FMOD_Channel_GetSystemObject_Prototype (channel.l, *system.l)
	Global FMOD_Channel_GetSystemObject.FMOD_Channel_GetSystemObject_Prototype
	FMOD_Channel_GetSystemObject = GetFunction(fmodLib, "FMOD_Channel_GetSystemObject")
	
	;- FMOD_Channel_Stop_
	Prototype.l FMOD_Channel_Stop_Prototype (channel.l)
	Global FMOD_Channel_Stop.FMOD_Channel_Stop_Prototype
	FMOD_Channel_Stop = GetFunction(fmodLib, "FMOD_Channel_Stop")
	
	;- FMOD_Channel_SetPaused_
	Prototype.l FMOD_Channel_SetPaused_Prototype (channel.l, paused.l)
	Global FMOD_Channel_SetPaused.FMOD_Channel_SetPaused_Prototype
	FMOD_Channel_SetPaused = GetFunction(fmodLib, "FMOD_Channel_SetPaused")
	
	;- FMOD_Channel_GetPaused_
	Prototype.l FMOD_Channel_GetPaused_Prototype (channel.l, *paused.l)
	Global FMOD_Channel_GetPaused.FMOD_Channel_GetPaused_Prototype
	FMOD_Channel_GetPaused = GetFunction(fmodLib, "FMOD_Channel_GetPaused")
	
	;- FMOD_Channel_SetVolume
	Prototype.l FMOD_Channel_SetVolume_Prototype(channel.l, Volume.f)
	Global FMOD_Channel_SetVolume.FMOD_Channel_SetVolume_Prototype
	FMOD_Channel_SetVolume = GetFunction(fmodLib, "FMOD_Channel_SetVolume")
	
	;- FMOD_Channel_GetVolume
	Prototype.l FMOD_Channel_GetVolume_Prototype(channel.l, *Volume.f)
	Global FMOD_Channel_GetVolume.FMOD_Channel_GetVolume_Prototype
	FMOD_Channel_GetVolume = GetFunction(fmodLib, "FMOD_Channel_GetVolume")
	
	;- FMOD_Channel_SetFrequency_
	Prototype.l FMOD_Channel_SetFrequency_Prototype (channel.l, Frequency.f)
	Global FMOD_Channel_SetFrequency.FMOD_Channel_SetFrequency_Prototype
	FMOD_Channel_SetFrequency = GetFunction(fmodLib, "FMOD_Channel_SetFrequency")
	
	;- FMOD_Channel_GetFrequency_
	Prototype.l FMOD_Channel_GetFrequency_Prototype (channel.l, *Frequency.f)
	Global FMOD_Channel_GetFrequency.FMOD_Channel_GetFrequency_Prototype
	FMOD_Channel_GetFrequency = GetFunction(fmodLib, "FMOD_Channel_GetFrequency")
	
	;- FMOD_Channel_SetPan_
	Prototype.l FMOD_Channel_SetPan_Prototype (channel.l, Pan.f)
	Global FMOD_Channel_SetPan.FMOD_Channel_SetPan_Prototype
	FMOD_Channel_SetPan = GetFunction(fmodLib, "FMOD_Channel_SetPan")
	
	;- FMOD_Channel_GetPan_
	Prototype.l FMOD_Channel_GetPan_Prototype (channel.l, *Pan.f)
	Global FMOD_Channel_GetPan.FMOD_Channel_GetPan_Prototype
	FMOD_Channel_GetPan = GetFunction(fmodLib, "FMOD_Channel_GetPan")
	
	;- FMOD_Channel_SetDelay_
	Prototype.l FMOD_Channel_SetDelay_Prototype (channel.l, Startdelay.l, Enddelay.l)
	Global FMOD_Channel_SetDelay.FMOD_Channel_SetDelay_Prototype
	FMOD_Channel_SetDelay = GetFunction(fmodLib, "FMOD_Channel_SetDelay")
	
	;- FMOD_Channel_GetDelay_
	Prototype.l FMOD_Channel_GetDelay_Prototype (channel.l, *Startdelay.l, *Enddelay.l)
	Global FMOD_Channel_GetDelay.FMOD_Channel_GetDelay_Prototype
	FMOD_Channel_GetDelay = GetFunction(fmodLib, "FMOD_Channel_GetDelay")
	
	;- FMOD_Channel_SetSpeakerMix_
	Prototype.l FMOD_Channel_SetSpeakerMix_Prototype (channel.l, Frontleft.f, Frontright.f, Center.f, Lfe.f, Backleft.f, Backright.f, Sideleft.f, Sideright.f)
	Global FMOD_Channel_SetSpeakerMix.FMOD_Channel_SetSpeakerMix_Prototype
	FMOD_Channel_SetSpeakerMix = GetFunction(fmodLib, "FMOD_Channel_SetSpeakerMix")
	
	;- FMOD_Channel_GetSpeakerMix_
	Prototype.l FMOD_Channel_GetSpeakerMix_Prototype (channel.l, *Frontleft.f, *Frontright.f, *Center.f, *Lfe.f, *Backleft.f, *Backright.f, *Sideleft.f, *Sideright.f)
	Global FMOD_Channel_GetSpeakerMix.FMOD_Channel_GetSpeakerMix_Prototype
	FMOD_Channel_GetSpeakerMix = GetFunction(fmodLib, "FMOD_Channel_GetSpeakerMix")
	
	;- FMOD_Channel_SetSpeakerLevels_
	Prototype.l FMOD_Channel_SetSpeakerLevels_Prototype (channel.l, Speaker.l, *Levels.f, Numlevels.l)
	Global FMOD_Channel_SetSpeakerLevels.FMOD_Channel_SetSpeakerLevels_Prototype
	FMOD_Channel_SetSpeakerLevels = GetFunction(fmodLib, "FMOD_Channel_SetSpeakerLevels")
	
	;- FMOD_Channel_GetSpeakerLevels_
	Prototype.l FMOD_Channel_GetSpeakerLevels_Prototype (channel.l, Speaker.l, *Levels.f, Numlevels.l)
	Global FMOD_Channel_GetSpeakerLevels.FMOD_Channel_GetSpeakerLevels_Prototype
	FMOD_Channel_GetSpeakerLevels = GetFunction(fmodLib, "FMOD_Channel_GetSpeakerLevels")
	
	;- FMOD_Channel_SetMute_
	Prototype.l FMOD_Channel_SetMute_Prototype (channel.l, Mute.l)
	Global FMOD_Channel_SetMute.FMOD_Channel_SetMute_Prototype
	FMOD_Channel_SetMute = GetFunction(fmodLib, "FMOD_Channel_SetMute")
	
	;- FMOD_Channel_GetMute_
	Prototype.l FMOD_Channel_GetMute_Prototype (channel.l, *Mute.l)
	Global FMOD_Channel_GetMute.FMOD_Channel_GetMute_Prototype
	FMOD_Channel_GetMute = GetFunction(fmodLib, "FMOD_Channel_GetMute")
	
	;- FMOD_Channel_SetPriority_
	Prototype.l FMOD_Channel_SetPriority_Prototype (channel.l, Priority.l)
	Global FMOD_Channel_SetPriority.FMOD_Channel_SetPriority_Prototype
	FMOD_Channel_SetPriority = GetFunction(fmodLib, "FMOD_Channel_SetPriority")
	
	;- FMOD_Channel_GetPriority_
	Prototype.l FMOD_Channel_GetPriority_Prototype (channel.l, *Priority.l)
	Global FMOD_Channel_GetPriority.FMOD_Channel_GetPriority_Prototype
	FMOD_Channel_GetPriority = GetFunction(fmodLib, "FMOD_Channel_GetPriority")
	
	;- FMOD_Channel_SetPosition_
	Prototype.l FMOD_Channel_SetPosition_Prototype (channel.l, Position.l, Postype.l)
	Global FMOD_Channel_SetPosition.FMOD_Channel_SetPosition_Prototype
	FMOD_Channel_SetPosition = GetFunction(fmodLib, "FMOD_Channel_SetPosition")
	
	;- FMOD_Channel_GetPosition_
	Prototype.l FMOD_Channel_GetPosition_Prototype (channel.l, *Position.l, Postype.l)
	Global FMOD_Channel_GetPosition.FMOD_Channel_GetPosition_Prototype
	FMOD_Channel_GetPosition = GetFunction(fmodLib, "FMOD_Channel_GetPosition")
	
	;- FMOD_Channel_SetReverbProperties_
	Prototype.l FMOD_Channel_SetReverbProperties_Prototype (channel.l, *Prop.l)
	Global FMOD_Channel_SetReverbProperties.FMOD_Channel_SetReverbProperties_Prototype
	FMOD_Channel_SetReverbProperties = GetFunction(fmodLib, "FMOD_Channel_SetReverbProperties")
	
	;- FMOD_Channel_GetReverbProperties_
	Prototype.l FMOD_Channel_GetReverbProperties_Prototype (channel.l, *Prop.l)
	Global FMOD_Channel_GetReverbProperties.FMOD_Channel_GetReverbProperties_Prototype
	FMOD_Channel_GetReverbProperties = GetFunction(fmodLib, "FMOD_Channel_GetReverbProperties")
	
	;- FMOD_Channel_SetChannelGroup_
	Prototype.l FMOD_Channel_SetChannelGroup_Prototype (channel.l, Channelgroup.l)
	Global FMOD_Channel_SetChannelGroup.FMOD_Channel_SetChannelGroup_Prototype
	FMOD_Channel_SetChannelGroup = GetFunction(fmodLib, "FMOD_Channel_SetChannelGroup")
	
	;- FMOD_Channel_GetChannelGroup_
	Prototype.l FMOD_Channel_GetChannelGroup_Prototype (channel.l, *Channelgroup.l)
	Global FMOD_Channel_GetChannelGroup.FMOD_Channel_GetChannelGroup_Prototype
	FMOD_Channel_GetChannelGroup = GetFunction(fmodLib, "FMOD_Channel_GetChannelGroup")
	
	;- FMOD_Channel_SetCallback_
	Prototype.l FMOD_Channel_SetCallback_Prototype (channel.l, Type.l, Callback.l, Command.l)
	Global FMOD_Channel_SetCallback.FMOD_Channel_SetCallback_Prototype
	FMOD_Channel_SetCallback = GetFunction(fmodLib, "FMOD_Channel_SetCallback")
	
	;- FMOD_Channel_Set3DAttributes_
	Prototype.l FMOD_Channel_Set3DAttributes_Prototype (channel.l, *Pos.l, *Vel.l)
	Global FMOD_Channel_Set3DAttributes.FMOD_Channel_Set3DAttributes_Prototype
	FMOD_Channel_Set3DAttributes = GetFunction(fmodLib, "FMOD_Channel_Set3DAttributes")
	
	;- FMOD_Channel_Get3DAttributes_
	Prototype.l FMOD_Channel_Get3DAttributes_Prototype (channel.l, *Pos.l, *Vel.l)
	Global FMOD_Channel_Get3DAttributes.FMOD_Channel_Get3DAttributes_Prototype
	FMOD_Channel_Get3DAttributes = GetFunction(fmodLib, "FMOD_Channel_Get3DAttributes")
	
	;- FMOD_Channel_Set3DMinMaxDistance_
	Prototype.l FMOD_Channel_Set3DMinMaxDistance_Prototype (channel.l, Mindistance.f, Maxdistance.f)
	Global FMOD_Channel_Set3DMinMaxDistance.FMOD_Channel_Set3DMinMaxDistance_Prototype
	FMOD_Channel_Set3DMinMaxDistance = GetFunction(fmodLib, "FMOD_Channel_Set3DMinMaxDistance")
	
	;- FMOD_Channel_Get3DMinMaxDistance_
	Prototype.l FMOD_Channel_Get3DMinMaxDistance_Prototype (channel.l, *Mindistance.f, *Maxdistance.f)
	Global FMOD_Channel_Get3DMinMaxDistance.FMOD_Channel_Get3DMinMaxDistance_Prototype
	FMOD_Channel_Get3DMinMaxDistance = GetFunction(fmodLib, "FMOD_Channel_Get3DMinMaxDistance")
	
	;- FMOD_Channel_Set3DConeSettings_
	Prototype.l FMOD_Channel_Set3DConeSettings_Prototype (channel.l, Insideconeangle.f, Outsideconeangle.f, Outsidevolume.f)
	Global FMOD_Channel_Set3DConeSettings.FMOD_Channel_Set3DConeSettings_Prototype
	FMOD_Channel_Set3DConeSettings = GetFunction(fmodLib, "FMOD_Channel_Set3DConeSettings")
	
	;- FMOD_Channel_Get3DConeSettings_
	Prototype.l FMOD_Channel_Get3DConeSettings_Prototype (channel.l, *Insideconeangle.f, *Outsideconeangle.f, *Outsidevolume.f)
	Global FMOD_Channel_Get3DConeSettings.FMOD_Channel_Get3DConeSettings_Prototype
	FMOD_Channel_Get3DConeSettings = GetFunction(fmodLib, "FMOD_Channel_Get3DConeSettings")
	
	;- FMOD_Channel_Set3DConeOrientation_
	Prototype.l FMOD_Channel_Set3DConeOrientation_Prototype (channel.l, *Orientation.l)
	Global FMOD_Channel_Set3DConeOrientation.FMOD_Channel_Set3DConeOrientation_Prototype
	FMOD_Channel_Set3DConeOrientation = GetFunction(fmodLib, "FMOD_Channel_Set3DConeOrientation")
	
	;- FMOD_Channel_Get3DConeOrientation_
	Prototype.l FMOD_Channel_Get3DConeOrientation_Prototype (channel.l, *Orientation.l)
	Global FMOD_Channel_Get3DConeOrientation.FMOD_Channel_Get3DConeOrientation_Prototype
	FMOD_Channel_Get3DConeOrientation = GetFunction(fmodLib, "FMOD_Channel_Get3DConeOrientation")
	
	;- FMOD_Channel_Set3DCustomRolloff_
	Prototype.l FMOD_Channel_Set3DCustomRolloff_Prototype (channel.l, *Points.l, numpoints.l)
	Global FMOD_Channel_Set3DCustomRolloff.FMOD_Channel_Set3DCustomRolloff_Prototype
	FMOD_Channel_Set3DCustomRolloff = GetFunction(fmodLib, "FMOD_Channel_Set3DCustomRolloff")
	
	;- FMOD_Channel_Get3DCustomRolloff_
	Prototype.l FMOD_Channel_Get3DCustomRolloff_Prototype (channel.l, *Points.l, *numpoints.l)
	Global FMOD_Channel_Get3DCustomRolloff.FMOD_Channel_Get3DCustomRolloff_Prototype
	FMOD_Channel_Get3DCustomRolloff = GetFunction(fmodLib, "FMOD_Channel_Get3DCustomRolloff")
	
	;- FMOD_Channel_Set3DOcclusion_
	Prototype.l FMOD_Channel_Set3DOcclusion_Prototype (channel.l, DirectOcclusion.f, ReverbOcclusion.f)
	Global FMOD_Channel_Set3DOcclusion.FMOD_Channel_Set3DOcclusion_Prototype
	FMOD_Channel_Set3DOcclusion = GetFunction(fmodLib, "FMOD_Channel_Set3DOcclusion")
	
	;- FMOD_Channel_Get3DOcclusion_
	Prototype.l FMOD_Channel_Get3DOcclusion_Prototype (channel.l, *DirectOcclusion.f, *ReverbOcclusion.f)
	Global FMOD_Channel_Get3DOcclusion.FMOD_Channel_Get3DOcclusion_Prototype
	FMOD_Channel_Get3DOcclusion = GetFunction(fmodLib, "FMOD_Channel_Get3DOcclusion")
	
	;- FMOD_Channel_Set3DSpread_
	Prototype.l FMOD_Channel_Set3DSpread_Prototype (channel.l, angle.f)
	Global FMOD_Channel_Set3DSpread.FMOD_Channel_Set3DSpread_Prototype
	FMOD_Channel_Set3DSpread = GetFunction(fmodLib, "FMOD_Channel_Set3DSpread")
	
	;- FMOD_Channel_Get3DSpread_
	Prototype.l FMOD_Channel_Get3DSpread_Prototype (channel.l, *angle.f)
	Global FMOD_Channel_Get3DSpread.FMOD_Channel_Get3DSpread_Prototype
	FMOD_Channel_Get3DSpread = GetFunction(fmodLib, "FMOD_Channel_Get3DSpread")
	
	;- FMOD_Channel_Set3DPanLevel_
	Prototype.l FMOD_Channel_Set3DPanLevel_Prototype (channel.l, float.f)
	Global FMOD_Channel_Set3DPanLevel.FMOD_Channel_Set3DPanLevel_Prototype
	FMOD_Channel_Set3DPanLevel = GetFunction(fmodLib, "FMOD_Channel_Set3DPanLevel")
	
	;- FMOD_Channel_Get3DPanLevel_
	Prototype.l FMOD_Channel_Get3DPanLevel_Prototype (channel.l, *float.f)
	Global FMOD_Channel_Get3DPanLevel.FMOD_Channel_Get3DPanLevel_Prototype
	FMOD_Channel_Get3DPanLevel = GetFunction(fmodLib, "FMOD_Channel_Get3DPanLevel")
	
	;- FMOD_Channel_Set3DDopplerLevel_
	Prototype.l FMOD_Channel_Set3DDopplerLevel_Prototype (channel.l, level.f)
	Global FMOD_Channel_Set3DDopplerLevel.FMOD_Channel_Set3DDopplerLevel_Prototype
	FMOD_Channel_Set3DDopplerLevel = GetFunction(fmodLib, "FMOD_Channel_Set3DDopplerLevel")
	
	;- FMOD_Channel_Get3DDopplerLevel_
	Prototype.l FMOD_Channel_Get3DDopplerLevel_Prototype (channel.l, *level.f)
	Global FMOD_Channel_Get3DDopplerLevel.FMOD_Channel_Get3DDopplerLevel_Prototype
	FMOD_Channel_Get3DDopplerLevel = GetFunction(fmodLib, "FMOD_Channel_Get3DDopplerLevel")
	
	;- FMOD_Channel_GetDSPHead_
	Prototype.l FMOD_Channel_GetDSPHead_Prototype (channel.l, *Dsp.l)
	Global FMOD_Channel_GetDSPHead.FMOD_Channel_GetDSPHead_Prototype
	FMOD_Channel_GetDSPHead = GetFunction(fmodLib, "FMOD_Channel_GetDSPHead")
	
	;- FMOD_Channel_AddDSP_
	Prototype.l FMOD_Channel_AddDSP_Prototype (channel.l, Dsp.l)
	Global FMOD_Channel_AddDSP.FMOD_Channel_AddDSP_Prototype
	FMOD_Channel_AddDSP = GetFunction(fmodLib, "FMOD_Channel_AddDSP")
	
	;- FMOD_Channel_IsPlaying_
	Prototype.l FMOD_Channel_IsPlaying_Prototype (channel.l, *Isplaying.l)
	Global FMOD_Channel_IsPlaying.FMOD_Channel_IsPlaying_Prototype
	FMOD_Channel_IsPlaying = GetFunction(fmodLib, "FMOD_Channel_IsPlaying")
	
	;- FMOD_Channel_IsVirtual_
	Prototype.l FMOD_Channel_IsVirtual_Prototype (channel.l, *Isvirtual.l)
	Global FMOD_Channel_IsVirtual.FMOD_Channel_IsVirtual_Prototype
	FMOD_Channel_IsVirtual = GetFunction(fmodLib, "FMOD_Channel_IsVirtual")
	
	;- FMOD_Channel_GetAudibility_
	Prototype.l FMOD_Channel_GetAudibility_Prototype (channel.l, *Audibility.f)
	Global FMOD_Channel_GetAudibility.FMOD_Channel_GetAudibility_Prototype
	FMOD_Channel_GetAudibility = GetFunction(fmodLib, "FMOD_Channel_GetAudibility")
	
	;- FMOD_Channel_GetCurrentSound_
	Prototype.l FMOD_Channel_GetCurrentSound_Prototype (channel.l, *Sound.l)
	Global FMOD_Channel_GetCurrentSound.FMOD_Channel_GetCurrentSound_Prototype
	FMOD_Channel_GetCurrentSound = GetFunction(fmodLib, "FMOD_Channel_GetCurrentSound")
	
	;- FMOD_Channel_GetSpectrum_
	Prototype.l FMOD_Channel_GetSpectrum_Prototype (channel.l, *Spectrumarray.f, Numvalues.l, Channeloffset.l, Windowtype.l)
	Global FMOD_Channel_GetSpectrum.FMOD_Channel_GetSpectrum_Prototype
	FMOD_Channel_GetSpectrum = GetFunction(fmodLib, "FMOD_Channel_GetSpectrum")
	
	;- FMOD_Channel_GetWaveData_
	Prototype.l FMOD_Channel_GetWaveData_Prototype (channel.l, *Wavearray.f, Numvalues.l, Channeloffset.l)
	Global FMOD_Channel_GetWaveData.FMOD_Channel_GetWaveData_Prototype
	FMOD_Channel_GetWaveData = GetFunction(fmodLib, "FMOD_Channel_GetWaveData")
	
	;- FMOD_Channel_GetIndex_
	Prototype.l FMOD_Channel_GetIndex_Prototype (channel.l, *Index.l)
	Global FMOD_Channel_GetIndex.FMOD_Channel_GetIndex_Prototype
	FMOD_Channel_GetIndex = GetFunction(fmodLib, "FMOD_Channel_GetIndex")
	
	;- FMOD_Channel_SetMode_
	Prototype.l FMOD_Channel_SetMode_Prototype (channel.l, Mode.l)
	Global FMOD_Channel_SetMode.FMOD_Channel_SetMode_Prototype
	FMOD_Channel_SetMode = GetFunction(fmodLib, "FMOD_Channel_SetMode")
	
	;- FMOD_Channel_GetMode_
	Prototype.l FMOD_Channel_GetMode_Prototype (channel.l, *Mode.l)
	Global FMOD_Channel_GetMode.FMOD_Channel_GetMode_Prototype
	FMOD_Channel_GetMode = GetFunction(fmodLib, "FMOD_Channel_GetMode")
	
	;- FMOD_Channel_SetLoopCount_
	Prototype.l FMOD_Channel_SetLoopCount_Prototype (channel.l, Loopcount.l)
	Global FMOD_Channel_SetLoopCount.FMOD_Channel_SetLoopCount_Prototype
	FMOD_Channel_SetLoopCount = GetFunction(fmodLib, "FMOD_Channel_SetLoopCount")
	
	;- FMOD_Channel_GetLoopCount_
	Prototype.l FMOD_Channel_GetLoopCount_Prototype (channel.l, *Loopcount.l)
	Global FMOD_Channel_GetLoopCount.FMOD_Channel_GetLoopCount_Prototype
	FMOD_Channel_GetLoopCount = GetFunction(fmodLib, "FMOD_Channel_GetLoopCount")
	
	;- FMOD_Channel_SetLoopPoints_
	Prototype.l FMOD_Channel_SetLoopPoints_Prototype (channel.l, Loopstart.l, Loopstarttype.l, Loopend.l, Loopendtype.l)
	Global FMOD_Channel_SetLoopPoints.FMOD_Channel_SetLoopPoints_Prototype
	FMOD_Channel_SetLoopPoints = GetFunction(fmodLib, "FMOD_Channel_SetLoopPoints")
	
	;- FMOD_Channel_GetLoopPoints_
	Prototype.l FMOD_Channel_GetLoopPoints_Prototype (channel.l, *Loopstart.l, Loopstarttype.l, *Loopend.l, Loopendtype.l)
	Global FMOD_Channel_GetLoopPoints.FMOD_Channel_GetLoopPoints_Prototype
	FMOD_Channel_GetLoopPoints = GetFunction(fmodLib, "FMOD_Channel_GetLoopPoints")
	
	;- FMOD_Channel_SetUserData_
	Prototype.l FMOD_Channel_SetUserData_Prototype (channel.l, userdata.l)
	Global FMOD_Channel_SetUserData.FMOD_Channel_SetUserData_Prototype
	FMOD_Channel_SetUserData = GetFunction(fmodLib, "FMOD_Channel_SetUserData")
	
	;- FMOD_Channel_GetUserData_
	Prototype.l FMOD_Channel_GetUserData_Prototype (channel.l, *userdata.l)
	Global FMOD_Channel_GetUserData.FMOD_Channel_GetUserData_Prototype
	FMOD_Channel_GetUserData = GetFunction(fmodLib, "FMOD_Channel_GetUserData")
	
	;- FMOD_ChannelGroup_Release_
	Prototype.l FMOD_ChannelGroup_Release_Prototype (Channelgroup.l)
	Global FMOD_ChannelGroup_Release.FMOD_ChannelGroup_Release_Prototype
	FMOD_ChannelGroup_Release = GetFunction(fmodLib, "FMOD_ChannelGroup_Release")
	
	;- FMOD_ChannelGroup_GetSystemObject_
	Prototype.l FMOD_ChannelGroup_GetSystemObject_Prototype (Channelgroup.l, *system.l)
	Global FMOD_ChannelGroup_GetSystemObject.FMOD_ChannelGroup_GetSystemObject_Prototype
	FMOD_ChannelGroup_GetSystemObject = GetFunction(fmodLib, "FMOD_ChannelGroup_GetSystemObject")
	
	;- FMOD_ChannelGroup_SetVolume_
	Prototype.l FMOD_ChannelGroup_SetVolume_Prototype (Channelgroup.l, Volume.f)
	Global FMOD_ChannelGroup_SetVolume.FMOD_ChannelGroup_SetVolume_Prototype
	FMOD_ChannelGroup_SetVolume = GetFunction(fmodLib, "FMOD_ChannelGroup_SetVolume")
	
	;- FMOD_ChannelGroup_GetVolume_
	Prototype.l FMOD_ChannelGroup_GetVolume_Prototype (Channelgroup.l, *Volume.f)
	Global FMOD_ChannelGroup_GetVolume.FMOD_ChannelGroup_GetVolume_Prototype
	FMOD_ChannelGroup_GetVolume = GetFunction(fmodLib, "FMOD_ChannelGroup_GetVolume")
	
	;- FMOD_ChannelGroup_SetPitch_
	Prototype.l FMOD_ChannelGroup_SetPitch_Prototype (Channelgroup.l, Pitch.f)
	Global FMOD_ChannelGroup_SetPitch.FMOD_ChannelGroup_SetPitch_Prototype
	FMOD_ChannelGroup_SetPitch = GetFunction(fmodLib, "FMOD_ChannelGroup_SetPitch")
	
	;- FMOD_ChannelGroup_GetPitch_
	Prototype.l FMOD_ChannelGroup_GetPitch_Prototype (Channelgroup.l, *Pitch.f)
	Global FMOD_ChannelGroup_GetPitch.FMOD_ChannelGroup_GetPitch_Prototype
	FMOD_ChannelGroup_GetPitch = GetFunction(fmodLib, "FMOD_ChannelGroup_GetPitch")
	
	;- FMOD_ChannelGroup_Stop_
	Prototype.l FMOD_ChannelGroup_Stop_Prototype (Channelgroup.l)
	Global FMOD_ChannelGroup_Stop.FMOD_ChannelGroup_Stop_Prototype
	FMOD_ChannelGroup_Stop = GetFunction(fmodLib, "FMOD_ChannelGroup_Stop")
	
	;- FMOD_ChannelGroup_OverrideVolume_
	Prototype.l FMOD_ChannelGroup_OverrideVolume_Prototype (Channelgroup.l, Volume.f)
	Global FMOD_ChannelGroup_OverrideVolume.FMOD_ChannelGroup_OverrideVolume_Prototype
	FMOD_ChannelGroup_OverrideVolume = GetFunction(fmodLib, "FMOD_ChannelGroup_OverrideVolume")
	
	;- FMOD_ChannelGroup_OverridePaused_
	Prototype.l FMOD_ChannelGroup_OverridePaused_Prototype (Channelgroup.l, paused.l)
	Global FMOD_ChannelGroup_OverridePaused.FMOD_ChannelGroup_OverridePaused_Prototype
	FMOD_ChannelGroup_OverridePaused = GetFunction(fmodLib, "FMOD_ChannelGroup_OverridePaused")
	
	;- FMOD_ChannelGroup_OverrideFrequency_
	Prototype.l FMOD_ChannelGroup_OverrideFrequency_Prototype (Channelgroup.l, Frequency.f)
	Global FMOD_ChannelGroup_OverrideFrequency.FMOD_ChannelGroup_OverrideFrequency_Prototype
	FMOD_ChannelGroup_OverrideFrequency = GetFunction(fmodLib, "FMOD_ChannelGroup_OverrideFrequency")
	
	;- FMOD_ChannelGroup_OverridePan_
	Prototype.l FMOD_ChannelGroup_OverridePan_Prototype (Channelgroup.l, Pan.f)
	Global FMOD_ChannelGroup_OverridePan.FMOD_ChannelGroup_OverridePan_Prototype
	FMOD_ChannelGroup_OverridePan = GetFunction(fmodLib, "FMOD_ChannelGroup_OverridePan")
	
	;- FMOD_ChannelGroup_OverrideMute_
	Prototype.l FMOD_ChannelGroup_OverrideMute_Prototype (Channelgroup.l, Mute.l)
	Global FMOD_ChannelGroup_OverrideMute.FMOD_ChannelGroup_OverrideMute_Prototype
	FMOD_ChannelGroup_OverrideMute = GetFunction(fmodLib, "FMOD_ChannelGroup_OverrideMute")
	
	;- FMOD_ChannelGroup_OverrideReverbProperties_
	Prototype.l FMOD_ChannelGroup_OverrideReverbProperties_Prototype (Channelgroup.l, *Prop.l)
	Global FMOD_ChannelGroup_OverrideReverbProperties.FMOD_ChannelGroup_OverrideReverbProperties_Prototype
	FMOD_ChannelGroup_OverrideReverbProperties = GetFunction(fmodLib, "FMOD_ChannelGroup_OverrideReverbProperties")
	
	;- FMOD_ChannelGroup_Override3DAttributes_
	Prototype.l FMOD_ChannelGroup_Override3DAttributes_Prototype (Channelgroup.l, *Pos.l, *Vel.l)
	Global FMOD_ChannelGroup_Override3DAttributes.FMOD_ChannelGroup_Override3DAttributes_Prototype
	FMOD_ChannelGroup_Override3DAttributes = GetFunction(fmodLib, "FMOD_ChannelGroup_Override3DAttributes")
	
	;- FMOD_ChannelGroup_OverrideSpeakerMix_
	Prototype.l FMOD_ChannelGroup_OverrideSpeakerMix_Prototype (Channelgroup.l, Frontleft.f, Frontright.f, Center.f, Lfe.f, Backleft.f, Backright.f, Sideleft.f, Sideright.f)
	Global FMOD_ChannelGroup_OverrideSpeakerMix.FMOD_ChannelGroup_OverrideSpeakerMix_Prototype
	FMOD_ChannelGroup_OverrideSpeakerMix = GetFunction(fmodLib, "FMOD_ChannelGroup_OverrideSpeakerMix")
	
	;- FMOD_ChannelGroup_AddGroup_
	Prototype.l FMOD_ChannelGroup_AddGroup_Prototype (Channelgroup.l, Group.l)
	Global FMOD_ChannelGroup_AddGroup.FMOD_ChannelGroup_AddGroup_Prototype
	FMOD_ChannelGroup_AddGroup = GetFunction(fmodLib, "FMOD_ChannelGroup_AddGroup")
	
	;- FMOD_ChannelGroup_GetNumGroups_
	Prototype.l FMOD_ChannelGroup_GetNumGroups_Prototype (Channelgroup.l, *Numgroups.l)
	Global FMOD_ChannelGroup_GetNumGroups.FMOD_ChannelGroup_GetNumGroups_Prototype
	FMOD_ChannelGroup_GetNumGroups = GetFunction(fmodLib, "FMOD_ChannelGroup_GetNumGroups")
	
	;- FMOD_ChannelGroup_GetGroup_
	Prototype.l FMOD_ChannelGroup_GetGroup_Prototype (Channelgroup.l, Index.l, *Group.l)
	Global FMOD_ChannelGroup_GetGroup.FMOD_ChannelGroup_GetGroup_Prototype
	FMOD_ChannelGroup_GetGroup = GetFunction(fmodLib, "FMOD_ChannelGroup_GetGroup")
	
	;- FMOD_ChannelGroup_GetDSPHead_
	Prototype.l FMOD_ChannelGroup_GetDSPHead_Prototype (Channelgroup.l, *Dsp.l)
	Global FMOD_ChannelGroup_GetDSPHead.FMOD_ChannelGroup_GetDSPHead_Prototype
	FMOD_ChannelGroup_GetDSPHead = GetFunction(fmodLib, "FMOD_ChannelGroup_GetDSPHead")
	
	;- FMOD_ChannelGroup_AddDSP_
	Prototype.l FMOD_ChannelGroup_AddDSP_Prototype (Channelgroup.l, Dsp.l)
	Global FMOD_ChannelGroup_AddDSP.FMOD_ChannelGroup_AddDSP_Prototype
	FMOD_ChannelGroup_AddDSP = GetFunction(fmodLib, "FMOD_ChannelGroup_AddDSP")
	
	;- FMOD_ChannelGroup_GetName_
	Prototype.l FMOD_ChannelGroup_GetName_Prototype (Channelgroup.l, *name.b, Namelen.l)
	Global FMOD_ChannelGroup_GetName.FMOD_ChannelGroup_GetName_Prototype
	FMOD_ChannelGroup_GetName = GetFunction(fmodLib, "FMOD_ChannelGroup_GetName")
	
	;- FMOD_ChannelGroup_GetNumChannels_
	Prototype.l FMOD_ChannelGroup_GetNumChannels_Prototype (Channelgroup.l, *Numchannels.l)
	Global FMOD_ChannelGroup_GetNumChannels.FMOD_ChannelGroup_GetNumChannels_Prototype
	FMOD_ChannelGroup_GetNumChannels = GetFunction(fmodLib, "FMOD_ChannelGroup_GetNumChannels")
	
	;- FMOD_ChannelGroup_GetChannel_
	Prototype.l FMOD_ChannelGroup_GetChannel_Prototype (Channelgroup.l, Index.l, *channel.l)
	Global FMOD_ChannelGroup_GetChannel.FMOD_ChannelGroup_GetChannel_Prototype
	FMOD_ChannelGroup_GetChannel = GetFunction(fmodLib, "FMOD_ChannelGroup_GetChannel")
	
	;- FMOD_ChannelGroup_GetSpectrum_
	Prototype.l FMOD_ChannelGroup_GetSpectrum_Prototype (Channelgroup.l, *Spectrumarray.f, Numvalues.l, Channeloffset.l, Windowtype.l)
	Global FMOD_ChannelGroup_GetSpectrum.FMOD_ChannelGroup_GetSpectrum_Prototype
	FMOD_ChannelGroup_GetSpectrum = GetFunction(fmodLib, "FMOD_ChannelGroup_GetSpectrum")
	
	;- FMOD_ChannelGroup_GetWaveData_
	Prototype.l FMOD_ChannelGroup_GetWaveData_Prototype (Channelgroup.l, *Wavearray.f, Numvalues.l, Channeloffset.l)
	Global FMOD_ChannelGroup_GetWaveData.FMOD_ChannelGroup_GetWaveData_Prototype
	FMOD_ChannelGroup_GetWaveData = GetFunction(fmodLib, "FMOD_ChannelGroup_GetWaveData")
	
	;- FMOD_ChannelGroup_SetUserData_
	Prototype.l FMOD_ChannelGroup_SetUserData_Prototype (Channelgroup.l, userdata.l)
	Global FMOD_ChannelGroup_SetUserData.FMOD_ChannelGroup_SetUserData_Prototype
	FMOD_ChannelGroup_SetUserData = GetFunction(fmodLib, "FMOD_ChannelGroup_SetUserData")
	
	;- FMOD_ChannelGroup_GetUserData_
	Prototype.l FMOD_ChannelGroup_GetUserData_Prototype (Channelgroup.l, *userdata.l)
	Global FMOD_ChannelGroup_GetUserData.FMOD_ChannelGroup_GetUserData_Prototype
	FMOD_ChannelGroup_GetUserData = GetFunction(fmodLib, "FMOD_ChannelGroup_GetUserData")
	
	;- FMOD_DSP_Release_
	Prototype.l FMOD_DSP_Release_Prototype (Dsp.l)
	Global FMOD_DSP_Release.FMOD_DSP_Release_Prototype
	FMOD_DSP_Release = GetFunction(fmodLib, "FMOD_DSP_Release")
	
	;- FMOD_DSP_GetSystemObject_
	Prototype.l FMOD_DSP_GetSystemObject_Prototype (Dsp.l, *system.l)
	Global FMOD_DSP_GetSystemObject.FMOD_DSP_GetSystemObject_Prototype
	FMOD_DSP_GetSystemObject = GetFunction(fmodLib, "FMOD_DSP_GetSystemObject")
	
	;- FMOD_DSP_AddInput_
	Prototype.l FMOD_DSP_AddInput_Prototype (Dsp.l, Target.l)
	Global FMOD_DSP_AddInput.FMOD_DSP_AddInput_Prototype
	FMOD_DSP_AddInput = GetFunction(fmodLib, "FMOD_DSP_AddInput")
	
	;- FMOD_DSP_DisconnectFrom_
	Prototype.l FMOD_DSP_DisconnectFrom_Prototype (Dsp.l, Target.l)
	Global FMOD_DSP_DisconnectFrom.FMOD_DSP_DisconnectFrom_Prototype
	FMOD_DSP_DisconnectFrom = GetFunction(fmodLib, "FMOD_DSP_DisconnectFrom")
	
	;- FMOD_DSP_Remove_
	Prototype.l FMOD_DSP_Remove_Prototype (Dsp.l)
	Global FMOD_DSP_Remove.FMOD_DSP_Remove_Prototype
	FMOD_DSP_Remove = GetFunction(fmodLib, "FMOD_DSP_Remove")
	
	;- FMOD_DSP_GetNumInputs_
	Prototype.l FMOD_DSP_GetNumInputs_Prototype (Dsp.l, *Numinputs.l)
	Global FMOD_DSP_GetNumInputs.FMOD_DSP_GetNumInputs_Prototype
	FMOD_DSP_GetNumInputs = GetFunction(fmodLib, "FMOD_DSP_GetNumInputs")
	
	;- FMOD_DSP_GetNumOutputs_
	Prototype.l FMOD_DSP_GetNumOutputs_Prototype (Dsp.l, *Numoutputs.l)
	Global FMOD_DSP_GetNumOutputs.FMOD_DSP_GetNumOutputs_Prototype
	FMOD_DSP_GetNumOutputs = GetFunction(fmodLib, "FMOD_DSP_GetNumOutputs")
	
	;- FMOD_DSP_GetInput_
	Prototype.l FMOD_DSP_GetInput_Prototype (Dsp.l, Index.l, *Input.l)
	Global FMOD_DSP_GetInput.FMOD_DSP_GetInput_Prototype
	FMOD_DSP_GetInput = GetFunction(fmodLib, "FMOD_DSP_GetInput")
	
	;- FMOD_DSP_GetOutput_
	Prototype.l FMOD_DSP_GetOutput_Prototype (Dsp.l, Index.l, *Output.l)
	Global FMOD_DSP_GetOutput.FMOD_DSP_GetOutput_Prototype
	FMOD_DSP_GetOutput = GetFunction(fmodLib, "FMOD_DSP_GetOutput")
	
	;- FMOD_DSP_SetInputMix_
	Prototype.l FMOD_DSP_SetInputMix_Prototype (Dsp.l, Index.l, Volume.f)
	Global FMOD_DSP_SetInputMix.FMOD_DSP_SetInputMix_Prototype
	FMOD_DSP_SetInputMix = GetFunction(fmodLib, "FMOD_DSP_SetInputMix")
	
	;- FMOD_DSP_GetInputMix_
	Prototype.l FMOD_DSP_GetInputMix_Prototype (Dsp.l, Index.l, Volume.f)
	Global FMOD_DSP_GetInputMix.FMOD_DSP_GetInputMix_Prototype
	FMOD_DSP_GetInputMix = GetFunction(fmodLib, "FMOD_DSP_GetInputMix")
	
	;- FMOD_DSP_SetInputLevels_
	Prototype.l FMOD_DSP_SetInputLevels_Prototype (Dsp.l, Index.l, Speaker.l, *Levels.f, Numlevels.l)
	Global FMOD_DSP_SetInputLevels.FMOD_DSP_SetInputLevels_Prototype
	FMOD_DSP_SetInputLevels = GetFunction(fmodLib, "FMOD_DSP_SetInputLevels")
	
	;- FMOD_DSP_GetInputLevels_
	Prototype.l FMOD_DSP_GetInputLevels_Prototype (Dsp.l, Index.l, Speaker.l, *Levels.f, Numlevels.l)
	Global FMOD_DSP_GetInputLevels.FMOD_DSP_GetInputLevels_Prototype
	FMOD_DSP_GetInputLevels = GetFunction(fmodLib, "FMOD_DSP_GetInputLevels")
	
	;- FMOD_DSP_SetOutputMix_
	Prototype.l FMOD_DSP_SetOutputMix_Prototype (Dsp.l, Index.l, Volume.f)
	Global FMOD_DSP_SetOutputMix.FMOD_DSP_SetOutputMix_Prototype
	FMOD_DSP_SetOutputMix = GetFunction(fmodLib, "FMOD_DSP_SetOutputMix")
	
	;- FMOD_DSP_GetOutputMix_
	Prototype.l FMOD_DSP_GetOutputMix_Prototype (Dsp.l, Index.l, Volume.f)
	Global FMOD_DSP_GetOutputMix.FMOD_DSP_GetOutputMix_Prototype
	FMOD_DSP_GetOutputMix = GetFunction(fmodLib, "FMOD_DSP_GetOutputMix")
	
	;- FMOD_DSP_SetOutputLevels_
	Prototype.l FMOD_DSP_SetOutputLevels_Prototype (Dsp.l, Index.l, Speaker.l, *Levels.f, Numlevels.l)
	Global FMOD_DSP_SetOutputLevels.FMOD_DSP_SetOutputLevels_Prototype
	FMOD_DSP_SetOutputLevels = GetFunction(fmodLib, "FMOD_DSP_SetOutputLevels")
	
	;- FMOD_DSP_GetOutputLevels_
	Prototype.l FMOD_DSP_GetOutputLevels_Prototype (Dsp.l, Index.l, Speaker.l, *Levels.f, Numlevels.l)
	Global FMOD_DSP_GetOutputLevels.FMOD_DSP_GetOutputLevels_Prototype
	FMOD_DSP_GetOutputLevels = GetFunction(fmodLib, "FMOD_DSP_GetOutputLevels")
	
	;- FMOD_DSP_SetActive_
	Prototype.l FMOD_DSP_SetActive_Prototype (Dsp.l, Active.l)
	Global FMOD_DSP_SetActive.FMOD_DSP_SetActive_Prototype
	FMOD_DSP_SetActive = GetFunction(fmodLib, "FMOD_DSP_SetActive")
	
	;- FMOD_DSP_GetActive_
	Prototype.l FMOD_DSP_GetActive_Prototype (Dsp.l, *Active.l)
	Global FMOD_DSP_GetActive.FMOD_DSP_GetActive_Prototype
	FMOD_DSP_GetActive = GetFunction(fmodLib, "FMOD_DSP_GetActive")
	
	;- FMOD_DSP_SetBypass_
	Prototype.l FMOD_DSP_SetBypass_Prototype (Dsp.l, Bypass.l)
	Global FMOD_DSP_SetBypass.FMOD_DSP_SetBypass_Prototype
	FMOD_DSP_SetBypass = GetFunction(fmodLib, "FMOD_DSP_SetBypass")
	
	;- FMOD_DSP_GetBypass_
	Prototype.l FMOD_DSP_GetBypass_Prototype (Dsp.l, *Bypass.l)
	Global FMOD_DSP_GetBypass.FMOD_DSP_GetBypass_Prototype
	FMOD_DSP_GetBypass = GetFunction(fmodLib, "FMOD_DSP_GetBypass")
	
	;- FMOD_DSP_Reset_
	Prototype.l FMOD_DSP_Reset_Prototype (Dsp.l)
	Global FMOD_DSP_Reset.FMOD_DSP_Reset_Prototype
	FMOD_DSP_Reset = GetFunction(fmodLib, "FMOD_DSP_Reset")
	
	;- FMOD_DSP_SetParameter_
	Prototype.l FMOD_DSP_SetParameter_Prototype (Dsp.l, Index.l, Value.f)
	Global FMOD_DSP_SetParameter.FMOD_DSP_SetParameter_Prototype
	FMOD_DSP_SetParameter = GetFunction(fmodLib, "FMOD_DSP_SetParameter")
	
	;- FMOD_DSP_GetParameter_
	Prototype.l FMOD_DSP_GetParameter_Prototype (Dsp.l, Index.l, *Value.f, *Valuestr.b, Valuestrlen.l)
	Global FMOD_DSP_GetParameter.FMOD_DSP_GetParameter_Prototype
	FMOD_DSP_GetParameter = GetFunction(fmodLib, "FMOD_DSP_GetParameter")
	
	;- FMOD_DSP_GetNumParameters_
	Prototype.l FMOD_DSP_GetNumParameters_Prototype (Dsp.l, *Numparams.l)
	Global FMOD_DSP_GetNumParameters.FMOD_DSP_GetNumParameters_Prototype
	FMOD_DSP_GetNumParameters = GetFunction(fmodLib, "FMOD_DSP_GetNumParameters")
	
	;- FMOD_DSP_GetParameterInfo_
	Prototype.l FMOD_DSP_GetParameterInfo_Prototype (Dsp.l, Index.l, *name.b, *label.b, *description.b, Descriptionlen.l, *min.f, *max.f)
	Global FMOD_DSP_GetParameterInfo.FMOD_DSP_GetParameterInfo_Prototype
	FMOD_DSP_GetParameterInfo = GetFunction(fmodLib, "FMOD_DSP_GetParameterInfo")
	
	;- FMOD_DSP_ShowConfigDialog_
	Prototype.l FMOD_DSP_ShowConfigDialog_Prototype (Dsp.l, hwnd.l, Show.l)
	Global FMOD_DSP_ShowConfigDialog.FMOD_DSP_ShowConfigDialog_Prototype
	FMOD_DSP_ShowConfigDialog = GetFunction(fmodLib, "FMOD_DSP_ShowConfigDialog")
	
	;- FMOD_DSP_GetInfo_
	Prototype.l FMOD_DSP_GetInfo_Prototype (Dsp.l, *name.b, *version.l, *Channels.l, *Configwidth.l, *Configheight.l)
	Global FMOD_DSP_GetInfo.FMOD_DSP_GetInfo_Prototype
	FMOD_DSP_GetInfo = GetFunction(fmodLib, "FMOD_DSP_GetInfo")
	
	;- FMOD_DSP_SetDefaults_
	Prototype.l FMOD_DSP_SetDefaults_Prototype (Dsp.l, Frequency.f, Volume.f, Pan.f, Priority.l)
	Global FMOD_DSP_SetDefaults.FMOD_DSP_SetDefaults_Prototype
	FMOD_DSP_SetDefaults = GetFunction(fmodLib, "FMOD_DSP_SetDefaults")
	
	;- FMOD_DSP_GetDefaults_
	Prototype.l FMOD_DSP_GetDefaults_Prototype (Dsp.l, *Frequency.f, *Volume.f, *Pan.f, *Priority.l)
	Global FMOD_DSP_GetDefaults.FMOD_DSP_GetDefaults_Prototype
	FMOD_DSP_GetDefaults = GetFunction(fmodLib, "FMOD_DSP_GetDefaults")
	
	;- FMOD_DSP_SetUserData_
	Prototype.l FMOD_DSP_SetUserData_Prototype (Dsp.l, userdata.l)
	Global FMOD_DSP_SetUserData.FMOD_DSP_SetUserData_Prototype
	FMOD_DSP_SetUserData = GetFunction(fmodLib, "FMOD_DSP_SetUserData")
	
	;- FMOD_DSP_GetUserData_
	Prototype.l FMOD_DSP_GetUserData_Prototype (Dsp.l, *userdata.l)
	Global FMOD_DSP_GetUserData.FMOD_DSP_GetUserData_Prototype
	FMOD_DSP_GetUserData = GetFunction(fmodLib, "FMOD_DSP_GetUserData")
	
	;- FMOD_Geometry_Release_
	Prototype.l FMOD_Geometry_Release_Prototype (Gemoetry.l)
	Global FMOD_Geometry_Release.FMOD_Geometry_Release_Prototype
	FMOD_Geometry_Release = GetFunction(fmodLib, "FMOD_Geometry_Release")
	
	;- FMOD_Geometry_AddPolygon_
	Prototype.l FMOD_Geometry_AddPolygon_Prototype (Geometry.l, DirectOcclusion.f, ReverbOcclusion.f, DoubleSided.l, NumVertices.l, *Vertices.l, *PolygonIndex.l)
	Global FMOD_Geometry_AddPolygon.FMOD_Geometry_AddPolygon_Prototype
	FMOD_Geometry_AddPolygon = GetFunction(fmodLib, "FMOD_Geometry_AddPolygon")
	
	;- FMOD_Geometry_GetNumPolygons_
	Prototype.l FMOD_Geometry_GetNumPolygons_Prototype (Geometry.l, *NumPolygons.l)
	Global FMOD_Geometry_GetNumPolygons.FMOD_Geometry_GetNumPolygons_Prototype
	FMOD_Geometry_GetNumPolygons = GetFunction(fmodLib, "FMOD_Geometry_GetNumPolygons")
	
	;- FMOD_Geometry_GetMaxPolygons_
	Prototype.l FMOD_Geometry_GetMaxPolygons_Prototype (Geometry.l, *MaxPolygons.l, *MaxVertices.l)
	Global FMOD_Geometry_GetMaxPolygons.FMOD_Geometry_GetMaxPolygons_Prototype
	FMOD_Geometry_GetMaxPolygons = GetFunction(fmodLib, "FMOD_Geometry_GetMaxPolygons")
	
	;- FMOD_Geometry_GetPolygonNumVertices_
	Prototype.l FMOD_Geometry_GetPolygonNumVertices_Prototype (Geometry.l, PolygonIndex.l, *NumVertices.l)
	Global FMOD_Geometry_GetPolygonNumVertices.FMOD_Geometry_GetPolygonNumVertices_Prototype
	FMOD_Geometry_GetPolygonNumVertices = GetFunction(fmodLib, "FMOD_Geometry_GetPolygonNumVertices")
	
	;- FMOD_Geometry_SetPolygonVertex_
	Prototype.l FMOD_Geometry_SetPolygonVertex_Prototype (Geometry.l, PolygonIndex.l, VertexIndex.l, *Vertex.l)
	Global FMOD_Geometry_SetPolygonVertex.FMOD_Geometry_SetPolygonVertex_Prototype
	FMOD_Geometry_SetPolygonVertex = GetFunction(fmodLib, "FMOD_Geometry_SetPolygonVertex")
	
	;- FMOD_Geometry_GetPolygonVertex_
	Prototype.l FMOD_Geometry_GetPolygonVertex_Prototype (Geometry.l, PolygonIndex.l, VertexIndex.l, *Vertex.l)
	Global FMOD_Geometry_GetPolygonVertex.FMOD_Geometry_GetPolygonVertex_Prototype
	FMOD_Geometry_GetPolygonVertex = GetFunction(fmodLib, "FMOD_Geometry_GetPolygonVertex")
	
	;- FMOD_Geometry_SetPolygonAttributes_
	Prototype.l FMOD_Geometry_SetPolygonAttributes_Prototype (Geometry.l, PolygonIndex.l, DirectOcclusion.f, ReverbOcclusion.f, DoubleSided.l)
	Global FMOD_Geometry_SetPolygonAttributes.FMOD_Geometry_SetPolygonAttributes_Prototype
	FMOD_Geometry_SetPolygonAttributes = GetFunction(fmodLib, "FMOD_Geometry_SetPolygonAttributes")
	
	;- FMOD_Geometry_GetPolygonAttributes_
	Prototype.l FMOD_Geometry_GetPolygonAttributes_Prototype (Geometry.l, PolygonIndex.l, *DirectOcclusion.f, *ReverbOcclusion.f, *DoubleSided.l)
	Global FMOD_Geometry_GetPolygonAttributes.FMOD_Geometry_GetPolygonAttributes_Prototype
	FMOD_Geometry_GetPolygonAttributes = GetFunction(fmodLib, "FMOD_Geometry_GetPolygonAttributes")
	
	;- FMOD_Geometry_SetActive_
	Prototype.l FMOD_Geometry_SetActive_Prototype (Geometry.l, Active.l)
	Global FMOD_Geometry_SetActive.FMOD_Geometry_SetActive_Prototype
	FMOD_Geometry_SetActive = GetFunction(fmodLib, "FMOD_Geometry_SetActive")
	
	;- FMOD_Geometry_GetActive_
	Prototype.l FMOD_Geometry_GetActive_Prototype (Geometry.l, *Active.l)
	Global FMOD_Geometry_GetActive.FMOD_Geometry_GetActive_Prototype
	FMOD_Geometry_GetActive = GetFunction(fmodLib, "FMOD_Geometry_GetActive")
	
	;- FMOD_Geometry_SetRotation_
	Prototype.l FMOD_Geometry_SetRotation_Prototype (Geometry.l, *Forward.l, *Up.l)
	Global FMOD_Geometry_SetRotation.FMOD_Geometry_SetRotation_Prototype
	FMOD_Geometry_SetRotation = GetFunction(fmodLib, "FMOD_Geometry_SetRotation")
	
	;- FMOD_Geometry_GetRotation_
	Prototype.l FMOD_Geometry_GetRotation_Prototype (Geometry.l, *Forward.l, *Up.l)
	Global FMOD_Geometry_GetRotation.FMOD_Geometry_GetRotation_Prototype
	FMOD_Geometry_GetRotation = GetFunction(fmodLib, "FMOD_Geometry_GetRotation")
	
	;- FMOD_Geometry_SetPosition_
	Prototype.l FMOD_Geometry_SetPosition_Prototype (Geometry.l, *Position.l)
	Global FMOD_Geometry_SetPosition.FMOD_Geometry_SetPosition_Prototype
	FMOD_Geometry_SetPosition = GetFunction(fmodLib, "FMOD_Geometry_SetPosition")
	
	;- FMOD_Geometry_GetPosition_
	Prototype.l FMOD_Geometry_GetPosition_Prototype (Geometry.l, *Position.l)
	Global FMOD_Geometry_GetPosition.FMOD_Geometry_GetPosition_Prototype
	FMOD_Geometry_GetPosition = GetFunction(fmodLib, "FMOD_Geometry_GetPosition")
	
	;- FMOD_Geometry_SetScale_
	Prototype.l FMOD_Geometry_SetScale_Prototype (Geometry.l, *Scale.l)
	Global FMOD_Geometry_SetScale.FMOD_Geometry_SetScale_Prototype
	FMOD_Geometry_SetScale = GetFunction(fmodLib, "FMOD_Geometry_SetScale")
	
	;- FMOD_Geometry_GetScale_
	Prototype.l FMOD_Geometry_GetScale_Prototype (Geometry.l, *Scale.l)
	Global FMOD_Geometry_GetScale.FMOD_Geometry_GetScale_Prototype
	FMOD_Geometry_GetScale = GetFunction(fmodLib, "FMOD_Geometry_GetScale")
	
	;- FMOD_Geometry_Save_
	Prototype.l FMOD_Geometry_Save_Prototype (Geometry.l, _data.l, *_dataSize.l)
	Global FMOD_Geometry_Save.FMOD_Geometry_Save_Prototype
	FMOD_Geometry_Save = GetFunction(fmodLib, "FMOD_Geometry_Save")
	
	;- FMOD_Geometry_SetUserData_
	Prototype.l FMOD_Geometry_SetUserData_Prototype (Geometry.l, userdata.l)
	Global FMOD_Geometry_SetUserData.FMOD_Geometry_SetUserData_Prototype
	FMOD_Geometry_SetUserData = GetFunction(fmodLib, "FMOD_Geometry_SetUserData")
	
	;- FMOD_Geometry_GetUserData_
	Prototype.l FMOD_Geometry_GetUserData_Prototype (Geometry.l, *userdata.l)
	Global FMOD_Geometry_GetUserData.FMOD_Geometry_GetUserData_Prototype
	FMOD_Geometry_GetUserData = GetFunction(fmodLib, "FMOD_Geometry_GetUserData")

EndIf