''-----------------------------------------------------------------------------
'' Заголовочный файл звуковой системы "Шквал" версия 1.48
'' команда     :
'' разработчик : Гилязетдинов Марат (Марыч) E-Mail AT_Marat@list.net
''-----------------------------------------------------------------------------
#Ifndef _SQUALL_H_INCLUDED_
#define _SQUALL_H_INCLUDED_
#EndIf

Extern "C"

#define IsTrue(r) IIf(r >= 0 , -1 , 0)
#define IsFalse(r) IIf(r < 0 , -1 , 0)

'' список ошибок
#define  SQUALL_ERROR_NO_SOUND               -1    ' в системе нет звукового устройства
#define  SQUALL_ERROR_MEMORY                 -2    ' ошибка выделения памяти
#define  SQUALL_ERROR_UNINITIALIZED          -3    ' класс не инициализирован
#define  SQUALL_ERROR_INVALID_PARAM          -4    ' ошибка параметры не годяться
#define  SQUALL_ERROR_CREATE_WINDOW          -5    ' невозможно создать скрытое окно
#define  SQUALL_ERROR_CREATE_DIRECT_SOUND    -6    ' ошибка при создании DirectSound объекта
#define  SQUALL_ERROR_CREATE_THREAD          -7    ' ошибка создания потока
#define  SQUALL_ERROR_SET_LISTENER_PARAM     -8    ' ошибка установки параметром слушателя
#define  SQUALL_ERROR_GET_LISTENER_PARAM     -9    ' ошибка получения параметров слушателя
#define  SQUALL_ERROR_NO_FREE_CHANNEL        -10   ' ошибка нет свободного канала для воспроизведения
#define  SQUALL_ERROR_CREATE_CHANNEL         -11   ' ошибка создания 3х мерного звукового буфера
#define  SQUALL_ERROR_CHANNEL_NOT_FOUND      -12   ' ошибка создания 3х мерного звукового буфера
#define  SQUALL_ERROR_SET_CHANNEL_PARAM      -13   ' ошибка заполнения звукового буфера
#define  SQUALL_ERROR_GET_CHANNEL_PARAM      -14   ' ошибка установки уровня громкости канала
#define  SQUALL_ERROR_METHOD                 -15   ' ошибка вызываетый метод не поддерживается
#define  SQUALL_ERROR_ALGORITHM              -16   ' ошибка 3D алгоритм не поддерживаеться
#define  SQUALL_ERROR_NO_EAX                 -17   ' ошибка EAX не поддерживаеться
#define  SQUALL_ERROR_EAX_VERSION            -18   ' ошибка версия EAX не поддерживаеться
#define  SQUALL_ERROR_SET_EAX_PARAM          -19   ' ошибка установки EAX параметров слушателя
#define  SQUALL_ERROR_GET_EAX_PARAM          -20   ' ошибка получения EAX параметров слушателя
#define  SQUALL_ERROR_NO_ZOOMFX              -21   ' ошибка ZOOMFX не поддерживается
#define  SQUALL_ERROR_SET_ZOOMFX_PARAM       -22   ' ошибка установки ZOOMFX параметров буфера
#define  SQUALL_ERROR_GET_ZOOMFX_PARAM       -23   ' ошибка получения ZOOMFX параметров буфера
#define  SQUALL_ERROR_UNKNOWN                -24   ' неизвестная ошибка
#define  SQUALL_ERROR_SAMPLE_INIT            -25   ' ошибка инициализации звуковых данных
#define  SQUALL_ERROR_SAMPLE_BAD             -26   ' плохой семпл
#define  SQUALL_ERROR_SET_MIXER_PARAM        -27   ' ошибка установки параметров микшера
#define  SQUALL_ERROR_GET_MIXER_PARAM        -28   ' ошибка получения параметров микшера

' настройки слушателя
#define SQUALL_LISTENER_MODE_IMMEDIATE 0           ' настройки пересчитываются немедленно
#define SQUALL_LISTENER_MODE_DEFERRED  1           ' настройки пересчитываются только после вызова метода Listener_Update

' способы обработки трехмерного звука без аппаратной поддержки
#define SQUALL_ALG_3D_DEFAULT          0           ' алгоритм по умолчанию
#define SQUALL_ALG_3D_OFF              1           ' 2D алгоритм
#define SQUALL_ALG_3D_FULL             2           ' полноценный 3D алгоритм
#define SQUALL_ALG_3D_LIGTH            3           ' облегченный 3D алгоритм

' обратные вызовы для работы с файлами

Type squall_callback_open_t As Function Cdecl (name_ As ZString Ptr) As UInteger
Type squall_callback_read_t As Function Cdecl (Handle As UInteger, Buffer As Any Ptr, Size As Integer) As Integer
Type squall_callback_seek_t As Function Cdecl (Handle As UInteger, Position As Integer, SeekMode As Integer) As Integer
Type squall_callback_close_t As Sub Cdecl (Handle As UInteger)


' обратные вызовы для работы с памятью
'typedef void*        (__cdecl* squall_callback_alloc_t)     (unsigned int Size);
'typedef void         (__cdecl* squall_callback_free_t)      (void* Ptr);

Type squall_callback_alloc_t As Function Cdecl (Size As UInteger) As Any Ptr
Type squall_callback_free_t As Sub( As Any Ptr)

' обратные вызовы для вызова обработчиков
Type squall_callback_listener_t As Sub  Cdecl (UserData As Any Ptr)
Type squall_callback_channel_t As Function Cdecl (ChannelID As Integer,UserData As Any Ptr) As Integer
Type squall_callback_end_channel_t As Function Cdecl (ChannelID As Integer,UserData As Any Ptr) As Integer

' структура для описания настроек двигателя
Type squall_parameters_t
	As Any Ptr   Window                                  ' окно к которому нужно прикреплять двигатель
	As Integer     Device                                ' номер устройства воспроизведения
	As Integer     SampleRate                            ' частота дискретизации
	As Integer     BitPerSample                          ' количество бит на выборку
	As Integer     Channels                              ' максимальное количество каналов
	As Integer     UseHW2D                               ' использование аппаратной акселерации для рассеянных каналов
	As Integer     UseHW3D                               ' использование аппаратной акселерации для точечных каналов
	As Integer     UseAlg                                ' используемый трехмерный алгоритм
	As Integer     BufferSize                            ' размер вторичного буфера в миллисекундах
	As Integer     ListenerMode                          ' промежуток времени через который будет происходить обновление
	As Single   DistanceFactor                           ' фактор дистанции
	As Single   RolloffFactor                            ' фактор удаления
	As Single   DopplerFactor                            ' эффект Допплера
End Type

' структура описывающая параметры звука по умолчанию
Type squall_sample_default_t
	As Integer     SampleGroupID                         ' принадлежность семпла к группе
	As Integer     Priority                              ' приоритет звука по умолчанию
	As Integer     Frequency                             ' частота звука по умолчанию
	As Integer     Volume                                ' громкость звука по умолчанию
	As Integer     Pan                                   ' панорама звука по умолчанию
	As Single   MinDist                                  ' минимальная граница слышимости по умолчанию
	As Single   MaxDist                                  ' максимальная граница слышимости по умолчанию
End Type

' структура описывающая текущее состояние каналов
Type squall_channels_t
	As Integer     Play                                  ' количество воспроизводящихся рассеянных каналов
	As Integer     Pause                                 ' количество стоящих в паузе рассеянных каналов
	As Integer     Prepare                               ' количество подготовленных рассеянных каналов
	As Integer     Play3D                                ' количество воспроизводящихся позиционных каналов
	As Integer     Pause3D                               ' количество стоящих в паузе позиционных каналов
	As Integer     Prepare3D                             ' количество подготовленных позиционных каналов
End Type

' структура описывающая параметры устройства воспроизведения
Type squall_device_caps_t
	As Integer     Flags                                 ' флаги определяющие свойства устройства
	As Integer     HardwareChannels                      ' количество аппаратных каналов
	As Integer     Hardware3DChannels                    ' количество аппаратных 3D каналов
End Type

' флаги описывающие возможности устройства воспроизведения
#define SQUALL_DEVICE_CAPS_HARDWARE    &h00000001  ' устройство поддерживает аппаратное смешивание каналов
#define SQUALL_DEVICE_CAPS_HARDWARE_3D &h00000002  ' устройство поддерживает аппаратное смешивание 3D каналов
#define SQUALL_DEVICE_CAPS_EAX10       &h00000004  ' устройство поддреживает EAX 1.0
#define SQUALL_DEVICE_CAPS_EAX20       &h00000008  ' устройство поддерживает EAX 2.0
#define SQUALL_DEVICE_CAPS_EAX30       &h00000010  ' устройство поддерживает EAX 3.0
#define SQUALL_DEVICE_CAPS_ZOOMFX      &h00000100  ' устройство поддерживает ZOOMFX

' флаги описывающие конфигурацию аккустики
#define SQUALL_SPEAKER_DEFAULT         &h00000000  ' аккустика по умолчанию
#define SQUALL_SPEAKER_HEADPHONE       &h00000001  ' наушники (головные телефоны)
#define SQUALL_SPEAKER_MONO            &h00000002  ' моно колонка (1.0)
#define SQUALL_SPEAKER_STEREO          &h00000003  ' стерео колонки (2.0)
#define SQUALL_SPEAKER_QUAD            &h00000004  ' квадро колонки (4.0)
#define SQUALL_SPEAKER_SURROUND        &h00000005  ' квадро система с буфером низких эффектов (4.1)
#define SQUALL_SPEAKER_5POINT1         &h00000006  ' пяти канальная система с буфером низких эффектов (5.1)

' статус канала
#define SQUALL_CHANNEL_STATUS_NONE     0           ' канала нет
#define SQUALL_CHANNEL_STATUS_PLAY     1           ' канал в режиме воспроизведения
#define SQUALL_CHANNEL_STATUS_PAUSE    2           ' канал в режиме паузы
#define SQUALL_CHANNEL_STATUS_PREPARED 3           ' канал в подготовленном состоянии

' структура параметров EAX слушателя
Union squall_eax_listener_t
' параметры EAX 1.0
Type
	As UInteger       Environment
	As Single         Volume
	As Single         DecayTime_sec
	As Single         Damping
End Type

