unit Squall;

interface

uses windows;

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

// настройки слушателя
 SQUALL_LISTENER_MODE_IMMEDIATE: Integer = 0;          // настройки пересчитываются немедленно
 SQUALL_LISTENER_MODE_DEFERRED: Integer =  1;          // настройки пересчитываются только после вызова метода Listener_Update

// Способы обработки трехмерного звука
 SQUALL_ALG_3D_DEFAULT: Integer =          0;          // алгоритм по умолчанию
 SQUALL_ALG_3D_OFF: Integer =              1;          // 2D алгоритм
 SQUALL_ALG_3D_FULL: Integer =             2;          // полноценный 3D алгоритм
 SQUALL_ALG_3D_LIGTH: Integer =            3;          // облегченный 3D алгоритм

// флаги описывающие возможности устройства воспроизведения
 SQUALL_DEVICE_CAPS_HARDWARE: Integer =    $00000001;  // устройство поддерживает аппаратное смешивание каналов
 SQUALL_DEVICE_CAPS_HARDWARE_3D: Integer = $00000002;  // устройство поддерживает аппаратное смешивание 3D каналов
 SQUALL_DEVICE_CAPS_EAX10: Integer =       $00000004;  // устройство поддреживает EAX 1.0
 SQUALL_DEVICE_CAPS_EAX20: Integer =       $00000008;  // устройство поддерживает EAX 2.0
 SQUALL_DEVICE_CAPS_EAX30: Integer =       $00000010;  // устройство поддерживает EAX 3.0
 SQUALL_DEVICE_CAPS_ZOOMFX: Integer =      $00000100;  // устройство поддерживает ZOOMFX

// флаги описывающие конфигурацию аккустики
 SQUALL_SPEAKER_DEFAULT: Integer =         $00000000;  // аккустика по умолчанию
 SQUALL_SPEAKER_HEADPHONE: Integer =       $00000001;  // наушники (головные телефоны)
 SQUALL_SPEAKER_MONO: Integer =            $00000002;  // моно колонка (1.0)
 SQUALL_SPEAKER_STEREO: Integer =          $00000003;  // стерео колонки (2.0)
 SQUALL_SPEAKER_QUAD: Integer =            $00000004;  // квадро колонки (4.0)
 SQUALL_SPEAKER_SURROUND: Integer =        $00000005;  // квадро система с буфером низких эффектов (4.1)
 SQUALL_SPEAKER_5POINT1: Integer =         $00000006;  // пяти канальная система с буфером низких эффектов (5.1)

// статус канала
 SQUALL_CHANNEL_STATUS_NONE: Integer =     0;          // канала нет
 SQUALL_CHANNEL_STATUS_PLAY: Integer =     1;          // канал в режиме воспроизведения
 SQUALL_CHANNEL_STATUS_PAUSE: Integer =    2;          // канал в режиме паузы
 SQUALL_CHANNEL_STATUS_PREPARED: Integer = 3;          // канал в подготовленном состоянии

// значения флагов слушателя в EAX начиная с версии 2.0
 SQUALL_EAX_LISTENER_FLAGS_DECAYTIMESCALE: Integer =          $00000001;
 SQUALL_EAX_LISTENER_FLAGS_REFLECTIONSSCALE: Integer =        $00000002;
 SQUALL_EAX_LISTENER_FLAGS_REFLECTIONSDELAYSCALE: Integer =   $00000004;
 SQUALL_EAX_LISTENER_FLAGS_REVERBSCALE: Integer =             $00000008;
 SQUALL_EAX_LISTENER_FLAGS_REVERBDELAYSCALE: Integer =        $00000010;
 SQUALL_EAX_LISTENER_FLAGS_DECAYHFLIMIT: Integer =            $00000020;

// значения флагов слушателя в EAX начиная версии 3.0
 SQUALL_EAX_LISTENER_FLAGS_ECHOTIMESCALE: Integer =           $00000040;
 SQUALL_EAX_LISTENER_FLAGS_MODULATIONTIMESCALE: Integer =     $00000080;

// значение флагов слушателя в EAX начиная с версии 2.0 по умолчанию
 SQUALL_EAX_LISTENER_FLAGS_DEFAULT: Integer =                 $0000003f;

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

// значения флагов канала в EAX начиная с версии 2.0
 SQUALL_EAX_CHANNEL_FLAGS_DIRECTHFAUTO: Integer =             $00000001;
 SQUALL_EAX_CHANNEL_FLAGS_ROOMAUTO: Integer =                 $00000002;
 SQUALL_EAX_CHANNEL_FLAGS_ROOMHFAUTO: Integer =               $00000004;
 SQUALL_EAX_CHANNEL_FLAGS_DEFAULT: Integer =                  $00000007;

type
// структура для описания настроек двигателя
 squall_parameters_t = record
  Window: PHandle;                                // окно к которому нужно прикреплять двигатель
  Device: Integer;                                // номер устройства воспроизведения
  SampleRate: Integer;                            // частота дискретизации
  BitPerSample: Integer;                          // количество бит на выборку
  Channels: Integer;                              // максимальное количество каналов
  UseHW2D: Integer;                               // использование аппаратной акселерации для рассеянных каналов
  UseHW3D: Integer;                               // использование аппаратной акселерации для точечных каналов
  UseAlg: Integer;                                // используемый трехмерный алгоритм
  BufferSize: Integer;                            // размер вторичного буфера в миллисекундах
  ListenerMode: Integer;                          // промежуток времени через который будет происходить обновление
  DistanceFactor: Single;                         // фактор дистанции
  RolloffFactor: Single;                          // фактор удаления
  DopplerFactor: Single;                          // эффект Допплера
 end;

// структура описывающая параметры звука по умолчанию
 squall_sample_default_t = record
  SampleGroupID: Integer;                         // принадлежность семпла к группе
  Priority: Integer;                              // приоритет звука по умолчанию
  Frequency: Integer;                             // частота звука по умолчанию
  Volume: Integer;                                // громкость звука по умолчанию
  Pan: Integer;                                   // панорама звука по умолчанию
  MinDist: Single;                                // минимальная граница слышимости по умолчанию
  MaxDist: Single;                                // максимальная граница слышимости по умолчанию
 end;

// структура описывающая текущее состояние каналов
 squall_channels_t = record
  Play: Integer;                                  // количество воспроизводящихся рассеянных каналов
  Pause: Integer;                                 // количество стоящих в паузе рассеянных каналов
  Prepare: Integer;                               // количество подготовленных рассеянных каналов
  Play3D: Integer;                                // количество воспроизводящихся позиционных каналов
  Pause3D: Integer;                               // количество стоящих в паузе позиционных каналов
  Prepare3D: Integer;                             // количество подготовленных позиционных каналов
 end;

// структура описывающая параметры устройства воспроизведения
 squall_device_caps_t = record
  Flags: Integer;                                 // флаги определяющие свойства устройства
  HardwareChannels: Integer;                      // количество аппаратных каналов
  Hardware3DChannels: Integer;                    // количество аппаратных 3D каналов
 end;

// структура параметров EAX слушателя
 squall_eax_listener_t = record
  case Integer of
  0:
   (// параметры EAX 1.0
    eax1: record
    Environment: Cardinal;
    Volume: Single;
    DecayTime_sec: Single;
    Damping: Single;
    end;
   );
  1:
   (// параметры EAX 2.0
    eax2: record
     Room: Integer;
     RoomHF: Integer;
     RoomRolloffFactor: Single;
     DecayTime: Single;
     DecayHFRatio: Single;
     Reflections: Integer;
     ReflectionsDelay: Single;
     Reverb: Integer;
     ReverbDelay: Single;
     Environment: Cardinal;
     EnvironmentSize: Single;
     EnvironmentDiffusion: Single;
     AirAbsorptionHF: Single;
     Flags: Cardinal;
    end;
   );
  2:
   (// параметры EAX 3.0
    eax3: record
     Environment: Cardinal;
     EnvironmentSize: Single;
     EnvironmentDiffusion: Single;
     Room: Integer;
     RoomHF: Integer;
     RoomLF: Integer;
     DecayTime: Single;
     DecayHFRatio: Single;
     DecayLFRatio: Single;
     Reflections: Integer;
     ReflectionsDelay: Single;
     ReflectionsPan: array [0..2] of Single;
     Reverb: Integer;
     ReverbDelay: Single;
     ReverbPan: array [0..2] of Single;
     EchoTime: Single;
     EchoDepth: Single;
     ModulationTime: Single;
     ModulationDepth: Single;
     AirAbsorptionHF: Single;
     HFReference: Single;
     LFReference: Single;
     RoomRolloffFactor: Single;
     Flags: Cardinal;
    end;
   );
 end;

// Cтруктура EAX параметров канала
 squall_eax_channel_t = record
  case Integer of
  0:
   (// EAX 1.0
    eax1: record
     Mix: Single;
    end;
   );
  1:
   (// EAX 2.0
    eax2: record
     Direct: Integer;
     DirectHF: Integer;
     Room: Integer;
     RoomHF: Integer;
     RoomRolloffFactor: Single;
     Obstruction: Integer;
     ObstructionLFRatio: Single;
     Occlusion: Integer;
     OcclusionLFRatio: Single;
     OcclusionRoomRatio: Single;
     OutsideVolumeHF: Integer;
     AirAbsorptionFactor: Single;
     Flags: Cardinal
    end;
   );
  2:
   (//  EAX 3.0
    eax3: record
     Direct: Integer;
     DirectHF: Integer;
     Room: Integer;
     RoomHF: Integer;
     Obstruction: Integer;
     ObstructionLFRatio: Single;
     Occlusion: Integer;
     OcclusionLFRatio: Single;
     OcclusionRoomRatio: Single;
     OcclusionDirectRatio: Single;
     Exclusion: Integer;
     ExclusionLFRatio: Single;
     OutsideVolumeHF: Integer;
     DopplerFactor: Single;
     RolloffFactor: Single;
     RoomRolloffFactor: Single;
     AirAbsorptionFactor: Single;
     Flags: Cardinal;
    end;
   );
 end;