' параметры EAX 2.0
Type
	As Integer         Room
	As Integer         RoomHF
	As Single          RoomRolloffFactor
	As Single          DecayTime
	As Single          DecayHFRatio
	As Integer         Reflections
	As Single          ReflectionsDelay
	As Integer         Reverb
	As Single          ReverbDelay
	As UInteger        Environment2
	As Single          EnvironmentSize
	As Single          EnvironmentDiffusion
	As Single          AirAbsorptionHF
	As UInteger        Flags
End Type

' параметры EAX 3.0
Type
	As UInteger        Environment3
	As Single          EnvironmentSize2
	As Single          EnvironmentDiffusion2
	As Integer         Room2
	As Integer         RoomHF2
	As Integer         RoomLF
	As Single          DecayTime2
	As Single          DecayHFRatio2
	As Single          DecayLFRatio
	As Integer         Reflections2
	As Single          ReflectionsDelay2
	As Single          ReflectionsPan(3)
	As Single          Reverb2
	As Single          ReverbDelay2
	As Single          ReverbPan(3)
	As Single          EchoTime
	As Single          EchoDepth
	As Single          ModulationTime
	As Single          ModulationDepth
	As Single          AirAbsorptionHF2
	As Single          HFReference
	As Single          LFReference
	As Single          RoomRolloffFactor2
	As UInteger            Flags2
End Type
End Union

' значения флагов слушателя в EAX начиная с версии 2.0
#define SQUALL_EAX_LISTENER_FLAGS_DECAYTIMESCALE          &h00000001
#define SQUALL_EAX_LISTENER_FLAGS_REFLECTIONSSCALE        &h00000002
#define SQUALL_EAX_LISTENER_FLAGS_REFLECTIONSDELAYSCALE   &h00000004
#define SQUALL_EAX_LISTENER_FLAGS_REVERBSCALE             &h00000008
#define SQUALL_EAX_LISTENER_FLAGS_REVERBDELAYSCALE        &h00000010
#define SQUALL_EAX_LISTENER_FLAGS_DECAYHFLIMIT            &h00000020

' значения флагов слушателя в EAX начиная версии 3.0
#define SQUALL_EAX_LISTENER_FLAGS_ECHOTIMESCALE           &h00000040
#define SQUALL_EAX_LISTENER_FLAGS_MODULATIONTIMESCALE     &h00000080

' значение флагов слушателя в EAX начиная с версии 2.0 по умолчанию
#define SQUALL_EAX_LISTENER_FLAGS_DEFAULT                 ( SQUALL_EAX_LISTENER_FLAGS_DECAYTIMESCALE          +   _
SQUALL_EAX_LISTENER_FLAGS_REFLECTIONSSCALE        +   _
SQUALL_EAX_LISTENER_FLAGS_REFLECTIONSDELAYSCALE   +   _
SQUALL_EAX_LISTENER_FLAGS_REVERBSCALE             +   _
SQUALL_EAX_LISTENER_FLAGS_REVERBDELAYSCALE        +   _
SQUALL_EAX_LISTENER_FLAGS_DECAYHFLIMIT    )

' номера предустановленных значений EAX окружения
#define SQUALL_EAX_OFF              -1
#define SQUALL_EAX_GENERIC           0
#define SQUALL_EAX_PADDEDCELL        1
#define SQUALL_EAX_ROOM              2
#define SQUALL_EAX_BATHROOM          3
#define SQUALL_EAX_LIVINGROOM        4
#define SQUALL_EAX_STONEROOM         5
#define SQUALL_EAX_AUDITORIUM        6
#define SQUALL_EAX_CONCERTHALL       7
#define SQUALL_EAX_CAVE              8
#define SQUALL_EAX_ARENA             9
#define SQUALL_EAX_HANGAR           10
#define SQUALL_EAX_CARPETEDHALLWAY  11
#define SQUALL_EAX_HALLWAY          12
#define SQUALL_EAX_STONECORRIDOR    13
#define SQUALL_EAX_ALLEY            14
#define SQUALL_EAX_FOREST           15
#define SQUALL_EAX_CITY             16
#define SQUALL_EAX_MOUNTAINS        17
#define SQUALL_EAX_QUARRY           18
#define SQUALL_EAX_PLAIN            19
#define SQUALL_EAX_PARKINGLOT       20
#define SQUALL_EAX_SEWERPIPE        21
#define SQUALL_EAX_UNDERWATER       22
#define SQUALL_EAX_DRUGGED          23
#define SQUALL_EAX_DIZZY            24
#define SQUALL_EAX_PSYCHOTIC        25

' Cтруктура EAX параметров канала
Union squall_eax_channel_t

' EAX 1.0
Type
	As Single              Mix
End Type

' EAX 2.0
Type
	As Integer              Direct
	As Integer              DirectHF
	As Integer              Room
	As Integer              RoomHF
	As Single               RoomRolloffFactor
	As Integer              Obstruction
	As Single               ObstructionLFRatio
	As Integer              Occlusion
	As Single               OcclusionLFRatio
	As Single               OcclusionRoomRatio
	As Integer              OutsideVolumeHF
	As Single               AirAbsorptionFactor
	As UInteger                 Flags
End Type

'  EAX 3.0
Type
	As Integer                Direct2
	As Integer                DirectHF2
	As Integer                Room2
	As Integer                RoomHF2
	As Integer                Obstruction2
	As Single                 ObstructionLFRatio2
	As Integer                Occlusion2
	As Single                 OcclusionLFRatio2
	As Single                 OcclusionRoomRatio2
	As Single                 OcclusionDirectRatio
	As Integer                Exclusion
	As Single                 ExclusionLFRatio
	As Integer                OutsideVolumeHF2
	As Single                 DopplerFactor
	As Single                 RolloffFactor
	As Single                 RoomRolloffFactor2
	As Single                 AirAbsorptionFactor2
	As UInteger               Flags2
End Type
End Union

' значения флагов канала в EAX начиная с версии 2.0
#define SQUALL_EAX_CHANNEL_FLAGS_DIRECTHFAUTO             &h00000001
#define SQUALL_EAX_CHANNEL_FLAGS_ROOMAUTO                 &h00000002
#define SQUALL_EAX_CHANNEL_FLAGS_ROOMHFAUTO               &h00000004
#define SQUALL_EAX_CHANNEL_FLAGS_DEFAULT                  (SQUALL_EAX_CHANNEL_FLAGS_DIRECTHFAUTO +   _
SQUALL_EAX_CHANNEL_FLAGS_ROOMAUTO     +  _
SQUALL_EAX_CHANNEL_FLAGS_ROOMHFAUTO   )
' структура ZOOMFX параметров источника звука
Type squall_zoomfx_channel_t
	As Single    Min_(3)
	As Single    Max_(3)
	As Single    Front(3)
	As Single    Top(3)
	As Integer     MacroFX
End Type


'''''''''''''''''''''''''''''''''''''''/
'''''''''''''''''''''''''''''''''''''''/
'                 Методы инициализация / освобождения
'''''''''''''''''''''''''''''''''''''''/
'''''''''''''''''''''''''''''''''''''''/
'-----------------------------------------------------------------------------
' Инициализация звуковой системы Шквал
' на входе    :  SystemParam -  указатель на структуру с параметрами
'                               звукового двигателя для инициализации.
'                               Если параметр будет равен 0 то звуковой
'                               двигатель создаст экземпляр объекта с
'                               следующими параметрами:
'                               Window         = 0     (создать свое окно)
'                               Device         = 0     (устройство по умолчанию)
'                               SampleRate     = 44100
'                               BitPerSample   = 16
'                               Channels       = 16
'                               UseHW2D        = true  (использовать)
'                               UseHW3D        = true  (использовать)
'                               UseAlg         = 0     (алгоритм по умолчанию)
'                               BufferSize     = 200
'                               ListenerMode   = 0     (немедленное применение)
'                               DistanceFactor = 1.0f
'                               RolloffFactor  = 1.0f
'                               DopplerFactor  = 1.0f
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Init Lib "Squall" Alias "SQUALL_Init"(SystemParam As squall_parameters_t Ptr) As Integer

'-----------------------------------------------------------------------------
' Освобождение занятых звуковой системой ресурсов
' на входе    :  *
' на выходе   :  *
'-----------------------------------------------------------------------------
Declare Sub SQUALL_Free Lib "Squall" Alias "SQUALL_Free" ()

'''''''''''''''''''''''''''''''''''''''/
'''''''''''''''''''''''''''''''''''''''/
'                  Методы для управления двигателем
'''''''''''''''''''''''''''''''''''''''/
'''''''''''''''''''''''''''''''''''''''/
'-----------------------------------------------------------------------------
' Включение/выключение паузы всех звуковых каналов
' на входе    :  Pause -  флаг включения/выключения паузы
'                         параметр может принимать слудующие значения
'                         true  - включить паузу
'                         false - выключить паузу
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------

Declare Function SQUALL_Pause Lib "Squall" Alias "SQUALL_Pause" (pause_ As Integer) As Integer

'-----------------------------------------------------------------------------
' Остановка всех звуковых каналов
' на входе    :  *
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------

Declare Function SQUALL_Stop Lib "Squall" Alias "SQUALL_Stop" () As Integer

'''''''''''''''''''''''''''''''''''''''/
'''''''''''''''''''''''''''''''''''''''/
'                    Методы для настройки двигателя
'''''''''''''''''''''''''''''''''''''''/
'''''''''''''''''''''''''''''''''''''''/
'-----------------------------------------------------------------------------
' Установка нового устройства воспроизведения
' на входе    :  Num   -  номер нового устройства воспроизведения, значение
'                         параметра должно быть в пределах от 0 до значения
'                         полученного с помощью метода SQUALL_GetNumDevice.
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------

Declare Function SQUALL_SetDevice Lib "Squall" Alias "SQUALL_SetDevice" (num As Integer) As Integer

'-----------------------------------------------------------------------------
' Получение номера текущего устройства воспроизведения
' на входе    :  *
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит номер текущего
'                устройства воспроизведения
'-----------------------------------------------------------------------------

Declare Function SQUALL_GetDevice Lib "Squall" Alias "SQUALL_GetDevice"() As Integer

'-----------------------------------------------------------------------------
' Включение/выключение использования аппаратной акселерации звука
' на входе    :  UseHW2D  -  флаг определяющий использование аппаратной
'                            акселерации рассеянных звуковых каналов,
'                            параметр может принимать следующие значения:
'                            true   - использовать аппаратную акселерацию
'                            false  - не использовать аппаратную акселерацию
'                UseHW3D  -  флаг определяющий использование аппаратной
'                            акселерации позиционных звуковых каналов
'                            параметр может принимать следующие значения:
'                            true   - использовать аппаратную акселерацию
'                            false  - не использовать аппаратную акселерацию
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------