// структура ZOOMFX параметров источника звука
 squall_zoomfx_channel_t = record
  Min: array [0..2] of Single;
  Max: array [0..2] of Single;
  Front: array [0..2] of Single;
  Top: array [0..2] of Single;
  MacroFX: Integer;
 end;

 psquall_parameters_t = ^squall_parameters_t;
 psquall_sample_default_t = ^squall_sample_default_t;
 psquall_eax_listener_t = ^squall_eax_listener_t;
 psquall_eax_channel_t = ^squall_eax_channel_t;
 psquall_zoomfx_channel_t = ^squall_zoomfx_channel_t;
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//                 Методы инициализация / освобождения
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
// Инициализация звуковой системы Шквал
// на входе    :  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,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Init(SystemParam: psquall_parameters_t): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Освобождение занятых звуковой системой ресурсов
// на входе    :  *
// на выходе   :  *
//-----------------------------------------------------------------------------
procedure SQUALL_Free();cdecl; external 'squall.dll';

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//                  Методы для управления двигателем
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
// Включение/выключение паузы всех звуковых каналов
// на входе    :  Pause -  флаг включения/выключения паузы
//                         параметр может принимать слудующие значения
//                         true  - включить паузу
//                         false - выключить паузу
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Pause(Pause: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Остановка всех звуковых каналов
// на входе    :  *
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Stop(): Integer; cdecl; external 'squall.dll';

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//                    Методы для настройки двигателя
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
// Установка нового устройства воспроизведения
// на входе    :  Num   -  номер нового устройства воспроизведения, значение
//                         параметра должно быть в пределах от 0 до значения
//                         полученного с помощью метода SQUALL_GetNumDevice.
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_SetDevice(Num: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение номера текущего устройства воспроизведения
// на входе    :  *
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит номер текущего
//                устройства воспроизведения
//-----------------------------------------------------------------------------
function SQUALL_GetDevice(): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Включение/выключение использования аппаратной акселерации звука
// на входе    :  UseHW2D  -  флаг определяющий использование аппаратной
//                            акселерации рассеянных звуковых каналов,
//                            параметр может принимать следующие значения:
//                            true   - использовать аппаратную акселерацию
//                            false  - не использовать аппаратную акселерацию
//                UseHW3D  -  флаг определяющий использование аппаратной
//                            акселерации позиционных звуковых каналов
//                            параметр может принимать следующие значения:
//                            true   - использовать аппаратную акселерацию
//                            false  - не использовать аппаратную акселерацию
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_SetHardwareAcceleration(UseHW2D,UseHW3D: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение текущих настроек использования аппаратной акселерации звука
// на входе    :  UseHW2D  -  указатель на переменную в которую нужно поместить
//                            текущее значение использования аппаратной
//                            акселерации для рассеянных звуковых каналов
//                UseHW3D  -  указатель на переменную в которую нужно поместить
//                            текущее значение использования аппаратной
//                            акселерации для позиционных звуковых каналов
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_GetHardwareAcceleration(var UseHW2D, UseHW3D: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка режима аккустики
// на входе    :  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,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_SetSpeakerMode(Mode: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
//	Получение текущего режима аккустики
//	на входе    :  *
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит номер текущего
//                режима аккустики
//-----------------------------------------------------------------------------
function SQUALL_GetSpeakerMode(): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка алгоритма расчета трехмерного звука
// на входе    :  Algoritm -  код применяемого алгоритма расчета звука
//                            параметр может принимать следуюшие значения:
//                            SQUALL_ALG_3D_DEFAULT - алгоритм по умолчанию
//                            SQUALL_ALG_3D_OFF     - 2D алгоритм
//                            SQUALL_ALG_3D_FULL    - полноценный 3D алгоритм
//                            SQUALL_ALG_3D_LIGTH   - облегченный 3D алгоритм
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Set3DAlgorithm(Algorithm: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получения текущего алгоритма расчета трехмерного звука
// на входе    :  *
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит номер текущего
//                алгоритма расчета трехмерного звука, результат может
//                принимать слудующие значения:
//                SQUALL_ALG_3D_DEFAULT - алгоритм по умолчанию
//                SQUALL_ALG_3D_OFF     - 2D алгоритм
//                SQUALL_ALG_3D_FULL    - полноценный 3D алгоритм
//                SQUALL_ALG_3D_LIGTH   - облегченный 3D алгоритм
//-----------------------------------------------------------------------------
function SQUALL_Get3DAlgorithm(): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка нового размера звукового буфера в милисекундах
// на входе    :  BufferSize  -  новый размер звукового буфера, в милисекундах
//                               параметр должен лежать в пределах от 200
//                               до 5000
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_SetBufferSize(BufferSize: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение текущего размера звукового буфера в милисекундах
// на входе    :  *
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит текущий размер
//                звукового буфера в милисекундах
//-----------------------------------------------------------------------------
function SQUALL_GetBufferSize(): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка внешней системы работы с памятью
// на входе    :  UserAlloc   -  указатель на внешний метод выделения памяти
//                UserFree    -  указатель на внешний метод освобождения памяти
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_SetMemoryCallbacks(UserAlloc,UserFree: pointer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка внешних методов для работы с файлами
// на входе    :  UserOpen    -  указатель на внешний метод открытия файлов
//                UserSeek    -  указатель на внешний метод позиционирования
//                               в открытом файле
//                UserRead    -  указатель на внешний метод чтения данных из
//                               открытого файла
//                UserClose   -  указатель на внешний метод закрытия открытого
//                               файла
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_SetFileCallbacks(UserOpen,UserSeek,UserRead,UserClose: Pointer): Integer; cdecl; external 'squall.dll';

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//              Методы для получения информация о системе
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
// Получение количества устройств воспроизведения звука
// на входе    :  *
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки.
//                в случае успешного вызова результат содержит количество
//                устройств воспроизведения в системе. Если в системе нет
//                устройств воспроизведения результат будет равен 0.
//-----------------------------------------------------------------------------
function SQUALL_GetNumDevice(): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение имени устройства по указаному номеру
// на входе    :  Num      -  номер устройства, значение параметра должно быть
//                            в пределах от 0 до значения полученного с помощью
//                            метода SQUALL_GetNumDevice.
//                Buffer   -  указатель на буфер куда нужно поместить имя
//                            устройства воспроизведения
//                Size     -  размер принимающего буфера в байтах
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_GetDeviceName(Num: Integer; Buffer: PAnsiChar; Size: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение свойств устройства воспроизведения по указаному номеру
// на входе    :  Num   -  номер устройства, значение параметра должно быть в
//                         пределах от 0 до значения полученного с помощью
//                         метода SQUALL_GetNumDevice.
//                Caps  -  указатель на структуру в которую нужно поместить
//                         свойства устройства воспроизведения
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_GetDeviceCaps(Num: Integer; var Caps:squall_device_caps_t): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение используемой версии EAX интерфейса
// на входе    :  *
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит максимально
//                доступную версию EAX
//-----------------------------------------------------------------------------
function SQUALL_GetEAXVersion(): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение информации о каналах
// на входе    :  Info  -  указатель на структуру в которую нужно поместить
//                         информацию о состоянии каналов
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_GetChannelsInfo(var info: squall_channels_t): Integer; cdecl; external 'squall.dll';

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//                    Методы для работы со слушателем
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
// Установка новых параметров слушателя
// на входе    :  Position -  указатель на структуру с новыми координатами
//                            позиции слушателя. В случае если позицию слушателя
//                            изменять не нужно, то данный параметр должен
//                            содержать 0 
//                Front    -  указатель на структуру с новым вектором 
//                            фронтального направления слушателя. В случае еслт
//                            вектор фронтального направления слушателя изменять
//                            не нужно, то данный парамерт должен содержать 0
//                Top      -  указатель на структуру с новым вектором
//                            вертикального направления слушателя. В случае если
//                            вектор вертикального направления изменять не нужно,
//                            то данный параметр должен содержать 0
//                Velocity -  указатель на структуру с новым вектором
//                            скорости перемещения слушателя. В случае если
//                            скорость перемещения слушателя изменять не нужно,
//                            то данный параметр должен содержать 0.
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Listener_SetParameters(Position,Front,Top,Velocity: PSingle): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение текущих параметров слушателя
// на входе    :  Position -  указатель на структуру в которую нужно
//                            поместить текущие координаты слушателя. В случае
//                            если значение координат слушателя не требуется
//                            определять, то данный параметр должен содержать 0.
//                Front    -  указатель на структуру в которую нужно
//                            поместить текущий вектор фронтального
//                            направления слушателя. В случае если вектор
//                            фронтального направления слушателя не требуется
//                            определять, то данный параметр должен содержать 0.
//                Top      -  указатель на структуру в которую нужно
//                            поместить текущий вектор вертикального
//                            направления слушателя. В случае если вектор
//                            вертикального направления слушателя не требуется
//                            определять, то данный параметр должен содержать 0.
//                Velocity -  указатель на структуру в которую нужно
//                            поместить текущий вектор скорости перемещения
//                            слушателя. В случае если скорость перемещения
//                            слушателя не требуется определять, то данный
//                            параметр должен содержать 0.
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Listener_GetParameters(var Position,Front,Top,Velocity: PSingle): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка новой скорости перемещения слушателя
// на входе    :  Velocity -  указатель на структуру с новым вектором
//                            скорости перемещения слушателя.
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Listener_SetVelocity(Velocity: PSingle): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение текущей скорости перемещения слушателя
// на входе    :  Velocity - указатель на структуру в которую нужно
//                           поместить текущий вектор скорости перемещения
//                           слушателя.
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Listener_GetVelocity(var Velocity: PSingle): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка новой позиции слушателя в пространстве
// на входе    :  Position -  указатель на структуру с новым вектором
//                            скорости перемещения слушателя.
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Listener_SetPosition(Position: PSingle): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение текущей позиции слушателя в пространстве
// на входе    :  Position -  указатель на структуру в которую нужно
//                            поместить текущий вектор скорости перемещения
//                            слушателя.
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Listener_GetPosition(var Position: PSingle): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка нового коэффициента преобразования дистанции
// на входе    :  DistanceFactor -  новый коэффициент преобразования дистанции
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Listener_SetDistanceFactor(DistanceFactor: Single): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение текущего коэффициента преобразования дистанции
// на входе    :  DistanceFactor -  указатель на переменную в которую нужно
//                                  поместить текущий коэффициент
//                                  преобразования дистанции
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Listener_GetDistanceFactor(var DistanceFactor: Single): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка нового коэффициента затухания звука в зависимости от растояния
// на входе    :  RolloffFactor  -  новый коэффициент преобразования затухания
//                                  звука,  значение параметра должно быть
//                                  в пределах от 0.1f до 10.0f
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Listener_SetRolloffFactor(RolloffFactor: Single): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение текущего коэффициента затухания звука в зависимости от растояния
// на входе    :  RolloffFactor  -  указатель на переменную в которую нужно
//                                  поместить текущий коэффициент преобразования
//                                  затухания звука
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Listener_GetRolloffFactor(var RolloffFactor: Single): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка нового коэффициента эффекта Допплера
// на входе    :  DopplerFactor  -  новый коэффициент эффекта Допплера, значение
//                                  параметра должно быть в пределах от 0.1f
//                                  до 10.0f
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Listener_SetDopplerFactor(DopplerFactor: Single): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение текущего коэффициента эффекта Допплера
// на входе    :  DopplerFactor  -  указатель на переменную в которую нужно
//                                  поместить текущий коэффициент эффекта
//                                  Допплера
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Listener_GetDopplerFactor(var DopplerFactor: Single): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Обновление трехмерных настроек
// на входе    :  *
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
// примечание  :  данный метод имеет смысл применять только в том случае когда
//                слушатель настроен на принудительное обновление трехмерных
//                настроек. По есть при инициализации двигателя слушатель
//                переведен в режим SQUALL_LISTENER_MODE_DEFERRED
//-----------------------------------------------------------------------------
function SQUALL_Listener_Update(): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка предустановленных значения окружения
// на входе    :  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,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Listener_EAX_SetPreset(Preset: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка новых EAX параметров слушателя
// на входе    :  Version     -  номер версии EAX интерфейса
//                Properties  -  указатель на структуру с новыми EAX параметрами
//                               слушателя
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Listener_EAX_SetProperties(Version: Integer;Properties: psquall_eax_listener_t): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение текущих EAX параметров слушателя
// на входе    :  Version     -  номер версии EAX интерфейса
//                Properties  -  указатель на структуру куда надо поместить
//                               текущие EAX параметры слушателя
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Listener_EAX_GetProperties(Version: Integer;var Properties: squall_eax_listener_t): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка обработчика слушателя
// на входе    :  Worker      -  указатель на обработчик слушателя, в случае
//                               если параметр равен 0, предедущий обработчик
//                               будет удален.
//                Param       -  указатель на данные пользователя, в случае
//                               данных пользователя нет, то данный параметр
//                               может содержать 0
//                UpdateTime  -  промежуток времени через который нужно
//                               вызывать обработчик параметр должен лежать
//                               в пределах от 1 до 5000
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Listener_SetWorker(Worker,Param: Pointer;UpdateTime: Cardinal): Integer; cdecl; external 'squall.dll';

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//                   Общие методы для работы с каналами
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
// Начало воспроизведения подготовленного звукового канала
// на входе    :  ChannelID   -  идентификатор подготовленного канала
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Channel_Start(ChannelID: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Включение/выключение паузы звукового канала
// на входе    :  ChannelID   -  идентификатор звукового канала
//                Pause       -  флаг включения/выключения паузы, параметр может
//                               принимать следующие значения:
//                               true  - включить паузу
//                               false - выключить паузу
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Channel_Pause(ChannelID,Pause: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Остановка звукового канала по идентификатору
// на входе    :  ChannelID   -  идентификатор звукового канала
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Channel_Stop(ChannelID: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение статуса звукового канала
// на входе    :  ChannelID   -  идентификатор звукового канала
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит статус канала,
//                результат может принимать следующие значения:
//                SQUALL_CHANNEL_STATUS_NONE       -  звукового канала с таким
//                                                    идентификатором нет
//                SQUALL_CHANNEL_STATUS_PLAY       -  звуковой канал
//                                                    воспроизводится
//                SQUALL_CHANNEL_STATUS_PAUSE      -  звуковой канал находится
//                                                    в режиме паузы
//                SQUALL_CHANNEL_STATUS_PREPARED   -  звуковой канал
//                                                    подготовлен
//-----------------------------------------------------------------------------
function SQUALL_Channel_Status(ChannelID: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка нового уровня громкости звукового канала в процентах
// на входе    :  ChannelID   -  идентификатор звукового канала
//                Volume      -  значение уровня громкости в провентах,
//                               значение ппараметра должно быть в пределах
//                               от 0 до 100
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Channel_SetVolume(ChannelID,Volume: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение текущего уровня громкости звукового канала в процентах
// на входе    :  ChannelID   -  идентификатор канала
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит текущее значение
//                громкости канала в процентах
//-----------------------------------------------------------------------------
function SQUALL_Channel_GetVolume(ChannelID: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Устанока новой частоты дискретизации звукового канала
// на входе    :  ChannelID   -  идентификатор звукового канала
//                Frequency   -  новое значение частоты дискретизации, значение
//                               параметра должно быть в пределах от 100 Герц
//                               до 1000000 Герц
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Channel_SetFrequency(ChannelID,Frequency: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение текущей частоты дискретизации звукового канала
// на входе    :  ChannelID   -  идентификатор звукового канала
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит текущее значение
//                частоты дискретизации звукового канала
//-----------------------------------------------------------------------------
function SQUALL_Channel_GetFrequency(ChannelID: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка новой позиции воспроизведения звукового канала в семплах
// на входе    :  ChannelID   -  идентификатор звукового канала
//                Position    -  новое значение позиции воспроизведения
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Channel_SetPlayPosition(ChannelID,Position: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение текущей позиции воспроизведения звукового канала в семплах
// на входе    :  ChannelID   -  идентификатор звукового канала
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит текущую позицию
//                воспроизведения
//-----------------------------------------------------------------------------
function SQUALL_Channel_GetPlayPosition(ChannelID: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка новой позиции воспроизведения звукового канала в миллисекундах
// на входе    :  ChannelID   -  идентификатор звукового канала
//                Position    -  новое значение позиции воспроизведения,
//                               в миллисекундах
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Channel_SetPlayPositionMs(ChannelID,Position: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение текущей позиции воспроизведения звукового канала в миллисекундах
// на входе    :  ChannelID   -  идентификатор звукового канала
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит текущую позицию
//                воспроизведения
//-----------------------------------------------------------------------------
function SQUALL_Channel_GetPlayPositionMs(ChannelID: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка обработчика звукового канала
// на входе    :  ChannelID   -  идентификатор звукового канала
//                Worker      -  указатель на обработчик звукового канала
//                Param       -  указатель на данные пользователя, в случае
//                               если данных пользователя нет, параметр может
//                               содержать 0
//                UpdateTime  -  промежуток времени в миллисекундах через
//                               который нужно вызывать обработчик, значение
//                               параметра должно быть в пределах от 1 до 5000
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Channel_SetWorker(ChannelID: Integer;Worker,Param: Pointer;UpdateTime: Cardinal): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка новых границ фрагмента звукового канала в семплах
// на входе    :  ChannelID   -  идентификатор звукового канала
//                Start       -  начальная позиция фрагмента, в отсчетах
//                End         -  конечная позиция фрагмента, в отсчетах
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Channel_SetFragment(ChannelID,Start,Endp: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение текущих границ фрагмента звукового канала в семплах
// на входе    :  ChannelID   -  идентификатор звукового канала
//                Start       -  указатель на переменную в которую нужно
//                               поместить начальную позицию фрагмента в
//                               отсчетах
//                End         -  указатель на переменную в которую нужно
//                               поместить конечную позицию фрагмента
//                               в отсчетах
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Channel_GetFragment(ChannelID: Integer; var Start,Endp: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка новых границ фрагмента звукового канала в миллисекундах
// на входе    :  ChannelID   -  идентификатор звукового канала
//                Start       -  начальная позиция фрагмента, позиция в
//                               миллисекундах
//                End         -  конечная позиция фрагмента, позиция в
//                               миллисекундах
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Channel_SetFragmentMs(ChannelID,Start,Endp: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение текущих границ фрагмента звукового канала в миллисекундах
// на входе    :  ChannelID   -  идентификатор звукового канала
//                Start       -  указатель на переменную в которую нужно
//                               поместить начальную позицию фрагмента
//                               в миллисекундах
//                End         -  указатель на переменную в которую нужно
//                               поместить конечную позицию фрагмента
//                               в миллисекундах
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Channel_GetFragmentMs(ChannelID: Integer; var Start,Endp: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение продолжительности исходных звуковых данных в семплах
// на входе    :  ChannelID   -  идентификатор звукового канала
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит продолжительность
//                исходных данных в семплах
//-----------------------------------------------------------------------------
function SQUALL_Channel_GetLength(ChannelID: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение продолжительности исходных звуковых данных в миллисекундах
// на входе    :  ChannelID   -  идентификатор звукового канала
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит продолжительность
//                исходных данных в милисекундах
//-----------------------------------------------------------------------------
function SQUALL_Channel_GetLengthMs(ChannelID: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка нового приоритета звукового канала
// на входе    :  ChannelID   -  идентификатор звукового канала
//                Priority    -  новый приоритет канала, значение параметра
//                               должно быть в пределах от 0 (самый низший
//                               приоритет) до 65535 (самый высший приоритет)
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Channel_SetPriority(ChannelID,Priority: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение текущего приоритета звукового канала
// на входе    :  ChannelID   -  идентификатор звукового канала
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит приоритет
//                звукового канала
//-----------------------------------------------------------------------------
function SQUALL_Channel_GetPriority(ChannelID: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение текущего значения флага зацикленности воспроизведения звукового
// канала
// на входе    :  ChannelID   -  идентификатор звукового канала
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит текущее значение
//                флага зацикленности воспроизведения канала, результат может
//                принимать следующие значения:
//                true  -  звуковой канал воспроизводится бесконечно
//                false -  звуковой канал воспроизводится один раз
//-----------------------------------------------------------------------------
function SQUALL_Channel_GetLoop(ChannelID: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка нового значения флага зацикленности воспроизведения звукового
// канала
// на входе    :  ChannelID   -  идентификатор звукового канала
//                Loop        -  флаг зацикленности канала, значение праметра
//                               может принимать следующие значения:
//                               true  -  бесконечное воспроизведение звукового
//                                        канала
//                               false -  воспроизведение звукового канала один
//                                        раз
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Channel_SetLoop(ChannelID,Loop: Integer): Integer; cdecl; external 'squall.dll';

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//                Методы для работы с рассеянными каналами
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
// Установка новой панорамы звукового канала
// на входе    :  ChannelID   -  идентификатор звукового канала
//                Pan         -  новое значение панорамы, значение параметра
//                               должено быть в пределах от 0 (максимальное
//                               смещение стерео баланса влево) до 100
//                               (максимальное смещение стерео баланса вправо)
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
// примечание  :  данный метод не работает с позиционными каналами
//-----------------------------------------------------------------------------
function SQUALL_Channel_SetPan(ChannelID,Pan: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение текущей панорамы звукового канала
// на входе    :  ChannelID   -  идентификатор звукового канала
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит текущее значение
//                панорамы канала
// примечание  :  данный метод не работает с позиционными каналами
//-----------------------------------------------------------------------------
function SQUALL_Channel_GetPan(ChannelID: Integer): Integer; cdecl; external 'squall.dll';

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//                Методы для работы с позиционными каналами
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
// Установка новой трехмерной позиции звукового канала в пространстве
// на входе    :  ChannelID   -  идентификатор звукового канала
//                Position    -  указатель на структуру с новыми координатами
//                               канала в пространстве
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
// примечание  :  данный метод не работает с рассеянными каналами
//-----------------------------------------------------------------------------
function SQUALL_Channel_Set3DPosition(ChannelID: Integer;Position: PSingle): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение текущей трехмерной позиции звукового канала в пространстве
// на входе    :  ChannelID   -  идентификатор звукового канала
//                Position    -  указатель на структуру в которую нужно
//                               поместить текущую трехмерную позицию звукового
//                               канала в пространстве
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
// примечание  :  данный метод не работает с рассеянными каналами
//-----------------------------------------------------------------------------
function SQUALL_Channel_Get3DPosition(ChannelID: Integer;Position: PSingle): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка новой скорости перемещения звукового канала
// на входе    :  ChannelID   -  идентификатор звукового канала
//                Velocity    -  указатель на структуру с новым вектором
//                               скорости перемещения звукового канала
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
// примечание  :  данный метод не работает с рассеянными каналами
//-----------------------------------------------------------------------------
function SQUALL_Channel_SetVelocity(ChannelID: Integer;Velocity: PSingle): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение текущей скорости перемещения звукового канала
// на входе    :  ChannelID   -  идентификатор звукового канала
//                Velocity    -  указатель на структуру в которую нужно
//                               поместить текущее значение вектора скорости
//                               звукового канала
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
// примечание  :  данный метод не работает с рассеянными каналами
//-----------------------------------------------------------------------------
function SQUALL_Channel_GetVelocity(ChannelID: Integer;Velocity: PSingle): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка нового минимального и максимального расстояния слышимости
// звукового канала
// на входе    :  ChannelID   -  идентификатор звукового канала
//                MinDist     -  новое минимальное расстояние слышимости
//                               значение параметра должно быть в пределах
//                               от 0.01f до 1000000000.0f
//                MaxDist     -  новое максимальное расстояние слышимости
//                               значение параметра должно быть в пределах
//                               от 0.01f до 1000000000.0f
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
// примечание  :  данный метод не работает с рассеянными каналами
//-----------------------------------------------------------------------------
function SQUALL_Channel_SetMinMaxDistance(ChannelID: Integer;MinDist,MaxDist: Single): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение текущего минимального растояния слышимости звукового канала
// на входе    :  ChannelID   -  идентификатор звукового канала
//                MinDist     -  указатель на переменную в которую нужно
//                               поместить текущее минимальное растояние
//                               слышимости
//                MinDist     -  указатель на переменную в которую нужно
//                               поместить текущее максимальное растояние
//                               слышимости
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
// примечание  :  данный метод не работает с рассеянными каналами
//-----------------------------------------------------------------------------
function SQUALL_Channel_GetMinMaxDistance(ChannelID: Integer;var MinDist,MaxDist: Single): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка параметров конуса распространения звукового канала
// на входе    :  ChannelID         -  идентификатор звукового канала
//                Orientation       -  указатель на струкруру с вектором
//                                     направления внутреннего и внешнего конуса,
//                                     в случае если значение вектора направления
//                                     внешнего и внутреннего конуса изменять
//                                     не нужно, то данный параметр должен
//                                     содержать 0
//                InsideConeAngle   -  угол внутреннего звукового конуса, значение
//                                     параметра должно быть в пределах от 1 до
//                                     360 градусов, в случае если значение
//                                     угла внутреннего звукового конуса изненять
//                                     не нужно, то данный параметр должен
//                                     содержать 0
//                OutsideConeAngle  -  угол внешнего звукового конуса, значение
//                                     параметра должно быть в пределах от 1 до
//                                     360 градусов, в случае если значение
//                                     угла внешнего звукового конуса изменять
//                                     не нужно, то данный параметр должен
//                                     содержать 0
//                OutsideVolume     -  уровень громкости источника за пределами
//                                     внешнего конуса, в процентах значение
//                                     праметра должно быть в пределах от 0
//                                     до 100
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
// примечание  :  данный метод не работает с рассеянными каналами
//-----------------------------------------------------------------------------
function SQUALL_Channel_SetConeParameters(ChannelID: Integer;Orientation: Single;InsideConeAngle, OutsideConeAngle, OutsideVolume: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение параметров конуса распространения звукового канала
// на входе    :  ChannelID         -  идентификатор звукового канала
//                Orientation       -  указатель на струкруру в которую нужно
//                                     поместить текущий вектор направления
//                                     внешнего и внутреннего конуса, в случае
//                                     если значение вектора внутреннего
//                                     и внешнего конуса, получать не нужно,
//                                     то данный параметр должен содержать 0
//                InsideConeAngle   -  указатель на переменную в которую нужно
//                                     поместить текущее значение угола внутреннего
//                                     конуса в градусах, в случае если значение
//                                     угла внутреннего конуса получать не нужно,
//                                     то данный параметр должен содержать 0
//                OutsideConeAngle  -  указатель на переменную в которую нужно
//                                     поместить текущее значение угола внешнего
//                                     конуса в градусах, в случае если значение
//                                     угла внешнего конуса получать не нужно,
//                                     то данный параметр должен содержать 0
//                OutsideVolume     -  указатель на переменную в которую нужно
//                                     поместить текущее значение уровеня громкости
//                                     источника за пределами внешнего конуса, в
//                                     процентах, в случае если значение уровня
//                                     громкости за пределами внешего конуса
//                                     получать не нужно, то данный параметр
//                                     должен содержать 0
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
// примечание  :  данный метод не работает с рассеянными каналами
//-----------------------------------------------------------------------------
function SQUALL_Channel_GetConeParameters(ChannelID: Integer; var Orientation: Single; var InsideConeAngle, OutsideConeAngle, OutsideVolume: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка новых EAX параметров звукового канала
// на входе    :  ChannelID   -  идентификатор звукового канала
//                Version     -  номер версии EAX, параметр определяет в каком
//                               формате передаются EAX параметры канала.
//                Properties  -  указатель на структуру описывающую параметры
//                               EAX канала, параметры должны быть в формате
//                               указанном параметром Version
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
// примечание  :  данный метод не работает с рассеянными каналами
//-----------------------------------------------------------------------------
function SQUALL_Channel_EAX_SetProperties(ChannelID, Version: Integer; EAXProperty: psquall_eax_channel_t): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение текущих EAX параметров звукового канала
// на входе    :  ChannelID   -  идентификатор звукового канала
//                Version     -  номер версии EAX, параметр определяет в каком
//                               формате получать EAX параметры канала.
//                Properties  -  указатель на структуру куда нужно поместить
//                               текущие параметры EAX канала, структура будет
//                               заполнена параметрами в формате указанном
//                               параметром Version
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
// примечание  :  данный метод не работает с рассеянными каналами
//-----------------------------------------------------------------------------
function SQUALL_Channel_EAX_GetProperties(ChannelID, Version: Integer; var EAXProperty: squall_eax_channel_t): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка новых ZOOMFX параметров звукового канала
// на входе    :  ChannelID   -  идентификатор звукового канала
//                Properties  -  указатель на структуру описывающую параметры
//                               ZOOMFX канала
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
// примечание  :  данный метод не работает с рассеянными каналами
//-----------------------------------------------------------------------------
function SQUALL_Channel_ZOOMFX_SetProperties(ChannelID: Integer; ZoomFXProperty: psquall_zoomfx_channel_t): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение текущих ZOOMFX параметров звукового канала
// на входе    :  ChannelID   -  идентификатор звукового канала
//                Properties  -  указатель на структуру куда нужно поместить
//                               текущие параметры ZOOMFX канала
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
// примечание  :  данный метод не работает с рассеянными каналами
//-----------------------------------------------------------------------------
function SQUALL_Channel_ZOOMFX_GetProperties(ChannelID: Integer; var ZoomFXProperty: squall_zoomfx_channel_t): Integer; cdecl; external 'squall.dll';

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//                Методы для работы с группами каналов
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
// Включение/выключение паузы группы каналов
// на входе    :  ChannelGroupID -  идентификатор группы каналов
//                Pause          -  флаг включения/выключения паузы, параметр
//                                  может принимать слудующие значения:
//                                  true  -  включить паузу
//                                  false -  выключить паузу
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_ChannelGroup_Pause(ChannelGroupID, Pause: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Остановка группы каналов
// на входе    :  ChannelGroupID -  идентификатор группы каналов
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_ChannelGroup_Stop(ChannelGroupID: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка уровня громкости группы каналов в процентах
// на входе    :  ChannelGroupID -  идентификатор группу каналов
//                Volume         -  значение урокня громкости, значение должно
//                                  лежать в пределах от 0 до 100
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_ChannelGroup_SetVolume(ChannelGroupID, Volume: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка новой частоты дискретизации группы каналов
// на входе    :  ChannelGroupID -  номер группы каналов
//                Frequency      -  новое значение частоты дискретизации,
//                                  значение параметра должно быть в пределах
//                                  от 100 до 1000000 Герц
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_ChannelGroup_SetFrequency(ChannelGroupID, Frequency: Integer): Integer; cdecl; external 'squall.dll';

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//                Методы для работы с семплами
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
// Создание семпла из файла
// на входе    :  FileName - указатель на имя файла
//                MemFlag  - флаг определяющий расположение файла, параметр
//                           может принимать следующие значения:
//                           true  -   размещать данные файла в памяти
//                           false -   разместить данные файла на диске
//                Default  - указатель на структуру параметров семпла по
//                           умолчанию, если параметр равен 0, загрузчик
//                           установит следующие параметры семпла по умолчанию:
//                           SampleGroupID - 0
//                           Priority      - 0
//                           Frequency     - 0
//                           Volume        - 100
//                           Pan           - 50
//                           MinDist       - 1.0f
//                           MaxDist       - 1000000000.0f
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит идентификатор
//                созданного семпла
//-----------------------------------------------------------------------------
function SQUALL_Sample_LoadFile(FileName: PAnsiChar;MemFlag: Integer; Default: psquall_sample_default_t): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Загрузка данных в хранилище из памяти
// на входе :  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,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит идентификатор
//                созданного семпла
//-----------------------------------------------------------------------------

function SQUALL_Sample_LoadFromMemory(MemoryPtr: Pointer; MemorySize: Cardinal; NewMemory: Integer; Default: psquall_sample_default_t): Integer; cdecl; external 'squall.dll';


//-----------------------------------------------------------------------------
// Освобождение всех семплов
// на входе    :  *
// на выходе   :  *
//-----------------------------------------------------------------------------
procedure SQUALL_Sample_UnloadAll() cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Освобождение указанного семпла
// на входе    :  SampleID -  идентификатор семпла
// на выходе   :  *
//-----------------------------------------------------------------------------
procedure SQUALL_Sample_Unload(SampleID: Integer) cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение продолжительности данных звукового файла в отсчетах
// на входе    :  SampleID -  идентификатор семпла
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит продолжительность
//                данных в отсчетах
//-----------------------------------------------------------------------------
function SQUALL_Sample_GetFileLength(SampleID: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение продолжительности данных звукового файла в миллисекундах
// на входе    :  SampleID -  идентификатор семпла
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит продолжительность
//                данных в милисекундах
//-----------------------------------------------------------------------------
function SQUALL_Sample_GetFileLengthMs(SampleID: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение частоты дискретизации данных звукового файла
// на входе    :  SampleID -  идентификатор семпла
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит частоту
//                дискретизации
//-----------------------------------------------------------------------------
function SQUALL_Sample_GetFileFrequency(SampleID: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Установка новых параметров семпла по умолчанию
// на входе    :  SampleID -  идентификатор семпла
//                Default  -  указатель на структуру с новыми параметрами семпла
//                            по умолчанию
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Sample_SetDefault(SampleID: Integer; Default: psquall_sample_default_t): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Получение текущих параметров семпла по умолчанию
// на входе    :  SampleID -  идентификатор семпла
//                Default  -  указатель на структуру в которую нужно поместить
//                            текущие параметры семпла по умолчанию
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Sample_GetDefault(SampleID: Integer; var Default: squall_sample_default_t): Integer; cdecl; external 'squall.dll';


//-----------------------------------------------------------------------------
// Создание и воспроизведение рассеянного канала из указанного семпла, опираясь
// на параметры семпла по умолчанию
// на входе    :  SampleID       -  идентификатор семпла
//                Loop           -  флаг зацикленности воспроизведения, параметр
//                                  может принимать следующие значения:
//                                  true  -  воспроизводить канал в цикле
//                                           бесконечно
//                                  false -  воспроизвести канал один раз
//                ChannelGroupID -  принадлежность создаваемого канала к группе
//                                  каналов, если значение параметра равно 0
//                                  значит звуковой канал не принадлежит группе
//                                  каналов.
//                Start          -  флаг запуска звука по окончанию создания
//                                  канала, параметр может принимать следующие
//                                  значения:
//                                  true  -  канал начнет воспроизводится сразу
//                                           после создания
//                                  false -  канал будет только подготовлен,
//                                           для того чтобы начать воспроизведение
//                                           нужно вызвать метод
//                                           SQUALL_Channel_Start()
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит идентификатор
//                созданного звукового канала
//-----------------------------------------------------------------------------
function SQUALL_Sample_Play(SampleID,Loop,Group,Start: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Создание и воспроизведение рассеянного канала из указанного семпла, опираясь
// на параметры семпла по умолчанию
// на входе    :  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,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит идентификатор
//                созданного звукового канала
//-----------------------------------------------------------------------------
function SQUALL_Sample_PlayEx(SampleID,Loop,Group,Start,Priority,Volume,Frequency,Pan: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Создание и воспроизведение позиционного (трехмерного) звукового канала из
// указаного семпла, опираясь на параметры семпла по умолчанию
// на входе    :  SampleID       -  идентификатор семпла
//                Loop           -  флаг зацикленности воспроизведения, параметр
//                                  может принимать следующие значения:
//                                  true  -  воспроизводить канал в цикле
//                                           бесконечно
//                                  false -  воспроизвести канал один раз
//                ChannelGroupID -  принадлежность создаваемого канала к группе
//                                  каналов, если значение параметра равно 0
//                                  значит звуковой канал не принадлежит группе
//                                  каналов.
//                Start          -  флаг запуска звука по окончанию создания
//                                  канала, параметр может принимать следующие
//                                  значения:
//                                  true  -  канал начнет воспроизводится сразу
//                                           после создания
//                                  false -  канал будет только подготовлен,
//                                           для того чтобы начать воспроизведение
//                                           нужно вызвать метод
//                                           SQUALL_Channel_Start()
//                Position       -  указатель на структуру c координатами
//                                  источника звукового канала
//                Velocity       -  указатель на вектор скорости источника
//                                  звукового канала, в случае если значение
//                                  вектора скорости устанавливать не надо,
//                                  то данный параметр должен быть равен 0
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит идентификатор
//                созданного звукового канала
//-----------------------------------------------------------------------------
function SQUALL_Sample_Play3D(SampleID,Loop,Group,Start: Integer; Position,Velocity: PSingle): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Создание и воспроизведение позиционного (трехмерного) звукового канала из
// указаного семпла
// на входе    :  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,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит идентификатор
//                созданного звукового канала
//-----------------------------------------------------------------------------
function SQUALL_Sample_Play3DEx(SampleID,Loop,Group,Start: Integer; Position,Velocity: PSingle;Priority,Volume,Frequency: Integer;MinDist,MaxDist: Single): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Включение/выключение паузы всех каналов использующих указаный семпл
// на входе    :  SampleID -  указатель на данные звука
//                Pause    -  флаг включения/выключения паузы, параметр может
//                            принимать следующие значения:
//                            true   - включить паузу
//                            false  - выключить паузу
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Sample_Pause(SampleID,Pause: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Остановка всех звуковых каналов использующих указанный семпл
// на входе    :  SampleID -  идентификатор семпла
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//-----------------------------------------------------------------------------
function SQUALL_Sample_Stop(SampleID: Integer): Integer; cdecl; external 'squall.dll';

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//                Методы для работы с группами семплов
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
// Создание и воспроизведения рассеяного канала из группы семплов, опираясь
// на параметры семпла по умолчанию
// на входе    :  SampleGroupID  -  идентификатор группы семплов
//                Loop           -  флаг зацикленности воспроизведения, параметр
//                                  может принимать следующие значения:
//                                  true  -  воспроизводить канал в цикле
//                                           бесконечно
//                                  false -  воспроизвести канал один раз
//                ChannelGroupID -  принадлежность создаваемого канала к группе
//                                  каналов, если значение параметра равно 0
//                                  значит звуковой канал не принадлежит группе
//                                  каналов.
//                Start          -  флаг запуска звука по окончанию создания
//                                  канала, параметр может принимать следующие
//                                  значения:
//                                  true  -  канал начнет воспроизводится сразу
//                                           после создания
//                                  false -  канал будет только подготовлен,
//                                           для того чтобы начать воспроизведение
//                                           нужно вызвать метод
//                                           SQUALL_Channel_Start()
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит идентификатор
//                созданного звукового канала
//-----------------------------------------------------------------------------
function SQUALL_SampleGroup_Play(SoundGroupID,Loop,Group,Start: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Создание и воспроизведения рассеяного канала из группы семплов
// на входе    :  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,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит идентификатор
//                созданного звукового канала
//-----------------------------------------------------------------------------
function SQUALL_SampleGroup_PlayEx(SoundGroupID,Loop,Group,Start,Priority,Volume,Frequency,Pan: Integer): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Создание и воспроизведение позиционного (трехмерного) звукового канала из
// указаной группы семплов, опираясь на параметры семпла по умолчанию
// на входе    :  SampleGroupID  -  идентификатор группы семплов
//                Loop           -  флаг зацикленности воспроизведения, параметр
//                                  может принимать следующие значения:
//                                  true  -  воспроизводить канал в цикле
//                                           бесконечно
//                                  false -  воспроизвести канал один раз
//                ChannelGroupID -  принадлежность создаваемого канала к группе
//                                  каналов, если значение параметра равно 0
//                                  значит звуковой канал не принадлежит группе
//                                  каналов.
//                Start          -  флаг запуска звука по окончанию создания
//                                  канала, параметр может принимать следующие
//                                  значения:
//                                  true  -  канал начнет воспроизводится сразу
//                                           после создания
//                                  false -  канал будет только подготовлен,
//                                           для того чтобы начать воспроизведение
//                                           нужно вызвать метод
//                                           SQUALL_Channel_Start()
//                Position       -  указатель на структуру c координатами
//                                  источника звукового канала
//                Velocity       -  указатель на вектор скорости источника
//                                  звукового канала, в случае если значение
//                                  вектора скорости устанавливать не надо,
//                                  то данный параметр должен быть равен 0
// на выходе   :  успешность, если возвращаемый результат больше либо равен 0,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит идентификатор
//                созданного звукового канала
//-----------------------------------------------------------------------------
function SQUALL_SampleGroup_Play3D(SoundGroupID,Loop,Group,Start: Integer; Position,Velocity: PSingle): Integer; cdecl; external 'squall.dll';

//-----------------------------------------------------------------------------
// Создание и воспроизведение позиционного (трехмерного) звукового канала из
// указаной группы семплов
// на входе    :  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,
//                вызов состоялся, иначе результат содержит код ошибки
//                в случае успешного вызова результат содержит идентификатор
//                созданного звукового канала
//-----------------------------------------------------------------------------
function SQUALL_SampleGroup_Play3DEx(SoundGroupID,Loop,Group,Start: Integer; Position,Velocity: PSingle; Priority,Volume,Frequency: Integer;MinDist,MaxDist: Single): Integer; cdecl; external 'squall.dll';

implementation

end.