Declare Function SQUALL_SetHardwareAcceleration Lib "Squall" Alias "SQUALL_SetHardwareAcceleration" (UseHW2D As Integer, UseHW3D As Integer) As Integer

'-----------------------------------------------------------------------------
' Получение текущих настроек использования аппаратной акселерации звука
' на входе    :  UseHW2D  -  указатель на переменную в которую нужно поместить
'                            текущее значение использования аппаратной
'                            акселерации для рассеянных звуковых каналов
'                UseHW3D  -  указатель на переменную в которую нужно поместить
'                            текущее значение использования аппаратной
'                            акселерации для позиционных звуковых каналов
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------

Declare Function SQUALL_GetHardwareAcceleration Lib "Squall" Alias "SQUALL_GetHardwareAcceleration" (UseHW2D As Integer Ptr, UseHW3D As Integer Ptr) As Integer
'-----------------------------------------------------------------------------
' Установка режима аккустики
' на входе    :  Mode  -  аккустическая модель, параметр может принимать
'                         следуюшие значения:
'                         SQUALL_SPEAKER_DEFAULT   - аккустика по умолчанию
'                         SQUALL_SPEAKER_HEADPHONE - наушники (головные телефоны)
'                         SQUALL_SPEAKER_MONO      - моно колонка (1.0)
'                         SQUALL_SPEAKER_STEREO    - стерео колонки (2.0)
'                         SQUALL_SPEAKER_QUAD      - квадро колонки (4.0)
'                         SQUALL_SPEAKER_SURROUND  - квадро система с буфером
'                                                    низких эффектов (4.1)
'                         SQUALL_SPEAKER_5POINT1   - пяти канальная система с
'                                                    буфером низких эффектов (5.1)
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_SetSpeakerMode Lib "Squall"  Alias "SQUALL_SetSpeakerMode" (mode As Integer) As Integer

'-----------------------------------------------------------------------------
'	Получение текущего режима аккустики
'	на входе    :  *
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит номер текущего
'                режима аккустики
'-----------------------------------------------------------------------------
Declare Function SQUALL_GetSpeakerMode Lib "Squall"  Alias "SQUALL_GetSpeakerMode" () As Integer

'-----------------------------------------------------------------------------
' Установка алгоритма расчета трехмерного звука
' на входе    :  Algoritm -  код применяемого алгоритма расчета звука
'                            параметр может принимать следуюшие значения:
'                            SQUALL_ALG_3D_DEFAULT - алгоритм по умолчанию
'                            SQUALL_ALG_3D_OFF     - 2D алгоритм
'                            SQUALL_ALG_3D_FULL    - полноценный 3D алгоритм
'                            SQUALL_ALG_3D_LIGTH   - облегченный 3D алгоритм
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------

Declare Function SQUALL_Set3DAlgorithm Lib "Squall"  Alias "SQUALL_Set3DAlgorithm" (Algorithm As Integer) As Integer

'-----------------------------------------------------------------------------
' Получения текущего алгоритма расчета трехмерного звука
' на входе    :  *
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит номер текущего
'                алгоритма расчета трехмерного звука, результат может
'                принимать слудующие значения:
'                SQUALL_ALG_3D_DEFAULT - алгоритм по умолчанию
'                SQUALL_ALG_3D_OFF     - 2D алгоритм
'                SQUALL_ALG_3D_FULL    - полноценный 3D алгоритм
'                SQUALL_ALG_3D_LIGTH   - облегченный 3D алгоритм
'-----------------------------------------------------------------------------
Declare Function SQUALL_Get3DAlgorithm Lib "Squall"  Alias "SQUALL_Get3DAlgorithm" () As Integer

'-----------------------------------------------------------------------------
' Установка нового размера звукового буфера в милисекундах
' на входе    :  BufferSize  -  новый размер звукового буфера, в милисекундах
'                               параметр должен лежать в пределах от 200
'                               до 5000
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_SetBufferSize Lib "Squall"  Alias "SQUALL_SetBufferSize" (BufferSize As Integer) As Integer

'-----------------------------------------------------------------------------
' Получение текущего размера звукового буфера в милисекундах
' на входе    :  *
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит текущий размер
'                звукового буфера в милисекундах
'-----------------------------------------------------------------------------
Declare Function SQUALL_GetBufferSize Lib "Squall"  Alias "SQUALL_GetBufferSize" () As Integer

'-----------------------------------------------------------------------------
' Установка внешней системы работы с памятью
' на входе    :  UserAlloc   -  указатель на внешний метод выделения памяти
'                UserFree    -  указатель на внешний метод освобождения памяти
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_SetMemoryCallbacks Lib "Squall"  Alias "SQUALL_SetMemoryCallbacks" (UserAlloc As squall_callback_alloc_t,UserFree As squall_callback_free_t) As Integer

'-----------------------------------------------------------------------------
' Установка внешних методов для работы с файлами
' на входе    :  UserOpen    -  указатель на внешний метод открытия файлов
'                UserSeek    -  указатель на внешний метод позиционирования
'                               в открытом файле
'                UserRead    -  указатель на внешний метод чтения данных из
'                               открытого файла
'                UserClose   -  указатель на внешний метод закрытия открытого
'                               файла
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_SetFileCallbacks Lib "Squall"  Alias "SQUALL_SetFileCallbacks" (UserOpen As squall_callback_open_t , UserSeek As squall_callback_seek_t ,UserRead As squall_callback_read_t , UserClose As squall_callback_close_t ) As Integer

'''''''''''''''''''''''''''''''''''''''/
'''''''''''''''''''''''''''''''''''''''/
'              Методы для получения информация о системе
'''''''''''''''''''''''''''''''''''''''/
'''''''''''''''''''''''''''''''''''''''/
'-----------------------------------------------------------------------------
' Получение количества устройств воспроизведения звука
' на входе    :  *
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки.
'                в случае успешного вызова результат содержит количество
'                устройств воспроизведения в системе. Если в системе нет
'                устройств воспроизведения результат будет равен 0.
'-----------------------------------------------------------------------------
Declare Function SQUALL_GetNumDevice Lib "Squall"  Alias "SQUALL_GetNumDevice" () As Integer

'-----------------------------------------------------------------------------
' Получение имени устройства по указаному номеру
' на входе    :  Num      -  номер устройства, значение параметра должно быть
'                            в пределах от 0 до значения полученного с помощью
'                            метода SQUALL_GetNumDevice.
'                Buffer   -  указатель на буфер куда нужно поместить имя
'                            устройства воспроизведения
'                Size     -  размер принимающего буфера в байтах
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_GetDeviceName Lib "Squall"  Alias "SQUALL_GetDeviceName" (Num As Integer, Buffer As ZString Ptr, Size As Integer) As Integer

'-----------------------------------------------------------------------------
' Получение свойств устройства воспроизведения по указаному номеру
' на входе    :  Num   -  номер устройства, значение параметра должно быть в
'                         пределах от 0 до значения полученного с помощью
'                         метода SQUALL_GetNumDevice.
'                Caps  -  указатель на структуру в которую нужно поместить
'                         свойства устройства воспроизведения
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_GetDeviceCaps Lib "Squall"  Alias "SQUALL_GetDeviceCaps" (Num As Integer, Caps As squall_device_caps_t Ptr) As Integer
'-----------------------------------------------------------------------------
' Получение используемой версии EAX интерфейса
' на входе    :  *
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит максимально
'                доступную версию EAX
'-----------------------------------------------------------------------------
Declare Function SQUALL_GetEAXVersion Lib "Squall"  Alias "SQUALL_GetEAXVersion" () As Integer

'-----------------------------------------------------------------------------
' Получение информации о каналах
' на входе    :  Info  -  указатель на структуру в которую нужно поместить
'                         информацию о состоянии каналов
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_GetChannelsInfo Lib "Squall"  Alias "SQUALL_GetChannelsInfo" (Info As squall_channels_t Ptr) As Integer


'''''''''''''''''''''''''''''''''''''''/
'''''''''''''''''''''''''''''''''''''''/
'                    Методы для работы со слушателем
'''''''''''''''''''''''''''''''''''''''/
'''''''''''''''''''''''''''''''''''''''/
'-----------------------------------------------------------------------------
' Установка новых параметров слушателя
' на входе    :  Position -  указатель на структуру с новыми координатами
'                            позиции слушателя. В случае если позицию слушателя
'                            изменять не нужно, то данный параметр должен
'                            содержать 0
'                Front    -  указатель на структуру с новым вектором
'                            фронтального направления слушателя. В случае еслт
'                            вектор фронтального направления слушателя изменять
'                            не нужно, то данный парамерт должен содержать 0
'                Top      -  указатель на структуру с новым вектором
'                            вертикального направления слушателя. В случае если
'                            вектор вертикального направления изменять не нужно,
'                            то данный параметр должен содержать 0
'                Velocity -  указатель на структуру с новым вектором
'                            скорости перемещения слушателя. В случае если
'                            скорость перемещения слушателя изменять не нужно,
'                            то данный параметр должен содержать 0.
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Listener_SetParameters Lib "Squall"  Alias "SQUALL_Listener_SetParameters" (Position As Single Ptr, Front As Single Ptr, Top As Single Ptr, Velocity As Single Ptr) As Integer

'-----------------------------------------------------------------------------
' Получение текущих параметров слушателя
' на входе    :  Position -  указатель на структуру в которую нужно
'                            поместить текущие координаты слушателя. В случае
'                            если значение координат слушателя не требуется
'                            определять, то данный параметр должен содержать 0.
'                Front    -  указатель на структуру в которую нужно
'                            поместить текущий вектор фронтального
'                            направления слушателя. В случае если вектор
'                            фронтального направления слушателя не требуется
'                            определять, то данный параметр должен содержать 0.
'                Top      -  указатель на структуру в которую нужно
'                            поместить текущий вектор вертикального
'                            направления слушателя. В случае если вектор
'                            вертикального направления слушателя не требуется
'                            определять, то данный параметр должен содержать 0.
'                Velocity -  указатель на структуру в которую нужно
'                            поместить текущий вектор скорости перемещения
'                            слушателя. В случае если скорость перемещения
'                            слушателя не требуется определять, то данный
'                            параметр должен содержать 0.
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Listener_GetParameters Lib "Squall"  Alias "SQUALL_Listener_GetParameters" (Position As Single Ptr, Front As Single Ptr, Top As Single Ptr, Velocity As Single Ptr) As Integer

'-----------------------------------------------------------------------------
' Установка новой скорости перемещения слушателя
' на входе    :  Velocity -  указатель на структуру с новым вектором
'                            скорости перемещения слушателя.
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Listener_SetVelocity Lib "Squall"  Alias "SQUALL_Listener_SetVelocity" (Velocity As Single Ptr) As Integer

'-----------------------------------------------------------------------------
' Получение текущей скорости перемещения слушателя
' на входе    :  Velocity - указатель на структуру в которую нужно
'                           поместить текущий вектор скорости перемещения
'                           слушателя.
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Listener_GetVelocity Lib "Squall"  Alias "SQUALL_Listener_GetVelocity" (Velocity As Single Ptr) As Integer

'-----------------------------------------------------------------------------
' Установка новой позиции слушателя в пространстве
' на входе    :  Position -  указатель на структуру с новым вектором
'                            скорости перемещения слушателя.
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Listener_SetPosition Lib "Squall"  Alias "SQUALL_Listener_SetPosition" (Position As Single Ptr) As Integer

'-----------------------------------------------------------------------------
' Получение текущей позиции слушателя в пространстве
' на входе    :  Position -  указатель на структуру в которую нужно
'                            поместить текущий вектор скорости перемещения
'                            слушателя.
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Listener_GetPosition Lib "Squall"  Alias "SQUALL_Listener_GetPosition" (Position As Single Ptr) As Integer

'-----------------------------------------------------------------------------
' Установка нового коэффициента преобразования дистанции
' на входе    :  DistanceFactor -  новый коэффициент преобразования дистанции
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Listener_SetDistanceFactor Lib "Squall"  Alias "SQUALL_Listener_SetDistanceFactor" (DistanceFactor As Single) As Integer

'-----------------------------------------------------------------------------
' Получение текущего коэффициента преобразования дистанции
' на входе    :  DistanceFactor -  указатель на переменную в которую нужно
'                                  поместить текущий коэффициент
'                                  преобразования дистанции
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Listener_GetDistanceFactor Lib "Squall"  Alias "SQUALL_Listener_GetDistanceFactor" (DistanceFactor As Single Ptr) As Integer

'-----------------------------------------------------------------------------
' Установка нового коэффициента затухания звука в зависимости от растояния
' на входе    :  RolloffFactor  -  новый коэффициент преобразования затухания
'                                  звука,  значение параметра должно быть
'                                  в пределах от 0.1f до 10.0f
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Listener_SetRolloffFactor Lib "Squall"  Alias "SQUALL_Listener_SetRolloffFactor" (RolloffFactor As Single) As Integer

'-----------------------------------------------------------------------------
' Получение текущего коэффициента затухания звука в зависимости от растояния
' на входе    :  RolloffFactor  -  указатель на переменную в которую нужно
'                                  поместить текущий коэффициент преобразования
'                                  затухания звука
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Listener_GetRolloffFactor Lib "Squall"  Alias "SQUALL_Listener_GetRolloffFactor" (RolloffFactor As Single Ptr) As Integer

'-----------------------------------------------------------------------------
' Установка нового коэффициента эффекта Допплера
' на входе    :  DopplerFactor  -  новый коэффициент эффекта Допплера, значение
'                                  параметра должно быть в пределах от 0.1f
'                                  до 10.0f
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Listener_SetDopplerFactor Lib "Squall"  Alias "SQUALL_Listener_SetDopplerFactor" (DopplerFactor As Single) As Integer

'-----------------------------------------------------------------------------
' Получение текущего коэффициента эффекта Допплера
' на входе    :  DopplerFactor  -  указатель на переменную в которую нужно
'                                  поместить текущий коэффициент эффекта
'                                  Допплера
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Listener_GetDopplerFactor Lib "Squall"  Alias "SQUALL_Listener_GetDopplerFactor" (DopplerFactor As Single Ptr) As Integer

'-----------------------------------------------------------------------------
' Обновление трехмерных настроек
' на входе    :  *
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
' примечание  :  данный метод имеет смысл применять только в том случае когда
'                слушатель настроен на принудительное обновление трехмерных
'                настроек. По есть при инициализации двигателя слушатель
'                переведен в режим SQUALL_LISTENER_MODE_DEFERRED
'-----------------------------------------------------------------------------
Declare Function SQUALL_Listener_Update Lib "Squall"  Alias "SQUALL_Listener_Update" () As Integer

'-----------------------------------------------------------------------------
' Установка предустановленных значения окружения
' на входе    :  Preset   -  номер предустановленного значения
'                            параметр может принимать следуюшие значения:
'                            SQUALL_EAX_OFF
'                            SQUALL_EAX_GENERIC
'                            SQUALL_EAX_PADDEDCELL
'                            SQUALL_EAX_ROOM
'                            SQUALL_EAX_BATHROOM
'                            SQUALL_EAX_LIVINGROOM
'                            SQUALL_EAX_STONEROOM
'                            SQUALL_EAX_AUDITORIUM
'                            SQUALL_EAX_CONCERTHALL
'                            SQUALL_EAX_CAVE
'                            SQUALL_EAX_ARENA
'                            SQUALL_EAX_HANGAR
'                            SQUALL_EAX_CARPETEDHALLWAY
'                            SQUALL_EAX_HALLWAY
'                            SQUALL_EAX_STONECORRIDOR
'                            SQUALL_EAX_ALLEY
'                            SQUALL_EAX_FOREST
'                            SQUALL_EAX_CITY
'                            SQUALL_EAX_MOUNTAINS
'                            SQUALL_EAX_QUARRY
'                            SQUALL_EAX_PLAIN
'                            SQUALL_EAX_PARKINGLOT
'                            SQUALL_EAX_SEWERPIPE
'                            SQUALL_EAX_UNDERWATER
'                            SQUALL_EAX_DRUGGED
'                            SQUALL_EAX_DIZZY
'                            SQUALL_EAX_PSYCHOTIC
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Listener_EAX_SetPreset Lib "Squall"  Alias "SQUALL_Listener_EAX_SetPreset" (Preset_ As Integer) As Integer

'-----------------------------------------------------------------------------
' Установка новых EAX параметров слушателя
' на входе    :  Version     -  номер версии EAX интерфейса
'                Properties  -  указатель на структуру с новыми EAX параметрами
'                               слушателя
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Listener_EAX_SetProperties Lib "Squall"  Alias "SQUALL_Listener_EAX_SetProperties" (Version As Integer, Properties As squall_eax_listener_t Ptr) As Integer

'-----------------------------------------------------------------------------
' Получение текущих EAX параметров слушателя
' на входе    :  Version     -  номер версии EAX интерфейса
'                Properties  -  указатель на структуру куда надо поместить
'                               текущие EAX параметры слушателя
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Listener_EAX_GetProperties Lib "Squall"  Alias "SQUALL_Listener_EAX_GetProperties" (Version As Integer, Properties As squall_eax_listener_t Ptr) As Integer

'-----------------------------------------------------------------------------
' Установка обработчика слушателя
' на входе    :  Worker      -  указатель на обработчик слушателя, в случае
'                               если параметр равен 0, предедущий обработчик
'                               будет удален.
'                Param       -  указатель на данные пользователя, в случае
'                               данных пользователя нет, то данный параметр
'                               может содержать 0
'                UpdateTime  -  промежуток времени через который нужно
'                               вызывать обработчик параметр должен лежать
'                               в пределах от 1 до 5000
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Listener_SetWorker Lib "Squall"  Alias "SQUALL_Listener_SetWorker" ( Worker As squall_callback_listener_t, Param As Any Ptr, UpdateTime As UInteger) As Integer

'''''''''''''''''''''''''''''''''''''''/
'''''''''''''''''''''''''''''''''''''''/
'                   Общие методы для работы с каналами
'''''''''''''''''''''''''''''''''''''''/
'''''''''''''''''''''''''''''''''''''''/
'-----------------------------------------------------------------------------
' Начало воспроизведения подготовленного звукового канала
' на входе    :  ChannelID   -  идентификатор подготовленного канала
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_Start Lib "Squall"  Alias "SQUALL_Channel_Start" (ChannelID As Integer) As Integer

'-----------------------------------------------------------------------------
' Включение/выключение паузы звукового канала
' на входе    :  ChannelID   -  идентификатор звукового канала
'                Pause       -  флаг включения/выключения паузы, параметр может
'                               принимать следующие значения:
'                               true  - включить паузу
'                               false - выключить паузу
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_Pause Lib "Squall"  Alias "SQUALL_Channel_Pause" (ChannelID As Integer, Pause_ As Integer) As Integer

'-----------------------------------------------------------------------------
' Остановка звукового канала по идентификатору
' на входе    :  ChannelID   -  идентификатор звукового канала
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_Stop Lib "Squall"  Alias "SQUALL_Channel_Stop" (ChannelID As Integer) As Integer

'-----------------------------------------------------------------------------
' Получение статуса звукового канала
' на входе    :  ChannelID   -  идентификатор звукового канала
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит статус канала,
'                результат может принимать следующие значения:
'                SQUALL_CHANNEL_STATUS_NONE       -  звукового канала с таким
'                                                    идентификатором нет
'                SQUALL_CHANNEL_STATUS_PLAY       -  звуковой канал
'                                                    воспроизводится
'                SQUALL_CHANNEL_STATUS_PAUSE      -  звуковой канал находится
'                                                    в режиме паузы
'                SQUALL_CHANNEL_STATUS_PREPARED   -  звуковой канал
'                                                    подготовлен
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_Status Lib "Squall"  Alias "SQUALL_Channel_Status" (ChannelID As Integer) As Integer

'-----------------------------------------------------------------------------
' Установка нового уровня громкости звукового канала в процентах
' на входе    :  ChannelID   -  идентификатор звукового канала
'                Volume      -  значение уровня громкости в провентах,
'                               значение ппараметра должно быть в пределах
'                               от 0 до 100
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_SetVolume Lib "Squall"  Alias "SQUALL_Channel_SetVolume" (ChannelID As Integer, Volume As Integer) As Integer

'-----------------------------------------------------------------------------
' Получение текущего уровня громкости звукового канала в процентах
' на входе    :  ChannelID   -  идентификатор канала
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит текущее значение
'                громкости канала в процентах
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_GetVolume Lib "Squall"  Alias "SQUALL_Channel_GetVolume" (ChannelID As Integer) As Integer

'-----------------------------------------------------------------------------
' Устанока новой частоты дискретизации звукового канала
' на входе    :  ChannelID   -  идентификатор звукового канала
'                Frequency   -  новое значение частоты дискретизации, значение
'                               параметра должно быть в пределах от 100 Герц
'                               до 1000000 Герц
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_SetFrequency Lib "Squall"  Alias "SQUALL_Channel_SetFrequency" (ChannelID As Integer, Frequency As Integer) As Integer

'-----------------------------------------------------------------------------
' Получение текущей частоты дискретизации звукового канала
' на входе    :  ChannelID   -  идентификатор звукового канала
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит текущее значение
'                частоты дискретизации звукового канала
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_GetFrequency Lib "Squall"  Alias "SQUALL_Channel_GetFrequency" (ChannelID As Integer) As Integer

'-----------------------------------------------------------------------------
' Установка новой позиции воспроизведения звукового канала в семплах
' на входе    :  ChannelID   -  идентификатор звукового канала
'                Position    -  новое значение позиции воспроизведения
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_SetPlayPosition Lib "Squall"  Alias "SQUALL_Channel_SetPlayPosition" (ChannelID As Integer, Position As Integer) As Integer

'-----------------------------------------------------------------------------
' Получение текущей позиции воспроизведения звукового канала в семплах
' на входе    :  ChannelID   -  идентификатор звукового канала
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит текущую позицию
'                воспроизведения
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_GetPlayPosition Lib "Squall"  Alias "SQUALL_Channel_GetPlayPosition" (ChannelID As Integer) As Integer

'-----------------------------------------------------------------------------
' Установка новой позиции воспроизведения звукового канала в миллисекундах
' на входе    :  ChannelID   -  идентификатор звукового канала
'                Position    -  новое значение позиции воспроизведения,
'                               в миллисекундах
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_SetPlayPositionMs Lib "Squall"  Alias "SQUALL_Channel_SetPlayPositionMs" (ChannelID As Integer, Position As Integer) As Integer

'-----------------------------------------------------------------------------
' Получение текущей позиции воспроизведения звукового канала в миллисекундах
' на входе    :  ChannelID   -  идентификатор звукового канала
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит текущую позицию
'                воспроизведения
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_GetPlayPositionMs Lib "Squall"  Alias "SQUALL_Channel_GetPlayPositionMs" (ChannelID As Integer) As Integer

'-----------------------------------------------------------------------------
' Установка обработчика звукового канала
' на входе    :  ChannelID   -  идентификатор звукового канала
'                Worker      -  указатель на обработчик звукового канала
'                Param       -  указатель на данные пользователя, в случае
'                               если данных пользователя нет, параметр может
'                               содержать 0
'                UpdateTime  -  промежуток времени в миллисекундах через
'                               который нужно вызывать обработчик, значение
'                               параметра должно быть в пределах от 1 до 5000
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_SetWorker Lib "Squall"  Alias "SQUALL_Channel_SetWorker" (ChannelID As Integer, Worker As squall_callback_channel_t , UpdateTime As UInteger) As Integer

'-----------------------------------------------------------------------------
' Установка обработчика окончания звукового канала
' на входе    :  ChannelID   -  идентификатор звукового канала
'                Worker      -  указатель на обработчик звукового канала
'                Param       -  указатель на данные пользователя, в случае
'                               если данных пользователя нет, параметр может
'                               содержать 0
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_SetEndWorker Lib "Squall"  Alias "SQUALL_Channel_SetEndWorker" (ChannelID As Integer, Worker As squall_callback_end_channel_t , param As Any Ptr) As Integer

'-----------------------------------------------------------------------------
' Установка новых границ фрагмента звукового канала в семплах
' на входе    :  ChannelID   -  идентификатор звукового канала
'                Start       -  начальная позиция фрагмента, в отсчетах
'                End         -  конечная позиция фрагмента, в отсчетах
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_SetFragment Lib "Squall"  Alias "SQUALL_Channel_SetFragment" (ChannelID As Integer, start As Integer , end_ As Integer) As Integer

'-----------------------------------------------------------------------------
' Получение текущих границ фрагмента звукового канала в семплах
' на входе    :  ChannelID   -  идентификатор звукового канала
'                Start       -  указатель на переменную в которую нужно
'                               поместить начальную позицию фрагмента в
'                               отсчетах
'                End         -  указатель на переменную в которую нужно
'                               поместить конечную позицию фрагмента
'                               в отсчетах
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_GetFragment Lib "Squall"  Alias "SQUALL_Channel_GetFragment" (ChannelID As Integer, start As Integer Ptr, end_ As Integer Ptr) As Integer

'-----------------------------------------------------------------------------
' Установка новых границ фрагмента звукового канала в миллисекундах
' на входе    :  ChannelID   -  идентификатор звукового канала
'                Start       -  начальная позиция фрагмента, позиция в
'                               миллисекундах
'                End         -  конечная позиция фрагмента, позиция в
'                               миллисекундах
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_SetFragmentMs Lib "Squall"  Alias "SQUALL_Channel_SetFragmentMs" (ChannelID As Integer, start As Integer , end_ As Integer) As Integer

'-----------------------------------------------------------------------------
' Получение текущих границ фрагмента звукового канала в миллисекундах
' на входе    :  ChannelID   -  идентификатор звукового канала
'                Start       -  указатель на переменную в которую нужно
'                               поместить начальную позицию фрагмента
'                               в миллисекундах
'                End         -  указатель на переменную в которую нужно
'                               поместить конечную позицию фрагмента
'                               в миллисекундах
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_GetFragmentMs Lib "Squall"  Alias "SQUALL_Channel_GetFragmentMs" (ChannelID As Integer, start As Integer Ptr, end_ As Integer Ptr) As Integer

'-----------------------------------------------------------------------------
' Получение продолжительности исходных звуковых данных в семплах
' на входе    :  ChannelID   -  идентификатор звукового канала
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит продолжительность
'                исходных данных в семплах
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_GetLength Lib "Squall"  Alias "SQUALL_Channel_GetLength" (ChannelID As Integer) As Integer

'-----------------------------------------------------------------------------
' Получение продолжительности исходных звуковых данных в миллисекундах
' на входе    :  ChannelID   -  идентификатор звукового канала
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит продолжительность
'                исходных данных в милисекундах
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_GetLengthMs Lib "Squall"  Alias "SQUALL_Channel_GetLengthMs" (ChannelID As Integer) As Integer

'-----------------------------------------------------------------------------
' Установка нового приоритета звукового канала
' на входе    :  ChannelID   -  идентификатор звукового канала
'                Priority    -  новый приоритет канала, значение параметра
'                               должно быть в пределах от 0 (самый низший
'                               приоритет) до 65535 (самый высший приоритет)
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_SetPriority Lib "Squall"  Alias "SQUALL_Channel_SetPriority" (ChannelID As Integer, Priority As Integer) As Integer

'-----------------------------------------------------------------------------
' Получение текущего приоритета звукового канала
' на входе    :  ChannelID   -  идентификатор звукового канала
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит приоритет
'                звукового канала
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_GetPriority Lib "Squall"  Alias "SQUALL_Channel_GetPriority" (ChannelID As Integer) As Integer

'-----------------------------------------------------------------------------
' Получение текущего значения флага зацикленности воспроизведения звукового
' канала
' на входе    :  ChannelID   -  идентификатор звукового канала
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит текущее значение
'                флага зацикленности воспроизведения канала, результат может
'                принимать следующие значения:
'                true  -  звуковой канал воспроизводится бесконечно
'                false -  звуковой канал воспроизводится один раз
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_GetLoop Lib "Squall"  Alias "SQUALL_Channel_GetLoop" (ChannelID As Integer) As Integer

'-----------------------------------------------------------------------------
' Установка нового значения флага зацикленности воспроизведения звукового
' канала
' на входе    :  ChannelID   -  идентификатор звукового канала
'                Loop        -  флаг зацикленности канала, значение праметра
'                               может принимать следующие значения:
'                               true  -  бесконечное воспроизведение звукового
'                                        канала
'                               false -  воспроизведение звукового канала один
'                                        раз
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_SetLoop Lib "Squall"  Alias "SQUALL_Channel_SetLoop" (ChannelID As Integer, loop_ As Integer) As Integer

'''''''''''''''''''''''''''''''''''''''/
'''''''''''''''''''''''''''''''''''''''/
'                Методы для работы с рассеянными каналами
'''''''''''''''''''''''''''''''''''''''/
'''''''''''''''''''''''''''''''''''''''/
'-----------------------------------------------------------------------------
' Установка новой панорамы звукового канала
' на входе    :  ChannelID   -  идентификатор звукового канала
'                Pan         -  новое значение панорамы, значение параметра
'                               должено быть в пределах от 0 (максимальное
'                               смещение стерео баланса влево) до 100
'                               (максимальное смещение стерео баланса вправо)
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
' примечание  :  данный метод не работает с позиционными каналами
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_SetPan Lib "Squall"  Alias "SQUALL_Channel_SetPan" (ChannelID As Integer, Pan As Integer) As Integer

'-----------------------------------------------------------------------------
' Получение текущей панорамы звукового канала
' на входе    :  ChannelID   -  идентификатор звукового канала
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит текущее значение
'                панорамы канала
' примечание  :  данный метод не работает с позиционными каналами
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_GetPan Lib "Squall"  Alias "SQUALL_Channel_GetPan" (ChannelID As Integer) As Integer

'''''''''''''''''''''''''''''''''''''''/
'''''''''''''''''''''''''''''''''''''''/
'                Методы для работы с позиционными каналами
'''''''''''''''''''''''''''''''''''''''/
'''''''''''''''''''''''''''''''''''''''/
'-----------------------------------------------------------------------------
' Установка новой трехмерной позиции звукового канала в пространстве
' на входе    :  ChannelID   -  идентификатор звукового канала
'                Position    -  указатель на структуру с новыми координатами
'                               канала в пространстве
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
' примечание  :  данный метод не работает с рассеянными каналами
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_Set3DPosition Lib "Squall"  Alias "SQUALL_Channel_Set3DPosition" (ChannelID As Integer, Position As Single Ptr) As Integer

'-----------------------------------------------------------------------------
' Получение текущей трехмерной позиции звукового канала в пространстве
' на входе    :  ChannelID   -  идентификатор звукового канала
'                Position    -  указатель на структуру в которую нужно
'                               поместить текущую трехмерную позицию звукового
'                               канала в пространстве
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
' примечание  :  данный метод не работает с рассеянными каналами
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_Get3DPosition Lib "Squall"  Alias "SQUALL_Channel_Get3DPosition" (ChannelID As Integer, Position As Single Ptr) As Integer

'-----------------------------------------------------------------------------
' Установка новой скорости перемещения звукового канала
' на входе    :  ChannelID   -  идентификатор звукового канала
'                Velocity    -  указатель на структуру с новым вектором
'                               скорости перемещения звукового канала
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
' примечание  :  данный метод не работает с рассеянными каналами
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_SetVelocity Lib "Squall"  Alias "SQUALL_Channel_SetVelocity" (ChannelID As Integer, Velocity As Single Ptr) As Integer

'-----------------------------------------------------------------------------
' Получение текущей скорости перемещения звукового канала
' на входе    :  ChannelID   -  идентификатор звукового канала
'                Velocity    -  указатель на структуру в которую нужно
'                               поместить текущее значение вектора скорости
'                               звукового канала
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
' примечание  :  данный метод не работает с рассеянными каналами
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_GetVelocity Lib "Squall"  Alias "SQUALL_Channel_GetVelocity" (ChannelID As Integer, Velocity As Single Ptr) As Integer

'-----------------------------------------------------------------------------
' Установка нового минимального и максимального расстояния слышимости
' звукового канала
' на входе    :  ChannelID   -  идентификатор звукового канала
'                MinDist     -  новое минимальное расстояние слышимости
'                               значение параметра должно быть в пределах
'                               от 0.01f до 1000000000.0f
'                MaxDist     -  новое максимальное расстояние слышимости
'                               значение параметра должно быть в пределах
'                               от 0.01f до 1000000000.0f
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
' примечание  :  данный метод не работает с рассеянными каналами
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_SetMinMaxDistance Lib "Squall"  Alias "SQUALL_Channel_SetMinMaxDistance" (ChannelID As Integer, MinDist As Single, MaxDist As Single) As Integer

'-----------------------------------------------------------------------------
' Получение текущего минимального растояния слышимости звукового канала
' на входе    :  ChannelID   -  идентификатор звукового канала
'                MinDist     -  указатель на переменную в которую нужно
'                               поместить текущее минимальное растояние
'                               слышимости
'                MinDist     -  указатель на переменную в которую нужно
'                               поместить текущее максимальное растояние
'                               слышимости
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
' примечание  :  данный метод не работает с рассеянными каналами
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_GetMinMaxDistance Lib "Squall"  Alias "SQUALL_Channel_GetMinMaxDistance" (ChannelID As Integer, MinDist As Single Ptr, MaxDist As Single Ptr) As Integer

'-----------------------------------------------------------------------------
' Установка параметров конуса распространения звукового канала
' на входе    :  ChannelID         -  идентификатор звукового канала
'                Orientation       -  указатель на струкруру с вектором
'                                     направления внутреннего и внешнего конуса,
'                                     в случае если значение вектора направления
'                                     внешнего и внутреннего конуса изменять
'                                     не нужно, то данный параметр должен
'                                     содержать 0
'                InsideConeAngle   -  угол внутреннего звукового конуса, значение
'                                     параметра должно быть в пределах от 1 до
'                                     360 градусов, в случае если значение
'                                     угла внутреннего звукового конуса изненять
'                                     не нужно, то данный параметр должен
'                                     содержать 0
'                OutsideConeAngle  -  угол внешнего звукового конуса, значение
'                                     параметра должно быть в пределах от 1 до
'                                     360 градусов, в случае если значение
'                                     угла внешнего звукового конуса изменять
'                                     не нужно, то данный параметр должен
'                                     содержать 0
'                OutsideVolume     -  уровень громкости источника за пределами
'                                     внешнего конуса, в процентах значение
'                                     праметра должно быть в пределах от 0
'                                     до 100
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
' примечание  :  данный метод не работает с рассеянными каналами
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_SetConeParameters Lib "Squall"  Alias "SQUALL_Channel_SetConeParameters" (ChannelID As Integer, Orientation As Single Ptr, InsideConeAngle As Integer, OutsideConeAngle As Integer, OutsideVolume As Integer) As Integer

'-----------------------------------------------------------------------------
' Получение параметров конуса распространения звукового канала
' на входе    :  ChannelID         -  идентификатор звукового канала
'                Orientation       -  указатель на струкруру в которую нужно
'                                     поместить текущий вектор направления
'                                     внешнего и внутреннего конуса, в случае
'                                     если значение вектора внутреннего
'                                     и внешнего конуса, получать не нужно,
'                                     то данный параметр должен содержать 0
'                InsideConeAngle   -  указатель на переменную в которую нужно
'                                     поместить текущее значение угола внутреннего
'                                     конуса в градусах, в случае если значение
'                                     угла внутреннего конуса получать не нужно,
'                                     то данный параметр должен содержать 0
'                OutsideConeAngle  -  указатель на переменную в которую нужно
'                                     поместить текущее значение угола внешнего
'                                     конуса в градусах, в случае если значение
'                                     угла внешнего конуса получать не нужно,
'                                     то данный параметр должен содержать 0
'                OutsideVolume     -  указатель на переменную в которую нужно
'                                     поместить текущее значение уровеня громкости
'                                     источника за пределами внешнего конуса, в
'                                     процентах, в случае если значение уровня
'                                     громкости за пределами внешего конуса
'                                     получать не нужно, то данный параметр
'                                     должен содержать 0
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
' примечание  :  данный метод не работает с рассеянными каналами
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_GetConeParameters Lib "Squall"  Alias "SQUALL_Channel_GetConeParameters" (ChannelID As Integer, Orientation As Single Ptr, InsideConeAngle As Integer Ptr, OutsideConeAngle As Integer Ptr, OutsideVolume As Integer Ptr) As Integer

'-----------------------------------------------------------------------------
' Установка новых EAX параметров звукового канала
' на входе    :  ChannelID   -  идентификатор звукового канала
'                Version     -  номер версии EAX, параметр определяет в каком
'                               формате передаются EAX параметры канала.
'                Properties  -  указатель на структуру описывающую параметры
'                               EAX канала, параметры должны быть в формате
'                               указанном параметром Version
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
' примечание  :  данный метод не работает с рассеянными каналами
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_EAX_SetProperties Lib "Squall"  Alias "SQUALL_Channel_EAX_SetProperties" (ChannelID As Integer, Version As Integer, Property_ As squall_eax_channel_t Ptr) As Integer

'-----------------------------------------------------------------------------
' Получение текущих EAX параметров звукового канала
' на входе    :  ChannelID   -  идентификатор звукового канала
'                Version     -  номер версии EAX, параметр определяет в каком
'                               формате получать EAX параметры канала.
'                Properties  -  указатель на структуру куда нужно поместить
'                               текущие параметры EAX канала, структура будет
'                               заполнена параметрами в формате указанном
'                               параметром Version
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
' примечание  :  данный метод не работает с рассеянными каналами
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_EAX_GetProperties Lib "Squall"  Alias "SQUALL_Channel_EAX_GetProperties" (ChannelID As Integer, Version As Integer, Property_ As squall_eax_channel_t Ptr) As Integer

'-----------------------------------------------------------------------------
' Установка новых ZOOMFX параметров звукового канала
' на входе    :  ChannelID   -  идентификатор звукового канала
'                Properties  -  указатель на структуру описывающую параметры
'                               ZOOMFX канала
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
' примечание  :  данный метод не работает с рассеянными каналами
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_ZOOMFX_SetProperties Lib "Squall"  Alias "SQUALL_Channel_ZOOMFX_SetProperties" (ChannelID As Integer, Property_ As squall_zoomfx_channel_t Ptr) As Integer

'-----------------------------------------------------------------------------
' Получение текущих ZOOMFX параметров звукового канала
' на входе    :  ChannelID   -  идентификатор звукового канала
'                Properties  -  указатель на структуру куда нужно поместить
'                               текущие параметры ZOOMFX канала
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
' примечание  :  данный метод не работает с рассеянными каналами
'-----------------------------------------------------------------------------
Declare Function SQUALL_Channel_ZOOMFX_GetProperties Lib "Squall"  Alias "SQUALL_Channel_ZOOMFX_GetProperties" (ChannelID As Integer, Property_ As squall_zoomfx_channel_t Ptr) As Integer

'''''''''''''''''''''''''''''''''''''''/
'''''''''''''''''''''''''''''''''''''''/
'                Методы для работы с группами каналов
'''''''''''''''''''''''''''''''''''''''/
'''''''''''''''''''''''''''''''''''''''/
'-----------------------------------------------------------------------------
' Включение/выключение паузы группы каналов
' на входе    :  ChannelGroupID -  идентификатор группы каналов
'                Pause          -  флаг включения/выключения паузы, параметр
'                                  может принимать слудующие значения:
'                                  true  -  включить паузу
'                                  false -  выключить паузу
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_ChannelGroup_Pause Lib "Squall"  Alias "SQUALL_ChannelGroup_Pause" (ChannelGroupID As Integer, Pause_ As Integer) As Integer

'-----------------------------------------------------------------------------
' Остановка группы каналов
' на входе    :  ChannelGroupID -  идентификатор группы каналов
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_ChannelGroup_Stop Lib "Squall"  Alias "SQUALL_ChannelGroup_Stop" (ChannelGroupID As Integer) As Integer

'-----------------------------------------------------------------------------
' Установка уровня громкости группы каналов в процентах
' на входе    :  ChannelGroupID -  идентификатор группу каналов
'                Volume         -  значение урокня громкости, значение должно
'                                  лежать в пределах от 0 до 100
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_ChannelGroup_SetVolume Lib "Squall"  Alias "SQUALL_ChannelGroup_SetVolume" (ChannelGroupID As Integer, Volume As Integer) As Integer

'-----------------------------------------------------------------------------
' Установка новой частоты дискретизации группы каналов
' на входе    :  ChannelGroupID -  номер группы каналов
'                Frequency      -  новое значение частоты дискретизации,
'                                  значение параметра должно быть в пределах
'                                  от 100 до 1000000 Герц
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_ChannelGroup_SetFrequency Lib "Squall"  Alias "SQUALL_ChannelGroup_SetFrequency" (ChannelGroupID As Integer, Frequency As Integer) As Integer

'''''''''''''''''''''''''''''''''''''''/
'''''''''''''''''''''''''''''''''''''''/
'                Методы для работы с семплами
'''''''''''''''''''''''''''''''''''''''/
'''''''''''''''''''''''''''''''''''''''/
'-----------------------------------------------------------------------------
' Создание семпла из файла
' на входе    :  FileName - указатель на имя файла
'                MemFlag  - флаг определяющий расположение файла, параметр
'                           может принимать следующие значения:
'                           true  -   размещать данные файла в памяти
'                           false -   разместить данные файла на диске
'                Default  - указатель на структуру параметров семпла по
'                           умолчанию, если параметр равен 0, загрузчик
'                           установит следующие параметры семпла по умолчанию:
'                           SampleGroupID - 0
'                           Priority      - 0
'                           Frequency     - 0
'                           Volume        - 100
'                           Pan           - 50
'                           MinDist       - 1.0f
'                           MaxDist       - 1000000000.0f
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит идентификатор
'                созданного семпла
'-----------------------------------------------------------------------------
Declare Function SQUALL_Sample_LoadFile Lib "Squall"  Alias "SQUALL_Sample_LoadFile" (FileName As ZString Ptr, MemFlag As Integer, Default As squall_sample_default_t Ptr) As Integer

'-----------------------------------------------------------------------------
' Загрузка данных в хранилище из памяти
' на входе :  MemoryPtr   - указатель на память с данными файла
'             MemorySize  - размер памяти с данными файла
'             NewMemory   - флаг определяющий способ размещения данных
'                           true -    выделить память и скопировать, то
'                                     есть двигатель выделяет память и
'                                     копирует данные указанные MemoryPtr.
'                                     После выполнения память можно удалить
'                           false -   использовать предлагаемую память, то
'                                     есть передаваемую память нельзя удалять
'             Default     - указатель на структуру параметров семпла по
'                           умолчанию, если параметр равен 0, загрузчик
'                           установит следующие параметры семпла по умолчанию:
'                           SampleGroupID - 0
'                           Priority      - 0
'                           Frequency     - 0
'                           Volume        - 100
'                           Pan           - 50
'                           MinDist       - 1.0f
'                           MaxDist       - 1000000000.0f
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит идентификатор
'                созданного семпла
'-----------------------------------------------------------------------------
Declare Function SQUALL_Sample_LoadFromMemory Lib "Squall"  Alias "SQUALL_Sample_LoadFromMemory" (MemoryPtr As Any Ptr, MemorySize As Integer, NewMemory As Integer,  Default As squall_sample_default_t Ptr) As Integer

'-----------------------------------------------------------------------------
' Освобождение всех семплов
' на входе    :  *
' на выходе   :  *
'-----------------------------------------------------------------------------
Declare Sub SQUALL_Sample_UnloadAll Lib "Squall"  Alias "SQUALL_Sample_UnloadAll" ()

'-----------------------------------------------------------------------------
' Освобождение указанного семпла
' на входе    :  SampleID -  идентификатор семпла
' на выходе   :  *
'-----------------------------------------------------------------------------
Declare Sub SQUALL_Sample_Unload Lib "Squall"  Alias "SQUALL_Sample_Unload" (SampleID As Integer)

'-----------------------------------------------------------------------------
' Получение продолжительности данных звукового файла в отсчетах
' на входе    :  SampleID -  идентификатор семпла
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит продолжительность
'                данных в отсчетах
'-----------------------------------------------------------------------------
Declare Function SQUALL_Sample_GetFileLength Lib "Squall"  Alias "SQUALL_Sample_GetFileLength" (SampleID As Integer) As Integer

'-----------------------------------------------------------------------------
' Получение продолжительности данных звукового файла в миллисекундах
' на входе    :  SampleID -  идентификатор семпла
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит продолжительность
'                данных в милисекундах
'-----------------------------------------------------------------------------
Declare Function SQUALL_Sample_GetFileLengthMs Lib "Squall"  Alias "SQUALL_Sample_GetFileLengthMs" (SampleID As Integer) As Integer

'-----------------------------------------------------------------------------
' Получение частоты дискретизации данных звукового файла
' на входе    :  SampleID -  идентификатор семпла
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит частоту
'                дискретизации
'-----------------------------------------------------------------------------
Declare Function SQUALL_Sample_GetFileFrequency Lib "Squall"  Alias "SQUALL_Sample_GetFileFrequency" (SampleID As Integer) As Integer

'-----------------------------------------------------------------------------
' Установка новых параметров семпла по умолчанию
' на входе    :  SampleID -  идентификатор семпла
'                Default  -  указатель на структуру с новыми параметрами семпла
'                            по умолчанию
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Sample_SetDefault Lib "Squall"  Alias "SQUALL_Sample_SetDefault" (SampleID As Integer, Default As squall_sample_default_t Ptr) As Integer

'-----------------------------------------------------------------------------
' Получение текущих параметров семпла по умолчанию
' на входе    :  SampleID -  идентификатор семпла
'                Default  -  указатель на структуру в которую нужно поместить
'                            текущие параметры семпла по умолчанию
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Sample_GetDefault Lib "Squall"  Alias "SQUALL_Sample_GetDefault" (SampleID As Integer, Default As squall_sample_default_t Ptr) As Integer

'-----------------------------------------------------------------------------
' Создание и воспроизведение рассеянного канала из указанного семпла, опираясь
' на параметры семпла по умолчанию
' на входе    :  SampleID       -  идентификатор семпла
'                Loop           -  флаг зацикленности воспроизведения, параметр
'                                  может принимать следующие значения:
'                                  true  -  воспроизводить канал в цикле
'                                           бесконечно
'                                  false -  воспроизвести канал один раз
'                ChannelGroupID -  принадлежность создаваемого канала к группе
'                                  каналов, если значение параметра равно 0
'                                  значит звуковой канал не принадлежит группе
'                                  каналов.
'                Start          -  флаг запуска звука по окончанию создания
'                                  канала, параметр может принимать следующие
'                                  значения:
'                                  true  -  канал начнет воспроизводится сразу
'                                           после создания
'                                  false -  канал будет только подготовлен,
'                                           для того чтобы начать воспроизведение
'                                           нужно вызвать метод
'                                           SQUALL_Channel_Start()
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит идентификатор
'                созданного звукового канала
'-----------------------------------------------------------------------------
Declare Function SQUALL_Sample_Play Lib "Squall"  Alias "SQUALL_Sample_Play" (SampleID As Integer , Loop_ As Integer , Group As Integer ,  Start As Integer) As Integer


'-----------------------------------------------------------------------------
' Создание и воспроизведение рассеянного канала из указанного семпла, опираясь
' на параметры семпла по умолчанию
' на входе    :  SampleID       -  идентификатор семпла
'                Loop           -  флаг зацикленности воспроизведения, параметр
'                                  может принимать следующие значения:
'                                  true  -  воспроизводить канал в цикле
'                                           бесконечно
'                                  false -  воспроизвести канал один раз
'                ChannelGroupID -  принадлежность создаваемого канала к группе
'                                  каналов, если значение параметра равно 0
'                                  значит звуковой канал не принадлежит группе
'                                  каналов.
'                Start          -  флаг запуска звука по окончанию создания
'                                  канала, параметр может принимать следующие
'                                  значения:
'                                  true  -  канал начнет воспроизводится сразу
'                                           после создания
'                                  false -  канал будет только подготовлен,
'                                           для того чтобы начать воспроизведение
'                                           нужно вызвать метод
'                                           SQUALL_Channel_Start()
'                Priority       -  приоритет создаваемого звукового канала,
'                                  значение параметра должно лежать в пределах
'                                  от 0 до 65535
'                Volume         -  громкость создаваемого звукового канала,
'                                  в процентах, значение параметра должно
'                                  лежать в пределах от 0 до 100
'                Frequency      -  частота дискретизации звукового канала,
'                                  значение параметра должно лежать в пределах
'                                  от 100 до 1000000000
'                Pan            -  панорама создаваемого звукового канала,
'                                  значение параметра должно лежать в пределах
'                                  от 0 до 100
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит идентификатор
'                созданного звукового канала
'-----------------------------------------------------------------------------
Declare Function SQUALL_Sample_PlayEx Lib "Squall"  Alias "SQUALL_Sample_PlayEx" (SampleID As Integer , Loop_ As Integer , Group As Integer ,  Start As Integer, Priority As Integer, Volume As Integer, Frequency As Integer, Pan As Integer) As Integer

'-----------------------------------------------------------------------------
' Создание и воспроизведение позиционного (трехмерного) звукового канала из
' указаного семпла, опираясь на параметры семпла по умолчанию
' на входе    :  SampleID       -  идентификатор семпла
'                Loop           -  флаг зацикленности воспроизведения, параметр
'                                  может принимать следующие значения:
'                                  true  -  воспроизводить канал в цикле
'                                           бесконечно
'                                  false -  воспроизвести канал один раз
'                ChannelGroupID -  принадлежность создаваемого канала к группе
'                                  каналов, если значение параметра равно 0
'                                  значит звуковой канал не принадлежит группе
'                                  каналов.
'                Start          -  флаг запуска звука по окончанию создания
'                                  канала, параметр может принимать следующие
'                                  значения:
'                                  true  -  канал начнет воспроизводится сразу
'                                           после создания
'                                  false -  канал будет только подготовлен,
'                                           для того чтобы начать воспроизведение
'                                           нужно вызвать метод
'                                           SQUALL_Channel_Start()
'                Position       -  указатель на структуру c координатами
'                                  источника звукового канала
'                Velocity       -  указатель на вектор скорости источника
'                                  звукового канала, в случае если значение
'                                  вектора скорости устанавливать не надо,
'                                  то данный параметр должен быть равен 0
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит идентификатор
'                созданного звукового канала
'-----------------------------------------------------------------------------
Declare Function SQUALL_Sample_Play3D Lib "Squall"  Alias "SQUALL_Sample_Play3D" (SampleID As Integer , Loop_ As Integer , Group As Integer ,  Start As Integer, Position As Single Ptr, Velocity As Single Ptr) As Integer

'-----------------------------------------------------------------------------
' Создание и воспроизведение позиционного (трехмерного) звукового канала из
' указаного семпла
' на входе    :  SampleID       -  идентификатор семпла
'                Loop           -  флаг зацикленности воспроизведения, параметр
'                                  может принимать следующие значения:
'                                  true  -  воспроизводить канал в цикле
'                                           бесконечно
'                                  false -  воспроизвести канал один раз
'                ChannelGroupID -  принадлежность создаваемого канала к группе
'                                  каналов, если значение параметра равно 0
'                                  значит звуковой канал не принадлежит группе
'                                  каналов.
'                Start          -  флаг запуска звука по окончанию создания
'                                  канала, параметр может принимать следующие
'                                  значения:
'                                  true  -  канал начнет воспроизводится сразу
'                                           после создания
'                                  false -  канал будет только подготовлен,
'                                           для того чтобы начать воспроизведение
'                                           нужно вызвать метод
'                                           SQUALL_Channel_Start()
'                Position       -  указатель на структуру c координатами
'                                  источника звукового канала
'                Velocity       -  указатель на вектор скорости источника
'                                  звукового канала, в случае если значение
'                                  вектора скорости устанавливать не надо,
'                                  то данный параметр должен быть равен 0
'                Priority       -  приоритет создаваемого звукового канала,
'                                  значение параметра должно лежать в пределах
'                                  от 0 до 65535
'                Volume         -  громкость создаваемого звукового канала,
'                                  в процентах, значение параметра должно
'                                  лежать в пределах от 0 до 100
'                Frequency      -  частота дискретизации звукового канала,
'                                  значение параметра должно лежать в пределах
'                                  от 100 до 1000000000
'                MinDist        -  минимальное растояние слышимости звукового
'                                  канала, значение параметра должно быть в
'                                  пределах от 0.01f до 1000000000.0f
'                MaxDist        -  максимальное растояние слышимости звукового
'                                  канала, значение параметра должно быть в
'                                  пределах от 0.01f до 1000000000.0f
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит идентификатор
'                созданного звукового канала
'-----------------------------------------------------------------------------
Declare Function SQUALL_Sample_Play3DEx Lib "Squall"  Alias "SQUALL_Sample_Play3DEx" (SampleID As Integer , Loop_ As Integer , Group As Integer ,  Start As Integer, Position As Single Ptr, Velocity As Single Ptr, Priority As Integer, Volume As Integer, Frequency As Integer, MinDist As Single, MaxDist As Single) As Integer

'-----------------------------------------------------------------------------
' Включение/выключение паузы всех каналов использующих указаный семпл
' на входе    :  SampleID -  указатель на данные звука
'                Pause    -  флаг включения/выключения паузы, параметр может
'                            принимать следующие значения:
'                            true   - включить паузу
'                            false  - выключить паузу
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Sample_Pause Lib "Squall"  Alias "SQUALL_Sample_Pause" (SampleID As Integer , Pause_ As Integer) As Integer

'-----------------------------------------------------------------------------
' Остановка всех звуковых каналов использующих указанный семпл
' на входе    :  SampleID -  идентификатор семпла
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'-----------------------------------------------------------------------------
Declare Function SQUALL_Sample_Stop Lib "Squall"  Alias "SQUALL_Sample_Stop" (SampleID As Integer) As Integer

'''''''''''''''''''''''''''''''''''''''/
'''''''''''''''''''''''''''''''''''''''/
'                Методы для работы с группами семплов
'''''''''''''''''''''''''''''''''''''''/
'''''''''''''''''''''''''''''''''''''''/
'-----------------------------------------------------------------------------
' Создание и воспроизведения рассеяного канала из группы семплов, опираясь
' на параметры семпла по умолчанию
' на входе    :  SampleGroupID  -  идентификатор группы семплов
'                Loop           -  флаг зацикленности воспроизведения, параметр
'                                  может принимать следующие значения:
'                                  true  -  воспроизводить канал в цикле
'                                           бесконечно
'                                  false -  воспроизвести канал один раз
'                ChannelGroupID -  принадлежность создаваемого канала к группе
'                                  каналов, если значение параметра равно 0
'                                  значит звуковой канал не принадлежит группе
'                                  каналов.
'                Start          -  флаг запуска звука по окончанию создания
'                                  канала, параметр может принимать следующие
'                                  значения:
'                                  true  -  канал начнет воспроизводится сразу
'                                           после создания
'                                  false -  канал будет только подготовлен,
'                                           для того чтобы начать воспроизведение
'                                           нужно вызвать метод
'                                           SQUALL_Channel_Start()
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит идентификатор
'                созданного звукового канала
'-----------------------------------------------------------------------------
Declare Function SQUALL_SampleGroup_Play Lib "Squall"  Alias "SQUALL_SampleGroup_Play" (SoundGroupID As Integer, Loop_ As Integer, Group As Integer, Start As Integer) As Integer

'-----------------------------------------------------------------------------
' Создание и воспроизведения рассеяного канала из группы семплов
' на входе    :  SampleGroupID  -  идентификатор группы семплов
'                Loop           -  флаг зацикленности воспроизведения, параметр
'                                  может принимать следующие значения:
'                                  true  -  воспроизводить канал в цикле
'                                           бесконечно
'                                  false -  воспроизвести канал один раз
'                ChannelGroupID -  принадлежность создаваемого канала к группе
'                                  каналов, если значение параметра равно 0
'                                  значит звуковой канал не принадлежит группе
'                                  каналов.
'                Start          -  флаг запуска звука по окончанию создания
'                                  канала, параметр может принимать следующие
'                                  значения:
'                                  true  -  канал начнет воспроизводится сразу
'                                           после создания
'                                  false -  канал будет только подготовлен,
'                                           для того чтобы начать воспроизведение
'                                           нужно вызвать метод
'                                           SQUALL_Channel_Start()
'                Priority       -  приоритет создаваемого звукового канала,
'                                  значение параметра должно лежать в пределах
'                                  от 0 до 65535
'                Volume         -  громкость создаваемого звукового канала,
'                                  в процентах, значение параметра должно
'                                  лежать в пределах от 0 до 100
'                Frequency      -  частота дискретизации звукового канала,
'                                  значение параметра должно лежать в пределах
'                                  от 100 до 1000000000
'                Pan            -  панорама создаваемого звукового канала,
'                                  значение параметра должно лежать в пределах
'                                  от 0 до 100
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит идентификатор
'                созданного звукового канала
'-----------------------------------------------------------------------------
Declare Function SQUALL_SampleGroup_PlayEx Lib "Squall"  Alias "SQUALL_SampleGroup_PlayEx" (SoundGroupID As Integer, Loop_ As Integer, Group As Integer, Start As Integer, Priority As Integer, Volume As Integer, Frequency As Integer, Pan As Integer) As Integer

'-----------------------------------------------------------------------------
' Создание и воспроизведение позиционного (трехмерного) звукового канала из
' указаной группы семплов, опираясь на параметры семпла по умолчанию
' на входе    :  SampleGroupID  -  идентификатор группы семплов
'                Loop           -  флаг зацикленности воспроизведения, параметр
'                                  может принимать следующие значения:
'                                  true  -  воспроизводить канал в цикле
'                                           бесконечно
'                                  false -  воспроизвести канал один раз
'                ChannelGroupID -  принадлежность создаваемого канала к группе
'                                  каналов, если значение параметра равно 0
'                                  значит звуковой канал не принадлежит группе
'                                  каналов.
'                Start          -  флаг запуска звука по окончанию создания
'                                  канала, параметр может принимать следующие
'                                  значения:
'                                  true  -  канал начнет воспроизводится сразу
'                                           после создания
'                                  false -  канал будет только подготовлен,
'                                           для того чтобы начать воспроизведение
'                                           нужно вызвать метод
'                                           SQUALL_Channel_Start()
'                Position       -  указатель на структуру c координатами
'                                  источника звукового канала
'                Velocity       -  указатель на вектор скорости источника
'                                  звукового канала, в случае если значение
'                                  вектора скорости устанавливать не надо,
'                                  то данный параметр должен быть равен 0
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит идентификатор
'                созданного звукового канала
'-----------------------------------------------------------------------------
Declare Function SQUALL_SampleGroup_Play3D Lib "Squall"  Alias "SQUALL_SampleGroup_Play3D" (SoundGroupID As Integer, Loop_ As Integer, Group As Integer, Start As Integer, Position As Single Ptr, Velocity As Single Ptr) As Integer

'-----------------------------------------------------------------------------
' Создание и воспроизведение позиционного (трехмерного) звукового канала из
' указаной группы семплов
' на входе    :  SampleGroupID  -  идентификатор группы семплов
'                Loop           -  флаг зацикленности воспроизведения, параметр
'                                  может принимать следующие значения:
'                                  true  -  воспроизводить канал в цикле
'                                           бесконечно
'                                  false -  воспроизвести канал один раз
'                ChannelGroupID -  принадлежность создаваемого канала к группе
'                                  каналов, если значение параметра равно 0
'                                  значит звуковой канал не принадлежит группе
'                                  каналов.
'                Start          -  флаг запуска звука по окончанию создания
'                                  канала, параметр может принимать следующие
'                                  значения:
'                                  true  -  канал начнет воспроизводится сразу
'                                           после создания
'                                  false -  канал будет только подготовлен,
'                                           для того чтобы начать воспроизведение
'                                           нужно вызвать метод
'                                           SQUALL_Channel_Start()
'                Position       -  указатель на структуру c координатами
'                                  источника звукового канала
'                Velocity       -  указатель на вектор скорости источника
'                                  звукового канала, в случае если значение
'                                  вектора скорости устанавливать не надо,
'                                  то данный параметр должен быть равен 0
'                Priority       -  приоритет создаваемого звукового канала,
'                                  значение параметра должно лежать в пределах
'                                  от 0 до 65535
'                Volume         -  громкость создаваемого звукового канала,
'                                  в процентах, значение параметра должно
'                                  лежать в пределах от 0 до 100
'                Frequency      -  частота дискретизации звукового канала,
'                                  значение параметра должно лежать в пределах
'                                  от 100 до 1000000000
'                MinDist        -  минимальное растояние слышимости звукового
'                                  канала, значение параметра должно быть в
'                                  пределах от 0.01f до 1000000000.0f
'                MaxDist        -  максимальное растояние слышимости звукового
'                                  канала, значение параметра должно быть в
'                                  пределах от 0.01f до 1000000000.0f
' на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
'                вызов состоялся, иначе результат содержит код ошибки
'                в случае успешного вызова результат содержит идентификатор
'                созданного звукового канала
'-----------------------------------------------------------------------------
Declare Function SQUALL_SampleGroup_Play3DEx Lib "Squall"  Alias "SQUALL_SampleGroup_Play3DEx" (SoundGroupID As Integer, Loop_ As Integer, Group As Integer, Start As Integer, Position As Single Ptr, Velocity As Single Ptr, Priority As Integer, Volume As Integer, Frequency As Integer, MinDist As Single, MaxDist As Single) As Integer

End Extern
